Question

我是python的初学者，我正在尝试创建一个使用gunicorn gevent的Flask应用程序。

我有一个接受许多参数的函数。例如main_function(A,B,C,D,E,F,G,H,I)。

我必须从此函数调用另一个函数function_one(A,B)，该函数从内部调用另一个函数，例如function_two(A,B)，依次调用另一个函数function_three(A,B），依此类推。

在某一点到达function_thirtythree，该参数应与A和B一起获得参数C,D。

现在我的问题是，我必须将C和D传递给function_one，然后将其传递给function_two，然后传递给function_three，依此类推，仅在function_thirty 3调用中使用？有更好的方法吗？

def function_thirtythree(A,B)
    return A + B+ C + D

def function_three(A,B)
    function_thirtythree(A,B)

def function_two(A,B):
    function_three(A,B)

def function_one(A,B):
    function_two(A,B)


def main_func(A,B,C,D,E,F,G,H,I):
    function_one(A,B)

Answer 1

如果您使用的是Flask，则可以使用应用程序上下文在请求中全局存储通用请求变量（请参见https://flask.palletsprojects.com/en/1.1.x/appcontext/?highlight=context%20global#storing-data）。

import flask

def main_function(A, B, C, D, E, F, G):
    flask.g.C = C
    flask.g.D = D

    ...

def function_thirtythree(A, B)
    return A + B + flask.g.C + flask.g.D

这当然需要您将flask作为定义在其中的任何库代码function_thirtythree的依赖项。

Answer 2

这称为“范围”，它确定代码中每个点上可用的变量。 “关闭”表示嵌套函数可以从其父函数访问变量。如果使用此示例，则无需向下传递x，y，z：

def outer(x):
    def middle(y):
        middle_scope = 'middle'
        def inner(z):
            return '%s %s %s %s' %  (x, y, middle_scope, z)
        return inner
    return middle

outer('x')('y')('z')

>>> 'x y middle z'

或者：

def outer(x, y, z):
    def middle(y=y):
        middle_scope = 'middle'
        def inner(z=z):
            return '%s %s %s %s' %  (x, y, middle_scope, z)
        return inner
    return middle

outer('x', 'y', 'z')()()

>>> 'x y middle z'

更新：

仅看到您对问题的修改。这些功能不是嵌套的。 function_thirtythree(A,B)将无法访问变量C或D。这些变量不在其范围内。您将必须将它们向下传递，或者将其分配为全局变量，如下所示：

A = 1
B = 2
C = 3
D = 4

def function_thirtythree(A,B)
    return A + B + C + D

function_thirtythree(5,4)

>>> 16

您将如何分配C＆D。如何？

def function_thirtythree(A,B)
    C = something
    D = something_else
    return A + B + C + D

否则，请继续并将这些变量传递到末尾。不必担心将C，D传递给函数2、3、4等。他们不使用它们，因此不会改变它们。他们将简单地通过：

def function_thirtythree(A,B,C,D)
    return A + B + C + D

def function_three(A,B,C,D)
    #do something with A & B only
    function_thirtythree(A,B,C,D)

def function_two(A,B,C,D):
    #do something with A & B only
    function_three(A,B,C,D)

def function_one(A,B,C,D):
    #do something with A & B only
    function_two(A,B,C,D)


def main_func(A,B,C,D,E,F,G,H,I):
    function_one(A,B,C,D)

在python产品代码中不向下传递变量的最佳方法是什么？

2 个答案: