第8章：对象引用、可变性和垃圾回收-当函数的参数作为引用时

Python 唯一支持的参数传递模式是“共享传参”，多数面向对象语言都是采用这一模式，包括 Ruby 和 Java（Java 的引用类型是这样的，基本类型是按值传参）。

“共享传参”是指函数的各个形式的参数获得实参中各个引用的副本，也就是说，函数内部的形参是实参的别名。

这个方案的结果是，函数可能会修改作为参数传入的可变对象，但是无法修改那个对象的标识（即不能把对象替换成另一个对象），详见示例：

def f(a, b):
    a += b
    return a


x = 1
y = 2
print(f(x, y))  # 3
# x 是不可变类型，未发生变化；
print(x)  # 1
print(y)  # 2

m = [1, 2]
n = [3, 4]
print(f(m, n))  # [1, 2, 3, 4]
# m 是可变类型，在函数内部被修改，外部也发生了变化；
print(m)  # [1, 2, 3, 4]
print(n)  # [3, 4]

t = (1, 2)
u = (3, 4)
print(f(t, u))  # (1, 2, 3, 4)
# t 是不可变类型，本身不可修改，所以函数内部处理时，是复制了 t 然后和 u 相加声称了一个新的元组对象，并且在离开函数时被销毁；
print(t)  # (1, 2)
print(u)  # (3, 4)

不要使用可变类型作为参数的默认值

可选参数可以有默认值，这是一个很棒的特性，但是，我们应该避免使用可变对象作为参数的默认值。

下面在示例中说明这个问题：

class HauntedBus:

    def __init__(self, passengers=[]):
        self.passengers = passengers

    def pick(self, name):
        self.passengers.append(name)

    def drop(self, name):
        self.passengers.remove(name)


bus1 = HauntedBus(['A', 'B'])

print(bus1.passengers)  # ['A', 'B']
bus1.pick('C')
bus1.drop('A')
print(bus1.passengers)  # ['B', 'C']

# bus1 没有问题，目前一切正常

# bus2 使用默认参数，是一个空列表
bus2 = HauntedBus()
bus2.pick('C')
print(bus2.passengers)  # ['C']

# bus3 也是用默认参数，但是默认列表不是空的！
bus3 = HauntedBus()
print(bus3.passengers)  # ['C']

# bus3 修改 passengers 属性后，bus2 竟然也同步修改了！
bus3.pick('D')
print(bus2.passengers)  # ['C', 'D']

# bus2.passengers 和 bus3.passengers 指向了同一个列表对象
print(bus2.passengers is bus3.passengers)  # True

# 而 bus1.passengers 则是另外一个列表
print(bus2.passengers is bus1.passengers)  # False

注意仔细看注释部分，可以发现一个问题，没有指定初始化参数的实例会共享同一个列表，这种问题在发生时很难被发现。出现这种问题的根源是，默认值在定义函数时开始计算(通常是加载时)，因此默认值变成了函数对象的属性，因此如果默认值是可变对象，而且修改了它的值，那么后续的函数调用都受收到影响。 

下方内存示意图可以更明确的看出，HauntedBus.__init__() 的默认值和 bus2.passengers、bus3.passengers 指向的都是同一个对象：

防御可变参数

如果定义的函数接收可变参数，应该谨慎考虑调用方是否期望修改传入的参数。例如函数接收一个字典，而在处理的过程中要修改它，那么这个副作用要不要体现在函数外部呢？根据接口设计原则，内部修改参数最好不要影响到外部，那么我们如何防止这种问题的发生呢？

下面看一个示例，我们从上一个例子中吸取了教训，然后优化了默认参数：

class TwilightBus:

    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers = passengers

    def pick(self, name):
        self.passengers.append(name)

    def drop(self, name):
        self.passengers.remove(name)


basketball_team = ['A', 'B', 'C', 'D']

bus = TwilightBus(basketball_team)

bus.drop('A')
bus.drop('B')

print(basketball_team)  # ['C', 'D']

但是我们发现了一个新的问题，假如有个篮球队 basketball_team 乘坐公交车，公交车每下一个人，乘客和队员就少一个人，这看起来很奇怪。这是因为我们将 basketball_team 作为 TwilightBus.__init__() 的实参，而赋值语句直接将 self.passengers 作为了 basketball_team 的别名，当 self.passengers 执行 append() 和 remove() 时直接修改了 basketball_team。

这里我们可以再次优化来解决这个问题，使用构造方法和 basketball_team 创建一个新的列表，然后将 self.passengers 分配给新的列表对象：

class TwilightBus:

    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers =list(passengers)

这么做还有一个好处就是传给 passengers 的值可以是任何可迭代对象了，不管是元组甚至是集合类型，都会被用来创建一个新的列表，并且不影响之后的 append()、remove() 操作。