Comprender el operador "es" de Python

El isoperador no coincide con los valores de las variables, sino con las propias instancias.

que significa realmente?

Declaro dos variables nombradas xy yasignando los mismos valores en ambas variables, pero devuelve falso cuando uso el isoperador.

Necesito una aclaración. Aquí está mi código.

x = [1, 2, 3]
y = [1, 2, 3]

print(x is y)  # It prints false!

No entendiste lo isque prueba el operador. Prueba si dos variables apuntan al mismo objeto , no si dos variables tienen el mismo valor.

De la documentación para el isoperador :

Los operadores isy la is notprueba de identidad del objeto: x is yes verdadero si y solo si xy yson el mismo objeto.

Utilice el ==operador en su lugar:

print(x == y)

Esto imprime True. xy yson dos listas separadas :

x[0] = 4
print(y)  # prints [1, 2, 3]
print(x == y)   # prints False

Si usa la id()función , verá eso xy ytendrá diferentes identificadores:

>>> id(x)
4401064560
>>> id(y)
4401098192

pero si se va a asignar ya xcontinuación, ambos apuntan al mismo objeto:

>>> x = y
>>> id(x)
4401064560
>>> id(y)
4401064560
>>> x is y
True

y ismuestra que ambos son el mismo objeto, regresa True.

Recuerde que en Python, los nombres son solo etiquetas que hacen referencia a valores ; puede hacer que varios nombres apunten al mismo objeto. isle dice si dos nombres apuntan a un mismo objeto. ==le dice si dos nombres se refieren a objetos que tienen el mismo valor.

Otro duplicado preguntaba por qué dos cadenas iguales generalmente no son idénticas, lo que realmente no se responde aquí:

>>> x = 'a' 
>>> x += 'bc'
>>> y = 'abc'
>>> x == y
True
>>> x is y
False

Entonces, ¿por qué no son la misma cadena? Especialmente dado esto:

>>> z = 'abc'
>>> w = 'abc'
>>> z is w
True

Dejemos la segunda parte por un momento. ¿Cómo podría ser cierto el primero?

El intérprete tendría que tener una "tabla interna", una tabla que mapee valores de cadena a objetos de cadena, por lo que cada vez que intente crear una nueva cadena con el contenido 'abc', obtendrá el mismo objeto. Wikipedia tiene una discusión más detallada sobre cómo funciona la pasantía.

Y Python tiene una mesa de prácticas de cadenas; puede internar cadenas manualmente con el sys.internmétodo.

De hecho, Python puede internar automáticamente cualquier tipo inmutable, pero no está obligado a hacerlo. Diferentes implementaciones incorporarán diferentes valores.

CPython (la implementación que estás usando si no sabes qué implementación estás usando) auto-interna enteros pequeños y algunos singleton especiales como False, pero no cadenas (o enteros grandes, o tuplas pequeñas, o cualquier otra cosa). Puedes ver esto con bastante facilidad:

>>> a = 0
>>> a += 1
>>> b = 1
>>> a is b
True
>>> a = False
>>> a = not a
>>> b = True
a is b
True
>>> a = 1000
>>> a += 1
>>> b = 1001
>>> a is b
False

OK, pero ¿por qué eran zy weran idénticos?

Ese no es el intérprete que interviene automáticamente, son los valores de plegado del compilador.

Si la misma cadena en tiempo de compilación aparece dos veces en el mismo módulo (lo que exactamente significa esto es difícil de definir, que no es lo mismo que un literal de cadena, porque r'abc', 'abc'y 'a' 'b' 'c'son todas diferentes literales, pero la misma cadena, pero fácil de entender intuitivamente), el compilador solo creará una instancia de la cadena, con dos referencias.

De hecho, el compilador puede ir aún más lejos: el optimizador 'ab' + 'c'puede convertirlo a 'abc', en cuyo caso se puede plegar junto con una 'abc'constante en el mismo módulo.

Nuevamente, esto es algo que Python está permitido pero no está obligado a hacer. Pero en este caso, CPython siempre pliega cadenas pequeñas (y también, por ejemplo, tuplas pequeñas). (Aunque el compilador declaración por declaración del intérprete interactivo no ejecuta la misma optimización que el compilador módulo a la vez, no verá exactamente los mismos resultados de forma interactiva).

Entonces, ¿qué debe hacer al respecto como programador?

Pues nada. Casi nunca tienes motivos para preocuparte si dos valores inmutables son idénticos. Si desea saber cuándo puede usar en a is blugar de a == b, está haciendo la pregunta incorrecta. Solo utilícelo siempre, a == bexcepto en dos casos:

• Para comparaciones más legibles con los valores singleton como x is None.
• Para valores mutables, cuando necesite saber si la mutación xafectará al y.

