Python：处理具有长参数列表的函数的最佳方法？

我已经找到了关于如何将一长串参数传递到函数中的各种详细解释，但我仍然有点怀疑这样做是否正确

换句话说，我怀疑我做错了，但我看不出如何做对

问题是：我有一个（不是很长的）递归函数，它使用了相当多的变量，需要修改其中的一些内容

我的结局是这样的：

def myFunction(alpha, beta, gamma, zeta, alphaList, betaList, gammaList, zetaList):
    <some operations>
    myFunction(alpha, beta, modGamma, zeta, modAlphaList, betaList, gammaList, modZetaList)

class FooParameters:
    alpha = 1.0
    beta = 1.0
    gamma = 1.0
    zeta = 1.0
    alphaList = []
    betaList = []
    gammaList = []
    zetaList = []

def myFunction（alpha、beta、gamma、zeta、alphaList、betaList、gammaList、zetaList）：
myFunction（alpha、beta、modGamma、zeta、modAlphaList、betaList、gammaList、modZetaList）

…我想看看我对原始变量所做的更改（在C中我只传递一个引用，但我听说在Python中它总是一个副本？）

---

对不起，如果没有，我不知道如何表达这个问题，这样我就可以找到相关的答案。

你可以输入一本词典，然后返回一本新词典。或者将您的方法放入类中，并将alpha、beta等作为属性。

您应该将

myFunction

放入类中。使用适当的属性设置类并调用适当的函数。然后，状态被很好地包含在类中。

您可以将所有参数封装在一个类中，如下所示：

def myFunction(alpha, beta, gamma, zeta, alphaList, betaList, gammaList, zetaList):
    <some operations>
    myFunction(alpha, beta, modGamma, zeta, modAlphaList, betaList, gammaList, modZetaList)

class FooParameters:
    alpha = 1.0
    beta = 1.0
    gamma = 1.0
    zeta = 1.0
    alphaList = []
    betaList = []
    gammaList = []
    zetaList = []

然后，您的函数接受一个单参数实例：

def myFunction(params):
    omega = params.alpha * params.beta + exp(params.gamma)
    # more magic...

打电话的方式如下：

testParams = FooParameters()
testParams.gamma = 2.3
myFunction(testParams)
print params.zetaList

---

因为params实例是通过引用传递的，所以函数中的更改会保留下来。

我不知道您从哪里知道Python在传递到函数时会复制值。事实并非如此

---

相反：函数中的每个参数都是引用原始对象的附加名称。如果您以某种方式更改该对象的值（例如，如果它是一个列表，并且您更改了它的一个成员），则原始对象也将看到该更改。但是，如果您将名称重新绑定到其他名称（例如，通过执行

alpha=my\u extally\u new\u value

），则原始名称将保持不变。

例如，这通常用于

matplotlib

。它们使用

*

或

**

传递一长串参数，如：

def function(*args, **kwargs):
    do something

调用函数：

function(1,2,3,4,5, a=1, b=2, b=3)

这里

1,2,3,4,5

将转到

args

，

a=1，b=2，c=3

将转到

kwargs

，作为字典。这样他们就可以达到你的功能，比如：

args = [1,2,3,4,5]
kwargs = {a:1, b:2, c:3}

---

你可以用你想要的方式对待他们。

你可能会受到类似的诱惑：

def myFunction(*args):
    var_names = ['alpha','beta','gamma','zeta']
    locals().update(zip(var_names,args))
    myFunction(alpha,beta,gamma,zeta)

然而，这种“经常”是行不通的。我建议引入另一个名称空间：

from collections import OrderedDict
def myFunction(*args):
    var_names = ['alpha','beta','gamma','zeta']
    vars = OrderedDict(zip(var_names,args))

    #get them all via vars[var_name]

    myFunction(*vars.values()) #since we used an orderedDict we can simply do *.values()

---

您可以在闭包中捕获未修改的值：

def myFunction(alpha, beta, gamma, zeta, alphaList, betaList, gammaList, zetaList):
    def myInner(g=gamma, al, zl):
        <some operations>
        myInner(modGamma, modAlphaList, modZetaList)
    myInner(al=alphaList, zl=zetaList)

def myFunction（alpha、beta、gamma、zeta、alphaList、betaList、gammaList、zetaList）：
def myInner（g=伽马、铝、锌）：
myInner（modGamma、modAlphaList、modZetaList）
myInner（al=字母列表，zl=齐塔人）

---

（顺便说一句，这是在Python中编写真正递归函数的唯一方法。）

您能给出一个具体的例子吗？在Python中，它从来都不是复制的。这个答案将帮助您了解参数在引用-->方面的行为，而从技术上讲，这样说是正确的“函数中的每个参数都是引用原始对象的附加名称”，不可变类型的行为不是人们期望的“通过引用”传递的变量的行为（如在C中）。如果函数中的

int

参数发生更改（例如，通过执行

alpha+=1

），原始变量不会受到影响。从技术上讲，python（就像其他主要编程语言一样，至少默认情况下是这样）使用“按值传递”语义。这就是他的想法来源。是的，它令人困惑。