¿Por qué comparar cadenas usando '==' o 'es' a veces produce un resultado diferente?

Tengo un programa Python donde dos variables se establecen en el valor 'public'. En una expresión condicional tengo la comparación var1 is var2que falla, pero si la cambio a var1 == var2ella, regresa True.

Ahora, si abro mi intérprete de Python y hago la misma comparación "es", tiene éxito.

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

¿Que me estoy perdiendo aqui?

ises prueba de identidad, ==es prueba de igualdad. lo que sucede en su código se emularía en el intérprete así:

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

así que no es de extrañar que no sean lo mismo, ¿verdad?

En otras palabras: ises elid(a) == id(b)

Otras respuestas aquí son correctas: isse usa para la comparación de identidad , mientras que ==se usa para la comparación de igualdad . Como lo que le importa es la igualdad (las dos cadenas deben contener los mismos caracteres), en este caso, el isoperador simplemente está equivocado y debería usarlo en su ==lugar.

La razón por la que isfunciona de manera interactiva es que (la mayoría) los literales de cadena están internados por defecto. De Wikipedia:

Las cadenas internas aceleran las comparaciones de cadenas, que a veces son un cuello de botella de rendimiento en aplicaciones (como compiladores y tiempos de ejecución de lenguaje de programación dinámico) que dependen en gran medida de tablas hash con claves de cadena. Sin pasantías, comprobar que dos cadenas diferentes son iguales implica examinar cada carácter de ambas cadenas. Esto es lento por varias razones: es inherentemente O (n) en la longitud de las cadenas; normalmente requiere lecturas de varias regiones de memoria, lo que lleva tiempo; y las lecturas llenan el caché del procesador, lo que significa que hay menos caché disponible para otras necesidades. Con cadenas internas, una simple prueba de identidad de objeto es suficiente después de la operación interna original; esto normalmente se implementa como una prueba de igualdad de puntero,

Entonces, cuando tiene dos literales de cadena (palabras que están literalmente escritas en el código fuente de su programa, rodeadas de comillas) en su programa que tienen el mismo valor, el compilador de Python internará automáticamente las cadenas, haciéndolas ambas almacenadas en el mismo ubicación de memoria (Tenga en cuenta que esto no siempre sucede, y las reglas para cuando esto sucede son bastante complicadas, ¡así que no confíe en este comportamiento en el código de producción!)

Dado que en su sesión interactiva ambas cadenas se almacenan en la misma ubicación de memoria, tienen la misma identidad , por lo que el isoperador funciona como se esperaba. Pero si construye una cadena por algún otro método (incluso si esa cadena contiene exactamente los mismos caracteres), entonces la cadena puede ser igual , pero no es la misma cadena , es decir, tiene una identidad diferente , porque es almacenado en un lugar diferente en la memoria.

La ispalabra clave es una prueba de identidad de objeto, mientras que ==es una comparación de valores.

Si lo usa is, el resultado será verdadero si y solo si el objeto es el mismo objeto. Sin embargo, ==será cierto siempre que los valores del objeto sean los mismos.

Una última cosa a tener en cuenta es que puede usar la sys.internfunción para asegurarse de obtener una referencia a la misma cadena:

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

Como se señaló anteriormente, no debe usarse ispara determinar la igualdad de cadenas. Pero esto puede ser útil para saber si tiene algún tipo de requisito extraño para usar is.

Tenga en cuenta que la internfunción solía estar integrada en Python 2 pero se movió al sysmódulo en Python 3.

ises prueba de identidad, ==es prueba de igualdad. Lo que esto significa es que ises una forma de verificar si dos cosas son las mismas , o simplemente equivalentes.

Digamos que tienes un personobjeto simple . Si se llama 'Jack' y tiene '23' años, es equivalente a otro Jack de 23 años, pero no es la misma persona.

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

Son de la misma edad, pero no son la misma instancia de persona. Una cadena puede ser equivalente a otra, pero no es el mismo objeto.

Esta es una nota al margen, pero en Python idiomático, a menudo verá cosas como:

if x is None: 
    # some clauses

Esto es seguro, porque se garantiza que habrá una instancia del Objeto nulo (es decir, Ninguno) .

Si no está seguro de lo que está haciendo, use '=='. Si tiene un poco más de conocimiento al respecto, puede usar 'es' para objetos conocidos como 'Ninguno'.

De lo contrario, terminarás preguntándote por qué las cosas no funcionan y por qué sucede esto:

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

Ni siquiera estoy seguro de que algunas cosas se mantengan igual entre diferentes versiones / implementaciones de Python.

