提问



Python文档似乎不清楚参数是通过引用还是值传递,以下代码生成未更改的值Original


class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change(self.variable)
        print(self.variable)

    def change(self, var):
        var = 'Changed'


有什么我可以通过实际参考传递变量吗?

最佳参考


参数通过赋值传递。这背后的理由是双重的:[106]



  1. 传入的参数实际上是对象的引用(但引用按值传递)

  2. 某些数据类型是可变的,但其他数据类型不是



所以:



  • 如果你将一个 mutable 对象传递给一个方法,那么该方法会获得对同一个对象的引用,你可以将它改变为你心中的喜悦,但如果你在方法中重新绑定引用,外部范围对它一无所知,在完成后,外部参考仍将指向原始对象。

  • 如果将 immutable 对象传递给方法,则仍然无法重新绑定外部引用,甚至不能改变对象。



为了更清楚,让我们举一些例子。


列表 - 可变类型



让我们尝试修改传递给方法的列表:


def try_to_change_list_contents(the_list):
    print('got', the_list)
    the_list.append('four')
    print('changed to', the_list)

outer_list = ['one', 'two', 'three']

print('before, outer_list =', outer_list)
try_to_change_list_contents(outer_list)
print('after, outer_list =', outer_list)


输出:


before, outer_list = ['one', 'two', 'three']
got ['one', 'two', 'three']
changed to ['one', 'two', 'three', 'four']
after, outer_list = ['one', 'two', 'three', 'four']


由于传入的参数是对outer_list的引用,而不是它的副本,我们可以使用变异列表方法来更改它,并将更改反映在外部范围中。


现在让我们看看当我们尝试更改作为参数传入的引用时会发生什么:


def try_to_change_list_reference(the_list):
    print('got', the_list)
    the_list = ['and', 'we', 'can', 'not', 'lie']
    print('set to', the_list)

outer_list = ['we', 'like', 'proper', 'English']

print('before, outer_list =', outer_list)
try_to_change_list_reference(outer_list)
print('after, outer_list =', outer_list)


输出:


before, outer_list = ['we', 'like', 'proper', 'English']
got ['we', 'like', 'proper', 'English']
set to ['and', 'we', 'can', 'not', 'lie']
after, outer_list = ['we', 'like', 'proper', 'English']


由于the_list参数是按值传递的,因此为其分配新列表不会影响方法外部的代码。 the_listouter_list引用的副本,我们the_list指向一个新列表,但没有办法改变outer_list指向的位置。


字符串 - 不可变类型



它是不可变的,所以我们无法改变字符串的内容


现在,让我们尝试更改参考


def try_to_change_string_reference(the_string):
    print('got', the_string)
    the_string = 'In a kingdom by the sea'
    print('set to', the_string)

outer_string = 'It was many and many a year ago'

print('before, outer_string =', outer_string)
try_to_change_string_reference(outer_string)
print('after, outer_string =', outer_string)


输出:


before, outer_string = It was many and many a year ago
got It was many and many a year ago
set to In a kingdom by the sea
after, outer_string = It was many and many a year ago


同样,由于the_string参数是按值传递的,因此为其分配新字符串不会影响方法外部的代码。 the_stringouter_string引用的副本,我们the_string指向一个新字符串,但没有办法改变outer_string指向的位置。


我希望这可以解决一些问题。


编辑:有人注意到,这并没有回答@David最初提出的问题,我能做些什么来通过实际参考传递变量?。让我们继续努力吧。


我们如何解决这个问题?



正如@Andrea的回答显示的那样,你可以返回新的值。这不会改变传递方式,但可以让你获得你想要的信息:


def return_a_whole_new_string(the_string):
    new_string = something_to_do_with_the_old_string(the_string)
    return new_string

# then you could call it like
my_string = return_a_whole_new_string(my_string)


如果你真的想避免使用返回值,你可以创建一个类来保存你的值并将它传递给函数或使用现有的类,如列表:


def use_a_wrapper_to_simulate_pass_by_reference(stuff_to_change):
    new_string = something_to_do_with_the_old_string(stuff_to_change[0])
    stuff_to_change[0] = new_string

# then you could call it like
wrapper = [my_string]
use_a_wrapper_to_simulate_pass_by_reference(wrapper)

