Forma pitónica para evitar las declaraciones "if x: return x"

Tengo un método que llama a otros 4 métodos en secuencia para verificar condiciones específicas, y regresa de inmediato (sin verificar los siguientes) cada vez que uno devuelve algo Verdad.

def check_all_conditions():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

Esto parece mucho código de equipaje. En lugar de cada instrucción if de 2 líneas, prefiero hacer algo como:

x and return x

Pero eso es inválido Python. ¿Me estoy perdiendo una solución simple y elegante aquí? Por cierto, en esta situación, esos cuatro métodos de verificación pueden ser costosos, por lo que no quiero llamarlos varias veces.

Podrías usar un bucle:

conditions = (check_size, check_color, check_tone, check_flavor)
for condition in conditions:
    result = condition()
    if result:
        return result

Esto tiene la ventaja adicional de que ahora puede hacer que el número de condiciones sea variable.

Puede usar map()+ filter()(las versiones de Python 3, use las future_builtinsversiones de Python 2) para obtener el primer valor coincidente:

try:
    # Python 2
    from future_builtins import map, filter
except ImportError:
    # Python 3
    pass

conditions = (check_size, check_color, check_tone, check_flavor)
return next(filter(None, map(lambda f: f(), conditions)), None)

pero si esto es más legible es discutible.

Otra opción es usar una expresión generadora:

conditions = (check_size, check_color, check_tone, check_flavor)
checks = (condition() for condition in conditions)
return next((check for check in checks if check), None)

Alternativamente a la buena respuesta de Martijn, podrías encadenar or. Esto devolverá el primer valor de verdad, o Nonesi no hay un valor de verdad:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor() or None

Manifestación:

>>> x = [] or 0 or {} or -1 or None
>>> x
-1
>>> x = [] or 0 or {} or '' or None
>>> x is None
True

No lo cambies

Hay otras formas de hacerlo, como lo muestran las otras respuestas. Ninguno es tan claro como su código original.

Efectivamente, la misma respuesta que timgeb, pero podría usar paréntesis para un mejor formato:

def check_all_the_things():
    return (
        one()
        or two()
        or five()
        or three()
        or None
    )

De acuerdo con la ley de Curly , puede hacer que este código sea más legible dividiendo dos preocupaciones:

• ¿Qué cosas reviso?
• ¿Ha vuelto una cosa verdad?

en dos funciones:

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions():
    for condition in all_conditions():
        if condition:
            return condition
    return None

Esto evita:

• estructuras lógicas complicadas
• líneas muy largas
• repetición

... conservando un flujo lineal y fácil de leer.

Probablemente también pueda encontrar nombres de funciones aún mejores, de acuerdo con su circunstancia particular, que lo hacen aún más legible.

Esta es una variante del primer ejemplo de Martijns. También utiliza el estilo "colección de llamadas" para permitir cortocircuitos.

En lugar de un bucle, puede usar el incorporado any.

conditions = (check_size, check_color, check_tone, check_flavor)
return any(condition() for condition in conditions) 

Tenga en cuenta que anydevuelve un valor booleano, por lo que si necesita el valor de retorno exacto del cheque, esta solución no funcionará. anyno va a distinguir entre 14, 'red', 'sharp', 'spicy'como valores de retorno, todos ellos serán devueltos como True.

¿Has considerado simplemente escribir if x: return xtodo en una línea?

def check_all_conditions():
    x = check_size()
    if x: return x

    x = check_color()
    if x: return x

    x = check_tone()
    if x: return x

    x = check_flavor()
    if x: return x

    return None

Esto no es menos repetitivo que lo que tenía, pero IMNSHO se lee bastante más suave.

Estoy bastante sorprendido de que nadie haya mencionado el incorporado anyque está hecho para este propósito:

def check_all_conditions():
    return any([
        check_size(),
        check_color(),
        check_tone(),
        check_flavor()
    ])

Tenga en cuenta que aunque esta implementación es probablemente la más clara, evalúa todas las comprobaciones, incluso si la primera es True.

Si realmente necesita detenerse en la primera verificación fallida, considere usar reducewhich está hecho para convertir una lista a un valor simple:

def check_all_conditions():
    checks = [check_size, check_color, check_tone, check_flavor]
    return reduce(lambda a, f: a or f(), checks, False)

reduce(function, iterable[, initializer]): Aplica la función de dos argumentos acumulativamente a los elementos de iterable, de izquierda a derecha, para reducir el iterable a un solo valor. El argumento izquierdo, x, es el valor acumulado y el argumento derecho, y, es el valor de actualización del iterable. Si el inicializador opcional está presente, se coloca antes de los elementos del iterable en el cálculo

En tu caso:

• lambda a, f: a or f()es la función que verifica si el acumulador ao la verificación actual f()es True. Tenga en cuenta que si aes así True, f()no será evaluado.
• checkscontiene funciones de verificación (el felemento de la lambda)
• False es el valor inicial, de lo contrario no se realizaría ninguna comprobación y el resultado siempre sería True

