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

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 缓存小整数对象，这是实现的详细信息。 对于大型整数，它不起作用：

>>> 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

请阅读和
https://coderoad.ru/26595/
.

有一个简单的经验规则来告诉你何时使用

==

或者

is

.

==

- 那是为了

价值平等

. 当您想知道两个对象是否具有相同的值时使用它。

is

- 为了

参考平等

. 当您想知道是否有两个链接到同一对象时使用它。

一般来说，当您使用简单类型进行比较时，您通常会检查

价值平等

, 所以你应该使用

==

. 例如，您的示例的目的可能检查是否 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 缓存范围内的整数对象 -5..256 作为副本 singleton 考虑表现。 以下是演示这一点的示例：

>>> 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

: 当您错误地使用它以获得价值平等时，行为仍然存在。

之间有什么区别

==

和

is

在 Python?

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

==

: 检查语义平等是等效对象 /这不一定是同一个对象/ 将被测试为平等。 如何
https://docs.python.org/3/refe ... isons
:

运营商 <, >, ==, >=, <=, 并进一步 != 比较两个对象的值。

is

: 检查身份 - 语义是该对象 /如何存储在内存中/

是一个

目的。 再次
https://docs.python.org/3/refe ... s-not
: :

运营商

is

和

is not

检查对象的身份：

x is y

是真的
如果并且只有

x

和

y

- 同一个对象。 对象的身份是
由功能决定

id//

.

x is not y

给出相反的结果
真正的重要性。

因此，身份的验证与平等的检查相同 IDs 对象。 IE，

a is b

这与：

id/a/ == id/b/

在哪里

id

- 拒绝返回整数的函数 "is guaranteed to be unique among simultaneously existing objects" /厘米。

help/id/

/ 在哪里

a

和

b

- 爱任意物体。

其他用途

您必须为其语义使用这些比较。 使用

is

验证身份和

==

验证平等。

PEP 8, 官方风格指南 Python 对于标准库也提到了
https://www.python.org/dev/pep ... tions
:

与单人类的比较类型

None

应该始终完成

is

或者

is not

, 永远不会运营商平等。

还要写的写作

if x

, 当你真的意思

if x is not None

--
例如，在检查变量或参数是否是默认值时

None

, 安装在其他值。 另一个值可以是类型 /例如
作为一个容器/ , 在逻辑上下文中可以是假的！

人格平等的定义

如果一个

is

真的，然后是平等

通常

它可以逻辑地派生，如果对象本身是本身的，那么它必须以等同于自身测试。

在大多数情况下，此逻辑是真的，但它依赖于特殊方法的实现

__eq__

. 像他们说的那样
https://docs.python.org/3/refe ... isons
,

平等比较的默认行为 /

==

和

!=

/ 基于
物体的身份。 因此，拷贝的平等比较
具有相同的身份导致平等和平等的比较
具有不同标识符的实例导致 inequality. 一
默认情况下的这种行为的动机是对所有对象的欲望
必须有反抗 /它是。 x-y 暗示 x == y/.

并且在序列的利益建议::

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

x is 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/

逆向是真的 - 如果测试不等于，通常可以得出结论，这不是相同的对象。

由于可以配置对平等的测试，因此所有类型都不总是如此。

一个例外

明显的例外是

nan

- 他总是测试不等于他自己：

>>> nan = float/'nan'/

>>> nan

nan

>>> nan is nan

True

>>> nan == nan # !!!!!

False

身份检查可能比检查平等的速度快得多 /可能需要递归成员检查/.

但是当您可以找到一个以上的对象时，它不能被平等替换。

请注意，列表平等的比较和元组将假设对象的身份是相同的 /因为它是一个快速检查/. 如果逻辑不一致，它可以创造矛盾 - 这是如何发生的

nan

:

>>> [nan] == [nan]

True

>>> /nan,/ == /nan,/

True

教练故事：

问题是在尝试使用

is

比较整数。 不要假设整数的实例是与另一链路上获得的实例相同的实例。 这个故事解释了原因。

评论员有一个代码，依赖于小整数的事实 /经过 -5 到 256 包括的/ 是单身b。 Python, 而不是平等检查。

哇，它会导致一些阴险的错误。 我有某种代码检查 a b, 谁在我想要的时候工作，因为 a 和 b 通常很少。 错误仅发生错误，在六个月的工作之后，因为 a 和 b 它终于足够大，不能缓存。 - 短裙

它在开发过程中工作。 也许几个单位的测试通过了。

他在生产中工作 - 直到代码检查了整个数字 256, 而在那一刻，他在生产中没有失败。

这是一种生产故障，可以在检查代码或可能使用样式检查时检测到。

让我强调：

==

确定值是否相等，并且

is

确定它们是否是相同的对象。

什么是有什么区别

is

和

==

?

==

和

is

- 这是不同的比较！ 因为其他人已经说过：

==

比较对象的对象。

is

比较对象的链接。

在 Python 名称例如，在这种情况下引用对象

value1

和

value2

请参阅副本

int

, 商店价值

1000

:

value1 = 1000

value2 = value1

https://i.stack.imgur.com/WLzXy.png
因为

value2

指的是相同的对象

is

, 和

==

灰尘

True

:

>>> value1 == value2

True

>>> value1 is value2

True

在以下示例名称中

value1

和

value2

属于不同的实例

int

, 即使两者都存储相同的整数：

