ternario - palabras reservadas python significado

¿Existe un Python equivalente al operador de fusión nula de C#?

Question

En C # hay un operador de unión nula (escrito como ?? ) que permite una fácil verificación (corta) de nulos durante la asignación:

string s = null;
var other = s ?? "some default value";

¿Hay un equivalente de python?

Sé que puedo hacer:

s = None
other = s if s else "some default value"

¿Pero hay un camino aún más corto (donde no necesito repetir s )?

Answer 1

Además de la respuesta de Juliano sobre el comportamiento de "o": es "rápido"

>>> 1 or 5/0
1

Así que a veces puede ser un atajo útil para cosas como

object = getCachedVersion() or getFromDB()

Answer 2

Aquí hay una función que devolverá el primer argumento que no es Ninguno:

def coalesce(*arg):
  return reduce(lambda x, y: x if x is not None else y, arg)

# Prints "banana"
print coalesce(None, "banana", "phone", None)

Reducir () podría iterar innecesariamente sobre todos los argumentos, incluso si el primer argumento no es Ninguno, por lo que también puede usar esta versión:

def coalesce(*arg):
  for el in arg:
    if el is not None:
      return el
  return None

Answer 3

Las dos funciones siguientes que he encontrado son muy útiles cuando se trata de muchos casos de prueba variables.

def nz(value, none_value, strict=True):
    '''''' This function is named after an old VBA function. It returns a default
        value if the passed in value is None. If strict is False it will
        treat an empty string as None as well.

        example:
        x = None
        nz(x,"hello")
        --> "hello"
        nz(x,"")
        --> ""
        y = ""   
        nz(y,"hello")
        --> ""
        nz(y,"hello", False)
        --> "hello" ''''''

    if value is None and strict:
        return_val = none_value
    elif strict and value is not None:
        return_val = value
    elif not strict and not is_not_null(value):
        return_val = none_value
    else:
        return_val = value
    return return_val 

def is_not_null(value):
    '''''' test for None and empty string ''''''
    return value is not None and len(str(value)) > 0

Answer 4

Me doy cuenta de que esto se responde, pero hay otra opción cuando se trata de objetos.

Si tienes un objeto que podría ser:

{
   name: {
      first: "John",
      last: "Doe"
   }
}

Puedes usar:

obj.get(property_name, value_if_null)

Me gusta:

obj.get("name", {}).get("first", "Name is missing") 

Al agregar {} como valor predeterminado, si falta el "nombre", se devuelve un objeto vacío y se pasa a la siguiente obtención. Esto es similar a null-safe-navigation en C #, que sería como obj?.name?.first .

Answer 5

estrictamente,

other = s if s is not None else "default value"

de lo contrario s = False se convertirá en "valor predeterminado", que puede no ser lo que se pretendía.

Si quieres hacer esto más corto, prueba

def notNone(s,d):
    if s is None:
        return d
    else:
        return s

other = notNone(s, "default value")

Answer 6

other = s or "some default value"

Ok, debe aclararse cómo funciona el operador or . Es un operador booleano, por lo que funciona en un contexto booleano. Si los valores no son booleanos, se convierten a booleanos para los fines del operador.

Tenga en cuenta que el operador or no devuelve solo True o False . En su lugar, devuelve el primer operando si el primer operando se evalúa como verdadero, y devuelve el segundo operando si el primer operando se evalúa como falso.

En este caso, la expresión x or y devuelve x si es True o se evalúa como verdadero cuando se convierte a booleano. De lo contrario, devuelve y . Para la mayoría de los casos, esto servirá para el mismo propósito del operador de unión nula de C♯, pero tenga en cuenta:

42    or "something"    # returns 42
0     or "something"    # returns "something"
None  or "something"    # returns "something"
False or "something"    # returns "something"
""    or "something"    # returns "something"

Si usa su variable s para contener algo que sea una referencia a la instancia de una clase o None (siempre que su clase no defina los miembros __nonzero__() y __len__() ), es seguro usar la misma semántica que El operador de unión nula.

De hecho, incluso puede ser útil tener este efecto secundario de Python. Como sabe qué valores se evalúan como falsos, puede usar esto para activar el valor predeterminado sin usar None específicamente (un objeto de error, por ejemplo).

En algunos idiomas, este comportamiento se conoce como el operador de Elvis .