python变量类似于Java中的引用型变量,因此最好把他们理解为附注在对象上的标注.
a = [1,2,3] b = a a.append(7) print(b)输出为:
[1, 2, 3, 7] // 可以发现,a和b引用同一个列表,而不是那个列表的副本因为变量只不过是标注,所以可以为对象贴上多个标注,贴的多个标注就是别名.
每个变量都有标识,类型和值.对象一旦创建,它的标识一定不会变;可以把标识（ID）理解为对象在内存中的地址. is运算符比较两个对象的标识; id()函数返回对象标识的整数表示.
标识最常使用is运算符检查,而不是直接比较ID.
charles = {'name':'charles', 'born':'1832'} lewis = charles print(lewis is charles) print(id(charles), id(lewis)) lewis['balence'] = 950 print(charles) alex = {'name': 'charles', 'born': '1832', 'balence': 950} print(alex == charles) print(alex is charles)输出:
True 140640659352168 140640659352168 {'name': 'charles', 'born': '1832', 'balence': 950} True //比较两个对象,结果相同,这是因为dic类的__eq__方法就是这样实现的 False //但是他们是不同的对象,标识不同. //可以发现,charles和lewis绑定同一个对象,alex绑定另外一个对象==运算符比较两个对象的值(对象中保存的数据),而is比较对象的标识（标识就是在内存中的位置） 在变量和"单例值"之间比较时,应该使用is.可以使用is检查变量绑定的值是不是None.
x is Noneis 运算符比 == 速度快，因为它不能重载，所以 Python 不用寻找并调用特殊方法，而是直接比较两个整数 ID。而 a == b 是语法糖，等同于 a.eq(b)。继承自 object 的__eq__ 方法比较两个对象的 ID，结果与 is 一样。但是多数内置类型使用更有意义的方式覆盖了 eq 方法，会考虑对象属性的值。相等性测试可能涉及大量处理工作。
元组与多数 Python 集合（列表、字典、集，等等）一样，保存的是对象的引用。而 str、bytes 和 array.array 等单一类型序列是扁平的，它们保存的不是引用，而是在连续的内存中保存数据本身（字符、字节和数字）。 元组的不可变性其实是指tuple数据结构的物理内容(保存的引用)不可变,与引用的对象无关. 复制对象时，相等性和一致性之间的区别有更深入的影响。副本与源对象相等，但是ID不同。可是，如果对象中包含其他对象，那么应该复制内部对象吗？可以共享内部对象吗？这些问题没有唯一的答案。
输出结果如下: 上图发现：
l2和l3对应着关于l1的浅拷贝，l4直接将l1起了一个别名，也就是说l4和l1指向了同一个对象。浅拷贝对于内层引用有影响，即内层引用还是指向了同一个对象。[3, [55, 44], (7, 8, 9)] //list(l1)创建l1的副本 True //副本和源列表相等对于列表和其他可变序列来说,还可以使用更简洁的l3 = l1[:]语句来创建副本 然而,构造方法或者[:] 做的是浅复制(就是复制了最外层容器,副本中的元素是源容器中元素的引用).如果所有的元素都是不可变的,那么这样没有问题,如果有可变的元素,会出现问题.
l1 = [3,[66,55,44],(7,8,9)] l2 = list(l1) l1.append(100) l1[1].remove(55) print('l1:',l1) print('l2:',l2) l2[1]+=[33,22] l2[2]+=(10,11) print('l1:',l1) print('l2:',l2)输出:
l1: [3, [66, 44], (7, 8, 9), 100] l2: [3, [66, 44], (7, 8, 9)] l1: [3, [66, 44, 33, 22], (7, 8, 9), 100] l2: [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)] # 对**元组**来说,+=运算符创建一个新元组,然后重新绑定给变量l2[2].现在l1和l2中最后位置上的元组不是同一个对象. # 总结：对+=和×=所做的增量赋值来说，如果左边的变量绑定的是不可变对象，会创建新对象；如果是可变对象，会就地修改。如图：
浅复制没什么问题，但有时我们需要的是深复制（即副本不共享内部对象的引用）。
import copy class Bus: 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) bus1 = Bus(['Alice', 'Bill', 'Claire', 'David']) bus2 = copy.copy(bus1) bus3 = copy.deepcopy(bus1) print(id(bus1), id(bus2), id(bus3)) bus1.drop('Bill') print(bus2.passengers) print(id(bus1.passengers), id(bus2.passengers),id(bus3.passengers)) print(bus3.passengers)输出:
140694379943920 140694379943976 140694379944088 ['Alice', 'Claire', 'David'] 140694377362824 140694377362824 140694377336776 ['Alice', 'Bill', 'Claire', 'David']结果如图： 使用 copy 和 deepcopy，创建 3 个不同的 Bus 实例。 审查 passengers 属性后发现：
bus1 和 bus2 共享同一个列表对象，因为 bus2 是bus1 的浅复制副本。bus3 是 bus1 的深复制副本，因此它的 passengers 属性指代另一个列表。 从上面可以发现，深拷贝和浅拷贝都会创建不同的对象，深拷贝是完全拷贝一个新的对象，浅拷贝不会拷贝子对象。结果如图： 从上图我们可以发现，
copy.deepcopy()会完全拷贝一个新的对象出现；copy.copy()不会拷贝其子对象，也就是说，如果原来的对象里面又包含别的对象的引用，则这个新的对象还是会指向这个旧的内层引用。 总结： copy.copy() 浅复制，不会拷贝其子对象，修改子对象，将受影响 . copy.deepcopy() 深复制，将拷贝其子对象，修改子对象，将不受影响.python唯一支持的参数传递模式是共享传参(call by sharing). 共享传参指函数的各个形式参数获得实参中各个引用的副本,也就是说,函数内部的形参是实参的别名。 这种方案的结果是，函数可能会修改作为参数传入的可变对象，但是无法修改那些对象的标识（即不能把一个对象替换成另一个对象）。
def f(a,b): a += b return a x,y = 1,2 print(f(x, y)) print(x, y) a = [1, 2] b = [3, 4] print(f(a, b)) print(a, b) t = (10, 20) u = (30, 40) print(f(t, u)) print(t, u)输出：
3 1 2 [1, 2, 3, 4] [1, 2, 3, 4] [3, 4] (10, 20, 30, 40) (10, 20) (30, 40)我们发现数字x没变,列表a变了,元组t没变
可选参数可以有默认值,这是python函数定义的一个很好的特性.但是我们应该避免使用可变的对象作为参数的默认值.
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(['Alice','Bill']) print(bus1.passengers) bus1.pick('Charlie') bus1.drop('Alice') print(bus1.passengers) bus2 = HauntedBus() bus2.pick('Carrie') print(bus2.passengers) bus3 = HauntedBus() print(bus3.passengers) bus3.pick('Dive') print(bus2.passengers) print(bus2.passengers is bus3.passengers) print(bus1.passengers)输出：
['Alice', 'Bill'] ['Bill', 'Charlie'] ['Carrie'] ['Carrie']//bus3一开始是空的，但是默认列表却不为空 ['Carrie', 'Dive'] True ['Bill', 'Charlie']问题在于，没有指定初始乘客的HauntedBus实例会共享同一个乘客列表。 使用可变类型作为函数参数的默认值有危险，因为如果就地修改了参数，默认值也就变了，这样会影响以后使用默认值的调用。 修正的方法很简单：在__init__方法中，传入passengers参数时，应该把参数值的副本赋值给self.passengers,
def __init__(self,passengers =None): if passengers is None: self.passengers = [] else: self.passengers = list(passengers)如果定义的函数接收可变参数，应该谨慎考虑调用方是否期望修改传入的参数。 示例 8-15 一个简单的类，说明接受可变参数的风险
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 = ['Sue', 'Tina', 'Maya', 'Diana', 'Pat'] >>> bus = TwilightBus(basketball_team) >>> bus.drop('Tina') >>> bus.drop('Pat') >>> basketball_team ['Sue', 'Maya', 'Diana']发现：下车的学生从篮球队中消失了！ TwilightBus 违反了设计接口的最佳实践，即“最少惊讶原则”。学生从校车中下车后，她的名字就从篮球队的名单中消失了，这确实让人惊讶。
这里的问题是，校车为传给构造方法的列表创建了别名。正确的做法是，校车自己维护乘客列表。修正的方法很简单：在 init 中，传入 passengers 参数时，应该把参数值的副本赋值给 self.passengers，像示例 8-8 中那样做（8.3 节）。
def __init__(self, passengers=None): if passengers is None: self.passengers = [] else: self.passengers = list(passengers) ➊➊ 创建 passengers 列表的副本；如果不是列表，就把它转换成列表。在内部像这样处理乘客列表，就不会影响初始化校车时传入的参数了。此外，这种处理方式还更灵活：现在，传给 passengers 参数的值可以是元组或任何其他可迭代对象，例如set 对象，甚至数据库查询结果，因为 list 构造方法接受任何可迭代对象。
del 语句删除名称，而不是对象。del 命令可能会导致对象被当作垃圾回收，但是仅当删除的变量保存的是对象的最后一个引用，或者无法得到对象时。 重新绑定也可能会导致对象的引用数量归零，导致对象被销毁。
在 CPython 中，垃圾回收使用的主要算法是引用计数。实际上，每个对象都会统计有多少引用指向自己。当引用计数归零时，对象立即就被销毁：CPython 会在对象上调用__del__ 方法（如果定义了），然后释放分配给对象的内存。 CPython 2.0 增加了分代垃圾回收算法，用于检测引用循环中涉及的对象组——如果一组对象之间全是相互引用，即 使再出色的引用方式也会导致组中的对象不可获取。Python 的其他实现有更复杂的垃圾回收程序，而且不依赖引用计数，这意味着，对象的引用数量为零时可能不会立即调用__del__ 方法。
正是因为有引用，对象才会在内存中存在。当对象的引用数量归零后，垃圾回收程序会把对象销毁。但是，有时需要引用对象，而不让对象存在的时间超过所需时间。这经常用在缓存中。 弱引用不会增加对象的引用数量。引用的目标对象称为所指对象（referent）。因此我们说，弱引用不会妨碍所指对象被当作垃圾回收。 弱引用在缓存应用中很有用，因为我们不想仅因为被缓存引用着而始终保存缓存对象。