anyy reduceson herramientas básicas para la programación funcional. ¡Te recomiendo encarecidamente que los entrenes y que también mapsea ​​increíble!

Si desea la misma estructura de código, ¡podría usar declaraciones ternarias!

def check_all_conditions():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

Creo que esto se ve bien y claro si lo miras.

Manifestación:

Para mí, la mejor respuesta es la de @ phil-frost, seguida de @ wayne-werner.

Lo que me parece interesante es que nadie ha dicho nada sobre el hecho de que una función devolverá muchos tipos de datos diferentes, lo que hará que sea obligatorio hacer controles sobre el tipo de x para realizar cualquier trabajo adicional.

Entonces mezclaría la respuesta de @ PhilFrost con la idea de mantener un solo tipo:

def all_conditions(x):
    yield check_size(x)
    yield check_color(x)
    yield check_tone(x)
    yield check_flavor(x)

def assessed_x(x,func=all_conditions):
    for condition in func(x):
        if condition:
            return x
    return None

Observe que xse pasa como un argumento, pero también all_conditionsse usa como un generador pasado de funciones de verificación donde todas ellas obtienen un xcontrol, y devuelven Trueo False. Al usar funccon all_conditionsel valor predeterminado, puede usar assessed_x(x), o puede pasar un generador personalizado adicional a través de func.

De esa manera, obtendrá xtan pronto como pase un cheque, pero siempre será del mismo tipo.

Idealmente, volvería a escribir las check_ funciones para devolver Trueo en Falselugar de un valor. Sus cheques luego se convierten

if check_size(x):
    return x
#etc

Suponiendo que su xno es inmutable, su función aún puede modificarlo (aunque no pueden reasignarlo), pero una función llamada checkrealmente no debería modificarlo de todos modos.

Una ligera variación en el primer ejemplo de Martijns anterior, que evita el if dentro del bucle:

Status = None
for c in [check_size, check_color, check_tone, check_flavor]:
  Status = Status or c();
return Status

Me gusta @ timgeb's. Mientras tanto, me gustaría agregar que no es necesario expresar Noneen la returndeclaración ya orque se evalúa la colección de declaraciones separadas y se devuelve el primer cero, ninguno vacío, ninguno, y si no hay ninguno, Nonese devuelve si hay un Noneo no!

Entonces mi check_all_conditions()función se ve así:

def check_all_conditions():
    return check_size() or check_color() or check_tone() or check_flavor()

Usando timeitcon number=10**7miré el tiempo de ejecución de una serie de sugerencias. En aras de la comparación, solo utilicé la random.random()función para devolver una cadena o en Nonefunción de números aleatorios. Aquí está el código completo:

import random
import timeit

def check_size():
    if random.random() < 0.25: return "BIG"

def check_color():
    if random.random() < 0.25: return "RED"

def check_tone():
    if random.random() < 0.25: return "SOFT"

def check_flavor():
    if random.random() < 0.25: return "SWEET"

def check_all_conditions_Bernard():
    x = check_size()
    if x:
        return x

    x = check_color()
    if x:
        return x

    x = check_tone()
    if x:
        return x

    x = check_flavor()
    if x:
        return x
    return None

def check_all_Martijn_Pieters():
    conditions = (check_size, check_color, check_tone, check_flavor)
    for condition in conditions:
        result = condition()
        if result:
            return result

def check_all_conditions_timgeb():
    return check_size() or check_color() or check_tone() or check_flavor() or None

def check_all_conditions_Reza():
    return check_size() or check_color() or check_tone() or check_flavor()

def check_all_conditions_Phinet():
    x = check_size()
    x = x if x else check_color()
    x = x if x else check_tone()
    x = x if x else check_flavor()

    return x if x else None

def all_conditions():
    yield check_size()
    yield check_color()
    yield check_tone()
    yield check_flavor()

def check_all_conditions_Phil_Frost():
    for condition in all_conditions():
        if condition:
            return condition

def main():
    num = 10000000
    random.seed(20)
    print("Bernard:", timeit.timeit('check_all_conditions_Bernard()', 'from __main__ import check_all_conditions_Bernard', number=num))
    random.seed(20)
    print("Martijn Pieters:", timeit.timeit('check_all_Martijn_Pieters()', 'from __main__ import check_all_Martijn_Pieters', number=num))
    random.seed(20)
    print("timgeb:", timeit.timeit('check_all_conditions_timgeb()', 'from __main__ import check_all_conditions_timgeb', number=num))
    random.seed(20)
    print("Reza:", timeit.timeit('check_all_conditions_Reza()', 'from __main__ import check_all_conditions_Reza', number=num))
    random.seed(20)
    print("Phinet:", timeit.timeit('check_all_conditions_Phinet()', 'from __main__ import check_all_conditions_Phinet', number=num))
    random.seed(20)
    print("Phil Frost:", timeit.timeit('check_all_conditions_Phil_Frost()', 'from __main__ import check_all_conditions_Phil_Frost', number=num))

