Maneira pitônica de evitar declarações “if x: return x”

Eu tenho um método que chama 4 outros métodos em sequência para verificar condições específicas e retorna imediatamente (não verificando os seguintes) sempre que alguém retorna algo Truthy.

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

Parece muito código de bagagem. Em vez de cada declaração if de 2 linhas, prefiro fazer algo como:

x and return x

Mas isso é Python inválido. Estou perdendo uma solução simples e elegante aqui? Aliás, nessa situação, esses quatro métodos de verificação podem ser caros, então não quero chamá-los várias vezes.

Você pode usar um loop:

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

Isso tem a vantagem adicional de que agora você pode tornar o número de condições variáveis.

Você pode usar map()+ filter()(as versões do Python 3, use as future_builtinsversões do Python 2) para obter o primeiro valor correspondente:

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)

mas se for mais legível, é discutível.

Outra opção é usar uma expressão geradora:

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)

Como alternativa à boa resposta de Martijn, você pode encadear or. Isso retornará o primeiro valor de verdade, ou Nonese não houver valor de verdade:

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

Não mude

Existem outras maneiras de fazer isso, como mostram as várias outras respostas. Nenhum é tão claro quanto o seu código original.

Efetivamente, a mesma resposta que timgeb, mas você pode usar parênteses para obter uma formatação melhor:

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

De acordo com a lei de Curly , você pode tornar esse código mais legível dividindo duas preocupações:

• Que coisas eu verifico?
• Uma coisa voltou verdadeira?

em duas funções:

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

Isso evita:

• estruturas lógicas complicadas
• linhas muito longas
• repetição

... preservando um fluxo linear e fácil de ler.

Você provavelmente também pode criar nomes de funções ainda melhores, de acordo com sua circunstância específica, o que o torna ainda mais legível.

Esta é uma variante do primeiro exemplo de Martijns. Ele também usa o estilo "coleção de callables" para permitir um curto-circuito.

Em vez de um loop, você pode usar o builtin any.

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

Observe que anyretorna um booleano; portanto, se você precisar do valor exato de retorno da verificação, esta solução não funcionará. anynão fará distinção entre 14, 'red', 'sharp', 'spicy'como valores de retorno, todos eles serão devolvidos como True.

Você já pensou em escrever if x: return xtudo em uma linha?

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

Isso não é menos repetitivo do que você tinha, mas IMNSHO parece um pouco mais suave.

Estou surpreso que ninguém tenha mencionado o built-in anyque é feito para esse fim:

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

Observe que embora essa implementação seja provavelmente a mais clara, ela avalia todas as verificações, mesmo que a primeira seja True.

Se você realmente precisar parar na primeira falha na verificação, considere usar o reduceque é feito para converter uma lista em um valor simples:

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]): Aplique a função de dois argumentos cumulativamente aos itens de iterável, da esquerda para a direita, para reduzir o iterável a um único valor. O argumento da esquerda, x, é o valor acumulado e o argumento da direita, y, é o valor de atualização do iterável. Se o inicializador opcional estiver presente, ele será colocado antes dos itens do iterável no cálculo

No seu caso:

• lambda a, f: a or f()é a função que verifica se o acumulador aou a verificação atual f()é True. Observe que se afor True,f() não será avaliado.
• checks contém funções de verificação (o f item do lambda)
• False é o valor inicial, caso contrário, nenhuma verificação aconteceria e o resultado seria sempre True

anye reducesão ferramentas básicas para programação funcional. Convido você a treiná-los e também o mapque é incrível!

Se você quiser a mesma estrutura de código, poderá usar declarações ternárias!

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

Eu acho que isso parece bom e claro, se você olhar para ele.

Demo:

Para mim, a melhor resposta é a do @ phil-frost, seguida pelo @ wayne-werner's.

O que acho interessante é que ninguém disse nada sobre o fato de que uma função retornará muitos tipos de dados diferentes, o que tornará obrigatório fazer verificações no tipo de x em si para realizar qualquer trabalho adicional.