do_something_with(wrapper[0])


虽然这看起来有点麻烦。

其它参考1


问题来自对Python中变量的误解。如果您习惯了大多数传统语言,那么您将拥有以下序列中发生的事情的心理模型:


a = 1
a = 2


您认为a是存储值1的内存位置,然后更新以存储值2。这不是Python中的工作原理。相反,a作为对具有值1的对象的引用开始,然后被重新分配为对具有值2的对象的引用即使a不再引用第一个对象,这两个对象可能会继续共存;实际上,它们可能被程序中的任何其他引用共享。


当您使用参数调用函数时,会创建一个引用传入的对象的新引用。这与函数调用中使用的引用是分开的,因此无法更新该引用并使其引用在一个新的对象。在你的例子中:


def __init__(self):
    self.variable = 'Original'
    self.Change(self.variable)

def Change(self, var):
    var = 'Changed'


self.variable是对字符串对象'Original'的引用。调用Change时,为对象创建第二个参考var。在函数内部,您将引用var重新分配给不同的字符串对象'Changed',但引用self.variable是分开的,不会更改。


解决这个问题的唯一方法是传递一个可变对象。因为两个引用都引用同一个对象,所以对象的任何更改都会反映在两个位置。


def __init__(self):         
    self.variable = ['Original']
    self.Change(self.variable)

def Change(self, var):
    var[0] = 'Changed'

其它参考2


我发现其他答案相当漫长而复杂,所以我创建了这个简单的图来解释Python处理变量和参数的方式。
[107]

其它参考3


它既不是按值传递,也不是按引用传递 - 它是逐个调用的。请见Fredrik Lundh:


http://effbot.org/zone/call-by-object.htm[108]


这是一个重要的引用:



  ......变量[[名称]]是不是对象;它们不能用其他变量表示或由对象引用。



在您的示例中,当调用Change方法时 - 为其创建命名空间;并且var成为该命名空间中字符串对象'Original'的名称。然后,该对象在两个名称空间中具有名称。接下来,var = 'Changed'var绑定到一个新的字符串对象,因此方法的命名空间会忘记'Original'。最后,该命名空间被遗忘,字符串'Changed'沿着有了它。[109]

其它参考4


考虑通过分配而不是通过引用/按值传递的内容。这样,只要您了解正常分配期间发生的情况,就可以清楚地知道发生了什么。


因此,将列表传递给函数/方法时,会将列表分配给参数名称。附加到列表将导致列表被修改。重新分配里面的函数将不会更改原始列表,因为:


a = [1, 2, 3]
b = a
b.append(4)
b = ['a', 'b']
print a, b      # prints [1, 2, 3, 4] ['a', 'b']


由于无法修改不可变类型,它们似乎就像通过值传递一样 - 将int传递给函数意味着将int分配给functions参数。你只能重新分配它,但它不会改变原始变量值。

其它参考5


Effbot(又名Fredrik Lundh)将Python的变量传递方式描述为逐个调用:http://effbot.org/zone/call-by-object.htm [110]


对象在堆上分配,指向它们的指针可以在任何地方传递。



  • 当您进行诸如x = 1000之类的赋值时,会创建一个字典条目,将当前名称空间中的字符串x映射到指向包含一千个整数对象的指针。

  • 使用x = 2000更新x时,会创建一个新的整数对象,并更新字典以指向新对象。旧的一千个对象不变(并且可能存在也可能不存在,具体取决于是否有任何其他对象引用)。

  • 当您执行y = x等新分配时,会创建一个新词典条目y,指向与x条目相同的对象。

  • 像字符串和整数这样的对象是不可变的。这只是意味着没有方法可以在创建对象后更改对象。例如,一旦创建了整数对象一千,它就永远不会改变。通过创建新的整数对象来完成数学。

  • 像列表这样的对象 mutable 。这意味着可以通过指向对象的任何内容来更改对象的内容。例如,x = []; y = x; x.append(10); print y将打印[10]。空列表已创建。 x和y都指向相同的列表。 append 方法改变(更新)列表对象(如向数据库添加记录),结果对x和y都可见(正如数据库更新可见与该数据库的每个连接)。



希望能为您澄清问题。

