根据Curly定律，你可以通过拆分两个关注点来提高代码的可读性:

我要检查哪些东西? 有一件事是真的吗?

分为两个功能:

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

这避免了:

复杂的逻辑结构 非常长的队伍 重复

.．.同时保留一个线性的，易于阅读的流。

根据您的特定情况，您可能还可以提出更好的函数名称，使其更具可读性。

python的方法是使用reduce(有人已经提到过)或itertools(如下所示)，但在我看来，简单地使用或操作符的短路可以产生更清晰的代码

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

这是马丁第一个例子的一个变种。为了允许短路，它还使用了“可调用对象的集合”样式。

而不是循环，你可以使用内置的任何。

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

注意，any返回一个布尔值，所以如果您需要检查的确切返回值，这个解决方案将不起作用。any将不会区分14，'red'， 'sharp'， 'spicy'作为返回值，它们都将作为True返回。

我很惊讶没有人提到内置的任何是为了这个目的:

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]):应用2的函数 参数从左到右累加到iterable的项， 从而将可迭代对象减少为单个值。左边的参数x， 累积值和正确的参数y是否更新 值。如果存在可选初始化式，则为 在计算中置于可迭代对象的项之前

在你的情况下:

lambda a, f: a或f()是检查累加器a或当前检查f()是否为True的函数。注意，如果a为True, f()将不会被求值。 检查包含检查函数(来自lambda的f项) False是初始值，否则不会发生检查，结果总是True

Any和reduce是函数式编程的基本工具。我强烈建议你训练这些以及地图，这是很棒的!

如果你需要Python 3.8，你可以使用“赋值表达式”的新特性来减少If -else链的重复:

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

我在过去看到过一些有趣的switch/case语句的dicts实现，这让我得出了这个答案。使用您提供的示例，您将得到以下结果。(使用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() else，则避免check_FUNCTION()。这对于长时间运行的函数很有用。dict中的lambdas将其值的执行延迟到while循环。

作为奖励，您可以修改执行顺序，甚至通过更改k和s跳过一些测试，例如k='c'，s={'c':'b'，'b':None}减少测试的数量并反转原始的处理顺序。

那些花时间的人可能会为在堆栈中增加一两个额外层的成本和字典查找的成本而讨价还价，但你似乎更关心代码的美观。

另一种更简单的实现方式可能是:

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

我指的不是pep8，而是用一个简明的描述性词语来代替句子。当然OP可能会遵循一些编码惯例，使用一些现有的代码库，或者不关心代码库中的简洁术语。