python - Python 避免深度嵌套函数调用

Question

我有一系列函数，其中一个函数的结果被输入到下一个函数中，再加上其他输入:

result = function1(
    function2(
        function3(
            function4(x, y, z),
            a, b, c),
        d, e, f),
    g, h, i)

这很丑陋且难以理解。特别是，function1 实际上是最后一个被调用的函数并不明显。

如何以Pythonic 方式将这段代码写得更好？

我可以例如将中间结果分配给变量:

j = function4(x, y, z)
k = function3(j, a, b, c)
l = function2(k, d, e, f)
result = function1(l, g, h, i)

但这也会将我不需要的东西放入命名空间中，并且可能会阻止释放大量内存 - 除非我添加 del j, k, l,这是它自己的一种丑陋。另外，我必须想出名字。

或者我也可以将最终结果的名称用于中间结果:

result = function4(x, y, z)
result = function3(result, a, b, c)
result = function2(result, d, e, f)
result = function1(result, g, h, i)

这里的缺点是相同的名称可能用于完全不同的事物，这可能会使阅读和调试变得更加困难。

那么也许_或__？

__ = function4(x, y, z)
__ = function3(__, a, b, c)
__ = function2(__, d, e, f)
result = function1(__, g, h, i)

好一点，但还是不太清楚。我可能需要在末尾添加一个 del __ 。

有没有更好、更Pythonic的方法？

Answer 1

我认为嵌套函数调用并将结果分配给变量并不是一个糟糕的解决方案，特别是如果您使用描述性名称在单个函数中捕获整体。函数的名称是自记录的，允许重用复杂的结构，并且在函数中创建的局部变量仅在函数执行的生命周期内存在，因此您的命名空间保持干净。

话虽如此，根据传递的值的类型，您可以对该类型进行子类化，并将函数添加为类上的方法，这将允许您链接调用，我认为这非常有用Pythonic(如果父类(super class)适合它的话)。

pandas 库的工作方式和最近发生的变化就是一个例子。过去，许多 pandas.DataFrame 方法会采用名为 inplace 的可选参数来允许用户更改此设置:

import pandas as pd

df = pd.DataFrame(my_data)
df = df.some_operation(arg1, arg2)
df = df.some_other_operation(arg3, arg4)
...

对此:

import pandas as pd

df = pd.DataFrame(my_data)
df.some_operation(arg1, arg2, inplace=True)
df.some_other_operation(arg3, arg4, inplace=True)

使用inplace=True，原始的DataFrame将被修改(或者至少，最终结果表明这就是发生的事情)，并且在某些情况下它可能仍然被退回，在其他情况下则根本不被退回。这个想法是避免创建额外的数据；此外，许多用户会使用多个变量(df1、df2 等)来保留所有中间结果，通常没有充分的理由。

但是，您可能知道该模式是 bad idea in pandas有几个原因。

相反，现代 pandas 方法始终返回 DataFrame 本身，而 inplace 在它仍然存在的地方已被弃用。但因为现在所有函数都返回实际结果的 DataFrame，所以这是有效的:

import pandas as pd

df = pd.DataFrame(my_data)\
        .some_operation(arg1, arg2)
        .some_other_operation(arg3, arg4)

(请注意，这最初适用于 pandas 中已有的许多情况，但一致性不是这里的重点，重要的是模式)

您的情况可能类似，具体取决于您要传递的具体内容。从您提供的示例来看，尚不清楚这些类型可能是什么。但考虑到您始终将函数结果作为第一个参数传递，您的实现似乎类似于:

def fun1(my_type_var, a, b, c):
    # perform some operation on my_type_var and return result of same type
    return operations_on(my_type_var, a, b, c)

def fun2(my_type_var, a, b, c):
    # similar
    return other_operations_on(my_type_var, a, b, c)

...

在这种情况下，更有意义的是:

class MyType:
    def method1(self, a, b, c):
        # perform some operation on self, then return the result, or self
        mt = operations_on(self, a, b, c)
        return mt

    ...

因为这将允许:

x = MyType().method1(arg1, arg2, arg3).method2(...)

并且根据您的类型，您可以选择修改 self 并返回它，或者使用新实例作为结果执行操作，如上例所示。更好的想法取决于您正在做什么、您的类型内部如何工作等等。