如何通过几个函数传递多个参数

Question

假设我们有一个公开的函数（级别 0）。我们用各种参数调用这个函数。该函数在内部调用第二个函数（级别 1），但不使用任何给定的参数，而是使用它们作为参数调用第三个函数（级别 2）。然而，它可能会做一些其他的事情。

我的问题是。我们如何传递参数而不在中间层函数（级别 1）中产生太多噪音？我在下面列出了一些可能的方法。但是请注意，其中一些相当丑陋，仅出于完整性原因才存在。我正在寻找一些既定的指导方针，而不是关于该主题的个人意见

# Transport all of them individually down the road.
# This is the most obvious way. However the amount of parameter increases the
# noise in A_1 since they are only passed along
def A_0(msg, term_print):
    A_1(msg, term_print)

def A_1(msg, term_print):
    A_2(msg, term_print)

def A_2(msg, term_print):
    print(msg, end=term_print)


# Create parameter object (in this case dict) and pass it down.
# Reduces the amount of parameters. However when only reading the source of B1
# it is impossible to determine what par is
def B_0(msg, term_print):
    B_1({'msg': msg, 'end': term_print})

def B_1(par):
    B_2(par)

def B_2(par):
    print(par['msg'], end=par['end'])


# Use global variables. We all know the pitfalls of global variables. However
# in python there are at least limited to their module
def C_0(msg, term_print):
    global MSG, TERM_PRINT

    MSG = msg
    TERM_PRINT = term_print
    C_1()

def C_1():
    C_2()

def C_2():
    print(MSG, end=TERM_PRINT)


# Use the fact that python creates function objects. We can now append those
# objects. This makes some more 'localised' variables than shown before. However
# this also makes the code harder to maintain. When we change D_2 we have to alter
# D_0 as well even though it never directly calls it
def D_0(msg, term_print):
    D_2.msg = msg
    D_2.term_print = term_print
    D_1()

def D_1():
    D_2()

def D_2():
    print(D_2.msg, end=D_2.term_print)


# Create a class with the functions E_1, E_2 to enclose the variables.
class E(dict):
    def E_1(self):
        self.E_2()

    def E_2(self):
        print(self['msg'], end=self['end'])

def E_0(msg, term_print):
    E([('msg', msg), ('end', term_print)]).E_1()


# Create a nested scope. This make it very hard to read the function. Furthermore
# F_1 cannot be called directly from outside (without abusing the construct)
def F_0(msg, term_print):
    def F_1():
        F_2()

    def F_2():
        print(msg, end=term_print)

    F_1()


A_0('What', ' ')
B_0('is', ' ')
C_0('the', ' ')
D_0('best', ' ')
E_0('way', '')
F_0('?', '\n')

Answer 1

如果不知道为什么有这么多参数和这么多级别的功能的全部细节，就很难给出完整的答案。但一般来说，传递太多参数会被认为是code smell.

一般来说，如果一组函数都使用相同的参数，则意味着它们在某种程度上密切相关，并且可能受益于将参数封装在类中，以便所有关联的方法可以共享该数据。

TooManyParameters 通常是一种 CodeSmell。如果必须一起传递那么多数据，则可能表明数据以某种方式相关并且希望封装在自己的类中。传入单独的单个数据结构并不能解决问题。相反，这个想法是，属于在一起的事物，保持在一起；属于分开的东西，分开；根据 OneResponsibilityRule。

事实上，您可能会发现，如果整个函数所做的只是将数据传递给其他函数，那么它们是完全不必要的。

class A():

    def __init__(self, msg, term_print)
        self.msg = msg
        self.term_print = term_print

    def a_0(self):
        return self.a_1()

    def a_1(self):
        return self.a_2()

    def a_2(self):
        print(msg, self.term_print)