Existe alguma diferença entre “foo é None” e “foo == None”?

Existe alguma diferença entre:

if foo is None: pass

e

if foo == None: pass

A convenção que eu já vi na maioria dos códigos Python (e no código que eu mesmo escrevo) é a primeira, mas recentemente me deparei com um código que usa a segunda. Nenhuma é uma instância (e a única instância, IIRC) de NoneType; portanto, isso não importa, certo? Existem circunstâncias em que isso possa acontecer?

issempre retorna Truese comparar a mesma instância do objeto

Considerando que, em ==última análise, é determinado pelo __eq__()método

ie

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

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

Você pode querer ler essa identidade e equivalência do objeto .

A declaração 'is' é usada para a identidade do objeto, verifica se os objetos se referem à mesma instância (mesmo endereço na memória).

E a instrução '==' refere-se à igualdade (mesmo valor).

Uma palavra de cautela:

if foo:
  # do something

Não é exatamente o mesmo que:

if x is not None:
  # do something

O primeiro é um teste de valor booleano e pode ser avaliado como falso em diferentes contextos. Existem várias coisas que representam false em um teste de valor booleano, por exemplo, contêineres vazios, valores booleanos. Nenhum também é avaliado como falso nessa situação, mas outras coisas também.

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

O motivo foo is Noneé a maneira preferida: você pode estar manipulando um objeto que define o seu próprio __eq__e que define o objeto como sendo igual a Nenhum. Portanto, sempre use foo is Nonese precisar ver se ele está de fato None.

Não há diferença porque objetos idênticos serão obviamente iguais. No entanto, o PEP 8 afirma claramente que você deve usar is:

Comparações com singletons como None devem sempre ser feitas com é ou não, nunca com os operadores de igualdade.

istestes de identidade, não de igualdade. Para sua declaração foo is none, o Python simplesmente compara o endereço de memória dos objetos. Isso significa que você está fazendo a pergunta "Eu tenho dois nomes para o mesmo objeto?"

==por outro lado, testa a igualdade conforme determinado pelo __eq__()método. Não se importa com identidade.

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é um operador singleton. Então None is Noneé sempre verdade.

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

Para Nenhum, não deve haver diferença entre igualdade (==) e identidade (é). O NoneType provavelmente retorna identidade para igualdade. Como None é a única instância que você pode fazer de NoneType (acho que isso é verdade), as duas operações são iguais. No caso de outros tipos, esse nem sempre é o caso. Por exemplo:

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

Isso imprimiria "Igual", pois as listas têm uma operação de comparação que não é o retorno padrão da identidade.

@ Jason :

Eu recomendo usar algo mais ao longo das linhas de

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

Não gosto de usar "if foo:", a menos que foo realmente represente um valor booleano (ou seja, 0 ou 1). Se foo for uma string, um objeto ou outra coisa, "if foo:" pode funcionar, mas me parece um atalho preguiçoso. Se você estiver verificando se x é Nenhum, diga "se x é Nenhum:".

Mais alguns detalhes:

1. A iscláusula realmente verifica se os dois objects estão no mesmo local de memória ou não. ou seja, se ambos apontam para o mesmo local de memória e têm o mesmo id.

2. Como consequência de 1, isgarante se os dois objects representados lexicamente têm ou não atributos idênticos (atributos-de-atributos ...) ou não

3. Instanciação de tipos primitivos, como bool, int, string(com algumas excepções), NoneTypetendo um mesmo valor será sempre no mesmo local de memória.

Por exemplo

>>> 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 como NoneTypesó pode ter uma instância na tabela de "pesquisa" do python, a primeira e a segunda são mais um estilo de programação do desenvolvedor que escreveu o código (talvez por consistência), em vez de ter qualquer razão lógica sutil para escolha um sobre o outro.

A conclusão de John Machin que Noneé um singleton é uma conclusão reforçada por esse código.

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

Uma vez que Noneé um singleton, x == Nonee x is Noneteria o mesmo resultado. No entanto, na minha opinião estética, x == Noneé melhor.

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