Python 中的变量都是引用式的，这个概念很容易在写代码的时候引入 bug，还不易察觉。这篇文章就是讲述 Python 中对象的引用和可变性，然而首先要抛弃变量是存储数据的盒子的传统观念。

变量不是盒子，是标签

Python 中对变量有一个形象的比喻：变量不是盒子，是标签。也就是说变量名都是对象的标注，不是一个盒子装着对象，贴了再多的标签，对象也只有一个。

用 c++ 的思想理解起来就是：Python 中对变量的赋值都是引用传递，而不是值传递。比如：

In [1]: aa = ["a", "b", "c"]

In [2]: bb = aa

In [3]: bb.append("d")

In [4]: bb
Out[4]: ['a', 'b', 'c', 'd']

In [5]: aa
Out[5]: ['a', 'b', 'c', 'd']

is 和 ==

Python 中的 is 比较的是对象的标识，可以理解成对象的地址；而 == 比较的是对象的值，可以理解成对象指向的值。

Python 中 is 运算符比 == 速度快，这是因为 is 不能重载，Python 不必寻找并调用其他特殊方法，直接比较对象的 id ；而 == 是语法糖，调用了 __eq__ 方法，所以 a == b 等同于 a.__eq__(b)。看个🌰：

In [1]: a = [1, 2, 3]

In [2]: b = a

In [3]: c = [1, 2, 3]

In [4]: a is b
Out[4]: True

In [5]: a is c
Out[5]: False

In [6]: a == b
Out[6]: True

In [7]: a == c
Out[7]: True

In [8]: id(a)
Out[8]: 4553282696

In [9]: id(b)
Out[9]: 4553282696

In [10]: id(c)
Out[10]: 4553460264

在写代码的日常中，我们关注的大多是值，而不是标识，所以 == 的使用频率比 is 多得多。然而在变量和单例值比较时，推荐使用 is。所以在判断某变量的值是否为 None 时，推荐的写法是 a is None ，否定的写法是 a is not None 。

元组的相对不变性

Python 中元组的存在是以其不可变性为特征，一旦创建不可修改。但元组和其他集合一样保存的是对象的引用，也就是说虽然元组本身不可变，但若其保存的对象是可变的，元组内的元素就是可变的。所以，元组的相对不可变性指的就是，tuple 数据结构的物理内容（即保存的引用）不变，与引用的对象无关。

看个🌰就知道了：

In [1]: a = (1, [1, 2])

In [2]: b = (1, [1, 2])

In [3]: a == b
Out[3]: True

In [4]: id(a[-1])
Out[4]: 4445861072

In [5]: a[-1].append(3)

In [6]: id(a[-1])
Out[6]: 4445861072

In [7]: a == b
Out[7]: False

深拷贝和浅拷贝

在 Python 中经常有拷贝的操作，然而这就是坑开始的地方。列表复制通常使用内置的 list 方法或直接 a = b[:] ，但默认的都是浅拷贝。浅拷贝的定义是：复制了最外层容器，副本中的元素是源容器中元素的引用。也就是说副本中的元素只是给原本中的元素贴上了标签，用的都是引用传递，无论原本还是副本中的对象有了修改，都会影响另一方。

用🌰说话：

In [1]: father = [1, 2, [3, 4]]

In [2]: sun = list(father)

In [3]: father.append(5)

In [4]: father
Out[4]: [1, 2, [3, 4], 5]

In [5]: sun
Out[5]: [1, 2, [3, 4]]

In [6]: father[2].append(6)

In [7]: father
Out[7]: [1, 2, [3, 4, 6], 5]

In [8]: sun
Out[8]: [1, 2, [3, 4, 6]]

In [9]: sun.append(7)

In [10]: father
Out[10]: [1, 2, [3, 4, 6], 5]

In [11]: sun
Out[11]: [1, 2, [3, 4, 6], 7]

上面的🌰中，sun 是 father 的副本，但是只拷贝了 0 ~ 2 位，可以看出只有这三位的元素互相影响。

由于上面🌰中拷贝的三位元素都是可变的，我们再看一个不可变的🌰：

In [1]: father = [1, 2, (3, 4)]

In [2]: sun = list(father)

In [3]: id(father[2])
Out[1]: 4397476104

In [4]: id(sun[2])
Out[2]: 4397476104

In [5]: father[2] += (5, 6)

In [6]: id(father[2])
Out[3]: 4398347376

In [7]: id(sun[2])
Out[4]: 4397476104

In [8]: father
Out[5]: [1, 2, (3, 4, 5, 6)]

In [9]: sun
Out[6]: [1, 2, (3, 4)]

看第 5 行，元组中 += 运算符相当于创建一个新的元组，然后赋值给 father，所以这时候两个列表中第 2 位的元素不再是同一个对象。