issolo devuelve verdadero si en realidad son el mismo objeto. Si fueran iguales, también aparecería un cambio en uno en el otro. He aquí un ejemplo de la diferencia.

>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> print x is y
False
>>> z = y
>>> print y is z
True
>>> print x is z
False
>>> y[0] = 5
>>> print z
[5, 2, 3]

A raíz de una pregunta duplicada , esta analogía podría funcionar:

# - Darling, I want some pudding!
# - There is some in the fridge.

pudding_to_eat = fridge_pudding
pudding_to_eat is fridge_pudding
# => True

# - Honey, what's with all the dirty dishes?
# - I wanted to eat pudding so I made some. Sorry about the mess, Darling.
# - But there was already some in the fridge.

pudding_to_eat = make_pudding(ingredients)
pudding_to_eat is fridge_pudding
# => False

isy is notson los dos operadores de identidad en Python. isEl operador no compara los valores de las variables, sino que compara las identidades de las variables. Considera esto:

>>> a = [1,2,3]
>>> b = [1,2,3]
>>> hex(id(a))
'0x1079b1440'
>>> hex(id(b))
'0x107960878'
>>> a is b
False
>>> a == b
True
>>>

El ejemplo anterior muestra que la identidad (también puede ser la dirección de memoria en Cpython) es diferente para ambos ay b(aunque sus valores son los mismos). Es por eso que cuando dice a is bque devuelve falso debido a la falta de coincidencia en las identidades de ambos operandos. Sin embargo, cuando dice a == b, devuelve verdadero porque la ==operación solo verifica si ambos operandos tienen el mismo valor asignado.

Ejemplo interesante (para la nota extra):

>>> del a
>>> del b
>>> a = 132
>>> b = 132
>>> hex(id(a))
'0x7faa2b609738'
>>> hex(id(b))
'0x7faa2b609738'
>>> a is b
True
>>> a == b
True
>>>

En el ejemplo anterior, aunque ay bson dos variables diferentes, se a is bdevolvió True. Esto se debe a que el tipo de aes intque es un objeto inmutable. Entonces, Python (supongo que para ahorrar memoria) asignó el mismo objeto a bcuando se creó con el mismo valor. Entonces, en este caso, las identidades de las variables coincidieron y a is bresultaron ser True.

Esto se aplicará a todos los objetos inmutables:

>>> del a
>>> del b
>>> a = "asd"
>>> b = "asd"
>>> hex(id(a))
'0x1079b05a8'
>>> hex(id(b))
'0x1079b05a8'
>>> a is b
True
>>> a == b
True
>>>

Espero que ayude.

x is yes lo mismo que id(x) == id(y)comparar la identidad de los objetos.

Como @ tomasz-kurgan señaló en el comentario a continuación, el isoperador se comporta de manera inusual con ciertos objetos.

P.ej

>>> class A(object):
...   def foo(self):
...     pass
... 
>>> a = A()
>>> a.foo is a.foo
False
>>> id(a.foo) == id(a.foo)
True

Árbitro;
https://docs.python.org/2/reference/expressions.html#is-not
https://docs.python.org/2/reference/expressions.html#id24

Como puede comprobar aquí a pequeños enteros. Los números por encima de 257 no son entradas pequeñas, por lo que se calcula como un objeto diferente.

Es mejor usar ==en su lugar en este caso.

Más información está aquí: http://docs.python.org/2/c-api/int.html

X apunta a una matriz, Y apunta a una matriz diferente. Esas matrices son idénticas, pero el isoperador observará esos punteros, que no son idénticos.

Compara la identidad del objeto, es decir, si las variables se refieren al mismo objeto en la memoria. Es como ==en Java o C (al comparar punteros).

Un ejemplo sencillo con frutas

fruitlist = [" apple ", " banana ", " cherry ", " durian "]
newfruitlist = fruitlist
verynewfruitlist = fruitlist [:]
print ( fruitlist is newfruitlist )
print ( fruitlist is verynewfruitlist )
print ( newfruitlist is verynewfruitlist )

Salida:

True
False
False

Si intentas

fruitlist = [" apple ", " banana ", " cherry ", " durian "]
newfruitlist = fruitlist
verynewfruitlist = fruitlist [:]
print ( fruitlist == newfruitlist )
print ( fruitlist == verynewfruitlist )
print ( newfruitlist == verynewfruitlist )

La salida es diferente:

True
True
True

Eso es porque el operador == compara solo el contenido de la variable. Para comparar las identidades de 2 variables use el operador is

Para imprimir el número de identificación:

print ( id( variable ) )

El isoperador no es más que una versión en inglés de ==. Debido a que los ID de las dos listas son diferentes, la respuesta es falsa. Puedes probar:

a=[1,2,3]
b=a
print(b is a )#True

* Porque las ID de ambas listas serían las mismas