Y a-t-il une différence entre «foo is None» et «foo == None»?

Y a-t-il une différence entre:

if foo is None: pass

et

if foo == None: pass

La convention que j'ai vue dans la plupart du code Python (et le code que j'écris moi-même) est la première, mais j'ai récemment rencontré du code qui utilise la seconde. Aucun n'est une instance (et la seule instance, IIRC) de NoneType, donc cela ne devrait pas avoir d'importance, non? Y a-t-il des circonstances dans lesquelles cela pourrait se produire?

isrenvoie toujours Trues'il compare la même instance d'objet

Alors que ==est finalement déterminé par la __eq__()méthode

c'est à dire

>>> class Foo(object):
       def __eq__(self, other):
           return True

>>> f = Foo()
>>> f == None
True
>>> f is None
False

Vous voudrez peut-être lire l' identité et l'équivalence de cet objet .

L'instruction «est» est utilisée pour l'identité de l'objet, elle vérifie si les objets se réfèrent à la même instance (même adresse en mémoire).

Et l'instruction '==' fait référence à l'égalité (même valeur).

Un mot d'avertissement:

if foo:
  # do something

N'est pas exactement le même que:

if x is not None:
  # do something

Le premier est un test de valeur booléenne et peut être évalué à faux dans différents contextes. Il y a un certain nombre de choses qui représentent faux dans une valeur booléenne teste par exemple des conteneurs vides, des valeurs booléennes. Aucun n'évalue également faux dans cette situation, mais d'autres choses aussi.

(ob1 is ob2) égal à (id(ob1) == id(ob2))

La raison en foo is Noneest que la méthode préférée est que vous pourriez manipuler un objet qui définit le sien __eq__, et qui définit l'objet comme égal à Aucun. Donc, utilisez toujours foo is Nonesi vous avez besoin de voir si c'est infact None.

Il n'y a pas de différence car les objets identiques seront bien sûr égaux. Cependant, PEP 8 indique clairement que vous devez utiliser is:

Les comparaisons avec des singletons comme None doivent toujours être faites avec is ou is, jamais avec les opérateurs d'égalité.

istests d'identité, pas d' égalité. Pour votre déclaration foo is none, Python compare simplement l'adresse mémoire des objets. Cela signifie que vous posez la question "Ai-je deux noms pour le même objet?"

==d'autre part, teste l'égalité telle que déterminée par la __eq__()méthode. Peu importe l'identité.

In [102]: x, y, z = 2, 2, 2.0

In [103]: id(x), id(y), id(z)
Out[103]: (38641984, 38641984, 48420880)

In [104]: x is y
Out[104]: True

In [105]: x == y
Out[105]: True

In [106]: x is z
Out[106]: False

In [107]: x == z
Out[107]: True

Noneest un opérateur singleton. C'est None is Nonetoujours vrai.

In [101]: None is None
Out[101]: True

Pour None, il ne devrait pas y avoir de différence entre l'égalité (==) et l'identité (is). Le NoneType renvoie probablement l'identité pour l'égalité. Puisque None est la seule instance que vous pouvez faire de NoneType (je pense que c'est vrai), les deux opérations sont les mêmes. Dans le cas d'autres types, ce n'est pas toujours le cas. Par exemple:

list1 = [1, 2, 3]
list2 = [1, 2, 3]
if list1==list2: print "Equal"
if list1 is list2: print "Same"

Cela afficherait "Equal" car les listes ont une opération de comparaison qui n'est pas le retour d'identité par défaut.

@ Jason :

Je recommande d'utiliser quelque chose de plus le long des lignes de

if foo:
    #foo isn't None
else:
    #foo is None

Je n'aime pas utiliser "if foo:" à moins que foo ne représente vraiment une valeur booléenne (c'est-à-dire 0 ou 1). Si foo est une chaîne ou un objet ou quelque chose d'autre, "if foo:" peut fonctionner, mais cela ressemble à un raccourci paresseux pour moi. Si vous vérifiez si x est Aucun, dites "si x est Aucun:".

Quelques détails supplémentaires:

1. La isclause vérifie en fait si les deux objects sont au même emplacement mémoire ou non. c'est-à-dire s'ils pointent tous deux vers le même emplacement mémoire et ont le même id.

2. En conséquence de 1, isassure si oui ou non les deux objects lexicalement représentés ont des attributs identiques (attributs-d'attributs ...) ou non

3. Instanciation des types primitifs comme bool, int, string(à quelques exceptions près), NoneTypeayant une même valeur sera toujours dans le même emplacement mémoire.

Par exemple

>>> int(1) is int(1)
True
>>> str("abcd") is str("abcd")
True
>>> bool(1) is bool(2)
True
>>> bool(0) is bool(0)
True
>>> bool(0)
False
>>> bool(1)
True

Et comme NoneTypeil ne peut y avoir qu'une seule instance de lui-même dans la table de "recherche" du python, le premier et le second sont plus un style de programmation du développeur qui a écrit le code (peut-être pour la cohérence) plutôt que d'avoir une raison logique subtile de choisissez l'un plutôt que l'autre.

La conclusion de John Machin qui Noneest un singleton est une conclusion renforcée par ce code.

>>> x = None
>>> y = None
>>> x == y
True
>>> x is y
True
>>> 

Depuis Noneest un singleton, x == Noneet x is Noneaurait le même résultat. Cependant, à mon avis esthétique,x == None c'est mieux.

a is b # returns true if they a and b are true alias
a == b # returns true if they are true alias or they have values that are deemed equivalence 


a = [1,3,4]
b = a[:] #creating copy of list
a is b # if gives false
False
a == b # gives true
True