if __name__ == '__main__':
    main()

Y aquí están los resultados:

Bernard: 7.398444877040768
Martijn Pieters: 8.506569201346597
timgeb: 7.244275416364456
Reza: 6.982133448743038
Phinet: 7.925932800076634
Phil Frost: 11.924794811353031

De esta manera está un poco fuera de la caja, pero creo que el resultado final es simple, legible y se ve bien.

La idea básica es raiseuna excepción cuando una de las funciones se evalúa como verdadera y devuelve el resultado. Así es como podría verse:

def check_conditions():
    try:
        assertFalsey(
            check_size,
            check_color,
            check_tone,
            check_flavor)
    except TruthyException as e:
        return e.trigger
    else:
        return None

Necesitará una assertFalseyfunción que genere una excepción cuando uno de los argumentos de la función llamada se evalúe como verdadero:

def assertFalsey(*funcs):
    for f in funcs:
        o = f()
        if o:
            raise TruthyException(o)

Lo anterior podría modificarse para proporcionar también argumentos para las funciones que se evaluarán.

Y, por supuesto, necesitarás el TruthyExceptionmismo. Esta excepción proporciona el objectque desencadenó la excepción:

class TruthyException(Exception):
    def __init__(self, obj, *args):
        super().__init__(*args)
        self.trigger = obj

Puede convertir la función original en algo más general, por supuesto:

def get_truthy_condition(*conditions):
    try:
        assertFalsey(*conditions)
    except TruthyException as e:
        return e.trigger
    else:
        return None

result = get_truthy_condition(check_size, check_color, check_tone, check_flavor)

Esto podría ser un poco más lento porque está utilizando una ifdeclaración y manejando una excepción. Sin embargo, la excepción sólo se maneja un máximo de una hora, por lo que el éxito de rendimiento debe ser menor a menos que vaya a ejecutar la verificación y obtener un Truevalor de muchos miles de veces.

La forma pitónica es usar reduce (como alguien ya mencionó) o itertools (como se muestra a continuación), pero me parece que simplemente usar un cortocircuito del oroperador produce un código más claro

from itertools import imap, dropwhile

def check_all_conditions():
    conditions = (check_size,\
        check_color,\
        check_tone,\
        check_flavor)
    results_gen = dropwhile(lambda x:not x, imap(lambda check:check(), conditions))
    try:
        return results_gen.next()
    except StopIteration:
        return None

Voy a saltar aquí y nunca he escrito una sola línea de Python, pero supongo que if x = check_something(): return xes válido.

si es así:

def check_all_conditions():

    if (x := check_size()): return x
    if (x := check_color()): return x
    if (x := check_tone()): return x
    if (x := check_flavor()): return x

    return None

O use max:

def check_all_conditions():
    return max(check_size(), check_color(), check_tone(), check_flavor()) or None

He visto algunas implementaciones interesantes de declaraciones de cambio / caso con dictos en el pasado que me llevaron a esta respuesta. Usando el ejemplo que ha proporcionado, obtendrá lo siguiente. (Es una locura using_complete_sentences_for_function_names, por check_all_conditionslo que cambia su nombre a status. Ver (1))

def status(k = 'a', s = {'a':'b','b':'c','c':'d','d':None}) :
  select = lambda next, test : test if test else next
  d = {'a': lambda : select(s['a'], check_size()  ),
       'b': lambda : select(s['b'], check_color() ),
       'c': lambda : select(s['c'], check_tone()  ),
       'd': lambda : select(s['d'], check_flavor())}
  while k in d : k = d[k]()
  return k

La función de selección elimina la necesidad de llamar cada check_FUNCTIONdos veces, es decir, evita check_FUNCTION() if check_FUNCTION() else nextagregar otra capa de función. Esto es útil para funciones de larga duración. Las lambdas en el dict retrasan la ejecución de sus valores hasta el ciclo while.

Como beneficio adicional, puede modificar el orden de ejecución e incluso omitir algunas de las pruebas alterando ky, spor ejemplo,k='c',s={'c':'b','b':None} reducir el número de pruebas e invertir el orden de procesamiento original.

Los timeitbecarios podrían regatear el costo de agregar una o dos capas adicionales a la pila y el costo de la búsqueda de datos, pero parece más preocupado por la belleza del código.

Alternativamente, una implementación más simple podría ser la siguiente:

def status(k=check_size) :
  select = lambda next, test : test if test else next
  d = {check_size  : lambda : select(check_color,  check_size()  ),
       check_color : lambda : select(check_tone,   check_color() ),
       check_tone  : lambda : select(check_flavor, check_tone()  ),
       check_flavor: lambda : select(None,         check_flavor())}
  while k in d : k = d[k]()
  return k

1. Quiero decir esto no en términos de pep8 sino en términos de usar una palabra descriptiva concisa en lugar de una oración. De acuerdo, el OP puede estar siguiendo alguna convención de codificación, trabajando una base de código existente o no importa términos breves en su base de código.