C'è qualche differenza tra "foo is None" e "foo == None"?

C'è qualche differenza tra:

if foo is None: pass

e

if foo == None: pass

La convenzione che ho visto nella maggior parte del codice Python (e nel codice che scrivo io stesso) è la prima, ma di recente mi sono imbattuto in codice che utilizza la seconda. Nessuna è un'istanza (e l'unica istanza, IIRC) di NoneType, quindi non dovrebbe importare, giusto? Ci sono circostanze in cui potrebbe?

isrestituisce sempre Truese confronta la stessa istanza di oggetto

Considerando che alla ==fine è determinato dal __eq__()metodo

vale a dire

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

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

Potresti voler leggere questa identità e l'equivalenza di questo oggetto .

L'istruzione 'is' viene utilizzata per l'identità dell'oggetto, controlla se gli oggetti si riferiscono alla stessa istanza (stesso indirizzo in memoria).

E l'istruzione '==' si riferisce all'uguaglianza (stesso valore).

Un avvertimento:

if foo:
  # do something

Non è esattamente lo stesso di:

if x is not None:
  # do something

Il primo è un test di valore booleano e può essere valutato come falso in contesti diversi. Ci sono un certo numero di cose che rappresentano false nei test di valori booleani, ad esempio contenitori vuoti, valori booleani. Nessuno valuta anche falso in questa situazione, ma lo fanno anche altre cose.

(ob1 is ob2) uguale a (id(ob1) == id(ob2))

Il motivo foo is Noneè il modo preferito è che potresti gestire un oggetto che definisce il proprio __eq__e che definisce l'oggetto uguale a Nessuno. Quindi, usa sempre foo is Nonese hai bisogno di vedere se è infatti None.

Non c'è differenza perché gli oggetti identici saranno ovviamente uguali. Tuttavia, PEP 8 afferma chiaramente che è necessario utilizzare is:

Il confronto con singoli come nessuno dovrebbe sempre essere fatto con o non è, mai operatori di uguaglianza.

istest per l'identità, non per l' uguaglianza. Per la tua affermazione foo is none, Python confronta semplicemente l'indirizzo di memoria degli oggetti. Significa che stai ponendo la domanda "Ho due nomi per lo stesso oggetto?"

==dall'altro lato verifica l'uguaglianza determinata dal __eq__()metodo. Non importa dell'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

Noneè un operatore singleton. Quindi None is Noneè sempre vero.

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

Per None non dovrebbe esserci differenza tra uguaglianza (==) e identità (is). NoneType probabilmente restituisce identità per uguaglianza. Poiché None è l'unica istanza che puoi fare di NoneType (penso che sia vero), le due operazioni sono le stesse. Nel caso di altri tipi questo non è sempre il caso. Per esempio:

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

Ciò stamperebbe "Uguale" poiché gli elenchi hanno un'operazione di confronto che non è la restituzione predefinita dell'identità.

@ Jason :

Consiglio di usare qualcosa di più sulla falsariga di

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

Non mi piace usare "if foo:" a meno che foo non rappresenti davvero un valore booleano (ovvero 0 o 1). Se foo è una stringa o un oggetto o qualcos'altro, "if foo:" potrebbe funzionare, ma a me sembra una scorciatoia pigra. Se stai controllando per vedere se x è Nessuno, dì "se x è Nessuno:".

Alcuni dettagli in più:

1. La isclausola controlla effettivamente se i due si objecttrovano nella stessa posizione di memoria o meno. vale a dire se entrambi puntano alla stessa posizione di memoria e hanno la stessa id.

2. Come conseguenza di 1, isassicura se i due simboli lessicali rappresentati objectabbiano o meno attributi identici (attributi di attributi ...) oppure no

3. Istanziazione dei tipi primitivi come bool, int, string(con qualche eccezione), NoneTypeavente lo stesso valore sarà sempre nella stessa posizione di memoria.

Per esempio

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

E poiché NoneTypepuò avere solo un'istanza di se stessa nella tabella "look-up" di Python, quindi la prima e la seconda sono più uno stile di programmazione dello sviluppatore che ha scritto il codice (forse per coerenza) piuttosto che avere una ragione logica per scegli uno sopra l'altro.

La conclusione di John Machin che Noneè un singleton è una conclusione sostenuta da questo codice.

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

Since Noneè un singleton x == Nonee x is Noneavrebbe lo stesso risultato. Tuttavia, secondo la mia opinione estetica, x == Noneè la cosa migliore.

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