函数的参数作为引用

Python 唯一支持的参数传递模式是共享传参&＃xff08;call by sharing&＃xff09;。共享传参指函数的各个形参获得实参中各个引用的副本。也就是说&＃xff0c;函数内部的形参是实参的别名。

解释 Python 中参数传递的方式时&＃xff0c;人们经常这样说&＃xff1a; “参数按值传递&＃xff0c;但是这里的值是引用。”这么说没错&＃xff0c;但是会引起误解&＃xff0c;因为在旧式语言中&＃xff0c;最常用的参数传递模式有按值传递&＃xff08;函数得到参数的副本&＃xff09;和按引用传递&＃xff08;函数得到参数的指针&＃xff09;。

在Python 中&＃xff0c;函数得到参数的副本&＃xff0c;但是参数始终是引用。因此&＃xff0c;如果参数引用的是可变对象&＃xff0c;那么对象可能会被修改&＃xff0c;但是对象的标识不变。此外&＃xff0c;因为函数得到的是参数引用的副本&＃xff0c;所以重新绑定&＃xff08;相当于重新赋值&＃xff09;对函数外部没有影响。

t1 &＃61; [1, 2, 3]

def foo(f):

    print(id(f))  # 139801222710408

    f &＃61; [1, 2, 3]

    print(id(f))  # 139801222747464

    f[1] &＃61; 10

print(id(t1))  # 139801222710408

foo(t1)

print(t1)  # [1, 2, 3]

深刻理解 函数的参数传递是引用的一个副本

下面我们使用weakref弱引用来观察变量的释放情况。

import weakref

def destroy_var():

    print(&＃39;variable destroy lol.&＃39;)

class Mylist(list):

    pass

a1 &＃61; Mylist([1, 2, 3])

weakref.finalize(a1, destroy_var)

print(a1)

a1 &＃61; Mylist([2, 3])

print(a1)

print(&＃39;new line --------------------&＃39;)

b1 &＃61; Mylist([4, 5, 6])

weakref.finalize(b1, destroy_var)

def foo(f):

    print(f)

    f &＃61; Mylist([5, 6])

    print(f)

foo(b1)

上面的打印如下&＃xff1a;

针对a1生命周期如图&＃xff1a;

首先数组对象开辟一块内存保存数据&＃xff0c;然后变量a1指向这个地址。当a1重新绑定后&＃xff0c;就会把原来的指向地址连接断开来指向新的地址。这样的话&＃xff0c;原来的数组对象由于没有引用关系&＃xff08;引用计数为0&＃xff09;&＃xff0c;就会被销毁。

根据上面打印的结果&＃xff0c;在变量重新赋值的时候就打印了destroy&＃xff0c;表示对象已经被销毁了。

针对b1的生命周期如图&＃xff1a;

首先数组对象[4,5,6]开辟一块内存保存数据&＃xff0c;然后变量b1指向这个地址。当把变量b1传给函数foo()的时候&＃xff0c;函数foo的形参值其实就是实参b1的一个引用的副本&＃xff08;b1&＃39;&＃xff09;。因为b1&＃39;是一个引用的副本&＃xff0c;所以在函数里面我们给这个变量重新赋值并不会销毁原来的对象[4,5,6]。

根据上面打印的结果&＃xff0c;如果不是一个引用的副本&＃xff0c;则在重新的赋值的时候就应该打印destroy而不是在脚本执行完毕的时候打印。

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

class HauntedBus:

    def __init__(self, passengers&＃61;[]):

        self.passengers &＃61; passengers

    def pick(self, name):

        self.passengers.append(name)

h1 &＃61; HauntedBus()

h1.pick(&＃39;zhexiao&＃39;)

print(h1.passengers)  # [&＃39;zhexiao&＃39;]

h2 &＃61; HauntedBus()

print(h2.passengers)  # [&＃39;zhexiao&＃39;]

不为 HauntedBus 指定乘客的话&＃xff0c;self.passengers 变成了 passengers 参数默认值的别名。出现这个问题的根源是&＃xff0c;默认值在定义函数时计算&＃xff08;通常在加载模块时&＃xff09;&＃xff0c;因此默认值变成了函数对象的属性。如果默认值是可变对象&＃xff0c;修改了它的值&＃xff0c;那么后续的函数调用都会受到影响。

可变默认值导致的这个问题说明了为什么通常使用 None 作为接收可变值的参数的默认值。

防御可变参数

如果函数接收一个字典&＃xff0c;而且在处理的过程中要修改它&＃xff0c;那么这个副作用要不要体现到函数外部&＃xff1f;

下面的例子可以看到&＃xff0c;我们的类把外部传入的实参也进行了修改&＃xff1a;

class HauntedBus:

    def __init__(self, passengers&＃61;None):

        if passengers is None:

            self.passengers &＃61; []

        else:

            self.passengers &＃61; passengers

    def drop(self, name):

        self.passengers.remove(name)

users &＃61; [&＃39;zhe&＃39;, &＃39;xiao&＃39;]

h1 &＃61; HauntedBus(users)

h1.drop(&＃39;zhe&＃39;)

print(h1.passengers)  # [&＃39;xiao&＃39;]

print(users)  # [&＃39;xiao&＃39;]

其实最好的做法是&＃xff1a;类自己维护一个可变列表&＃xff0c;将内部的列表与外部传入的实参列表区分开。下面我们用list函数创建 passengers 列表的副本&＃xff0c;这样即使类的内部对self.passengers有修改也不会影响外部的列表参数users。

def __init__(self, passengers&＃61;None):

    if passengers is None:

        self.passengers &＃61; []

    else:

        self.passengers &＃61; list(passengers)

除非这个方法确实想修改通过参数传入的对象&＃xff0c;否则在类中直接把参数赋值给实例变量之前一定要三思&＃xff0c;因为这样会为参数对象创建别名。如果不确定&＃xff0c;那就创建副本。

变量保存的是引用 总结

变量保存的是引用&＃xff0c;这一点对 Python 编程有很多实际的影响&＃xff1a;

1. 简单的赋值不创建副本。

2. 对 &＃43;&＃61; 或 *&＃61; 所做的增量赋值来说&＃xff0c;如果左边的变量绑定的是不可变对象&＃xff0c;会创建新对象&＃xff1b;如果是可变对象&＃xff0c;会就地修改。

3. 为现有的变量赋予新值&＃xff0c;不会修改之前绑定的变量&＃xff0c;这叫重新绑定。现在变量绑定了其他对象。如果变量是之前那个对象的最后一个引用&＃xff0c;对象会被当作垃圾回收。

4. 函数的参数以别名的形式传递&＃xff0c;这意味着&＃xff0c;函数可能会修改通过参数传入的可变对象。这一行为无法避免&＃xff0c;除非在本地创建副本&＃xff0c;或者使用不可变对象。

5. 使用可变类型作为函数参数的默认值有危险&＃xff0c;因为如果就地修改了参数&＃xff0c;默认值也就变了&＃xff0c;这会影响以后使用默认值的调用。

在 CPython 中&＃xff0c;对象的引用数量归零后&＃xff0c;对象会被立即销毁。如果除了循环引用之外没有其他引用&＃xff0c;两个对象都会被销毁。