Por que comparar seqüências de caracteres usando '==' ou 'is' às vezes produz um resultado diferente?

Eu tenho um programa Python onde duas variáveis ​​são definidas para o valor 'public'. Em uma expressão condicional, tenho a comparação var1 is var2que falha, mas se eu a alterar, var1 == var2ela retornará True.

Agora, se eu abrir meu interpretador Python e fizer a mesma comparação "is", ele será bem-sucedido.

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

O que estou perdendo aqui?

isé teste de identidade, ==é teste de igualdade. o que acontece no seu código seria emulado no intérprete assim:

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

então, não é de admirar que eles não sejam os mesmos, certo?

Em outras palavras: isé oid(a) == id(b)

Outras respostas aqui estão corretas: isé usada para comparação de identidade , enquanto ==é usada para comparação de igualdade . Como você se preocupa com a igualdade (as duas cadeias devem conter os mesmos caracteres), nesse caso, o isoperador está simplesmente errado e você deve usá-lo ==.

A razão pela qual isfunciona interativamente é que (a maioria) literais de string são internados por padrão. Da Wikipedia:

As cadeias internas aceleram as comparações de cadeias, que às vezes são um gargalo de desempenho em aplicativos (como compiladores e tempos de execução da linguagem de programação dinâmica) que dependem muito de tabelas de hash com chaves de cadeia. Sem internar, verificar se duas cadeias diferentes são iguais envolve examinar todos os caracteres das duas cadeias. Isso é lento por vários motivos: é inerentemente O (n) no comprimento das cadeias; normalmente requer leituras de várias regiões da memória, o que leva tempo; e as leituras preenchem o cache do processador, o que significa que há menos cache disponível para outras necessidades. Com cadeias internas, um teste simples de identidade de objeto é suficiente após a operação interna original; isso geralmente é implementado como um teste de igualdade de ponteiro,

Portanto, quando você tem duas literais de string (palavras que são literalmente digitadas no código-fonte do programa, entre aspas) no programa que possuem o mesmo valor, o compilador Python internará automaticamente as strings, tornando-as armazenadas da mesma forma localização da memória. (Observe que isso nem sempre acontece, e as regras para quando isso acontece são bastante complicadas; portanto, não confie nesse comportamento no código de produção!)

Como na sua sessão interativa, ambas as seqüências são realmente armazenadas no mesmo local de memória, elas têm a mesma identidade , portanto o isoperador trabalha conforme o esperado. Mas se você construir uma string por outro método (mesmo que ela contenha exatamente os mesmos caracteres), a string poderá ser igual , mas não será a mesma string - ou seja, ela terá uma identidade diferente , porque é armazenado em um local diferente na memória.

A ispalavra-chave é um teste para a identidade do objeto, enquanto ==é uma comparação de valores.

Se você usar is, o resultado será verdadeiro se e somente se o objeto for o mesmo objeto. No entanto, ==será verdade sempre que os valores do objeto forem os mesmos.

Uma última coisa a observar, você pode usar a sys.internfunção para garantir que você esteja obtendo uma referência para a mesma string:

>>> from sys import intern
>>> a = intern('a')
>>> a2 = intern('a')
>>> a is a2
True

Como indicado acima, você não deve usar ispara determinar a igualdade de cadeias. Mas isso pode ser útil para saber se você tem algum tipo de requisito estranho de usar is.

Observe que a internfunção costumava ser embutida no Python 2, mas foi movida para o sysmódulo no Python 3.

isé teste de identidade, ==é teste de igualdade. O que isso significa é que isé uma maneira de verificar se duas coisas são iguais ou apenas equivalentes.

Digamos que você tenha um personobjeto simples . Se ele é chamado de 'Jack' e tem '23' anos, é equivalente a outro Jack de 23 anos, mas não é a mesma pessoa.

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

Eles têm a mesma idade, mas não são a mesma instância de pessoa. Uma string pode ser equivalente a outra, mas não é o mesmo objeto.

Esta é uma observação lateral, mas no python idiomático, você verá frequentemente coisas como:

if x is None: 
    # some clauses

Isso é seguro, porque é garantido que haja uma instância do Objeto Nulo (ou seja, Nenhum) .

Se você não tiver certeza do que está fazendo, use o '=='. Se você tiver um pouco mais de conhecimento, poderá usar 'is' para objetos conhecidos como 'None'.

Caso contrário, você acabará se perguntando por que as coisas não funcionam e por que isso acontece:

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

Não tenho certeza se algumas coisas são garantidas para permanecerem iguais entre diferentes versões / implementações do python.

