之间有区别"=="和"是"？

https://stackoverflow.com/questions/132988

02-07-2019
|

题

我谷歌-fu 已经失败了我。

在蟒蛇，是下述两个试验对于平等等?

n = 5
# Test one.
if n == 5:
    print 'Yay!'

# Test two.
if n is 5:
    print 'Yay!'

这不会举行真正的对象，你会比较情况(a list 说)?

好了，这种回答我的问题：

L = []
L.append(1)
if L == [1]:
    print 'Yay!'
# Holds true, but...

if L is [1]:
    print 'Yay!'
# Doesn't.

所以 == 测试值在哪里 is 测试，看看他们是同样的对象？

解决方案

如果两个变量指向同一个对象，则

将返回 True ，如果变量引用的对象相等，则 == 。

>>> a = [1, 2, 3]
>>> b = a
>>> b is a 
True
>>> b == a
True
>>> b = a[:] # Make a new copy of list `a` via the slice operator, and assign it to variable `b`
>>> b is a
False
>>> b == a
True

在您的情况下，第二个测试仅起作用，因为Python缓存小整数对象，这是一个实现细节。对于较大的整数，这不起作用：

>>> 1000 is 10**3
False
>>> 1000 == 10**3
True

对于字符串文字也是如此：

>>> "a" is "a"
True
>>> "aa" is "a" * 2
True
>>> x = "a"
>>> "aa" is x * 2
False
>>> "aa" is intern(x*2)
True

请参阅此问题以及。

其他提示

有一个简单的规则的拇指来告诉你什么时候使用 == 或 is.

== 是为了 值平等.用它的时候你很想知道，如果两个物体具有同样的价值。
is 是为了 参考平等.用它的时候你很想知道，如果两个参考文献可参考同样的对象。

在一般情况下，当你在比较东西的一个简单的类型，您通常会检查 值平等, 所以你应该使用 ==.例如，意的例子可能是检查是否有价值等于2(==)，而不是是否 x 字面意思是指相同的对象为2。

别注意：因为CPython参考执行工作，你会得到意想不到的和不一致的结果，如果错误的使用 is 为比较的参考平等在整数：

>>> a = 500
>>> b = 500
>>> a == b
True
>>> a is b
False

这就是我们期望： a 和 b 具有同样的价值，但是截然不同的实体。但这是什么？

>>> c = 200
>>> d = 200
>>> c == d
True
>>> c is d
True

这是不一致的早期结果。什么在这里？事实证明的参考执行Python缓存整对象的范围为-5..256作为单独的实例用于性能的原因。这里有一个例子证明了这一点：

>>> for i in range(250, 260): a = i; print "%i: %s" % (i, a is int(str(i)));
... 
250: True
251: True
252: True
253: True
254: True
255: True
256: True
257: False
258: False
259: False

这是另一个明显的理由不能使用 is:该行为是留给实现当你错误地使用它的价值平等。

== 确定值是否相等，而是确定它们是否完全相同且相等。

Python中 == 和之间是否有区别？

是的，它们有非常重要的区别。

== ：检查是否相等 - 语义是等效对象（不一定是同一个对象）将测试相等。正如文档所说：

运算符＆lt;，＆gt;，==，＆gt; =，＆lt; =和！=比较两个对象的值。

是 ：检查身份 - 语义是对象（在内存中保存）是对象。同样，文档说明：

运算符是，不是测试对象标识： x是y 是真的当且仅当 x 和 y 是同一个对象时。对象标识是使用 id（）函数确定。 x不是y 产生逆真理价值。

因此，检查身份与检查对象的ID是否相等是一样的。也就是说，

a is b

与：

相同

id(a) == id(b)

其中 id 是内置函数，它返回一个“保证在同时存在的对象中是唯一的”整数。（参见 help（id）），其中 a 和 b 是任意对象。

其他使用方法

您应该将这些比较用于其语义。使用检查身份，使用 == 检查相等性。

PEP 8，标准库的官方Python风格指南也提到 的两个用例是 ：

无等单身人士的比较应始终使用或   不是，绝不是相等的运算符。

另外，当你真正指的是如果x不是None 时，要小心写 if x -   例如在测试默认为 None 的变量或参数时   被设定为其他值。另一个值可能有一个类型（例如   作为容器）在布尔上下文中可能是假的！

从身份推断平等

如果为真，则通常可以推断出相等性 - 逻辑上，如果一个对象本身，那么它应该测试为等同于它自己。

