为什么使用'=='或'is'比较字符串有时会产生不同的结果？

Question

我有一个Python程序,其中两个变量设置为该值'public'.在条件表达式中,我的比较var1 is var2失败了,但是如果我将其更改为var1 == var2它则返回True.

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

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

我在这里错过了什么？

Answer 1

is是身份测试,==是平等测试.您的代码中会发生什么,将在解释器中模拟如下:

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

所以,难怪他们不一样,对吧？

换句话说:is是id(a) == id(b)

Answer 2

这里的其他答案是正确的:is用于身份比较,同时==用于相等比较.因为你关心的是相等(两个字符串应该包含相同的字符),在这种情况下,is操作符是完全错误的,你应该使用它==.

原因is工程交互是(最)字符串文字拘留默认.来自维基百科:

Interned字符串加速字符串比较,这有时是应用程序(例如编译器和动态编程语言运行时)中的性能瓶颈,这些应用程序严重依赖于带有字符串键的哈希表.没有实习,检查两个不同的字符串是否相等涉及检查两个字符串的每个字符.由于以下几个原因,这很慢:它本身就是字符串长度的O(n); 它通常需要从几个内存区域读取,这需要时间; 并且读取填满了处理器缓存,这意味着可用于其他需求的缓存更少.对于实习字符串,在原始实习操作之后,简单的对象标识测试就足够了; 这通常实现为指针相等性测试,通常只是一个没有内存引用的机器指令.

因此,当您在程序中有两个字符串文字(字面上键入您的程序源代码,用引号括起来)时,Python编译器将自动实习字符串,使它们都存储在同一个字符串中记忆位置.(请注意,这并不总是会发生,并且发生这种情况的规则非常复杂,因此请不要在生产代码中依赖此行为!)

由于在交互式会话中,两个字符串实际上都存储在同一个内存位置,因此它们具有相同的标识,因此is运算符可以按预期工作.但是,如果你用一些其他的方法创建一个字符串(即使该字符串包含恰好相同的字符),则该字符串可能是相等的,但不是相同的字符串 -也就是说,它有不同的身份,因为它是存储在内存中的不同位置.

Answer 3

该is关键字是对象标识一个测试而==是一个值比较.

如果使用is,当且仅当对象是同一对象时,结果才为真.但是,==只要对象的值相同,就会出现这种情况.

Answer 4

最后要注意的是,您可以使用实习函数来确保您获得对同一字符串的引用:

>>> a = intern('a')
>>> a2 = intern('a')
>>> a is a2
True

如上所述,您可能不应该做的是确定字符串上的相等性.但这可能有助于了解您是否有某种奇怪的要求使用is.

请注意,实习函数已从内置函数转移到sysPython 3 的模块中.

Answer 5

is是身份测试,==是平等测试.这意味着,这is是一种检查两件事情是相同的事情,还是仅仅相同的事情的方法.

假设你有一个简单的person对象.如果它被命名为'杰克'并且是'23'岁,它相当于另一个23岁的杰克,但它不是同一个人.

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

他们的年龄相同,但他们不是同一个人.字符串可能与另一个字符串等效,但它不是同一个对象.

Answer 6

这是一个旁注,但在惯用的python中,你经常会看到如下内容:

if x is None: 
    # some clauses

这是安全的,因为可以保证Null对象的一个​​实例(即None).

Answer 7

如果您不确定自己在做什么,请使用'=='.如果您对此有更多的了解,可以使用'is'作为'None'等已知对象.

否则你最终会想知道为什么事情不起作用以及为什么会这样:

>>> a = 1
>>> b = 1
>>> b is a
True
>>> a = 6000
>>> b = 6000
>>> b is a
False

我甚至不确定在不同的python版本/实现之间是否保证某些东西保持不变.

Answer 8

根据我对python的有限经验,is用于比较两个对象以查看它们是否是相同的对象而不是具有相同值的两个不同对象. ==用于确定值是否相同.

这是一个很好的例子:

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

s1是一个unicode字符串,s2是一个普通的字符串.它们的类型不同,但值相同.

Answer 9

我认为这与以下事实有关:当'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'的相同对象,如果我拥有它会使它们成为同一个对象.

Answer 10

我相信这被称为"实习"字符串.Python可以做到这一点,Java也是如此,在优化模式下进行编译时,C和C++也是如此.

如果使用两个相同的字符串,而不是通过创建两个字符串对象来浪费内存,则所有具有相同内容的实习字符串都指向相同的内存.

这导致Python"is"运算符返回True,因为具有相同内容的两个字符串指向同一个字符串对象.这也将发生在Java和C中.

这仅对节省内存有用.您不能依赖它来测试字符串相等性,因为各种解释器和编译器以及JIT引擎不能总是这样做.

Answer 11

我正在回答这个问题,即使这个问题已经过时了,因为上面的答案没有引用语言参考

实际上是运算符检查标识和==运算符检查是否相等,

来自语言参考:

类型几乎影响对象行为的所有方面.甚至对象标识的重要性在某种意义上也受到影响:对于不可变类型,计算新值的操作实际上可以返回对具有相同类型和值的任何现有对象的引用,而对于可变对象,这是不允许的.例如,在a = 1之后; b = 1,a和b可能会或可能不会引用具有值1的同一对象,具体取决于实现,但在c = []之后; d = [],c和d保证引用两个不同的,唯一的,新创建的空列表.(注意c = d = []将同一个对象分配给c和d.)

所以从上面的语句我们可以推断,当用"is"检查时,不可变类型的字符串可能会失败,并且当用"is"检查时可能检查成功

这同样适用于int,tuple,它们也是不可变类型

Answer 12

该==运营商测试值等价.该is运营商的测试对象标识,Python的测试两者是否真的是同一个对象(即住在内存中的地址相同).

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

在此例如,Python只创建了一个字符串对象,都a和b参照它.原因是Python在内部缓存并重用一些字符串作为优化,在内存中只有一个字符串'banana',由a和b共享; 要触发正常行为,您需要使用更长的字符串:

>>> 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引用一个对象而你指定了b = a,那么两个变量都引用同一个对象:

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

Answer 13

is将比较内存位置。它用于对象级比较。

==将比较程序中的变量。它用于在值级别进行检查。

is 检查地址级别的等效性

== 检查价值水平的等价性