Cách Pythonic để tránh các câu lệnh x nếu return x x return

Tôi có một phương thức gọi 4 phương thức khác theo trình tự để kiểm tra các điều kiện cụ thể và trả về ngay lập tức (không kiểm tra các phương thức sau) mỗi khi trả về một điều gì đó Sự thật.

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

Điều này có vẻ như rất nhiều mã hành lý. Thay vì mỗi câu lệnh if 2 dòng, tôi muốn làm một cái gì đó như:

x and return x

Nhưng đó là Python không hợp lệ. Tôi có thiếu một giải pháp đơn giản, thanh lịch ở đây không? Ngẫu nhiên, trong tình huống này, bốn phương thức kiểm tra đó có thể tốn kém, vì vậy tôi không muốn gọi chúng nhiều lần.

Bạn có thể sử dụng một vòng lặp:

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

Điều này có thêm lợi thế là bây giờ bạn có thể biến số điều kiện thành biến.

Bạn có thể sử dụng map()+ filter()(phiên bản Python 3, sử dụng các future_builtinsphiên bản trong Python 2) để nhận giá trị khớp đầu tiên như vậy:

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)

nhưng nếu điều này dễ đọc hơn là tranh cãi.

Một tùy chọn khác là sử dụng biểu thức trình tạo:

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)

Ngoài ra, với câu trả lời hay của Martijn, bạn có thể xâu chuỗi or. Điều này sẽ trả về giá trị trung thực đầu tiên hoặc Nonenếu không có giá trị trung thực:

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

Bản giới thiệu:

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

Đừng thay đổi nó

Có nhiều cách khác để làm điều này như các câu trả lời khác nhau cho thấy. Không có gì rõ ràng như mã ban đầu của bạn.

Trong câu trả lời có hiệu quả tương tự như dòng thời gian, nhưng bạn có thể sử dụng dấu ngoặc đơn để định dạng đẹp hơn:

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

Theo luật của xoăn , bạn có thể làm cho mã này dễ đọc hơn bằng cách chia hai mối quan tâm:

• Những gì tôi kiểm tra?
• Có một điều trở lại đúng?

thành hai chức năng:

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

Điều này tránh:

• cấu trúc logic phức tạp
• những hàng thật dài
• sự lặp lại

... Trong khi bảo tồn một luồng tuyến tính, dễ đọc.

Bạn có thể cũng có thể đưa ra các tên hàm thậm chí tốt hơn, theo hoàn cảnh cụ thể của bạn, làm cho nó thậm chí còn dễ đọc hơn.

Đây là một biến thể của ví dụ đầu tiên của Martijns. Nó cũng sử dụng kiểu "bộ sưu tập các cuộc gọi" để cho phép đoản mạch.

Thay vì một vòng lặp, bạn có thể sử dụng nội dung any.

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

Lưu ý rằng anytrả về boolean, vì vậy nếu bạn cần giá trị trả về chính xác của séc, giải pháp này sẽ không hoạt động. anysẽ không phân biệt được giữa 14, 'red', 'sharp', 'spicy'như các giá trị trở lại, tất cả họ sẽ được trả lại như True.

Bạn đã xem xét chỉ viết if x: return xtất cả trên một dòng?

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

Đây không phải là ít lặp đi lặp lại so với những gì bạn đã có, nhưng IMNSHO nó đọc khá mượt mà.

Tôi khá ngạc nhiên khi không ai đề cập đến phần tích hợp anyđược tạo ra cho mục đích này:

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

Lưu ý rằng mặc dù việc triển khai này có thể là rõ ràng nhất, nhưng nó đánh giá tất cả các kiểm tra ngay cả khi kiểm tra đầu tiên là True.

Nếu bạn thực sự cần dừng lại ở lần kiểm tra thất bại đầu tiên, hãy xem xét sử dụng reducedanh sách được thực hiện để chuyển đổi danh sách thành giá trị đơn giản:

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]): Áp dụng hàm của hai đối số tích lũy cho các mục của iterable, từ trái sang phải, để giảm số lần lặp xuống một giá trị. Đối số bên trái, x, là giá trị tích lũy và đối số bên phải, y, là giá trị cập nhật từ lần lặp. Nếu trình khởi tạo tùy chọn có mặt, nó được đặt trước các mục của phép lặp trong phép tính

Trong trường hợp của bạn:

• lambda a, f: a or f()là chức năng kiểm tra xem bộ tích lũy ahoặc kiểm tra hiện tại f()là True. Lưu ý rằng nếu acó True, f()sẽ không được đánh giá.
• checkschứa các chức năng kiểm tra ( fmục từ lambda)
• False là giá trị ban đầu, nếu không sẽ không có kiểm tra nào xảy ra và kết quả sẽ luôn là True

anyvà reducelà các công cụ cơ bản để lập trình chức năng. Tôi đặc biệt khuyến khích bạn đào tạo những điều này cũng như mapđó là tuyệt vời quá!

Nếu bạn muốn cấu trúc mã tương tự, bạn có thể sử dụng các câu lệnh 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

Tôi nghĩ rằng điều này có vẻ tốt đẹp và rõ ràng nếu bạn nhìn vào nó.

Bản giới thiệu:

Đối với tôi, câu trả lời tốt nhất là từ @ phil-frost, tiếp theo là @ wayne-werner's.

Điều tôi cảm thấy thú vị là không ai nói gì về thực tế rằng một hàm sẽ trả về nhiều loại dữ liệu khác nhau, điều này sẽ khiến sau đó bắt buộc phải kiểm tra loại x để thực hiện bất kỳ công việc nào khác.

