'==＆quot之间是否有区别和“是”

Question

我的 google-fu 使我失败了。

在Python中，以下两个测试是否相等？

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

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

对于您将要比较实例的对象（<代码>列表 Say），这是否成立？

好的，所以这种答案是我的问题：

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

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

so == 测试值是测试以查看它们是否是同一对象？

Answer 1

IS 将返回 true 如果两个变量指向同一对象（在内存）， == 如果变量所指的对象是等于的。

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

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

在您的情况下，第二个测试之所以起作用，是因为python加速了小整数对象，这是一个实现细节。 For larger integers, this does not work:

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

The same holds true for string literals:

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

Please see

Answer 2

有一个简单的经验法则可以告诉您何时使用 == 或是。

• == 是值等于。当您想知道两个对象是否具有相同的值时，请使用它。
• IS 是参考等效。当您想知道两个引用是否参考同一对象时，请使用它。

通常，当您将某些内容与简单类型进行比较时，通常会检查 value equality ，因此应使用 == 。例如，您的示例的目的可能是检查x的值是否等于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 Caches Integer对象的参考实现为-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 的另一个明显原因：当您错误地将其用于值平等时，该行为将留给实现。

Answer 3

== 和是之间的区别

是的，他们有一个非常重要的区别。

== ：检查等效 - 语义是等效对象（不一定是同一对象）将测试为均等。如文档说：

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

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

运算符是和不是对象身份的测试： x是y 是正确的
如果并且仅当 x 和 y 是同一对象。对象身份是
使用 id（）函数确定。 x不是y 产生逆
真实价值。

因此，对身份的检查与检查对象ID的平等相同。也就是说，

a is b

与以下内容相同：

id(a) == id(b)

其中 id 是返回整数“保证在同时存在的对象之间是唯一唯一的”函数（请参见 help> help> help（id） ），其中 a 和 b 是任何任意对象。

其他使用方向，

您应该使用这些比较来为其语义使用。使用 IS 要检查身份， == 以检查平等。

因此，通常，我们使用是来检查身份。当我们检查一个只能在存储器中仅存在的对象（在文档中称为“单例”）时，这通常很有用。

is 的用例包括：

• none
• 枚举值（使用枚举模块的枚举时）
• 通常
• 是由类别定义产生的类对象
• 通常由功能定义产生的对象，
• 该对象 函数定义对象。在内存中只能存在一次（通常是所有单例）
• 您想要的特定对象，您想要的身份

常规用例， == 包括：

• 数字，包括整数
• 字符串
• 列表
• sets sets
• dicturies dictuaries dictuaries
• customable
• 对象在大多数情况下

，对象再次，对于 == ，您想要的对象可能不是 same 对象，而是 等效一个

PEP 8指示

PEP 8，官方Python样式指南还提到 是 ：

与之类的单例进行比较
不是，从来都不是平等运算符。

另外，当您真正指的是时，请当心如果您的意思是，则如果x不是没有 -
例如，在测试默认为无的变量或参数时
被设置为其他值。另一个值可能具有类型（这样
作为一个容器），在布尔上下文中可能是错误的！

从身份中推论平等

如果为是正确的，那么平等可以通常被推断出 - 从逻辑上讲，如果对象本身是本身，则应与自身相等的测试。

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

平等比较的默认行为（ == 和！= ）是基于
对象的身份。因此，实例的平等比较
具有相同的身份会导致平等和平等比较
具有不同身份的实例导致不平等。一个
这种默认行为的动机是所有对象的愿望
应该是反身的（ie 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)

隔开效率通常也为true-由于并非平等，您通常可以推断它们不是同一对象。

由于可以自定义平等测试，因此对于所有类型的推断并不总是成立。

一个

例外的一个例外是 nan - 它始终测试与自身的测试：

>>> nan = float('nan')
>>> nan
nan
>>> nan is nan
True
>>> nan == nan           # !!!!!
False

检查身份的检查比检查平等要快得多（这可能需要递归检查成员）。

但是，它不能代替平等，而您可能会发现一个以上的对象等效。

请注意，比较列表和元组的平等将假定对象的身份相等（因为这是快速检查）。如果逻辑不一致，这可能会产生矛盾 - 因为它是 nan ：

>>> [nan] == [nan]
True
>>> (nan,) == (nan,)
True

一个警示性的故事：

问题是尝试使用 is 来比较整数。您不应该假设整数的实例与另一个参考获得的实例是相同的实例。这个故事解释了原因。

一位评论者的代码依赖于以下事实：小整数（-5至256）是Python中的单例，而不是检查平等。

哇，这可能会导致一些阴险的错误。我有一些检查A是否为B的代码，因为A和B通常数量很少。该错误仅在生产六个月后才发生，因为A和B终于足够大以至于没有缓存。 - GWG

它在开发中起作用。它可能已经通过了一些Unistests。

它在生产中起作用 - 直到该代码检查了大于256的整数，这时它的生产失败了。

这是一种生产故障，本来可以在代码审查中或可能与样式检查器一起捕获的失败。

让我强调： 请勿使用 is 来比较整数。

Answer 4

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

Answer 5

是和 == 之间有什么区别？

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

