【发布时间】：2011-04-12 17:20:24
【问题描述】：
我很惊讶
[] is not []
评估为True。
这段代码发生了什么？ not 和 is 语句到底在做什么？
【问题讨论】：
标签： python
【发布时间】：2011-04-12 17:20:24
【问题描述】：
a is not b 是一个特殊的运算符，相当于not a is b。
如果 a 和 b 绑定到同一个对象，则运算符 a is b 返回 True，否则返回 False。当您创建两个空列表时，您会得到两个不同的对象，因此 is 返回 False（因此 is not 返回 True）。
【讨论】：
-
如果 a 和 b 是同一个对象 - 我希望 绑定到同一个对象 更好。
is是身份比较。
== 是相等比较。
您的陈述是制作两个不同的列表并检查它们是否是同一个实例，而实际上它们不是。如果您使用==，它将返回 true，因为它们都是空列表。
【讨论】：
描述为什么会发生的最好方法是：
这是你的例子
>>> x = []
>>> y = []
>>> print(x is y)
... False
x和y其实是两个不同的列表，所以如果你给x加点东西，y里面就不会出现了
>>> x.append(1)
>>> print(x)
... [1]
>>> print(y)
... []
那么我们如何让 (x is y) 评估为真？
>>> x = []
>>> y = x
>>> print(x is y)
... True
>>> x.append(10)
>>> print(x)
... [10]
>>> print(y)
... [10]
>>> print(x is y)
... True
如果你想看看两个列表是否有相同的内容...
>>> x = []
>>> y = []
>>> print(x == y)
... True
>>> x.append(21)
>>> print(x)
... [21]
>>> print(y)
... []
>>> print(x == y)
... False
>>> y = [21]
>>> print(x == y)
... True
【讨论】：
-
很好的答案，但是，在阅读 Python 参考中的this 之后，我感到困惑：由于自动垃圾收集、空闲列表和描述符的动态特性，您可能会注意到 is 运算符的某些使用中看似不寻常的行为，例如涉及实例方法或常量之间的比较。
-
"..所以如果你向 x 添加一些东西，它不会出现在 y" - 这对我来说似乎是错误的。试试
a="test";b="test";a is b。它会给你True，即使改变一个不会改变另一个。 -
@Pithikos 这是因为您正在使用的特定 python 版本中的优化，这不是保证。此外，字符串是不可变的，因此您无法更改其中一个值。您只能将新字符串分配给同一个变量。
is 表示是同一个实例。如果运算符两侧的变量指向同一个对象，则计算结果为 true，否则为 false。
Reference，靠近底部。
【讨论】：
是检查身份。 [] 和 [] 是两个不同（但等效）的列表。如果要检查两个列表是否为空，可以使用它们的真值（空字符串、集合和零为 false）。
if not ([] and []):
print 'Spanish Inquisition'
is 保证返回 True 的唯一时间是单例，例如 None。与 Highlander 一样，您的程序中只能有一个 None 实例 - 每次您返回 None 时，它与您键入 print None 时引用的 none 完全相同。
[], OTOH，不保证是空列表，并且在布尔上下文中评估为 False。
【讨论】：
-
a = b。我相信我们现在可以保证a is b. -
@recursive，你知道字符串/数字是不是这样？
-
据我所知，一切都是如此。在 python 中将
b分配给a时，您将a分配为对b当前引用的对象的引用。所以他们的身份将是相同的。它是 python，所以可能会做一些奇怪的事情，比如覆盖赋值来打破这个，但总的来说，我会说是的。 -
我想这是有道理的 - 并且与
a = "hi"; b = "hi"不同，is的行为除了返回 True 或 False 之外不保证。 -
当我执行这个
[] and []的结果是[]...这是什么意思？
我知道我正在发布一个相当老的帖子。但是，这可能会帮助像我这样偶然发现的人。
“is”检查内存地址是否相同，而“==”检查值是否相同。从下面的例子中会很清楚
我们先说不可变对象，因为它很容易理解
# could be any immutable object
immutable_a = 10
immutable_b = 10
# prints address of a and b variable
print "address of a is %s" % id(immutable_a)
print "address of a is %s" % id(immutable_b)
# as both addresses is same, following shall be true
print immutable_a is immutable_b
# as the values are also same, following shall be true as well
print immutable_a == immutable_b
现在让我们谈谈可变对象
# could be any mutable object
mutable_a = [10]
mutable_b = [10]
# prints address of a and b variable
print "address of mutable_a is %s" % id(mutable_a)
print "address of mutable_b is %s" % id(mutable_b)
# as addresses are not same, following shall be false
print mutable_a is mutable_b
# as the values are same, following shall be true
print mutable_a == mutable_b
【讨论】：
@Jiaaro 是对的。将is 与不可变数据类型一起使用是危险的，因为由于 Python 解释器优化，它是不可预测的。
看这个例子：
10 * "a" is 10 * "a" # True
100 * "a" is 100 * "a" # False
在第二行中，为解释器创建一个具有新 id 的新对象会更快。因此，请仅对可变类型使用 is 运算符。
【讨论】：