在大多数情况下，这种逻辑是正确的，但它依赖于 __ eq __ 特殊方法的实现。正如 docs 所说，

相等性比较的默认行为（ == 和！= ）基于对象的身份。因此，实例的相等比较具有相同身份的结果是平等的，而且是相等的比较具有不同身份的实例导致不平等。一个这种默认行为的动机是所有对象的愿望应该是反身的（即x是y意味着x == y）。

为了保持一致，建议：

平等比较应该是反身的。换句话说，相同   对象应该相等：

x是y 暗示 x == y

我们可以看到这是自定义对象的默认行为：

>>> class Object(object): pass
>>> obj = Object()
>>> obj2 = Object()
>>> obj == obj, obj is obj
(True, True)
>>> obj == obj2, obj is obj2
(False, False)

对立面通常也是正确的 - 如果某些事情测试不相等，你通常可以推断它们不是同一个对象。

自测试以来

之间有什么区别 `is` 和 `==`?

== 和 is 是不同的比较！正如其他人已经说的：

== 比较价值的对象。
is 比较引用的对象。

在蟒蛇的名字指的对象，例如在这种情况下 value1 和 value2 指 int 实例储存价值 1000:

value1 = 1000
value2 = value1

因 value2 指的是同样的对象 is 和 == 会给 True:

>>> value1 == value2
True
>>> value1 is value2
True

在下面的例子的名字 value1 和 value2 请参考不同的 int 实例，即使这两个存储相同的整数：

>>> value1 = 1000
>>> value2 = 1000

因为相同的价值(integer)储存 == 将 True, 这就是为什么它通常被称为"价值比较"。然而 is 将返回 False 因为这些都是不同的对象：

>>> value1 == value2
True
>>> value1 is value2
False

当使用哪个？

一般 is 是一个更快的比较。这就是为什么CPython缓存(或者也许 重复利用 将是更好的术语)中的某些物体，如小型整数，一些串，等等。但是，这应被视为 实施细节 可能(即使不可能的)变化在任何一点没有警告。

你应该 只使用 is 如果你：

想要检查如果两个对象是真相同的目的(不一样的"值")。一个例子，可以如果你的使用一个单独目的为恒定。
想比较一个值蟒蛇恒.常量在蟒是：
- None
- True¹
- False¹
- NotImplemented
- Ellipsis
- __debug__
- 课程(例如 int is int 或 int is float)
- 有可能是额外的常量在内置模块或第3党模块。例如 np.ma.masked 从顽固模块)

在 每一个其他情况下则应使用 == 要检查平等。

我可以自定义的行为？

有一些方面来 == 没有提到已经在其他的答案：这是一部分蟒蛇"数据模型".这意味着其行为可以定制使用 __eq__ 法。例如：

class MyClass(object):
    def __init__(self, val):
        self._value = val

    def __eq__(self, other):
        print('__eq__ method called')
        try:
            return self._value == other._value
        except AttributeError:
            raise TypeError('Cannot compare {0} to objects of type {1}'
                            .format(type(self), type(other)))

这只是一个人工实例来说明，其方法是真正称为：

>>> MyClass(10) == MyClass(10)
__eq__ method called
True

注意到默认情况下(如果没有其他的执行情况 __eq__ 可以发现类或超类) __eq__ 使用 is:

class AClass(object):
    def __init__(self, value):
        self._value = value

>>> a = AClass(10)
>>> b = AClass(10)
>>> a == b
False
>>> a == a

所以它实际上是重要的，以实现 __eq__ 如果你想要"更多"，不仅仅是参照比较的定制课程。

另一方面你不能自定义 is 检查。它将始终比较只是如果你有同样的参考。

将这些比较总是返回布尔?

因 __eq__ 可以重新实现或复盖，它不仅限于返回 True 或 False.它的可能任何回报(但在大多数情况下，应当返回布尔!).

例如，与顽固阵列 == 将返回的一个阵列：

>>> import numpy as np
>>> np.arange(10) == 2
array([False, False,  True, False, False, False, False, False, False, False], dtype=bool)

但 is 检查总是会返回 True 或 False!

¹ 因为艾伦的大厅中提到的评论：

通常你不应该做任何 is True 或 is False 检查，因为一个常使用这些"核查"上下文中隐含的转换条件布尔(例如在一个 if 发言).这样做的 is True 比较和隐布尔铸做更多的工作不仅仅是这样做的布尔投-你自己限制在布尔(而不考虑功能已大大增强).

像述pep8提到：