>>> value1 = 1000

>>> value2 = 1000

https://i.stack.imgur.com/IJgBI.png
由于相同的价值 /整数/ 储存

==

将

True

, 所以它经常被称为 "value comparison". 但

is

多窝白

False

, 因为这些是不同的对象：

>>> value1 == value2

True

>>> value1 is value2

False

何时和何时使用？

通常，

is

- 它是更快的比较。 这就是为什么 CPython c /或者也许最好使用

再次

/ 某些对象，例如小整数，一些线等，但它应该被视为

实施细节

, 哪个行 /即使它不太可能/ 在没有警告的情况下随时更改。

你必须

只使用

is

,

如果你：

需要检查两个对象是否真的是相同的对象 /而不仅仅是一样的 "value"/. 可能是一个例子

使用对象 singleton 作为一个常数。

需要将该值与其进行比较
https://docs.python.org/library/constants.html
Python . 常数B. Python 是：

None

True

1

False

1

NotImplemented

Ellipsis

__debug__

班级 /例如，

int is int

或者

int is float

/

嵌入式模块或第三方模块中可能存在额外的常量。 例如
https://docs.scipy.org/doc/num ... asked
来自模块 NumPy/


在

您必须使用的任何其他情况

==

验证平等。

我可以设置行为吗？

还有另一个方面

==

, 哪个在其他答案中未提及：这是部分
https://docs.python.org/3/refe ... model
. 这意味着他的行为可以使用该方法配置。
https://docs.python.org/refere ... _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__

, 如果你想 "more", 而不仅仅是比较用户类的链接！

另一方面，您无法配置检查

is

. 他将永远比较

只要

如果您具有相同的链接。

这些比较是否总是返回逻辑值？

只要

__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

或者检查总会回来 !

1

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

通常，您不应该进行任何支票

is True

或者

is False

, 因为通常是这些 "checks" 用于隐式转换的上下文中使用

健康）状况

在逻辑上 /例如，在运营商中

if

/. 比较

is True

和

隐式逻辑铸造使得更多的工作不仅仅是执行逻辑 - 你把自己限制在布尔数字 /什么不被视为pythonic/.

如何 PEP8 提到：

不要将逻辑值与逻辑值进行比较

True

或者

False

, 使用

==

.

Yes: if greeting:

No: if greeting == True:

Worse: if greeting is True:

他们

完全不同

.

is

检查对象的身份

==

检查平等 /依赖于两个操作数类型的概念/.

这只是一个幸福的巧合 "

is

", 似乎它与小整数正确合作。 /例如， 5 == 4+1/. 这是因为
https://docs.python.org/2/c-ap ... mLong
. 此行为完全取决于实现，不保证保护所有类型的次要变革操作。

例如， 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/librar ... isons

is

人格识别测试

==

对平等的测试

每个人 /小的/ 整个值与一个值进行比较，所以全部 3 相同且等于。 但是，这是实现的详细信息，而不是语言规范的一部分

你的答案是忠诚的。 操作员

is

比较两个对象的身份。 操作员

==

比较两个对象的值。

物体的身份永远不会在创建后改变; 您可以将其视为内存中的对象地址。

您可以通过定义方法来控制对象对象的比较的行为

__cmp__

或者
https://docs.python.org/refere ... ation
, 如

__eq__

.

看看堆栈溢出的问题
https://coderoad.ru/306313/
数字 .

它主要减少到这一事实 "

is

" 检查它们是否是相同的对象，而不仅仅相互等于对象 /低于256以下的数字是一个特例/.

简而言之，

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

正如John Feminella说，大多数时候你都会使用 = = 和 != 因为你的目标是比较价值。 我只是想对你做的事情进行分类 rest 时间：

有一个且只有一个副本 NoneType, 即，他们都不是 singleton. 所以，

foo == None

和

foo is None

意思是同样的事情。 但是，测试

is

更快，更新“公约即可使用

foo is None

.

如果您从事一些自我分析或携带垃圾收集或检查您的自定义小工具是否适用于Interc行或类似的东西，您可能有一个先例

foo

is

bar

.

True 和 False 还 /现在/ 是单身，但是为

foo == True

而对于

foo is True

没有先例使用 .

Python 差差 is 和 equals/==/

操作员 is 它看起来与平等运营商相同
这不是一回事。

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.

大多数人已经回答了这个问题。 就像额外的纸币一样 /根据我的理解和实验，但不是来自一个记录的来源/, 陈述

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

从上面的答案应该如下阅读：

== 如果变量引用的对象等于并属于一种类型 / 班级
.

我基于以下测试得出了这个结论：

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/

这里列表和皮层的内容是相同的，但类型 / 班级各种各样。

由于此帖子中的其他人在这个问题上详细响应，我想

强调

主要是比较

is

和

==

一段时间

, 哪个可以给出不同的结果，我会呼吁程序员仔细使用它们。

要比较字符串，请务必使用

==

反而

is

:

str = 'hello'

if /str is 'hello'/:

 print /'str is hello'/

if /str == 'hello'/:

 print /'str == hello'/

的：

str is hello

str == hello

但

在下面的例子中

==

和

is

会得到不同的结果：

str = 'hello sam'

 if /str is 'hello sam'/:

 print /'str is hello sam'/

 if /str == 'hello sam'/:

 print /'str == hello sam'/

的：

str == hello sam

输出

:

使用

is

小心比较字符串