1.值传递 VS 引用传递
相信学过Java/C++等其他编程语言的小伙伴，对常见的两种函数参数传递方式(值传递和引用传递)已经不陌生啦。
所谓值传递就是拷贝参数的值，然后传递给函数中的新变量。这样，原来变量与新变量之间互相独立，不会产生影响 。下面以C++的代码为例，分析一下值传递方式的过程：
#include
using namespace std;
/* 值传递举例 */
// 交换两个变量的值
void swap(int x, int y){
int tmp;
tmp = x;
x = y;
y = tmp;
return;
}
int main(){
int a = 1, b = 100;
cout <"交换前, a = " <",b = " <endl;
swap(a, b);
cout <"交换前, a = " <",b = " <endl;
return 0;
}
#include
using namespace std;
/* 值传递举例 */
// 交换两个变量的值
void swap(int x, int y){
int tmp;
tmp = x;
x = y;
y = tmp;
return;
}
int main(){
int a = 1, b = 100;
cout <"交换前, a = " <",b = " <endl;
swap(a, b);
cout <"交换前, a = " <",b = " <endl;
return 0;
}
上例中swap()函数将a和b的值
拷贝 了一份传递给形参x和y。因此，在swap()函数内部再交换x和y的值，x和y值互换。但是，实参a和b的值不受影响。调用swap()函数前后，a和b的值不变。
所谓引用传递是指将参数的引用传递给新的变量， 原变量和新变量都会指向同一块内存地址 。如果改变了其中任何一个变量的值，那么另一个变量也会随之发生改变。修改上面的C++代码，将swap()函数的形参x和y声明为引用类型：
#include
using namespace std;
/* 引用传递举例 */
// 交换两个变量的值
void swap(int& x, int& y){
int tmp;
tmp = x;
x = y;
y = tmp;
return;
}
int main(){
int a = 1, b = 100;
cout <"交换前, a = " <",b = " <endl;
swap(a, b);
cout <"交换后, a = " <",b = " <endl;
return 0;
}
#include
using namespace std;
/* 引用传递举例 */
// 交换两个变量的值
void swap(int& x, int& y){
int tmp;
tmp = x;
x = y;
y = tmp;
return;
}
int main(){
int a = 1, b = 100;
cout <"交换前, a = " <",b = " <endl;
swap(a, b);
cout <"交换后, a = " <",b = " <endl;
return 0;
}
修改后的代码中，由于swap()函数的形参是引用类型。实参a、b与形参x、y一模一样，形参与实参都会指向同一块内存地址。形参x和y的任何改变都会导致a和b的相应改变。
2.Python中的变量与赋值
直接看Python代码
，上菜~
a = 1
b = a
a = a + 1
a = 1
b = a
a = a + 1
上面的代码虽然简单，里面却包含了python语言的一些基本原理。首先，将1赋值给a，换言之就是a指向了1这个整型对象。如下图所示：
接着，b=a表示将变量b也同时指向1这个整型对象。
注意：python中的对象可以被多个变量所指向或引用。
最后，执行a = a + 1。
注意：在python中像整型、浮点型、字符串等都是不可变对象 。所以，a = a + 1并不是让a的值自增1，而是表示重新创建一个新的值为2的整型对象，并让变量a指向它。但是，变量b的指向仍不变，仍然执行1这个整型对象。
PS：可以使用Python中的内建函数id()来判断两个对象是否相同。
通过上面的一波解释，相信聪明的小伙伴们已经知道：a和b开始只是两个指向同一个整型对象的变量而已。简单的赋值语句b = a，并不表示重新创建了新的对象，只是让同一个对象被多个变量指向或引用而已。
此外，指向同一个对象也并不意味着两个变量就会被绑定在一起。如果你给其中一个变量重新赋值，并不会影响其他变量的值。理解了上面简单的变量赋值例子，下面再来看一个可变对象列表的例子：
l1 = [1, 2, 3]
l2 = l1
l1.append(4)
print("l1:", l1)
print("l2:", l2)
l1 = [1, 2, 3]
l2 = l1
l1.append(4)
print("l1:", l1)
print("l2:", l2)
与上一段代码类似，首先让变量l1和l2同时指向列表对象[1,2,3]。由于列表是可变对象，因此l1.append(4)不会创建一个新的列表，仅仅是在原列表的末尾插入一个元素4，变成[1,2,3,4]。由于l1和l2变量同时指向这个列表对象，所以列表的变化会同时反映在两个变量上。最后，l1和l2的值都同时变成[1,2,3,4]。
此外，还需要注意：Python中的变量可以被删除，但对象无法被删除。如下面的代码段所示：
l1 = [1, 2, 3]
del l1
l1 = [1, 2, 3]
del l1 del l1删除了l1这个变量，从此之后你无法访问l1了。但是，列表对象[1,2,3]仍然存在。python程序运行时，其自带的垃圾回收机制会跟踪每个对象的引用。如果[1,2,3]这个列表对象除l1外，还在别的地方被引用。那么，[1,2,3]就不会被回收。反之，则会被回收。
对以上内容进行总结，有如下结论：
(1).变量的赋值，只是表示让变量指向了某个对象，并不表示拷贝对象的值给变量。此外，一个对象，可以被多个变量同时所指向。
(2).可变对象(如：列表、字典、集合等)的改变，会影响所有指向该对象的变量。
(3).对不可变对象(如：字符串、元组、整型等)来说，所有指向这些对象的变量的值总是一样的，不会发生改变。但是，可以通过某些操作(如：+=等)更新不可变对象的值时，会返回一个新的对象。
(4).变量可以被删除，但对象无法被删除。
3.Python中函数的参数传递
首先，引用Python官方文档中的一段话：
Remember that arguments are passed by assignment in Python. Since assignment just creates references to objects, there’s no alias between an argument name in the caller and callee, and so no call-by-reference per se.
上面的这段话，翻译过来就是说Python中的参数传递是赋值传递或者称为对象的引用传递。
由于Python中所有的数据类型实质都是对象，因此在参数传递时，只是让新变量与原变量指向相同的对象而已，并不存在值传递或引用传递这个说法。 下面以一个简单的例子来分析一下：
def foo(b):
b = 2
a = 1
foo(a)
print("a =", a) # a = 1
def foo(b):
b = 2
a = 1
foo(a)
print("a =", a) # a = 1 在上面的代码段中，函数foo()在进行参数传递时，让变量a和b同时指向了1这个整型对象。但是，当执行到b=2时，系统又会创建一个值为2的整型对象，并让变量b指向它。然而，变量a仍然指向的是1这个整型对象。所以，最终的结果是a = 1。
有的小伙伴们可能就会问，如果我就是想改变变量a的值，那又改咋办呢？方法当然是有的，只需要让函数foo()返回新的变量并赋值给a。这样，变量a就指向了一个新的整型对象。
def foo(b):
b = 2
return b
a = 1
a = foo(a)
print("a =", a) # a = 2
def foo(b):
b = 2
return b
a = 1
a = foo(a)
print("a =", a) # a = 2此外，值得注意的是：当可变对象作为函数参数传入入函数内部时，改变可变对象的值，就会影响所有指向它的变量。如下面的例子所示：
def bar(l2):
l2.append(4)
l1 = [1, 2, 3]
bar(l1)
print("l1 =", l1) # [1, 2, 3, 4]
def bar(l2):
l2.append(4)
l1 = [1, 2, 3]
bar(l1)
print("l1 =", l1) # [1, 2, 3, 4]上面的代码段中，l1和l2两个变量同时指向值为[1,2,3]的列表对象。由于列表是可变对象，执行append()函数时，在列表对象末尾插入新元素4，变量l1和l2的值都会发生变化。但是，下面这个例子就比较特殊，看似是在列表的末尾增加一个新元素，实质却得到明显不同的结果。
def func(l2):
l2 = l2 + [4]
l1 = [1, 2, 3]
func(l1)
print("l1 =", l1) # [1, 2, 3]
def func(l2):
l2 = l2 + [4]
l1 = [1, 2, 3]
func(l1)
print("l1 =", l1) # [1, 2, 3]为啥上面代码段输出l1的结果仍然是[1,2,3]呢？为啥不会是[1,2,3,4]呢?原因在于l2 = l2 + [4]表示创建了一个末尾插入元素4的新列表对象，并且让变量l2指向这个新的列表对象。前面的整个过程与变量l1无关，因此l1的值不会改变。同样地，如果要改变l1的值，就必须让变量l1指向函数func()返回的新列表对象。如下面的代码段所示：
def func(l2):
l2 = l2 + [4]
return l2
l1 = [1, 2, 3]
l1 = func(l1)
print("l1 =", l1) # [1, 2, 3, 4]
def func(l2):
l2 = l2 + [4]
return l2
l1 = [1, 2, 3]
l1 = func(l1)
print("l1 =", l1) # [1, 2, 3, 4]4.总结
与其他编程语言不同，Python中的参数传递既不是值传递，也不是引用传递，而是
赋值或者叫对象的引用传递 ：不是指向一个具体的内存地址，而是指向一个具体的对象。
如果是可变对象，当其改变时，所有指向这个对象的变量都会发生改变；如果是不可变对象，当其发生改变时，简单的赋值运算只会改变其中一个变量的值，其余变量不会受到影响 。
