¿Cómo me refiero al objeto nulo en Python?

En Python, el objeto 'nulo' es el singleton None.

La mejor manera de verificar las cosas para "Ninguna" es utilizar el operador de identidad is:

if foo is None:
    ...

None, Python es nulo?

No hay nullen Python, en cambio hay None. Como ya se dijo, la forma más precisa de probar que algo se ha dado Nonecomo valor es usar el isoperador de identidad, que prueba que dos variables se refieren al mismo objeto.

>>> foo is None
True
>>> foo = 'bar' 
>>> foo is None
False

Los basicos

Hay y solo puede haber uno None

Nonees la única instancia de la clase NoneTypey cualquier otro intento de instanciar esa clase devolverá el mismo objeto, lo que hace Noneun singleton. Los recién llegados a Python a menudo ven mensajes de error que mencionan NoneTypey se preguntan qué es. Es mi opinión personal que estos mensajes simplemente podrían mencionarse Nonepor su nombre porque, como veremos en breve, Nonedeja poco espacio para la ambigüedad. Entonces, si ve algún TypeErrormensaje que menciona que NoneTypeno puede hacer esto o no puede hacer eso, solo sepa que es simplemente el Noneque se estaba utilizando de una manera que no puede.

Además, Nonees una constante incorporada, tan pronto como inicie Python, estará disponible para usar desde cualquier lugar, ya sea en módulo, clase o función. NoneTypepor el contrario, no, primero debe obtener una referencia al consultar Nonesu clase.

>>> NoneType
NameError: name 'NoneType' is not defined
>>> type(None)
NoneType

Puede verificar Nonela singularidad con la función de identidad de Python id(). Devuelve el número único asignado a un objeto, cada objeto tiene uno. Si la identificación de dos variables es la misma, de hecho apuntan al mismo objeto.

>>> NoneType = type(None)
>>> id(None)
10748000
>>> my_none = NoneType()
>>> id(my_none)
10748000
>>> another_none = NoneType()
>>> id(another_none)
10748000
>>> def function_that_does_nothing(): pass
>>> return_value = function_that_does_nothing()
>>> id(return_value)
10748000

None no se puede sobrescribir

En una versión mucho más antigua de Python (anterior a la 2.4), era posible reasignar None, pero ya no. Ni siquiera como un atributo de clase o en los confines de una función.

# In Python 2.7
>>> class SomeClass(object):
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: cannot assign to None
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to None

# In Python 3.5
>>> class SomeClass:
...     def my_fnc(self):
...             self.None = 'foo'
SyntaxError: invalid syntax
>>> def my_fnc():
        None = 'foo'
SyntaxError: cannot assign to keyword

Por lo tanto, es seguro asumir que todas las Nonereferencias son iguales. No hay "costumbre" None.

Para probar el Noneuso del isoperador

Al escribir código, puede sentirse tentado a probar Noneness como este:

if value==None:
    pass

O para probar la falsedad como esta

if not value:
    pass

Debe comprender las implicaciones y por qué a menudo es una buena idea ser explícito.

Caso 1: probar si un valor es None

porque hacer esto

value is None

más bien que

value==None

El primero es equivalente a:

id(value)==id(None)

Mientras que la expresión value==Nonede hecho se aplica así

value.__eq__(None)

Si el valor es realmente None, obtendrá lo que esperaba.

>>> nothing = function_that_does_nothing()
>>> nothing.__eq__(None)
True

En los casos más comunes, el resultado será el mismo, pero el __eq__()método abre una puerta que anula cualquier garantía de precisión, ya que se puede anular en una clase para proporcionar un comportamiento especial.

Considera esta clase.

>>> class Empty(object):
...     def __eq__(self, other):
...         return not other

Entonces lo pruebas Noney funciona

>>> empty = Empty()
>>> empty==None
True

Pero luego también funciona en la cadena vacía

>>> empty==''
True

Y todavía

>>> ''==None
False
>>> empty is None
False

Caso 2: uso Nonecomo un booleano

Las siguientes dos pruebas

if value:
    # do something

if not value:
    # do something

de hecho son evaluados como

if bool(value):
    # do something