再说深拷贝，深拷贝的定义是：副本不共享内部对象的引用。一看定义就知道，这是我们大多情况需要的，而 copy 模块中的 copy 和 deepcopy 函数就是实现浅拷贝和深拷贝的。还用 father & sun 做🌰：

In [1]: import copy

In [2]: father = [1, 2, [3, 4]]

In [3]: sun1 = copy.copy(father)

In [4]: sun2 = copy.deepcopy(father)

In [5]: father[2].append(5)

In [6]: father
Out[6]: [1, 2, [3, 4, 5]]

In [7]: sun1
Out[7]: [1, 2, [3, 4, 5]]

In [8]: sun2
Out[8]: [1, 2, [3, 4]]

In [9]: sun2[2].append(6)

In [10]: father
Out[10]: [1, 2, [3, 4, 5]]

In [11]: sun1
Out[11]: [1, 2, [3, 4, 5]]

In [12]: sun2
Out[12]: [1, 2, [3, 4, 6]]

sun2 是 father 的深拷贝，可以看出是一个独立的对象，不跟 father 共享任何元素。

函数的传参

再看函数的传参，c++ 中函数的传参方式分值传递、引用传递和指针传递，而 Python 中函数的传参方式只有一种：共享传参，也就是说函数内部的形参是实参的别名。

那么坑来了。

坑

我们有时候会给函数加一个有默认值的参数，这是为了很好的向后兼容。如果不小心把这个默认值设成了可变参数，连怎么掉进坑的都不知道。看个🌰：

class Father:
    sex = "male"

    def __init__(self, name, age, money=[]):
        self._name = name
        self.__age = age
        self.money = money

class Sun(Father):
    def __init__(self, name, age):
        super(Sun, self).__init__(name, age)

if __name__ == "__main__":
    f = Father("f_name", 23)
    s = Sun("s_name", 3)
    print("father's default money: {}".format(f.money))
    f.money.append(100)
    print("father put 100 in money: {}".format(f.money))
    print("sun's default money: {}".format(s.money))
    s.money.append(10)
    print("sun put 10 in money: {}".format(s.money))
    print("now, father's money: {}".format(f.money))

上面类 Father 的 __init__ 函数的参数 money 设置了默认值 [] 。类 Sun 是继承自 Father 的，如果 father 在自己的钱包里放了 100 块钱，这时候 sun 的口袋却默认有了 100 块钱。看运行结果：

father's default money: []
father put 100 in money: [100]
sun's default money: [100]
sun put 10 in money: [100, 10]
now, father's money: [100, 10]

这样一来，爸爸和儿子的钱包就成了共享的了，很容易引发家庭矛盾。出现这个问题的根源在于，默认值在定义函数时计算（通常在加载模块时），因此默认值变成了函数对象的属性。我们可以通过下面这段代码验证：

print(Father.__init__.__defaults__[0] is f.money)
print(f._name is s._name)
print(f.money is s.money)

运行结果：

True
False
True

因此，如果默认值是可变对象，而且修改了它的值，那么后续的函数调用都会受到影响。

防坑

为了防止踩到上面这样的坑，我们需要将函数默认值设成不可变的，如 None。上面的🌰就需要改成这样：

class Father:
    sex = "male"

    def __init__(self, name, age, money=None):
        self._name = name
        self.__age = age
        if money:
            self.money = list(money)
        else:
            self.money = []


class Sun(Father):
    def __init__(self, name, age):
        super(Sun, self).__init__(name, age)

运行结果：

father's default money: []
father put 100 in money: [100]
sun's default money: []
sun put 10 in money: [10]
now, father's money: [100]

由运行结果可以看出，这时候父子两人的钱包就是独立的，互不影响了。

Python 驻留机制

不知道玩蛇的同学有没有发现一个问题，如下：

In [1]: a = 1

In [2]: b = 1

In [3]: a is b
Out[3]: True

In [4]: a = 10000

In [5]: b = 10000

In [6]: a is b
Out[6]: False

这个问题十分有趣，但是不影响平时写代码，只是 CPython 的细节实现，不知道完全没关系。

Python 有个驻留机制，即共享字符串字面量，是一种优化措施，防止重复创建热门数字。但 CPython 不会驻留所有字符串和整数，驻留的条件是实现细节，而且没有文档说明。

字符串驻留的范围：0 ~ 9A ~ Z_a ~ z；
整数的驻留范围：-5 ~ 256 。
如果字符串或整数不在上述范围，Python 就会创建一个新的对象。

我们可以查看 id 来证明：

In [7]: a = 1

In [8]: b = 1

In [9]: id(a)
Out[9]: 140387930888536

In [10]: id(b)
Out[10]: 140387930888536

In [11]: c = 257

In [12]: d = 257

In [13]: id(c)
Out[13]: 140387934343656

In [14]: id(d)
Out[14]: 140387934343848