Pythonic способ избежать высказываний «if x: return x»

У меня есть метод, который вызывает 4 других метода в последовательности, чтобы проверить определенные условия, и возвращает сразу (не проверяя следующие) всякий раз, когда кто-то возвращает что-то 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

Это похоже на большой багажный код. Вместо каждого двухстрочного оператора if я бы предпочел сделать что-то вроде:

x and return x

Но это неверный Python. Я скучаю по простому, элегантному решению здесь? Кстати, в этой ситуации эти четыре метода проверки могут быть дорогими, поэтому я не хочу вызывать их несколько раз.

Вы можете использовать цикл:

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

Это дает дополнительное преимущество: теперь вы можете изменять число условий.

Вы можете использовать map()+ filter()(версии Python 3, используйте future_builtinsверсии в Python 2), чтобы получить первое такое соответствующее значение:

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)

но если это более читаемым спорно.

Другой вариант - использовать выражение генератора:

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)

В качестве альтернативы хорошему ответу Мартина, вы можете зацепить or. Это вернет первое истинное значение, или Noneесли нет истинного значения:

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

Демо-версия:

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

Не меняй

Есть другие способы сделать это, как показывают различные другие ответы. Ни один не так ясен, как ваш оригинальный код.

По сути, тот же ответ, что и у Timgeb, но вы можете использовать круглые скобки для лучшего форматирования:

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

Согласно закону Керли , вы можете сделать этот код более читабельным, разделив две задачи:

• Какие вещи я проверяю?
• Вернулась ли одна вещь верной?

на две функции:

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

Это позволяет избежать:

• сложные логические структуры
• действительно длинные очереди
• репетиция

... сохраняя линейный, легко читаемый поток.

Вы также можете придумать еще лучшие имена функций, в зависимости от ваших конкретных обстоятельств, которые делают его еще более читабельным.

Это вариант первого примера Мартинса. Он также использует стиль "коллекции вызываемых", чтобы обеспечить короткое замыкание.

Вместо цикла вы можете использовать встроенный any.

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

Обратите внимание, что anyвозвращается логическое значение, поэтому, если вам нужно точное возвращаемое значение чека, это решение не будет работать. anyне будет различать 14, 'red', 'sharp', 'spicy'как возвращаемые значения, все они будут возвращены как True.

Рассматривали ли вы просто писать if x: return xвсе в одну строку?

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

Это не менее повторяюще, чем то, что вы имели, но IMNSHO читается немного более плавно.

Я весьма удивлен, что никто не упомянул встроенное, anyкоторое сделано для этой цели:

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

Обратите внимание, что хотя эта реализация, вероятно, является самой ясной, она оценивает все проверки, даже если первая из них True.

Если вам действительно нужно остановиться на первой неудачной проверке, рассмотрите возможность использования reduceкоторой для преобразования списка в простое значение:

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]): Применить функцию двух аргументов кумулятивно к элементам итерируемого слева направо, чтобы свести итерируемое к одному значению. Левый аргумент x - это накопленное значение, а правый аргумент y - это значение обновления из итерируемого. Если присутствует необязательный инициализатор, он помещается перед элементами итерируемого в вычислении

В твоем случае:

• lambda a, f: a or f()это функция , которая проверяет , что либо аккумулятор aили текущий контроль f()является True. Обратите внимание, что если aесть True, f()не будет оцениваться.
• checksсодержит функции проверки ( fэлемент из лямбды)
• False является начальным значением, иначе проверка не произойдет, и результат всегда будет True

anyи reduceявляются основными инструментами для функционального программирования. Я настоятельно рекомендую вам обучить их, а также mapэто здорово!

Если вам нужна та же структура кода, вы можете использовать троичные операторы!

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

Я думаю, это выглядит красиво и понятно, если вы посмотрите на это.

Демо-версия:

Для меня лучший ответ - ответ @ phil-frost, за которым следует @ wayne-werner.

Что мне кажется интересным, так это то, что никто ничего не сказал о том факте, что функция будет возвращать много разных типов данных, что сделает обязательным выполнение проверок самого типа x для дальнейшей работы.