不比较布尔值 True 或 False 使用 ==.
Yes:   if greeting:
No:    if greeting == True:
Worse: if greeting is True:

他们完全不同。 是检查对象标识，而 == 检查是否相等（依赖于两个操作数类型的概念）。

“ is ”只是一个幸运的巧合。似乎可以正确地使用小整数（例如5 == 4 + 1）。这是因为 CPython优化了范围内整数的存储（-5）通过使他们成为单身人士。这种行为完全取决于实现，并不保证在各种微小的变革操作下都能保留。

例如，Python 3.5也会创建短字符串单例，但切片会破坏这种行为：

>>> "foo" + "bar" == "foobar"
True
>>> "foo" + "bar" is "foobar"
True
>>> "foo"[:] + "bar" == "foobar"
True
>>> "foo"[:] + "bar" is "foobar"
False

https://docs.python.org/library/stdtypes.html#comparisons

是测试身份 == 测试是否相等

每个（小）整数值映射到单个值，因此每3个相同且相等。这是一个实现细节，但不是语言规范的一部分

你的答案是对的。 是运算符比较两个对象的标识。 == 运算符比较两个对象的值。

对象的标识一旦创建就永远不会改变;你可以把它想象成对象在内存中的地址。

您可以通过定义 __ cmp __ 方法或丰富的比较方法，如 __ eq __ 。

== 运算符比较两个操作数的值并检查值是否相等。而是运算符检查两个操作数是否都引用同一个对象。

a = [1,2,3,4]
b = a
print(a == b) # true
print(a is b) # true

但如果我们这样做

b = a[:] # b now references a copy of a
print(a == b) # true
print(a is b) # false
print(a is not b) # true

基本上，可以被认为是 id（a）== id（b）的简写。然而，除此之外，运行时环境的怪癖使事情进一步复杂化。与相比，短字符串和小整数将返回 True ，因为Python机器试图为相同的对象使用更少的内存。

a = 'python'
b = 'python'

print(a == b) # true
print(a is b) # true

看看Stack Overflow问题 Python的＆＃8220;是＆＃8221;运算符意外地使用整数 。

它主要归结为“ is ”＆quot;检查它们是否是同一个对象，而不仅仅是彼此相等（低于256的数字是特殊情况）。

正如John Feminella所说，大多数时候你会使用==和！=，因为你的目标是比较价值观。我只想对剩下的时间进行分类：

NoneType只有一个实例，即None是一个单例。因此 foo == None 和 foo是None 意味着相同。但是是测试更快，Pythonic约定是使用 foo是None 。

如果您正在对垃圾收集进行一些内省或讨论或检查您的自定义字符串实习小工具是否正常工作或类似，那么您可能有一个用例 foo 是杆



 True和False也是（现在）单例，但 foo == True 没有用例， foo没有用例是True 。



	
		
	
	
			他们中的大多数已经回答了问题。正如附加说明（基于我的理解和实验，但不是来自记录的来源），声明


   ==如果变量引用的对象相等


以上答案应该被理解为


   ==如果变量引用的对象相等且属于同一类型/类的对象


。我根据以下测试得出了这个结论：

list1 = [1,2,3,4]
tuple1 = (1,2,3,4)

print(list1)
print(tuple1)
print(id(list1))
print(id(tuple1))

print(list1 == tuple1)
print(list1 is tuple1)


这里列表和元组的内容相同，但类型/类别不同。 
	


	
		
	
	
			简而言之，是检查两个引用是否指向同一个对象。 == 检查两个对象是否具有相同的值。

a=[1,2,3]
b=a        #a and b point to the same object
c=list(a)  #c points to different object 

if a==b:
    print('#')   #output:#
if a is b:
    print('##')  #output:## 
if a==c:
    print('###') #output:## 
if a is c:
    print('####') #no output as c and a point to different object 
	


	
		
	
	
			其实我想把它添加为评论，但不能轻易美化它因此添加作为答案，请不要将此视为答案。 

这就是我要理解的 -  


  逐一执行并理解每一步的输出


a = [1,2]
b = [1,2,3]
b.pop()
id(a)
id(b)
a is b
a == b
	


	
		
	
	
			正如本文中的其他人详细回答了这个问题，我强调主要是是和 ==   for strings 可以提供不同的结果，我会敦促程序员小心使用它们。

对于字符串比较，请确保使用 == 而不是 ：

str = 'hello'
if (str is 'hello'):
    print ('str is hello')
if (str == 'hello'):
    print ('str == hello')


输出：

str is hello
str == hello


 但在下面的示例中 == 和 会得到不同的结果：

