Modo pitonico per evitare le istruzioni "if x: return x"

Ho un metodo che chiama in sequenza altri 4 metodi per verificare condizioni specifiche, e ritorna immediatamente (non controllando quelli seguenti) ogni volta che si restituisce qualcosa di vero.

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

Sembra un sacco di codice bagaglio. Invece di ogni istruzione if a 2 righe, preferirei fare qualcosa del tipo:

x and return x

Ma questo non è Python valido. Mi sto perdendo una soluzione semplice ed elegante qui? Per inciso, in questa situazione, quei quattro metodi di controllo possono essere costosi, quindi non voglio chiamarli più volte.

È possibile utilizzare un ciclo:

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

Ciò ha l'ulteriore vantaggio di poter ora rendere variabile il numero di condizioni.

È possibile utilizzare map()+ filter()(le versioni di Python 3, utilizzare le future_builtinsversioni in Python 2) per ottenere il primo valore corrispondente:

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)

ma se questo è più leggibile è discutibile.

Un'altra opzione è utilizzare un'espressione del generatore:

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)

In alternativa alla bella risposta di Martijn, potresti incatenare or. Ciò restituirà il primo valore di verità, o Nonese non esiste alcun valore di verità:

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

demo:

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

Non cambiarlo

Esistono altri modi per farlo, come mostrano le varie altre risposte. Nessuno è chiaro come il tuo codice originale.

In effetti la stessa risposta di timgeb, ma è possibile utilizzare la parentesi per una formattazione migliore:

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

Secondo la legge di Curly , puoi rendere questo codice più leggibile dividendo due preoccupazioni:

• Quali cose controllo?
• Una cosa è tornata vera?

in due funzioni:

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

Questo evita:

• strutture logiche complicate
• linee davvero lunghe
• ripetizione

... preservando un flusso lineare e di facile lettura.

Probabilmente puoi anche trovare nomi di funzioni ancora migliori, in base alle tue circostanze particolari, che lo rendono ancora più leggibile.

Questa è una variante del primo esempio di Martijns. Utilizza anche lo stile "raccolta di callable" per consentire il corto circuito.

Invece di un loop puoi usare il builtin any.

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

Nota che anyrestituisce un valore booleano, quindi se hai bisogno del valore restituito esatto del controllo, questa soluzione non funzionerà. anynon distinguere tra 14, 'red', 'sharp', 'spicy'come valori di ritorno, saranno tutti restituiti come True.

Hai mai considerato di scrivere if x: return xtutto su una riga?

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

Questo non è meno ripetitivo di quello che avevi, ma IMNSHO sembra un po 'più fluido.

Sono abbastanza sorpreso che nessuno abbia menzionato l'incasso anyche è stato realizzato per questo scopo:

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

Si noti che sebbene questa implementazione sia probabilmente la più chiara, valuta tutti i controlli anche se lo è il primo True.

Se hai davvero bisogno di fermarti al primo controllo fallito, considera l'utilizzo di reducequale è fatto per convertire un elenco in un semplice valore:

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]): Applica cumulativamente la funzione di due argomenti agli elementi di iterabile, da sinistra a destra, in modo da ridurre l'iterabile a un singolo valore. L'argomento sinistro, x, è il valore accumulato e l'argomento destro, y, è il valore di aggiornamento dall'iterabile. Se l'inizializzatore opzionale è presente, viene inserito prima degli elementi dell'iterabile nel calcolo

Nel tuo caso:

