Cara Pythonic untuk menghindari pernyataan “if x: return x”

Saya memiliki metode yang memanggil 4 metode lain secara berurutan untuk memeriksa kondisi tertentu, dan segera kembali (tidak memeriksa yang berikut) setiap kali seseorang mengembalikan sesuatu yang Sejati.

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

Ini sepertinya banyak kode bagasi. Alih-alih setiap pernyataan 2-baris jika, saya lebih suka melakukan sesuatu seperti:

x and return x

Tapi itu Python tidak valid. Apakah saya melewatkan solusi sederhana dan elegan di sini? Kebetulan, dalam situasi ini, keempat metode pemeriksaan mungkin mahal, jadi saya tidak ingin memanggil mereka beberapa kali.

Anda bisa menggunakan loop:

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

Ini memiliki keuntungan tambahan yang sekarang Anda dapat membuat jumlah kondisi menjadi variabel.

Anda bisa menggunakan map()+ filter()(versi Python 3, menggunakan future_builtinsversi dalam Python 2) untuk mendapatkan nilai pencocokan pertama seperti:

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)

tetapi jika ini lebih mudah dibaca bisa diperdebatkan.

Pilihan lain adalah menggunakan ekspresi generator:

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)

Atau sebagai jawaban baik Martijn, Anda bisa berantai or. Ini akan mengembalikan nilai kebenaran pertama, atau Nonejika tidak ada nilai kebenaran:

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

Jangan ubah itu

Ada cara lain untuk melakukan ini sebagaimana ditunjukkan oleh berbagai jawaban lainnya. Tidak ada yang sejelas kode asli Anda.

Secara efektif jawaban yang sama dengan timgeb, tetapi Anda bisa menggunakan tanda kurung untuk pemformatan yang lebih baik:

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

Menurut hukum Curly , Anda dapat membuat kode ini lebih mudah dibaca dengan membagi dua masalah:

• Apa yang harus saya periksa?
• Apakah satu hal kembali benar?

menjadi dua fungsi:

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

Ini menghindari:

• struktur logis yang rumit
• garis yang sangat panjang
• pengulangan

... sembari mempertahankan alur yang linier dan mudah dibaca.

Anda mungkin juga dapat membuat nama fungsi yang lebih baik, sesuai dengan keadaan khusus Anda, yang membuatnya lebih mudah dibaca.

Ini adalah varian dari Martijns, contoh pertama. Ini juga menggunakan "koleksi callable" -style untuk memungkinkan hubungan arus pendek.

Alih-alih loop Anda bisa menggunakan builtin any.

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

Perhatikan bahwa anymengembalikan boolean, jadi jika Anda membutuhkan nilai pengembalian yang tepat dari cek, solusi ini tidak akan berfungsi. anytidak akan membedakan antara 14, 'red', 'sharp', 'spicy'sebagai nilai-nilai kembali, mereka semua akan dikembalikan sebagai True.

Sudahkah Anda mempertimbangkan untuk menulis if x: return xsemuanya dalam satu baris?

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

Ini tidak kurang berulang dari apa yang Anda miliki, tetapi IMNSHO bunyinya sedikit lebih lancar.

Saya cukup terkejut tidak ada yang menyebutkan built-in anyyang dibuat untuk tujuan ini:

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

Perhatikan bahwa meskipun implementasi ini mungkin yang paling jelas, ia mengevaluasi semua pemeriksaan bahkan jika yang pertama adalah True.

Jika Anda benar-benar harus berhenti di cek gagal pertama, pertimbangkan untuk menggunakan reduceyang dibuat untuk mengkonversi daftar ke nilai sederhana:

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]): Menerapkan fungsi dua argumen secara kumulatif ke item yang dapat diubah, dari kiri ke kanan, sehingga mengurangi iterable ke nilai tunggal. Argumen kiri, x, adalah nilai akumulasi dan argumen kanan, y, adalah nilai pembaruan dari iterable. Jika inisialisasi opsional hadir, ia ditempatkan sebelum item iterable dalam perhitungan

Dalam kasus Anda:

• lambda a, f: a or f()adalah fungsi yang memeriksa apakah akumulator aatau cek saat f()ini True. Perhatikan bahwa jika aadalah True,f() tidak akan dievaluasi.
• checks berisi fungsi pemeriksaan (the f item dari lambda)
• False adalah nilai awal, jika tidak cek tidak akan terjadi dan hasilnya akan selalu True

anydan reducemerupakan alat dasar untuk pemrograman fungsional. Saya sangat mendorong Anda untuk melatih ini dan mapyang juga luar biasa!

Jika Anda menginginkan struktur kode yang sama, Anda bisa menggunakan pernyataan ternary!

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

Saya pikir ini terlihat bagus dan jelas jika Anda melihatnya.

Demo:

Bagi saya, jawaban terbaik adalah dari @ phil-frost, diikuti oleh @ wayne-werner's.

Apa yang saya temukan menarik adalah bahwa tidak ada yang mengatakan apa-apa tentang fakta bahwa suatu fungsi akan mengembalikan banyak tipe data yang berbeda, yang akan membuat wajib untuk melakukan pemeriksaan pada tipe x itu sendiri untuk melakukan pekerjaan lebih lanjut.

Jadi saya akan mencampur respon @ PhilFrost dengan ide menjaga satu tipe:

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

