函数的参数作为引用
Python 唯一支持的参数传递模式是共享传参（call by sharing）。共享传参指函数的各个形参获得实参中各个引用的副本。也就是说，函数内部的形参是实参的别名。
解释 Python 中参数传递的方式时，人们经常这样说： “参数按值传递，但是这里的值是引用。”这么说没错，但是会引起误解，因为在旧式语言中，最常用的参数传递模式有按值传递（函数得到参数的副本）和按引用传递（函数得到参数的指针）。
在Python 中，函数得到参数的副本，但是参数始终是引用。因此，如果参数引用的是可变对象，那么对象可能会被修改，但是对象的标识不变。此外，因为函数得到的是参数引用的副本，所以重新绑定（相当于重新赋值）对函数外部没有影响。
t1 = [1, 2, 3]
def foo(f):
print(id(f)) # 139801222710408
f = [1, 2, 3]
print(id(f)) # 139801222747464
f[1] = 10
print(id(t1)) # 139801222710408
foo(t1)
print(t1) # [1, 2, 3]
深刻理解 函数的参数传递是引用的一个副本
下面我们使用weakref弱引用来观察变量的释放情况。
import weakref
def destroy_var():
print('variable destroy lol.')
class Mylist(list):
pass
a1 = Mylist([1, 2, 3])
weakref.finalize(a1, destroy_var)
print(a1)
a1 = Mylist([2, 3])
print(a1)
print('new line --------------------')
b1 = Mylist([4, 5, 6])
weakref.finalize(b1, destroy_var)
def foo(f):
print(f)
f = Mylist([5, 6])
print(f)
foo(b1)
上面的打印如下：
针对a1生命周期如图：
首先数组对象开辟一块内存保存数据，然后变量a1指向这个地址。当a1重新绑定后，就会把原来的指向地址连接断开来指向新的地址。这样的话，原来的数组对象由于没有引用关系（引用计数为0），就会被销毁。
根据上面打印的结果，在变量重新赋值的时候就打印了destroy，表示对象已经被销毁了。
针对b1的生命周期如图：
首先数组对象[4,5,6]开辟一块内存保存数据，然后变量b1指向这个地址。当把变量b1传给函数foo()的时候，函数foo的形参值其实就是实参b1的一个引用的副本（b1'）。因为b1'是一个引用的副本，所以在函数里面我们给这个变量重新赋值并不会销毁原来的对象[4,5,6]。
根据上面打印的结果，如果不是一个引用的副本，则在重新的赋值的时候就应该打印destroy而不是在脚本执行完毕的时候打印。
不要使用可变类型作为参数的默认值
class HauntedBus:
def __init__(self, passengers=[]):
self.passengers = passengers
def pick(self, name):
self.passengers.append(name)
h1 = HauntedBus()
h1.pick('zhexiao')
print(h1.passengers) # ['zhexiao']
h2 = HauntedBus()
print(h2.passengers) # ['zhexiao']
不为 HauntedBus 指定乘客的话，self.passengers 变成了 passengers 参数默认值的别名。出现这个问题的根源是，默认值在定义函数时计算（通常在加载模块时），因此默认值变成了函数对象的属性。如果默认值是可变对象，修改了它的值，那么后续的函数调用都会受到影响。
可变默认值导致的这个问题说明了为什么通常使用 None 作为接收可变值的参数的默认值。
防御可变参数
如果函数接收一个字典，而且在处理的过程中要修改它，那么这个副作用要不要体现到函数外部？
下面的例子可以看到，我们的类把外部传入的实参也进行了修改：
class HauntedBus:
def __init__(self, passengers=None):
if passengers is None:
self.passengers = []
else:
self.passengers = passengers
def drop(self, name):
self.passengers.remove(name)
users = ['zhe', 'xiao']
h1 = HauntedBus(users)
h1.drop('zhe')
print(h1.passengers) # ['xiao']
print(users) # ['xiao']
其实最好的做法是：类自己维护一个可变列表，将内部的列表与外部传入的实参列表区分开。下面我们用list函数创建 passengers 列表的副本，这样即使类的内部对self.passengers有修改也不会影响外部的列表参数users。
def __init__(self, passengers=None):
if passengers is None:
else:
self.passengers = list(passengers)
除非这个方法确实想修改通过参数传入的对象，否则在类中直接把参数赋值给实例变量之前一定要三思，因为这样会为参数对象创建别名。如果不确定，那就创建副本。
变量保存的是引用 总结
变量保存的是引用，这一点对 Python 编程有很多实际的影响：
1. 简单的赋值不创建副本。
2. 对 += 或 *= 所做的增量赋值来说，如果左边的变量绑定的是不可变对象，会创建新对象；如果是可变对象，会就地修改。
3. 为现有的变量赋予新值，不会修改之前绑定的变量，这叫重新绑定。现在变量绑定了其他对象。如果变量是之前那个对象的最后一个引用，对象会被当作垃圾回收。
4. 函数的参数以别名的形式传递，这意味着，函数可能会修改通过参数传入的可变对象。这一行为无法避免，除非在本地创建副本，或者使用不可变对象。
5. 使用可变类型作为函数参数的默认值有危险，因为如果就地修改了参数，默认值也就变了，这会影响以后使用默认值的调用。
在 CPython 中，对象的引用数量归零后，对象会被立即销毁。如果除了循环引用之外没有其他引用，两个对象都会被销毁。