• lambda a, f: a or f()è la funzione che controlla che sia l'accumulatore ao il controllo corrente f()è True. Nota che, se lo aè True, f()non verrà valutato.
• checkscontiene funzioni di controllo (l' felemento dalla lambda)
• False è il valore iniziale, altrimenti non verrebbe eseguito alcun controllo e il risultato sarebbe sempre True

anye reducesono strumenti di base per la programmazione funzionale. Ti incoraggio vivamente ad allenarli e anche mapquesto è fantastico!

Se vuoi la stessa struttura di codice, puoi usare le dichiarazioni ternarie!

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

Penso che questo sia carino e chiaro se lo guardi.

demo:

Per me, la risposta migliore è quella di @ phil-frost, seguita da @ wayne-werner's.

Ciò che trovo interessante è che nessuno ha detto nulla sul fatto che una funzione restituirà molti tipi di dati diversi, il che renderà quindi obbligatorio fare controlli sul tipo di x stesso per fare qualsiasi ulteriore lavoro.

Quindi mescolerei la risposta di @ PhilFrost con l'idea di mantenere 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

Si noti che xviene passato come argomento, ma all_conditionsviene anche utilizzato come generatore passato di funzioni di controllo in cui tutte ottengono un oggetto xda controllare e restituire TrueoFalse . Usando funccon all_conditionscome valore predefinito, è possibile utilizzare assessed_x(x)o è possibile passare un ulteriore generatore personalizzato tramite func.

In questo modo, ricevi xnon appena passa un controllo, ma sarà sempre dello stesso tipo.

Idealmente, riscriverei le check_ funzioni per restituire Trueo Falsepiuttosto che un valore. I tuoi controlli diventano quindi

if check_size(x):
    return x
#etc

Supponendo che il tuo xnon sia immutabile, la tua funzione può comunque modificarlo (anche se non possono riassegnarlo) - ma una funzione chiamata checknon dovrebbe davvero modificarlo comunque.

Una leggera variazione sul primo esempio di Martijns sopra, che evita il if all'interno del loop:

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

Mi piace @ timgeb's. Nel frattempo vorrei aggiungere che esprime Nonenella returndichiarazione non è necessario in quanto la raccolta delle ordichiarazioni separate vengono valutati e, nessuno-vuoto, viene restituito nessuno-None il primo nessuno-zero e se non c'è alcun allora Noneviene restituito se c'è Noneo no!

Quindi la mia check_all_conditions()funzione è simile a questa:

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

Usando timeitcon number=10**7ho esaminato il tempo di esecuzione di una serie di suggerimenti. Per fare un confronto, ho appena usato la random.random()funzione per restituire una stringa o in Nonebase a numeri casuali. Ecco l'intero codice:

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

E qui ci sono i risultati:

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

In questo modo è un po 'fuori dagli schemi, ma penso che il risultato finale sia semplice, leggibile e bello.

L'idea di base è raiseun'eccezione quando una delle funzioni viene valutata come vera e restituisce il risultato. Ecco come potrebbe apparire:

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

Avrai bisogno di una assertFalseyfunzione che solleva un'eccezione quando uno degli argomenti della funzione chiamata viene valutato come vero:

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

Quanto sopra potrebbe essere modificato in modo da fornire anche argomenti per le funzioni da valutare.

E ovviamente avrai bisogno dello TruthyExceptionstesso. Questa eccezione fornisce objectciò che ha attivato l'eccezione:

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

Naturalmente puoi trasformare la funzione originale in qualcosa di più generale:

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)

Questo potrebbe essere un po 'più lento perché stai usando sia ifun'istruzione che gestisci un'eccezione. Tuttavia, l'eccezione viene gestita al massimo una volta, quindi l'hit to performance dovrebbe essere minore a meno che non ti aspetti di eseguire il controllo e ottenere un Truevalore molte migliaia di volte.

Il modo pitonico sta usando il ridurre (come qualcuno già menzionato) o gli itertools (come mostrato sotto), ma mi sembra che il semplice utilizzo di un corto circuito ordell'operatore produca un codice più chiaro

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

Ho intenzione di saltare qui e non ho mai scritto una sola riga di Python, ma suppongo if x = check_something(): return xsia valido?

se è così:

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

Oppure usa max:

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

Ho visto alcune implementazioni interessanti di istruzioni switch / case con dicts in passato che mi hanno portato a questa risposta. Usando l'esempio che hai fornito otterrai quanto segue. (È una follia using_complete_sentences_for_function_names, quindi check_all_conditionsviene ribattezzato status. Vedi (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 funzione di selezione elimina la necessità di chiamare ciascuna check_FUNCTIONdue volte, ad esempio si evita check_FUNCTION() if check_FUNCTION() else nextaggiungendo un altro livello di funzione. Questo è utile per le funzioni di lunga durata. Gli lambda nel dict ritardano l'esecuzione dei suoi valori fino al ciclo while.

Come bonus, puoi modificare l'ordine di esecuzione e persino saltare alcuni dei test alterando ke, sad esempio, k='c',s={'c':'b','b':None}riduce il numero di test e inverte l'ordine di elaborazione originale.

Il timeit borsisti potrebbero contrattare sul costo dell'aggiunta di uno o due strati extra allo stack e il costo per il dict alzare lo sguardo, ma sembri più preoccupato della bellezza del codice.

In alternativa, un'implementazione più semplice potrebbe essere la seguente:

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. Intendo questo non in termini di pep8 ma in termini di utilizzo di una parola descrittiva concisa al posto di una frase. Concesso l'OP potrebbe seguire una convenzione di codifica, lavorare su una base di codice esistente o non occuparsi di termini concisi nella loro base di codice.