其它参考6


从技术上讲, Python总是使用传递参考值。我将重复我的其他答复以支持我的发言。


Python始终使用传递引用值。没有任何异常。任何变量赋值都意味着复制参考值。没有异常。任何变量都是绑定到参考值的名称。总是如此。


您可以将参考值视为目标对象的地址。使用时会自动取消引用该地址。这样,使用参考值,您似乎直接使用目标对象。但总会有一个参考,更多的是跳到目标。


下面是证明Python使用引用传递的示例:





如果参数是按值传递的,则无法修改外部lst。绿色是目标对象(黑色是存储在内部的值,红色是对象类型),黄色是内部具有参考值的内存 - 绘制为箭头。蓝色实线箭头是传递给函数的参考值(通过虚线蓝色箭头路径)。丑陋的深黄色是内部字典。 (它实际上也可以画成绿色椭圆。颜色和形状只表示它是内部的。)


您可以使用id()内置函数来了解参考值是什么(即目标对象的地址)。[112]


在编译语言中,变量是能够捕获类型值的内存空间。在Python中,变量是绑定到引用变量的名称(内部捕获为字符串),该引用变量保存目标对象的引用值。变量的名称是内部字典中的键,该字典项的值部分将参考值存储到目标。


参考值隐藏在Python中。没有任何用于存储引用值的显式用户类型。但是,您可以使用list元素(或任何其他合适的容器类型中的元素)作为引用变量,因为所有容器都将元素存储为对目标的引用换句话说,元素实际上不包含在容器中 - 只有对元素的引用。

其它参考7


我通常使用的一个简单技巧就是将其包装在一个列表中:


def Change(self, var):
    var[0] = 'Changed'

variable = ['Original']
self.Change(variable)      
print variable[0]


(是的,我知道这可能很不方便,但有时这很简单。)

其它参考8


(编辑 - 布莱尔更新了他非常受欢迎的答案,现在它已经准确了)


我认为值得注意的是,目前投票率最高的帖子(布莱尔康拉德)虽然在结果方面是正确的,但却是误导性的,并且基于其定义是不正确的。虽然有许多语言(如C)允许用户通过引用传递或按值传递,但Python不是其中之一。


David Cournapeau的回答指出了真正的答案,并解释了为什么布莱尔康拉德的帖子中的行为似乎是正确的,而定义则不然。


在Python按值传递的范围内,所有语言都是按值传递的,因为必须发送一些数据(无论是值还是引用)。但是,这并不意味着Python在C程序员会想到它的意义上是通过值传递的。


如果你想要这种行为,布莱尔康拉德的回答很好。但是如果你想知道为什么Python既没有通过价值传递也没有通过参考传递的细节,请阅读David Cournapeau的回答。

其它参考9


Python

中没有变量

理解参数传递的关键是停止思考变量。 Python中有名称和对象,它们在一起
看起来像变量,但始终区分三者是有用的。



  1. Python有名称和对象。

  2. 分配将名称绑定到对象。

  3. 将参数传递给函数还会将名称(函数的参数名称)绑定到对象。



这就是它的全部。可变性与这个问题无关。


例:


a = 1


这会将名称a绑定到一个包含值1的整数类型的对象。


b = x


这会将名称b绑定到名称x当前绑定的同一对象。
之后,名称b与名称x无关。


参见Python 3语言参考中的3.1和4.2节。[113] [114]





所以在问题中显示的代码中,语句self.Change(self.variable)将名称var(在函数Change的范围内)绑定到保存值'Original'的对象和赋值var = 'Changed'(在函数体Change中)再次指定相同的名称:对于其他一些对象(碰巧也包含一个字符串,但可能完全是其他东西)。

其它参考10


你在这里得到了一些非常好的答案。


x = [ 2, 4, 4, 5, 5 ]
print x  # 2, 4, 4, 5, 5

def go( li ) :
  li = [ 5, 6, 7, 8 ]  # re-assigning what li POINTS TO, does not
  # change the value of the ORIGINAL variable x

go( x ) 
print x  # 2, 4, 4, 5, 5  [ STILL! ]


raw_input( 'press any key to continue' )

其它参考11