Da minha experiência limitada com python, isé usado para comparar dois objetos para ver se eles são o mesmo objeto, em oposição a dois objetos diferentes com o mesmo valor. ==é usado para determinar se os valores são idênticos.

Aqui está um bom exemplo:

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

s1é uma string unicode e s2é uma string normal. Eles não são do mesmo tipo, mas têm o mesmo valor.

Eu acho que tem a ver com o fato de que, quando a comparação 'é' avaliada como falsa, dois objetos distintos são usados. Se for avaliada como verdadeira, significa que internamente está usando o mesmo objeto exato e não criando um novo, possivelmente porque você os criou em uma fração de 2 segundos ou mais e porque não há um grande intervalo de tempo entre otimizado e usa o mesmo objeto.

É por isso que você deve usar o operador de igualdade ==, não ispara comparar o valor de um objeto de sequência.

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

Neste exemplo, criei s2, que era um objeto de string diferente anteriormente igual a 'one', mas não é o mesmo objeto sporque, porque o intérprete não usou o mesmo objeto que eu não o atribua inicialmente a 'one', se eu tivesse, teria feito do mesmo objeto.

Eu acredito que isso é conhecido como seqüências "internadas". O Python faz isso, o Java e o C e C ++ ao compilar nos modos otimizados.

Se você usar duas cadeias idênticas, em vez de desperdiçar memória criando dois objetos de cadeia, todas as cadeias internas com o mesmo conteúdo apontam para a mesma memória.

Isso resulta no operador Python "is" retornando True, porque duas cadeias com o mesmo conteúdo estão apontando para o mesmo objeto. Isso também acontecerá em Java e em C.

Isso é útil apenas para economia de memória. Você não pode confiar nele para testar a igualdade de cadeias, porque os vários intérpretes e compiladores e mecanismos JIT nem sempre podem fazê-lo.

Estou respondendo à pergunta mesmo que a pergunta seja antiga, porque nenhuma resposta acima cita a referência de idioma

Na verdade, o operador is verifica a identidade e == operador verifica a igualdade,

Referência da linguagem:

Os tipos afetam quase todos os aspectos do comportamento do objeto. Até a importância da identidade do objeto é afetada em algum sentido: para tipos imutáveis, operações que computam novos valores podem realmente retornar uma referência a qualquer objeto existente com o mesmo tipo e valor, enquanto que para objetos mutáveis ​​isso não é permitido . Por exemplo, depois de a = 1; b = 1, aeb pode ou não se referir ao mesmo objeto com o valor um, dependendo da implementação, mas depois de c = []; d = [], c e d são garantidos para se referir a duas listas vazias diferentes, exclusivas e recém-criadas. (Observe que c = d = [] atribui o mesmo objeto a c e d.)

portanto, da declaração acima, podemos inferir que as seqüências de caracteres que são do tipo imutável podem falhar quando marcadas com "é" e podem ser bem-sucedidas quando marcadas com "é"

O mesmo se aplica para int, tupla, que também são tipos imutáveis

A ==equivalência do valor do teste do operador. O isoperador testa a identidade do objeto, o Python testa se os dois são realmente o mesmo objeto (ou seja, vivem no mesmo endereço na memória).

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

Neste exemplo, o Python criou apenas um objeto de string e os dois ae bse refere a ele. O motivo é que o Python armazena e reutiliza internamente algumas seqüências de caracteres como uma otimização; na verdade, existe apenas uma string 'banana' na memória, compartilhada por aeb; Para disparar o comportamento normal, você precisa usar seqüências mais longas:

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

Ao criar duas listas, você obtém dois objetos:

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

Nesse caso, diríamos que as duas listas são equivalentes, porque têm os mesmos elementos, mas não são idênticas, porque não são o mesmo objeto. Se dois objetos são idênticos, eles também são equivalentes, mas se forem equivalentes, não são necessariamente idênticos.

Se ase refere a um objeto e você atribui b = a, as duas variáveis ​​se referem ao mesmo objeto:

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

isirá comparar a localização da memória. É usado para comparação em nível de objeto.

==irá comparar as variáveis ​​no programa. É usado para verificar em um nível de valor.

is verifica a equivalência no nível do endereço

== verifica a equivalência no nível do valor

isé teste de identidade, ==é teste de igualdade (consulte a documentação do Python ).

Na maioria dos casos, se a is b, então a == b. Mas há exceções, por exemplo:

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

Portanto, você só pode usar ispara testes de identidade, nunca para testes de igualdade.