Então, eu misturaria a resposta do @ PhilFrost com a idéia de manter um único 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 isso xé passado como argumento, mas também all_conditionsé usado como um gerador passado de funções de verificação, onde todas elas recebem uma xverificação e retornam Trueou False. Usando funccom all_conditionso valor padrão, você pode usarassessed_x(x) , ou você pode passar um gerador de ainda mais personalizado viafunc .

Dessa forma, você recebe xassim que um cheque passa, mas sempre será do mesmo tipo.

Idealmente, eu reescreveria as check_ funções para retornar Trueou, em Falsevez de um valor. Seus cheques então se tornam

if check_size(x):
    return x
#etc

Supondo que você xnão seja imutável, sua função ainda poderá modificá-la (embora não possa reatribuí-la) - mas uma função chamada checknão deve realmente modificá-la de qualquer maneira.

Uma pequena variação no primeiro exemplo de Martijns acima, que evita o se dentro do loop:

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

Eu gosto de @ timgeb's. Enquanto isso, gostaria de acrescentar que a expressão Nonena returndeclaração não é necessária, pois a coleção de orinstruções separadas é avaliada e a primeira zero-zero, nenhuma-vazia, nenhuma-Nenhuma é retornada e, se não houver nenhuma, Noneé retornada. se existe Noneou não!

Então, minha check_all_conditions()função é assim:

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

Usando timeit com number=10**7eu olhei para o tempo de execução de várias sugestões. Para fins de comparação, usei a random.random()função para retornar uma string ou com Nonebase em números aleatórios. Aqui está o código inteiro:

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 aqui estão os resultados:

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

Dessa forma, é um pouco fora da caixa, mas acho que o resultado final é simples, legível e com boa aparência.

A idéia básica é raiseuma exceção quando uma das funções é avaliada como verdadeira e retorna o resultado. Aqui está como isso pode parecer:

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

Você precisará de uma assertFalseyfunção que crie uma exceção quando um dos argumentos de função chamados for avaliado como verdadeiro:

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

O exposto acima pode ser modificado para fornecer também argumentos para as funções a serem avaliadas.

E é claro que você precisará do TruthyExceptionpróprio. Esta exceção fornece o objectque acionou a exceção:

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

Você pode transformar a função original em algo mais geral, é claro:

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)

Isso pode ser um pouco mais lento porque você está usando uma ifinstrução e manipulando uma exceção. No entanto, a exceção é tratada apenas no máximo uma vez, portanto, o impacto no desempenho deve ser menor, a menos que você espere executar a verificação e obter um Truevalor muitos milhares de vezes.

A maneira pitônica é usar o comando reduzir (como alguém já mencionado) ou ferramentas (como mostrado abaixo), mas parece-me que o simples uso do curto-circuito do oroperador produz um código mais 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

Vou pular aqui e nunca escrevi uma única linha de Python, mas presumo que if x = check_something(): return xseja válido?

se então:

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

Ou use max:

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

Eu já vi algumas implementações interessantes de declarações de troca / caso com ditados no passado que me levaram a essa resposta. Usando o exemplo que você forneceu, você obteria o seguinte. (É loucura using_complete_sentences_for_function_names, então check_all_conditionsé renomeado para status. Veja (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

A função de seleção elimina a necessidade de chamar cada check_FUNCTIONduas vezes, ou seja, você evitacheck_FUNCTION() if check_FUNCTION() else next adicionando outra camada de função. Isso é útil para funções de execução longa. As lambdas no ditado atrasam a execução de seus valores até o loop while.

Como bônus, você pode modificar a ordem de execução e até pular alguns dos testes alterando ke, spor exemplo,k='c',s={'c':'b','b':None} reduzindo o número de testes e revertendo a ordem de processamento original.

o timeit bolsistas podem pechinchar sobre o custo de adicionar uma ou duas camadas extras à pilha e o custo do ditado procurar, mas você parece mais preocupado com a beleza do código.

Como alternativa, uma implementação mais simples pode ser a seguinte:

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. Quero dizer isso não em termos de pep8, mas em termos de usar uma palavra descritiva concisa no lugar de uma frase. Concedido que o OP pode estar seguindo alguma convenção de codificação, trabalhando em uma base de código existente ou não se importando com termos concisos em sua base de código.