str = 'hello sam'
    if (str is 'hello sam'):
        print ('str is hello sam')
    if (str == 'hello sam'):
        print ('str == hello sam')


输出：

str == hello sam


 <强>结论： 

小心地使用 来比较字符串
	


	
		
	
	
			 Python之间的差异是等于（==）


   is运算符可能看起来与等于运算符相同但是
  他们不一样。
  
  检查两个变量是否指向同一个对象
  ==符号检查两个变量的值是否相同。
  
  因此，如果is运算符返回True，那么相等就是肯定的
  是的，但相反的可能是也可能不是。


这是一个展示相似性和差异的例子。

>>> a = b = [1,2,3]
>>> c = [1,2,3]
>>> a == b
True
>>> a == c
True
>>> a is b
True
>>> a is c
False
>>> a = [1,2,3]
>>> b = [1,2]
>>> a == b
False
>>> a is b
False
>>> del a[2]
>>> a == b
True
>>> a is b
False



Tip: Avoid using is operator for immutable types such as strings and numbers, the result is unpredictable.

	


	
		
	
	
			＆QUOT; ==＆QUOT;比较值

＆QUOT;是＆QUOT;比较基础对象

# this pgm is to show you the diff b/n == and is

# a==b and a is b

# == compares values
# is compares references i.e compares wether two variables refer to same object(memory)

a=10
b=10
print(a==b) # returns True as a,b have same value 10 
print(a is b)
# returns True,
# we usually falsey assume that a =10 a new object . b=10 a new obj created
# but actually when b=10 ,nothing but b is pointed to 10 until value of a or b is changed from 10 

a=[1]
b=[1]
print(a==b)
#returns True as a,b have a list element 1
print(a is b)
#returns False because here two different objs are created when initiated with lists
	


	
		
	
	
			
o1是o2  =>的比较如果o1和o2都指向同一物理位置存储器(换句话说，如果他们是同一对象)

o1==o2  =>这里蟒蛇叫o1的__cmp__(o2)方法，该方法最好应该比较的价值和返回真正的或虚假的。(换句话说，它比较值)

JAVA人： 


在爪哇，以确定是否两个串变量的参考相同
物理存储位置的使用  str1==str2.(称为对象
身份，并且它被写在  蟒为str1是str2). 
比较串值，  usestr1.等(str2);在  蟒蛇，
使用str1==str2.


例如：

class A():
    ...:     def __init__(self,a):
    ...:         self.a = a
    ...:     def __repr__(self):
    ...:         return str(self.a)
    ...:     def __cmp__(self, value):
    ...:         print self.a
    ...:         print value.a
    ...:         return cmp(self.a, value.a)


蟒蛇壳输出：  


  o=A(2)
 o1=o
  
  o==o1 
 2 
 2 
 真的
  
  o是o1
 真的
  
  o1=A(2)
  
  o是o1
 假

    	


	
		
	
	
			
如果你跟JavaScript(然而，不推荐进行比较的一种语言vs的另一个):


使用  is  对于严格的比较。Javascript当量(===)
使用  ==  对于平等的比较。

    	


	
		
	
	
			虽然所有这些依赖于执行异议指针比较与值比较的答案都可能是正确的，但使用 is 来确定变量值是否为时有更深层次的语法原因（在布尔逻辑中通常表示为 NULL ）。 

在关系数据库和其他逻辑系统中， NULL 意味着实际值是“未知”。因此，逻辑表达式 xx == NULL 必须始终评估为 NULL 本身，因为无法知道 xx ，无论它是什么价值有，与未知值相同。在更严格遵守布尔逻辑规则的编程语言中， xx == NULL （或Pythonically  xx == None ）正确评估为 NULL ，并且必须提供替代方法来确定变量值是否为 NULL 。 Python在这方面是一个异常值，因为对象引用 None 的单一性质。但是为了清晰和逻辑正确，使用Python 是比较运算符在我看来更为健全。
	


	
		
	
	
			
是的，有区别两者。 


'=='  :比较对象的价值。 
'在'  :比较对象参考。

a = [1,2,3]  
b = a # both pointing to same object (memory location)

a == b:  
True  
a in b:   
True  #because a and b are pointing to same object



现在，让我们考虑这样的情况：

a = [1,2,3]
b = list(a)  # creating copy of object a

a == b:  
True  # as values are same
a in b:   
False  # because they are pointing to different object.



	
		
			许可以下： CC-BY-SA 和 归因
			不隶属于 StackOverflow