Comprendre l'opérateur «est» de Python

L' isopérateur ne correspond pas aux valeurs des variables, mais aux instances elles-mêmes.

Qu'est-ce que cela signifie vraiment?

J'ai déclaré deux variables nommées xet yaffectant les mêmes valeurs dans les deux variables, mais cela renvoie false lorsque j'utilise l' isopérateur.

J'ai besoin d'une clarification. Voici mon code.

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

print(x is y)  # It prints false!

Vous avez mal compris ce que isteste l' opérateur. Il teste si deux variables pointent sur le même objet , pas si deux variables ont la même valeur.

À partir de la documentation pour l' isopérateur :

Les opérateurs iset is nottest pour l'identité d'objet: x is yest vrai si et seulement si xet ysont le même objet.

Utilisez ==plutôt l' opérateur:

print(x == y)

Cela imprime True. xet ysont deux listes distinctes :

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

Si vous utilisez la id()fonction, vous verrez cela xet yaurez des identifiants différents:

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

mais si vous deviez attribuer yà xalors les deux pointent vers le même objet:

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

et ismontre que les deux sont le même objet, il retourne True.

N'oubliez pas qu'en Python, les noms ne sont que des étiquettes référençant des valeurs ; vous pouvez faire pointer plusieurs noms vers le même objet. isvous indique si deux noms pointent vers un seul et même objet. ==vous indique si deux noms font référence à des objets qui ont la même valeur.

Un autre doublon demandait pourquoi deux chaînes égales ne sont généralement pas identiques, ce qui n'est pas vraiment répondu ici:

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

Alors, pourquoi ne sont-ils pas la même chaîne? Surtout compte tenu de ceci:

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

Retardons un peu la deuxième partie. Comment le premier pourrait-il être vrai?

L'interpréteur devrait avoir une "table interne", une table mappant des valeurs de chaîne à des objets de chaîne, donc chaque fois que vous essayez de créer une nouvelle chaîne avec le contenu 'abc', vous récupérez le même objet. Wikipedia a une discussion plus détaillée sur le fonctionnement du stage.

Et Python a une table interne de chaînes; vous pouvez manuellement interner des chaînes avec la sys.internméthode.

En fait, Python est autorisé à interner automatiquement tous les types immuables, mais pas obligé de le faire. Différentes implémentations intègreront différentes valeurs.

CPython (l'implémentation que vous utilisez si vous ne savez pas quelle implémentation vous utilisez) auto-interne de petits entiers et certains singletons spéciaux comme False, mais pas des chaînes (ou de grands entiers, ou de petits tuples, ou autre chose). Vous pouvez voir cela assez facilement:

>>> 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, mais pourquoi étaient zet widentiques?

Ce n'est pas l'interpréteur qui effectue automatiquement l'internation, ce sont les valeurs de repli du compilateur.

Si la même chaîne de compilation apparaît deux fois dans le même module (ce que cela signifie exactement est difficile à définir, ce n'est pas la même chose comme un littéral de chaîne, parce que r'abc', 'abc'et 'a' 'b' 'c'sont toutes différentes littéraux , mais la même chaîne, mais facile à comprendre intuitivement), le compilateur ne créera qu'une seule instance de la chaîne, avec deux références.

En fait, le compilateur peut aller encore plus loin: 'ab' + 'c'peut être converti en 'abc'par l'optimiseur, auquel cas il peut être plié avec une 'abc'constante dans le même module.

Encore une fois, c'est quelque chose que Python est autorisé mais pas obligé de faire. Mais dans ce cas, CPython plie toujours de petites chaînes (et aussi, par exemple, de petits tuples). (Bien que le compilateur instruction par instruction de l'interpréteur interactif n'exécute pas la même optimisation que le compilateur module à la fois, vous ne verrez donc pas exactement les mêmes résultats de manière interactive.)

Alors, que devez-vous faire à ce sujet en tant que programmeur?

Eh bien… rien. Vous n'avez presque jamais aucune raison de vous soucier si deux valeurs immuables sont identiques. Si vous voulez savoir quand vous pouvez utiliser à la a is bplace de a == b, vous posez la mauvaise question. Il suffit de toujours utiliser a == bsauf dans deux cas:

• Pour des comparaisons plus lisibles avec les valeurs de singleton comme x is None.
• Pour les valeurs mutables, lorsque vous avez besoin de savoir si la mutation xaffectera le y.

isne renvoie true que s'il s'agit en fait du même objet. S'ils étaient identiques, un changement dans l'un apparaîtrait également dans l'autre. Voici un exemple de la différence.

>>> 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]

Invité par une question en double , cette analogie pourrait fonctionner:

# - 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

iset is notsont les deux opérateurs d'identité en Python. isL'opérateur ne compare pas les valeurs des variables, mais compare les identités des variables. Considère ceci:

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

L'exemple ci-dessus vous montre que l'identité (peut également être l'adresse mémoire en Cpython) est différente pour les deux aet b(même si leurs valeurs sont identiques). C'est pourquoi lorsque vous dites a is bqu'il renvoie false en raison de la non-concordance dans les identités des deux opérandes. Cependant, lorsque vous dites a == b, il renvoie true car l' ==opération vérifie uniquement si les deux opérandes ont la même valeur qui leur est attribuée.

Exemple intéressant (pour le grade supplémentaire):

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

Dans l'exemple ci-dessus, même si aet bsont deux variables différentes, a is brenvoyées True. C'est parce que le type de aest intqui est un objet immuable. Donc, python (je suppose pour économiser de la mémoire) a alloué le même objet à bsa création avec la même valeur. Donc, dans ce cas, les identités des variables correspondaient et a is bse sont avérées être True.

Cela s'appliquera à tous les objets immuables:

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

J'espère que cela pourra aider.

x is yest identique à la id(x) == id(y)comparaison de l'identité des objets.

Comme @ tomasz-kurgan l'a souligné dans le commentaire ci-dessous, l' isopérateur se comporte de manière inhabituelle avec certains objets.

Par exemple

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

Réf;
https://docs.python.org/2/reference/expressions.html#is-not
https://docs.python.org/2/reference/expressions.html#id24

Comme vous pouvez le vérifier ici à un petit nombre entier. Les nombres supérieurs à 257 ne sont pas de petits nombres, ils sont donc calculés comme un objet différent.

Il est préférable d'utiliser à la ==place dans ce cas.

Plus d'informations ici: http://docs.python.org/2/c-api/int.html

X pointe vers un tableau, Y pointe vers un autre tableau. Ces tableaux sont identiques, mais l' isopérateur examinera ces pointeurs, qui ne sont pas identiques.

Il compare l'identité de l'objet, c'est-à-dire si les variables font référence au même objet en mémoire. C'est comme ==dans Java ou C (en comparant les pointeurs).

Un exemple simple avec des fruits

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

Production:

True
False
False

Si tu essayes

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

La sortie est différente:

True
True
True

C'est parce que l'opérateur == compare uniquement le contenu de la variable. Pour comparer les identités de 2 variables, utilisez l' opérateur is

Pour imprimer le numéro d'identification:

print ( id( variable ) )

L' isopérateur n'est rien d'autre qu'une version anglaise de ==. Parce que les ID des deux listes sont différents, la réponse est fausse. Tu peux essayer:

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

* Parce que les identifiants des deux listes seraient les mêmes