Python 为什么使用'=='；或'；是'；有时会产生不同的结果？

我有一个Python程序，其中两个变量被设置为值

“public”

。在条件表达式中，比较

var1是var2

，但如果将其更改为

var1==var2

，则返回

True

现在，如果我打开Python解释器并进行相同的“是”比较，它就会成功

>>> s1 = 'public'
>>> s2 = 'public'
>>> s2 is s1
True

---

这里我遗漏了什么？

关键字是对对象身份的测试，而

=

是一个值比较

---

如果使用

is

，则当且仅当对象是同一对象时，结果才为真。但是，只要对象的值相同，

=

就会为真。

is关键字是对对象标识的测试，而

=

是值比较

---

如果使用

is

，则当且仅当对象是同一对象时，结果才为真。但是，只要对象的值相同，

=

就会为真。

我认为这与以下事实有关：当“is”比较结果为false时，使用两个不同的对象。如果它的计算结果为true，这意味着它在内部使用相同的对象，而不是创建新对象，这可能是因为您在大约2秒的时间内创建了它们，并且由于优化和使用同一对象之间没有很大的时间间隔

这就是为什么您应该使用相等运算符

==

，而不是

is

，来比较字符串对象的值

>>> s = 'one'
>>> s2 = 'two'
>>> s is s2
False
>>> s2 = s2.replace('two', 'one')
>>> s2
'one'
>>> s2 is s
False
>>> 

---

在本例中，我创建了s2，它是一个不同的字符串对象，以前等于'one'，但它与

s

不是同一个对象，因为解释器没有使用相同的对象，因为我最初没有将它分配给'one'，如果我有它，它会使它们成为相同的对象。

我认为这与以下事实有关：，当“is”比较的计算结果为false时，将使用两个不同的对象。如果它的计算结果为true，这意味着它在内部使用相同的对象，而不是创建新对象，这可能是因为您在大约2秒的时间内创建了它们，并且由于优化和使用同一对象之间没有很大的时间间隔

这就是为什么您应该使用相等运算符

==

，而不是

is

，来比较字符串对象的值

>>> s = 'one'
>>> s2 = 'two'
>>> s is s2
False
>>> s2 = s2.replace('two', 'one')
>>> s2
'one'
>>> s2 is s
False
>>> 

---

在本例中，我创建了s2，它是一个不同的字符串对象，以前等于'one'，但它与

s

不是同一个对象，因为解释器没有使用同一个对象，因为我最初没有将它分配给'one'，如果我有，它会使它们成为同一个对象。

is

是身份测试，

=

是平等性测试。在解释器中将模拟代码中发生的情况，如下所示：

>>> a = 'pub'
>>> b = ''.join(['p', 'u', 'b'])
>>> a == b
True
>>> a is b
False

难怪他们不一样，对吧

---

换句话说：

a是b

相当于

id（a）==id（b）

是身份测试，
==
是平等测试。在解释器中将模拟代码中发生的情况，如下所示：

>>> a = 'pub'
>>> b = ''.join(['p', 'u', 'b'])
>>> a == b
True
>>> a is b
False

难怪他们不一样，对吧

换句话说：
a is b
相当于
id（a）==id（b）
根据我对python有限的经验，
is
用于比较两个对象，以确定它们是否是相同的对象，而不是具有相同值的两个不同对象<代码>=

用于确定值是否相同

下面是一个很好的例子：

>>> s1 = u'public'
>>> s2 = 'public'
>>> s1 is s2
False
>>> s1 == s2
True

---

s1

是unicode字符串，

s2

是普通字符串。它们不是相同的类型，而是相同的值。

根据我对python有限的经验，

is

用于比较两个对象，看看它们是否是相同的对象，而不是具有相同值的两个不同对象<代码>=用于确定值是否相同

下面是一个很好的例子：

>>> s1 = u'public'
>>> s2 = 'public'
>>> s1 is s2
False
>>> s1 == s2
True

---

s1

是unicode字符串，

s2

是普通字符串。它们不是相同的类型，而是相同的值。

我相信这就是所谓的“内部”字符串。Python也这样做，java也是如此，编译时，C和C++也是这样的。 如果您使用两个相同的字符串，那么所有具有相同内容的插入字符串都指向相同的内存，而不是通过创建两个字符串对象来浪费内存

这导致Python“is”操作符返回True，因为两个具有相同内容的字符串指向同一个字符串对象。这在Java和C中也会发生

---

不过，这只对节省内存有用。您不能依赖它来测试字符串的相等性，因为各种解释器、编译器和JIT引擎不能总是这样做。

我相信这就是所谓的“内部”字符串。Python也这样做，java也是如此，编译时，C和C++也是这样的。 如果您使用两个相同的字符串，那么所有具有相同内容的插入字符串都指向相同的内存，而不是通过创建两个字符串对象来浪费内存

这导致Python“is”操作符返回True，因为两个具有相同内容的字符串指向同一个字符串对象。这在Java和C中也会发生

---

不过，这只对节省内存有用。您不能依靠它来测试字符串是否相等，因为各种解释器、编译器和JIT引擎都不能始终做到这一点。

这里的其他答案是正确的：

is

用于标识比较，而

=

用于相等比较。因为您关心的是相等（两个字符串应该包含相同的字符），所以在这种情况下，

is

运算符完全错误，您应该使用

==

is

以交互方式工作的原因是（大多数）字符串文本默认为。Fr

class Person(object):
   def __init__(self, name, age):
       self.name = name
       self.age = age

   def __eq__(self, other):
       return self.name == other.name and self.age == other.age

jack1 = Person('Jack', 23)
jack2 = Person('Jack', 23)

jack1 == jack2 # True
jack1 is jack2 # False

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

>>> a = 'banana'
>>> b = 'banana'
>>> a is b
True

>>> a = 'a longer banana'
>>> b = 'a longer banana'
>>> a == b, a is b
(True, False)

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

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