Python的函数参数传递：传值？引用？

我想，这个标题或许是很多初学者的问题。尤其是像我这样的对C/C++比较熟悉，刚刚进入Python殿堂的朋友们。C/C++的函数参数的传递方式根深蒂固的影响这我们的思维–引用？传值？究竟是那种呢。语言的特性决定了是使用的方法，那么，现在我们来探究一下python的函数参数传递方式。

对象vs变量

在python中，

类型

属于

对象

，

变量

是没有类型的，这正是python的语言特性，也是吸引着很多pythoner的一点。所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。所以，希望大家在看到一个python变量的时候，把

变量

和真正的

内存对象

分开。类型是属于对象的，而不是变量。这样，很多问题就容易思考了。例如：对象vs变量

1 2	nfoo = 1 #一个指向int数据类型的nfoo（再次提醒，nfoo没有类型） lstFoo = [1] #一个指向list类型的lstFoo，这个list中包含一个整数1

可更改(mutable)与不可更改(immutable)对象

对应于上一个概念，就必须引出另了另一概念，这就是

可更改（mutable）对象

与

不可更改（immutable）对象

。对于python比较熟悉的人们都应该了解这个事实，在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。那么，这些所谓的可改变和不可改变影响着什么呢？可更改vs不可更改

1 2345

nfoo = 1 nfoo = 2 lstFoo = [1] lstFoo[0] = 2

代码第2行中，内存中原始的1对象因为不能改变，于是被“抛弃”，另nfoo指向一个新的int对象，其值为2代码第5行中，更改list中第一个元素的值，因为list是可改变的，所以，第一个元素变更为2。其实应该说，lstFoo指向一个

包含一个对象的数组

。赋值所发生的事情，是有一个新int对象被指定给lstFoo所指向的数组对象的第一个元素，但是对于lstFoo本身来说，所指向的数组对象并没有变化，只是数组对象的内容发生变化了。这个看似void*的变量所指向的对象仍旧是刚刚的那个有一个int对象的list。如下图所示：<imgsrc="http://7xljtv.com1.z0.glb.clouddn.com/static/images/2015-10-24-python-passing-arguments-as-value-or-reference/mutable-immutable-object.png-watermark.black" "="" style="border: 1px solid rgb(221, 221, 221); display: block !important; margin: 0px auto;max-width: 100%; height: auto; cursor: -webkit-zoom-in; box-sizing: border-box; padding: 3px;">

Python的函数参数传递：传值？引用？

对于变量（与对象相对的概念），其实，python函数参数传递可以理解为就是变量传值操作，用C++的方式理解，就是对void*赋值。如果这个变量的值不变，我们看似就是引用，如果这个变量的值改变，我们看着像是在赋值。有点晕是吧，我们仍旧据个例子。不可变对象参数调用

1 2345

def ChangeInt( a ): a = 10 nfoo = 2 ChangeInt(nfoo) print nfoo #结果是2

这时发生了什么，有一个int对象2，和指向它的变量nfoo，当传递给ChangeInt的时候，按照传值的方式，复制了变量nfoo的值，这样，a就是nfoo指向同一个Int对象了，函数中a=10的时候，发生什么？（还记得我上面讲到的那些概念么），int是不能更改的对象，于是，做了一个新的int对象，另a指向它（但是此时，被变量nfoo指向的对象，没有发生变化），于是在外面的感觉就是函数没有改变nfoo的值，看起来像C++中的传值方式。可变对象参数调用

1 2345

def ChangeList( a ): a[0] = 10 lstFoo = [2] ChangeList(lstFoo ) print nfoo #结果是[10]

当传递给ChangeList的时候，变量仍旧按照“传值”的方式，复制了变量lstFoo 的值，于是a和lstFoo 指向同一个对象，但是，list是可以改变的对象，对a[0]的操作，就是对lstFoo指向的对象的内容的操作，于是，这时的a[0] = 10，就是更改了lstFoo 指向的对象的第一个元素，所以，再次输出lstFoo 时，显示[10]，内容被改变了，看起来，像C++中的按引用传递。恩，现在是不是对python中的变量和对象的概念有了更深入的理解了呢？通过我上面的解释，我想大家也可以自己搞定其他类型对象的传递问题了吧。----------------------Python的文档对参数传递的是值还是引用没有明确说明,下面的代码没有改变值

Original

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

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

有什么方法能让通过引用来改变变量吗?参数是通过assignment来传递的.原因是双重的:传递的参数实际上是一个对象的引用(但是这个引用是通过值传递的)一些数据类型是可变的,但有一些就不是.所以:如果传递一个可变对象到一个方法,方法就会获得那个对象的引用,而你也可以随心所欲的改变它了.但是你在方法里重新绑定了这个引用,外部是无法得知的,而当函数完成后,外界的引用依然指向原来的对象.如果你传递一个不可变的对象到一个方法,你仍然不能在外边重新绑定引用,你连改变对象都不可以.为了弄懂,来几个例子.

列表-可变类型

让我们试着修改当做参数传递给方法的列表:

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_list

是

outer_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_string

只是

outer_string

引用(名词)的副本,所以我们让

the_string

指向一个新字符串,依然无法改变

outer_string

的指向.希望你清楚以上那些.修改:到现在位置还没有回答"有什么方法同过引用传递变量?",让我们往下看.

我们该怎么办?

你可以返回一个新值.这不会改变传过来的值,但是能得到你想要的结果.

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

# 你可以像这样调用
my_string = return_a_whole_new_string(my_string)

总结：1，当函数参数为数字，字符串，元组的时候，是值传递，不能在函数内部改变原数字，字符串，元组，也就是对外部原来的参数没有影响；但是在这种情况下想要改变原参数，则可以通过返回一个新值 的方法，如：你可以返回一个新值.这不会改变传过来的值,但是能得到你想要的结果.

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

# 你可以像这样调用
my_string = return_a_whole_new_string(my_string)

2，当函数参数为列表，字典的时候，是传引用，在函数内部，可以改变原参数，但是要注意的是，如果在函数内部，对形参重新赋值而不是修改，则不会改变原参数的指向，具体请参考上文。