Vì vậy, tôi sẽ trộn phản hồi của @ PhilFrost với ý tưởng giữ một loại duy nhất:

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

Lưu ý rằng xđược thông qua như là một đối số, nhưng cũng all_conditionsđược sử dụng như một trình tạo các hàm kiểm tra được thông qua trong đó tất cả chúng đều xđược kiểm tra và trả về Truehoặc False. Bằng cách sử dụng funcvới all_conditionsgiá trị mặc định, bạn có thể sử dụng assessed_x(x)hoặc bạn có thể chuyển một trình tạo được cá nhân hóa thêm thông qua func.

Bằng cách đó, bạn nhận được xngay khi một kiểm tra vượt qua, nhưng nó sẽ luôn là cùng một loại.

Lý tưởng nhất, tôi sẽ viết lại các check_ hàm để trả về Truehoặc Falsehơn là một giá trị. Séc của bạn sau đó trở thành

if check_size(x):
    return x
#etc

Giả sử bạn xkhông phải là bất biến, chức năng của bạn vẫn có thể sửa đổi nó (mặc dù họ không thể gán lại nó) - nhưng checkdù sao thì một chức năng được gọi là không nên sửa đổi nó.

Một biến thể nhỏ trên ví dụ đầu tiên của Martijns ở trên, sẽ tránh được nếu bên trong vòng lặp:

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

Tôi thích @ tim xoay của. Trong khi đó, tôi muốn nói thêm rằng việc thể hiện Nonetrong returntuyên bố là không cần thiết vì bộ sưu tập các orcâu lệnh tách biệt được đánh giá và không có gì đầu tiên, không trống, không ai được trả về và nếu không có thì Nonesẽ được trả về có Nonehay không có!

Vì vậy, check_all_conditions()chức năng của tôi trông như thế này:

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

Sử dụng timeitvới number=10**7tôi đã xem xét thời gian chạy của một số gợi ý. Để so sánh, tôi chỉ sử dụng random.random()hàm để trả về một chuỗi hoặc Nonedựa trên các số ngẫu nhiên. Đây là toàn bộ mã:

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

Và đây là kết quả:

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

Cách này là một chút bên ngoài của hộp, nhưng tôi nghĩ rằng kết quả cuối cùng là đơn giản, dễ đọc và trông đẹp.

Ý tưởng cơ bản là raisemột ngoại lệ khi một trong các hàm đánh giá là trung thực và trả về kết quả. Đây là cách nó có thể trông:

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

Bạn sẽ cần một assertFalseyhàm làm tăng ngoại lệ khi một trong các đối số hàm được gọi là đánh giá là trung thực:

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

Ở trên có thể được sửa đổi để cũng cung cấp các đối số cho các chức năng được đánh giá.

Và tất nhiên bạn sẽ cần TruthyExceptionchính nó. Ngoại lệ này cung cấp ngoại lệ objectkích hoạt ngoại lệ:

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

Tất nhiên, bạn có thể biến chức năng ban đầu thành một cái gì đó tổng quát hơn:

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)

Điều này có thể chậm hơn một chút vì bạn đang sử dụng cả ifcâu lệnh và xử lý ngoại lệ. Tuy nhiên, ngoại lệ chỉ được xử lý tối đa một lần, do đó, lần truy cập hiệu suất chỉ là nhỏ trừ khi bạn muốn chạy kiểm tra và nhận được Truegiá trị nhiều nghìn lần.

Cách pythonic là sử dụng less (như ai đó đã đề cập) hoặc itertools (như hiển thị bên dưới), nhưng đối với tôi, chỉ cần sử dụng ngắn mạch của ortoán tử sẽ tạo ra mã rõ ràng hơn

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

Tôi sẽ nhảy vào đây và chưa bao giờ viết một dòng Python nào, nhưng tôi cho if x = check_something(): return xlà hợp lệ?

nếu vậy:

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

Hoặc sử dụng max:

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

Tôi đã thấy một số triển khai thú vị của các báo cáo chuyển đổi / trường hợp với các dấu hiệu trong quá khứ dẫn tôi đến câu trả lời này. Sử dụng ví dụ bạn đã cung cấp, bạn sẽ nhận được những điều sau đây. (Thật điên rồ using_complete_sentences_for_function_names, vì vậy check_all_conditionsđược đổi tên thành status. Xem (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

Hàm select sẽ loại bỏ nhu cầu gọi check_FUNCTIONhai lần tức là bạn tránh check_FUNCTION() if check_FUNCTION() else nextbằng cách thêm một lớp chức năng khác. Điều này rất hữu ích cho các chức năng chạy dài. Các lambdas trong việc thực thi độ trễ dict của các giá trị của nó cho đến vòng lặp while.

Là một phần thưởng, bạn có thể sửa đổi thứ tự thực hiện và thậm chí bỏ qua một số thử nghiệm bằng cách thay đổi kvà sví dụ như k='c',s={'c':'b','b':None}giảm số lượng thử nghiệm và đảo ngược thứ tự xử lý ban đầu.

Các timeitnghiên cứu sinh có thể mặc cả về chi phí thêm một hoặc hai lớp bổ sung vào ngăn xếp và chi phí cho việc tìm kiếm chính tả nhưng bạn có vẻ quan tâm nhiều hơn đến tính hay của mã.

Ngoài ra, việc thực hiện đơn giản hơn có thể là như sau:

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. Ý tôi là điều này không phải ở khía cạnh pep8 mà là về cách sử dụng một từ mô tả ngắn gọn thay cho câu. Cấp cho OP có thể tuân theo một số quy ước mã hóa, làm việc một số cơ sở mã hiện có hoặc không quan tâm đến các điều khoản ngắn gọn trong cơ sở mã của họ.