Desde mi experiencia limitada con python, isse utiliza para comparar dos objetos para ver si son el mismo objeto en oposición a dos objetos diferentes con el mismo valor. ==se usa para determinar si los valores son idénticos.

Aquí hay un buen ejemplo:

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

s1es una cadena unicode y s2es una cadena normal. No son del mismo tipo, pero tienen el mismo valor.

Creo que tiene que ver con el hecho de que, cuando la comparación 'es' se evalúa como falsa, se utilizan dos objetos distintos. Si se evalúa como verdadero, eso significa que internamente está usando el mismo objeto exacto y no está creando uno nuevo, posiblemente porque los creó en una fracción de 2 segundos más o menos y porque no hay una gran brecha de tiempo entre está optimizado y usa el mismo objeto

Es por eso que debería usar el operador de igualdad ==, no is, para comparar el valor de un objeto de cadena.

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

En este ejemplo, hice s2, que era un objeto de cadena diferente previamente igual a 'uno' pero no es el mismo objeto que s, porque el intérprete no usó el mismo objeto ya que inicialmente no lo asigné a 'uno', si lo hubiera hecho les habría hecho el mismo objeto.

Creo que esto se conoce como cadenas "internas". Python hace esto, también Java, y también C y C ++ cuando compila en modos optimizados.

Si usa dos cadenas idénticas, en lugar de desperdiciar memoria creando dos objetos de cadena, todas las cadenas internas con el mismo contenido apuntan a la misma memoria.

Esto da como resultado que el operador "is" de Python devuelva True porque dos cadenas con el mismo contenido apuntan al mismo objeto de cadena. Esto también sucederá en Java y en C.

Sin embargo, esto solo es útil para ahorrar memoria. No puede confiar en él para probar la igualdad de cadena, porque los diversos intérpretes y compiladores y motores JIT no siempre pueden hacerlo.

Estoy respondiendo la pregunta a pesar de que la pregunta es demasiado antigua porque ninguna de las respuestas anteriores cita la referencia del idioma

En realidad, el operador verifica la identidad y == el operador verifica la igualdad,

De la referencia del lenguaje:

Los tipos afectan a casi todos los aspectos del comportamiento del objeto. Incluso la importancia de la identidad del objeto se ve afectada en cierto sentido: para los tipos inmutables, las operaciones que calculan nuevos valores en realidad pueden devolver una referencia a cualquier objeto existente con el mismo tipo y valor, mientras que para los objetos mutables esto no está permitido . Por ejemplo, después de a = 1; b = 1, ayb pueden o no referirse al mismo objeto con el valor uno, dependiendo de la implementación, pero después de c = []; d = [], cyd están garantizados para referirse a dos listas vacías diferentes, únicas y recién creadas. (Tenga en cuenta que c = d = [] asigna el mismo objeto a c y d.)

entonces, de la declaración anterior, podemos inferir que las cadenas que son de un tipo inmutable pueden fallar cuando se verifican con "es" y pueden ser exitosas cuando se marcan con "es"

Lo mismo aplica para int, tuple que también son tipos inmutables

La ==equivalencia del valor de prueba del operador. El isoperador prueba la identidad del objeto, Python prueba si los dos son realmente el mismo objeto (es decir, viven en la misma dirección en la memoria).

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

En este ejemplo, Python solo creó un objeto de cadena, y ambos, ay se brefiere a él. La razón es que Python almacena en caché internamente y reutiliza algunas cadenas como una optimización, realmente solo hay una cadena 'banana' en la memoria, compartida por a y b; Para desencadenar el comportamiento normal, debe usar cadenas más largas:

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

Cuando crea dos listas, obtiene dos objetos:

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

En este caso, diríamos que las dos listas son equivalentes, porque tienen los mismos elementos, pero no idénticos, porque no son el mismo objeto. Si dos objetos son idénticos, también son equivalentes, pero si son equivalentes, no son necesariamente idénticos.

Si se arefiere a un objeto y usted lo asigna b = a, ambas variables se refieren al mismo objeto:

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

iscomparará la ubicación de la memoria. Se utiliza para la comparación a nivel de objeto.

==comparará las variables en el programa. Se utiliza para verificar en un nivel de valor.

is comprueba la equivalencia de nivel de dirección

== comprueba la equivalencia de nivel de valor

ises una prueba de identidad, ==es una prueba de igualdad (consulte la documentación de Python ).

En la mayoría de los casos, si a is b, entonces a == b. Pero hay excepciones, por ejemplo:

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

Por lo tanto, solo puede usar ispara pruebas de identidad, nunca pruebas de igualdad.