if not bool(value):
    # do something

Nonees una "falsey", lo que significa que si se convierte en booleano, volverá Falsey, si se aplica, el notoperador volverá True. Sin embargo, tenga en cuenta que no es una propiedad exclusiva de None. Además de Falsesí mismo, la propiedad se comparte mediante listas vacías, tuplas, conjuntos, dictados, cadenas, así como 0, y todos los objetos de las clases que implementan el __bool__()método mágico para devolver False.

>>> bool(None)
False
>>> not None
True

>>> bool([])
False
>>> not []
True

>>> class MyFalsey(object):
...     def __bool__(self):
...         return False
>>> f = MyFalsey()
>>> bool(f)
False
>>> not f
True

Por lo tanto, cuando pruebe las variables de la siguiente manera, tenga más en cuenta lo que está incluyendo o excluyendo de la prueba:

def some_function(value=None):
    if not value:
        value = init_value()

En lo anterior, ¿quiso llamar init_value()cuando el valor se estableció específicamente en None, o quiso decir que un valor establecido en 0, o la cadena vacía, o una lista vacía también deberían activar la inicialización? Como dije, ten en cuenta. Como suele ser el caso en Python, explícito es mejor que implícito .

None en la práctica

None utilizado como valor de señal

Nonetiene un estado especial en Python. Es un valor de referencia favorito porque muchos algoritmos lo tratan como un valor excepcional. En tales escenarios, se puede usar como un indicador para indicar que una condición requiere un manejo especial (como la configuración de un valor predeterminado).

Puede asignar Nonea la palabra clave argumentos de una función y luego probarla explícitamente.

def my_function(value, param=None):
    if param is None:
        # do something outrageous!

Puede devolverlo como predeterminado cuando intente acceder al atributo de un objeto y luego probarlo explícitamente antes de hacer algo especial.

value = getattr(some_obj, 'some_attribute', None)
if value is None:
    # do something spectacular!

Por defecto, el get()método de un diccionario regresa Noneal intentar acceder a una clave no existente:

>>> some_dict = {}
>>> value = some_dict.get('foo')
>>> value is None
True

Si intentara acceder a él utilizando la notación de subíndice KeyError, se generaría

>>> value = some_dict['foo']
KeyError: 'foo'

Del mismo modo, si intenta hacer estallar un elemento no existente

>>> value = some_dict.pop('foo')
KeyError: 'foo'

que puede suprimir con un valor predeterminado que generalmente se establece en None

value = some_dict.pop('foo', None)
if value is None:
    # booom!

None se utiliza como indicador y valor válido

Los usos descritos anteriormente se Noneaplican cuando no se considera un valor válido, sino más bien como una señal para hacer algo especial. Sin embargo, hay situaciones en las que a veces es importante saber de dónde Noneviene porque, aunque se usa como señal, también podría ser parte de los datos.

Cuando consulta un objeto para obtener su atributo con el getattr(some_obj, 'attribute_name', None)regreso, Noneno le dice si el atributo al que estaba intentando acceder estaba configurado Noneo si estaba completamente ausente del objeto. La misma situación al acceder a una clave de un diccionario some_dict.get('some_key'), como , no sabe si some_dict['some_key']falta o si está configurada en None. Si necesita esa información, la forma habitual de manejar esto es intentar acceder directamente al atributo o clave desde una try/exceptconstrucción:

try:
    # equivalent to getattr() without specifying a default
    # value = getattr(some_obj, 'some_attribute')
    value = some_obj.some_attribute
    # now you handle `None` the data here
    if value is None:
        # do something here because the attribute was set to None
except AttributeError:
    # we're now hanling the exceptional situation from here.
    # We could assign None as a default value if required.
    value = None 
    # In addition, since we now know that some_obj doesn't have the
    # attribute 'some_attribute' we could do something about that.
    log_something(some_obj)

De manera similar con dict:

try:
    value = some_dict['some_key']
    if value is None:
        # do something here because 'some_key' is set to None
except KeyError:
    # set a default 
    value = None
    # and do something because 'some_key' was missing
    # from the dict.
    log_something(some_dict)