Perhatikan bahwa xdilewatkan sebagai argumen, tetapi juga all_conditionsdigunakan sebagai generator lulus dari fungsi pemeriksaan di mana semuanya mendapatkan xdiperiksa, dan kembali Trueatau False. Dengan menggunakan funcdengan all_conditionssebagai nilai default, Anda dapat menggunakan assessed_x(x), atau Anda dapat melewati generator pribadi lebih lanjut melalui func.

Dengan begitu, Anda mendapatkan xbegitu satu cek berlalu, tetapi itu akan selalu menjadi tipe yang sama.

Idealnya, saya akan menulis ulang check_ fungsi untuk mengembalikan Trueatau Falsedaripada nilai. Cek Anda kemudian menjadi

if check_size(x):
    return x
#etc

Dengan asumsi Anda xtidak dapat diubah, fungsi Anda masih dapat memodifikasinya (meskipun mereka tidak dapat menugaskannya kembali) - tetapi fungsi yang dipanggil checktidak boleh benar-benar memodifikasinya.

Sedikit variasi pada Martijns contoh pertama di atas, yang menghindari if di dalam loop:

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

Saya suka @ timgeb. Sementara itu saya ingin menambahkan bahwa mengekspresikan Nonedalam returnpernyataan tidak diperlukan karena kumpulan orpernyataan terpisah dievaluasi dan yang pertama tidak-nol, tidak-kosong, tidak ada-Tidak ada yang dikembalikan dan jika tidak ada maka Nonedikembalikan apakah adaNone atau tidak!

Jadi check_all_conditions()fungsi saya terlihat seperti ini:

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

Menggunakan timeitdengan number=10**7saya melihat waktu berjalan sejumlah saran. Demi perbandingan, saya hanya menggunakan random.random()fungsi untuk mengembalikan string atau Noneberdasarkan angka acak. Ini seluruh kodenya:

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

Dan inilah hasilnya:

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

Cara ini sedikit di luar kotak, tapi saya pikir hasil akhirnya sederhana, mudah dibaca, dan terlihat bagus.

Ide dasarnya adalah raisepengecualian ketika salah satu fungsi mengevaluasi sebagai kebenaran, dan mengembalikan hasilnya. Begini tampilannya:

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

Anda akan membutuhkan assertFalseyfungsi yang menimbulkan pengecualian ketika salah satu dari argumen fungsi yang dipanggil mengevaluasi sebagai benar:

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

Di atas dapat dimodifikasi sehingga juga memberikan argumen untuk fungsi yang akan dievaluasi.

Dan tentu saja Anda akan membutuhkannya TruthyExceptionsendiri. Pengecualian ini memberikan objectyang memicu pengecualian:

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

Anda dapat mengubah fungsi asli menjadi sesuatu yang lebih umum, tentu saja:

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)

Ini mungkin sedikit lebih lambat karena Anda menggunakan ifpernyataan dan penanganan pengecualian. Namun, pengecualian hanya ditangani maksimal satu kali, sehingga hit ke kinerja harus kecil kecuali jika Anda berharap untuk menjalankan pemeriksaan dan mendapatkan Truenilai ribuan kali.

Cara pythonic adalah dengan menggunakan perkecil (seperti yang telah seseorang sebutkan) atau itertools (seperti yang ditunjukkan di bawah), tetapi bagi saya tampaknya hanya dengan menggunakan korsleting dari oroperator menghasilkan kode yang lebih jelas.

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

Saya akan melompat ke sini dan tidak pernah menulis satu baris pun Python, tapi saya berasumsi if x = check_something(): return x valid?

jika begitu:

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

Atau gunakan max:

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

Saya telah melihat beberapa implementasi yang menarik dari pernyataan switch / case dengan dikt di masa lalu yang mengarahkan saya ke jawaban ini. Dengan menggunakan contoh yang Anda berikan Anda akan mendapatkan yang berikut. (Ini kegilaan using_complete_sentences_for_function_names, jadi check_all_conditionsberganti nama menjadi status. Lihat (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

Fungsi pilih menghilangkan kebutuhan untuk memanggil masing-masing check_FUNCTIONdua kali yaitu Anda menghindaricheck_FUNCTION() if check_FUNCTION() else next dengan menambahkan lapisan fungsi lain. Ini berguna untuk fungsi yang berjalan lama. Lambda dalam eksekusi penundaan nilai-nilai itu sampai loop sementara.

Sebagai bonus, Anda dapat memodifikasi urutan eksekusi dan bahkan melewatkan beberapa tes dengan mengubah kdan smisalnyak='c',s={'c':'b','b':None} mengurangi jumlah tes dan membalik urutan pemrosesan asli.

Itu timeit orang mungkin tawar-menawar tentang biaya menambahkan satu atau dua lapisan tambahan ke tumpukan dan biaya untuk mendikte mencari tetapi Anda tampaknya lebih peduli dengan kecantikan kode.

Atau implementasi yang lebih sederhana mungkin sebagai berikut:

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. Maksud saya ini bukan dalam hal pep8 tetapi dalam hal menggunakan satu kata deskriptif ringkas sebagai pengganti kalimat. Memang OP mungkin mengikuti beberapa konvensi pengkodean, bekerja satu basis kode yang ada atau tidak peduli dengan istilah singkat dalam basis kode mereka.