在这种情况下,方法Change中标题为var的变量被赋予对self.variable的引用,并立即将字符串赋给var。它不再指向self.variable。以下代码片段显示了如果修改varself.variable指向的数据结构会发生什么,在本例中是一个列表:


>>> class PassByReference:
...     def __init__(self):
...         self.variable = ['Original']
...         self.change(self.variable)
...         print self.variable
...         
...     def change(self, var):
...         var.append('Changed')
... 
>>> q = PassByReference()
['Original', 'Changed']
>>> 


我相信别人可以进一步澄清这一点。

其它参考12


Python的pass-by-assignment方案与C ++的引用参数选项并不完全相同,但事实证明它与C语言(和其他语言)的参数传递模型非常相似:



  • 不可变参数实际上是通过按值传递的。整数和字符串等对象是通过对象引用而不是通过复制传递的,但是因为无论如何都无法更改不可变对象,效果就像制作副本一样。

  • 可变参数有效地传递通过指针。列表之类的对象
    和字典也通过对象引用传递,这类似于C的方式
    将数组作为指针传递 - 可变对象可以在函数中就地更改,
    很像C阵列。


其它参考13


你可以说你需要有一个可变对象,但是我建议你检查全局变量,因为它们可以帮助你甚至解决这类问题!


http://docs.python.org/3/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python[115]


例:


>>> def x(y):
...     global z
...     z = y
...

>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'z' is not defined

>>> x(2)
>>> x
<function x at 0x00000000020E1730>
>>> y
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'y' is not defined
>>> z
2

其它参考14


这里的答案有很多见解,但我认为这里没有明确提到另外一点。引自python文档https://docs.python.org/2/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python [116]


在Python中,仅在函数内引用的变量是隐式全局的。如果在函数体内的任何位置为变量赋值,则假定它是局部的。如果在函数内部为变量赋值,则变量是隐式本地的,您需要将其显式声明为全局。
虽然起初有点令人惊讶,但片刻的考虑解释了这一点。一方面,要求全局指定变量可以防止意外的副作用。另一方面,如果所有全局引用都需要全局,那么您将始终使用全局。您必须将对内置函数或导入模块的组件的每个引用声明为全局。这种混乱会破坏全球声明识别副作用的有用性。


即使将可变对象传递给函数,这仍然适用。对我来说,清楚地解释了分配给对象和操作函数中对象之间行为差异的原因。


def test(l):
    print "Received", l , id(l)
    l = [0, 0, 0]
    print "Changed to", l, id(l)  # New local object created, breaking link to global l

l= [1,2,3]
print "Original", l, id(l)
test(l)
print "After", l, id(l)


得到:


Original [1, 2, 3] 4454645632
Received [1, 2, 3] 4454645632
Changed to [0, 0, 0] 4474591928
After [1, 2, 3] 4454645632


因此,对未声明为全局变量的全局变量的赋值会创建一个新的本地对象,并断开与原始对象的链接。

其它参考15


以下是Python中使用的概念pass by object的简单(我希望)解释
每当你将一个对象传递给该函数时,对象本身就会被传递(Python中的对象实际上就是你在其他编程语言中调用一个值)而不是对该对象的引用。换句话说,当你调用时:


def change_me(list):
   list = [1, 2, 3]

my_list = [0, 1]
change_me(my_list)


正在传递实际对象 - [[0,1]](在其他编程语言中称为值)。所以实际上函数change_me会尝试做类似的事情:


[0, 1] = [1, 2, 3]


这显然不会改变传递给函数的对象。如果函数看起来像这样:


def change_me(list):
   list.append(2)


然后调用将导致:


[0, 1].append(2)


这显然会改变对象。这个答案解释得很好。

其它参考16


除了关于这些东西如何在Python中运行的所有重要解释之外,我没有看到对该问题的简单建议。当您似乎创建对象和实例时,处理实例变量并更改它们的pythonic方法如下:


class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.Change()
        print self.variable

    def Change(self):
        self.variable = 'Changed'


在实例方法中,通常引用self来访问实例属性。在__init__中设置实例属性并在实例方法中读取或更改它们是正常的。这也是你将self的第一个参数传递给def Change的原因。


另一个解决方案是创建一个这样的静态方法:


class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.variable = PassByReference.Change(self.variable)
        print self.variable

    @staticmethod
    def Change(var):
        var = 'Changed'
        return var

其它参考17


有一个小技巧可以通过引用传递一个对象,即使该语言不可能。它也适用于Java,它是带有一个项目的列表。 ;-)


class PassByReference:
    def __init__(self, name):
        self.name = name

def changeRef(ref):
    ref[0] = PassByReference('Michael')

obj = PassByReference('Peter')
print obj.name

p = [obj] # A pointer to obj! ;-)
changeRef(p)

print p[0].name # p->name


这是一个丑陋的黑客,但它确实有效。;-P

其它参考18


我使用以下方法将一些Fortran代码快速转换为Python。确实,它并没有通过引用传递,因为提出了原始问题,但在某些情况下这是一个简单的工作。


a=0
b=0
c=0
def myfunc(a,b,c):
    a=1
    b=2
    c=3
    return a,b,c

a,b,c = myfunc(a,b,c)
print a,b,c

其它参考19


虽然通过引用传递并不适合python并且应该很少使用,但是有一些解决方法实际上可以使得当前分配给局部变量的对象或甚至从被调用函数内部重新分配局部变量。


基本思想是拥有一个可以进行访问的函数,可以作为对象传递给其他函数或存储在类中。


一种方法是在包装函数中使用global(对于全局变量)或nonlocal(对于函数中的局部变量)。


def change(wrapper):
    wrapper(7)

x = 5
def setter(val):
    global x
    x = val
print(x)


同样的想法适用于阅读和del变量。


对于刚刚读取,甚至有一种更简单的方法就是使用lambda: x返回一个可调用的函数,当被调用时返回x的当前值。这有点像在遥远的过去用于语言的按姓名呼叫。


传递3个包装器来访问变量有点笨拙,因此可以将它们包装到具有代理属性的类中:


class ByRef:
    def __init__(self, r, w, d):
        self._read = r
        self._write = w
        self._delete = d
    def set(self, val):
        self._write(val)
    def get(self):
        return self._read()
    def remove(self):
        self._delete()
    wrapped = property(get, set, remove)

# left as an exercise for the reader: define set, get, remove as local functions using global / nonlocal
r = ByRef(get, set, remove)
r.wrapped = 15


Pythons反射支持使得可以获得一个能够在给定范围内重新分配名称/变量而无需在该范围内显式定义函数的对象:


class ByRef:
    def __init__(self, locs, name):
        self._locs = locs
        self._name = name
    def set(self, val):
        self._locs[self._name] = val
    def get(self):
        return self._locs[self._name]
    def remove(self):
        del self._locs[self._name]
    wrapped = property(get, set, remove)

def change(x):
    x.wrapped = 7

def test_me():
    x = 6
    print(x)
    change(ByRef(locals(), "x"))
    print(x)


这里ByRef类包含字典访问。因此,对wrapped的属性访问被转换为传递的字典中的项访问权限。通过传递内置locals的结果和局部变量的名称,最终访问局部变量。从3.5开始的python文档建议更改字典可能不起作用,但它似乎对我有用。

其它参考20


给定python处理值和引用它们的方式,可以引用任意实例属性的唯一方法是按名称:


class PassByReferenceIsh:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print self.variable

    def change(self, var):
        self.__dict__[var] = 'Changed'


在实际代码中,您当然会在dict查找中添加错误检查。

其它参考21


由于您的示例恰好是面向对象的,因此您可以进行以下更改以获得类似的结果:


class PassByReference:
    def __init__(self):
        self.variable = 'Original'
        self.change('variable')
        print(self.variable)

    def change(self, var):
        setattr(self, var, 'Changed')

# o.variable will equal 'Changed'
o = PassByReference()
assert o.variable == 'Changed'

其它参考22


您只能使用空类作为实例来存储引用对象,因为内部对象属性存储在实例字典中。查看示例。


class RefsObj(object):
    "A class which helps to create references to variables."
    pass

...

# an example of usage
def change_ref_var(ref_obj):
    ref_obj.val = 24

ref_obj = RefsObj()
ref_obj.val = 1
print(ref_obj.val) # or print ref_obj.val for python2
change_ref_var(ref_obj)
print(ref_obj.val)