• == 比较对象的值。
• IS 比较对象的引用。

在Python名称中，请参阅对象，例如在这种情况下 value1 和 value2 请参阅 int 存储值 1000 实例代码>：

value1 = 1000
value2 = value1

因为 value2 是指同一对象 is 和 == 将给出 true true 代码>：

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

在下面的示例中，名称 value1 和 value2 请参阅不同的 int 实例，即使两者都存储相同的整数：

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

由于存储相同的值（整数） == 将为 true ，所以这就是为什么通常称为“值比较”的原因。但是，是将返回 false ，因为这些是不同的对象：

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

何时使用？

通常，是是一个更快的比较。这就是为什么cpython缓存（或 reuses 将是更好的术语）某些对象（例如小整数，某些字符串等）。即使不太可能）在没有警告的情况下改变。

则应仅使用 IS 是 。

• 如果您：

  想检查两个对象是否真的是相同的对象（不仅是相同的“值”）， 一个示例可以是如果 you 将单例对象用作常数。

• 想要将一个值与
  

  • 无
  • true ¹
  • false ¹
  • 通知
  • 省略号
  • __ debug __
  • 类（例如 int是int 或 int是float ）
  • 内置模块或第三方模块中可能会有其他常数。例如 来自numpy模块）

，在中，您应该使用 == 检查平等性。

我可以自定义行为吗？

== 在其他答案中尚未提及的某些方面：它是 pythons“数据模型” 。这意味着可以使用 __ eq eq __ 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 __ 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 __ 实际上重要的是，如果您想要“更多”，而不仅仅是自定义类的参考比较！

另一方面，您无法自定义是检查。如果您有相同的参考，它将始终比较 。

这些比较会总是返回布尔值吗？

因为 __ EQ __ 可以重新实现或覆盖，因此不限于返回 true 或 false 。它可以返回任何东西（但是在大多数情况下，它应该返回布尔值！）。

例如，使用numpy数组 == 将返回数组：

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

但是 is 检查将始终返回 true 或 false 呢

---

¹ 作为评论中提到的亚伦大厅：

通常，您不应该做任何是true 或是false 检查，因为通常使用这些检查“在将条件隐式转换为布尔值的上下文中（例如，在语句中，在中）。因此，执行是True 比较和隐含的布尔演员所做的不仅仅是做布尔演员的工作更多的工作 - 您将自己限制在布尔人上（这不被视为Pythonic） 。

就像PEP8提到的那样：

不要将布尔值与 true 或 false 使用 == 。。

 是：如果问候：
否：如果问候== true：
更糟糕的是：如果问候是真的：
 

Answer 6

它们完全不同。 is 检查对象标识，而 == 检查相等性（这一概念取决于两个操作数的类型）。

“is”似乎可以正确地处理小整数（例如 5 == 4+1），这只是一个幸运的巧合。这是因为 CPython 优化了范围 (-5到 256）通过使它们成为单例。此行为完全依赖于实现，并且不保证在各种较小的转换操作下保留。

例如，Python 3.5 也使短字符串成为单例，但对它们进行切片会破坏这种行为：

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

Answer 7

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

is 身份测试
== 测试相等性

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

Answer 8

您的答案是正确的。 是操作员比较两个对象的身份。 == 操作员比较两个对象的值。

一旦创建对象的身份就永远不会改变。您可能会认为它是内存中对象的地址。

您可以通过定义 __ cmp __ 方法或a 丰富的比较 __ eq __ 之类的方法。

Answer 9

查看 Stack Overflow 问题Python 的“is”运算符对整数的行为异常。

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

Answer 10

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

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 

Answer 11

正如本文中的其他人在详细介绍 == 和之间的区别是用于比较对象或变量时，我将强调主要是是和 == 的比较可以给出不同的结果，我敦促程序员仔细使用它们。

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

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

out：

str is hello
str == hello

但是在下面的示例中 == 和 IS 将获得不同的结果：

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

OUT：

str2 == hello sam

结论和分析：

使用 is 仔细以比较字符串之间。
由于是用于比较对象的，并且在python 3+中，每个变量（例如字符串）解释为对象，让我们看看上面段落中发生了什么。

在python中，有 id 函数显示对象在其寿命中的唯一常数。此ID在Python解释器的后端使用，用 关键字比较两个对象。

str = 'hello'
id('hello')
> 140039832615152
id(str)
> 140039832615152

但

str2 = 'hello sam'
id('hello sam')
> 140039832615536
id(str2)
> 140039832615792

Answer 12

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

有一个和只有一个非类型的实例，即无是单身人士。因此， foo ==无和 foo是无表示相同的意思。但是， IS 测试更快，Pythonic约定是使用 foo是无。

如果您正在进行一些内省或用垃圾收集进行烦恼或检查您的自定义字符串Indivenning小工具正在工作或类似的工作，那么您可能有一个用例/代码>。

TROUKY和FALSE也是（现在）Singletons，但是 foo == true 也没有用例，并且 foo的用例为true 。

Answer 13

他们中的大多数已经回答了这一点。作为附加说明（基于我的理解和实验，但不是来自记录的来源），该声明

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

从上述答案等于

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

的对象

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

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)

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