Los dos ejemplos anteriores muestran cómo manejar casos de objeto y diccionario, ¿qué pasa con las funciones? Lo mismo, pero usamos el argumento de palabra clave de doble asterisco para ese fin:

def my_function(**kwargs):
    try:
        value = kwargs['some_key'] 
        if value is None:
            # do something because 'some_key' is explicitly 
            # set to None
    except KeyError:
        # we assign the default
        value = None
        # and since it's not coming from the caller.
        log_something('did not receive "some_key"')

None usado solo como un valor válido

Si encuentra que su código está lleno del try/exceptpatrón anterior simplemente para diferenciar entre Noneindicadores y Nonedatos, simplemente use otro valor de prueba. Hay un patrón en el que un valor que queda fuera del conjunto de valores válidos se inserta como parte de los datos en una estructura de datos y se usa para controlar y probar condiciones especiales (por ejemplo, límites, estado, etc.). Tal valor se llama centinela y se puede usar de la misma manera que Nonese usa como señal. Es trivial crear un centinela en Python.

undefined = object()

El undefinedobjeto anterior es único y no hace mucho de nada que pueda ser de interés para un programa, por lo tanto, es un excelente reemplazo Nonecomo indicador. Se aplican algunas advertencias, más sobre eso después del código.

Con función

def my_function(value, param1=undefined, param2=undefined):
    if param1 is undefined:
        # we know nothing was passed to it, not even None
        log_something('param1 was missing')
        param1 = None


    if param2 is undefined:
        # we got nothing here either
        log_something('param2 was missing')
        param2 = None

Con dict

value = some_dict.get('some_key', undefined)
if value is None:
    log_something("'some_key' was set to None")

if value is undefined:
    # we know that the dict didn't have 'some_key'
    log_something("'some_key' was not set at all")
    value = None

Con un objeto

value = getattr(obj, 'some_attribute', undefined) 
if value is None:
    log_something("'obj.some_attribute' was set to None")
if value is undefined:
    # we know that there's no obj.some_attribute
    log_something("no 'some_attribute' set on obj")
    value = None

Como mencioné anteriormente, los centinelas personalizados vienen con algunas advertencias. Primero, no son palabras clave como None, por lo que Python no las protege. Puede sobrescribir lo undefinedanterior en cualquier momento, en cualquier lugar del módulo que esté definido, así que tenga cuidado de cómo los expone y usa. A continuación, la instancia devuelta por object()no es un singleton, si realiza esa llamada 10 veces obtendrá 10 objetos diferentes. Finalmente, el uso de un centinela es altamente idiosincrásico. Un centinela es específico de la biblioteca en la que se usa y, como tal, su alcance generalmente debe limitarse a los elementos internos de la biblioteca. No debería "filtrarse". El código externo solo debe ser consciente de él, si su propósito es extender o complementar la API de la biblioteca.

No se llama nulo como en otros idiomas, pero None. Siempre hay una sola instancia de este objeto, por lo que puede verificar la equivalencia con x is None(comparación de identidad) en lugar de x == None, si lo desea.

En Python, para representar la ausencia de un valor, puede usar el valor None ( types.NoneType.None ) para objetos y "" (o len () == 0 ) para cadenas. Por lo tanto:

if yourObject is None:  # if yourObject == None:
    ...

if yourString == "":  # if yourString.len() == 0:
    ...

En cuanto a la diferencia entre "==" y "es", la prueba de identidad de objeto usando "==" debería ser suficiente. Sin embargo, dado que la operación "es" se define como la operación de identidad de objeto, probablemente sea más correcto usarla, en lugar de "==". No estoy seguro si hay incluso una diferencia de velocidad.

De todos modos, puedes echar un vistazo a:

• Constante incorporada de Python doc página.
• Python Truth Value Testing doc page.

Nulo es un tipo de objeto especial como:

>>>type(None)
<class 'NoneType'>

Puede verificar si un objeto está en la clase 'NoneType':

>>>variable = None
>>>variable is None
True

Más información está disponible en Python Docs

Por prueba de valor de Verdad , 'Ninguno' prueba directamente como FALSO, por lo que la expresión más simple será suficiente:

if not foo: