Пітонічний спосіб уникнути висловлювань "якщо 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

Це здається великим кодом багажу. Замість кожного 2-рядкового оператора 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. Це поверне перше значення truthy, або Noneякщо немає значення truthy:

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

Це дозволяє уникнути:

• складні логічні структури
• дійсно довгі рядки
• повторення

... зберігаючи лінійний, легкий для читання потік.

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

Це варіант першого прикладу Martijns. Він також використовує стиль "колекції дзвінків", щоб дозволити коротке замикання.

Замість циклу ви можете використовувати вбудований 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's.

Що мені здається цікавим, це те, що ніхто не сказав нічого про те, що функція повертає безліч різних типів даних, що зробить обов'язковим проведення перевірки типу 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значення багато тисяч тисяч разів.

Пітонічний спосіб - або використання скорочення (як хтось уже згадував), або 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

У минулому я бачив кілька цікавих реалізацій операторів переключення / випадку з диктами, які привели мене до цієї відповіді. Використовуючи наведений приклад, ви отримаєте наступне. (Це божевілля 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

Функція select позбавляє від необхідності виклику кожного check_FUNCTIONразу двічі, тобто ви уникаєте check_FUNCTION() if check_FUNCTION() else nextдодавання іншого функціонального рівня. Це корисно для тривалих функцій. Лямбди в дикті затримують виконання його значень до циклу 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, а з точки зору використання одного стислого описового слова замість речення. Отриманий ОП може дотримуватися деякої конвенції кодування, працюючи з деякою існуючою базою коду або не піклуючись про стислі терміни в їхній кодовій базі.