这篇主要总结Python函数参数传递。

背景

函数的参数传递方式常见的有三种：
1、传值调用；
2、传指针调用；
3、传引用调用；
这种划分方式并不严格，因为传指针调用实质就是传值，但是，传指针调用实现的功能与传引用调用相同

我们从实现的角度来划分，有以下两种：
1、将实参拷贝一份到函数作用域；
2、不拷贝实参，而是将获取实参数据的途径（指针或引用）传入函数，使用时，直接操作实参。

从上面总结的两点，可以有以下观点：
1、方式1不会操作原数据，方式2会操作原数据
2、对于小数据量（例如，基本数据类型）而言，通常选择方式1
3、对于大数据量（例如，对象实例）而言，通常选择方式2

另外，从函数设计的原则上讲：在选择方式2时尽量避免改变原始数据，除非功能上有必要。
当然，这只是原则，是否遵守全在程序员自己把握。

好了，絮絮叨叨一堆，终于进入正题：
———————-傲娇的分割线————————

Python一切皆对象，参数皆引用

不太记得这句话的出处了，但是理解这句话对于理解Python函数参数传递很有帮助

1. Python的可变对象与不可变对象

首先，摘抄Python官方文档中的一段话来给出可变对象和不可变对象的定义：

Objects whose value can change are said to be mutable;
objects whose value is unchangeable once they are created are called immutable.

OK，既然Python中一切皆对象，而对象又可以分为mutable和immutable，那么，我们可以对Python中常见的对象类型按照是否可变进行划分：

Python 中还有其他对象类型，比如：functions，Classes，可以简单的认为属于mutable类型

举例：

# 以List为例展示mutable对象
>>> a = [1,2,3]   # 创建了一个List对象，值为1,2,3，名字是a
>>> b = a         # 为新创建的对象赋一个新变量b
>>> a
[1, 2, 3]
>>> b
[1, 2, 3]
>>> b[0] = 0      # 通过b改变List对象内的值
>>> b
[0, 2, 3]
>>> a             # 可以看到创建的List对象发生了变化
[0, 2, 3]
# 以Tuple为例展示immutable对象不可修改
>>> c = (1,2,3)
>>> c[0] = 0
Traceback (most recent call last):
  File \"\", line 1, in 
TypeError: \'tuple\' object does not support item assignment

Tips: 有一点需要说明一下：
由于在动态语言中，变量“绑定”的对象是动态的，所以，下面的例子不能作为immutable不可变的反例：

>>> i = 50
>>> i += 2
>>> i
52

原因在于 i = 50 和 i +=2 中 i 的所“绑定”的对象不同：当执行 i +=2 时 i 所表示的对象从 Number 型的对象 50，变成了 Number 型的对象 52 。
Python的内置函数id()可以查看对象的identity，下述例子可以说明，i “绑定”的对象是不同的。

>>> i = 50
>>> id(i)
26607512
>>> i += 2
>>> id(i)
26607464

2. Python函数参数传递

Python的函数参数传递方式是传引用调用

Python的函数参数传递方式只有一种：传引用调用。
既然只有一种，那还有什么可讨论的呢？
虽然Python的函数参数传递方式只有一种，但是由于Python中的对象分immutable和mutable，造成在效果上出现了两种：传值调用和传引用调用。
这也是容易造成误解的地方：认为Python有两种参数传递方式。

1、首先用例子解释一下：当传递的参数是不可变对象时，效果相当于传值调用：

>>> x = 6
>>> def foo(y):
...     y = 7
... 
>>> foo(x)
>>> x
6

可以看到，变量x并未发生变化，这在效果上与传值调用是一样的。但是，对于Python而言，实际发生的情况并不是传值调用，而是等效于下述代码：

>>>x = 6
>>>y = x    # 等价与foo(x)
>>>y = 7    # 等价于执行foo函数中的y=7
>>>x
6

2、用例子解释：当传递的参数是可变对象时，效果相当于传引用调用

>>> x = [1,2,3]
>>> def foo(y):
...     y[0] = 0
... 
>>> foo(x)
>>> x
[0, 2, 3]

可以看到在函数foo中对传入的list对象x的数据进行改变，这在效果上与传引用调用是一致的。
但是，需要注意下面这种情况：

>>> x = [1,2,3]
>>> def foo(y):
...     y = [0,1,2]    #这里y重新“绑定”了新的List对象
... 
>>> foo(x)
>>> x
[1, 2, 3]

在上例中，函数foo内部变量y发生了重新“绑定”，因此不能该达到改变原数据的目的

总结要点:
在使用Python函数的参数传递时，确定是否改变原数据需要注意两点：

1. 传入的实参是可变对象(mutable object)还是不可变对象(immutable object)
2. 函数的形参是否发生“重绑定”的情况。