Поэтому я бы смешал ответ @ PhilFrost с идеей сохранить один тип:

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

Обратите внимание, что xон передается как аргумент, но также all_conditionsиспользуется как переданный генератор проверяющих функций, где все они получают xпроверяемый объект и возвращают Trueили False. При использовании funcс в all_conditionsкачестве значения по умолчанию, вы можете использовать assessed_x(x), или вы можете пройти дальше персонализированный генератор черезfunc .

Таким образом, вы получите, xкак только пройдет одна проверка, но она всегда будет одного типа.

В идеале я бы переписал check_ функции для возврата Trueили Falseвместо значения. Ваши чеки становятся

if check_size(x):
    return x
#etc

Предполагая, что ваша xпеременная не является неизменной, ваша функция все равно может изменить ее (хотя они не могут переназначить ее), но вызываемая функция на checkсамом деле не должна изменять ее.

Небольшое изменение в первом примере Martijns выше, которое позволяет избежать if внутри цикла:

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

Мне нравится @ Timgeb's. В то же время я хотел бы добавить, что выражение Noneв returnвыражении не требуется, так как orоценивается коллекция разделенных выражений и возвращается первое ненулевое, пустое, пустое и если не существует, то Noneвозвращается есть лиNone или нет!

Итак, моя check_all_conditions()функция выглядит так:

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

Использование timeitс number=10**7я посмотрел на время выполнения ряда предложений. Для сравнения я просто использовал random.random()функцию для возврата строки или Noneна основе случайных чисел. Вот весь код:

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

И вот результаты:

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

Этот способ немного нестандартен, но я думаю, что конечный результат прост, удобочитаем и выглядит красиво.

Основная идея заключается в raiseисключении, когда одна из функций оценивается как верная и возвращает результат. Вот как это может выглядеть:

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

Вам понадобится assertFalseyфункция, которая вызывает исключение, когда один из аргументов вызываемой функции оценивается как истинный:

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

Выше может быть изменено, чтобы также обеспечить аргументы для функций, которые будут оцениваться.

И конечно тебе понадобится TruthyExceptionсама. Это исключение обеспечивает то, objectчто вызвало исключение:

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

Конечно, вы можете превратить оригинальную функцию во что-то более общее:

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)

Это может быть немного медленнее, потому что вы используете как ifоператор, так и обработку исключения. Однако исключение обрабатывается не более одного раза, поэтому снижение производительности должно быть незначительным, если вы не собираетесь запускать проверку и получать Trueзначение много-много тысяч раз.

Питонический способ - это использовать redu (как кто-то уже упоминал) или itertools (как показано ниже), но мне кажется, что простое использование короткого замыкания orоператора дает более четкий код

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

Я собираюсь прыгнуть сюда и никогда не писал ни одной строки Python, но я предполагаю, что if x = check_something(): return xэто правильно?

если так:

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

Или используйте max:

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

В прошлом я видел несколько интересных реализаций операторов switch / case с диктовками, которые привели меня к этому ответу. Используя приведенный вами пример, вы получите следующее. (Это безумие using_complete_sentences_for_function_names, поэтому check_all_conditionsпереименовано в status. См. (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

Функция выбора избавляет от необходимости вызывать каждый check_FUNCTIONдважды, т.е. вы избегаетеcheck_FUNCTION() if check_FUNCTION() else next добавления другого функционального слоя. Это полезно для долго работающих функций. Лямбды в dict задерживают выполнение его значений до цикла while.

В качестве бонуса вы можете изменить порядок выполнения и даже пропустить некоторые тесты, изменив kи, sнапример,k='c',s={'c':'b','b':None} уменьшив количество тестов и отменив исходный порядок обработки.

timeit стипендиатов может торговаться стоимость добавления дополнительного слоя или два стека и стоимость для Dict посмотреть , но вы , кажется , больше озабочены красивости кода.

Альтернативно, более простая реализация может быть следующей:

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. Я имею в виду это не с точки зрения pep8, а с точки зрения использования одного краткого описательного слова вместо предложения. Конечно, OP может следовать некоторому соглашению о кодировании, работать с какой-то существующей кодовой базой или не заботиться о кратких терминах в их кодовой базе.