对象的标注、引用、别名
Python变量类似于Java中的引用式变量，因此最好把他们理解为附加在对象上的标注。
Python赋值语句应该始终先读右边。
对象在右边创建或获取，再此之后左边的变量才会绑定到对象上，这就像为对象贴上标注。
变量只不过是标注，所以无法阻止为对象贴上多个标注。贴的多个标注，就是别名。
>>> f1 = {'name':'Li','age':19}
>>> f2 = f1 # f2是f1的别名
>>> f2 is f1
True
每个变量（object）都有标识（identity）、类型（type）和值（value）。
对象一旦创建，它的标识绝不会变。可以把标识理解为对象在内存中的地址。
is运算符比较两个对象的标识，id()函数返回对象标识的整数表示，==运算符比较两个对象的值（对象中保存的数据）。
▲ 对+= 或 *= 所做的增量赋值来说，如果左边的变量绑定的是不可变对象，会创建新对象，如果是可变对象，会就地修改。
元组的相对不可变性
元组的相对不可变性：
元组与多数Python集合（列表、字典、集）一样，保存的是对象的引用。
如果引用的元素是可变的，即便元组本身不可变，元素依然可变。
copy、deepcopy
浅复制：（复制最外层容器，副本中的元素是源容器中元素的引用）
复制列表最简单的方式：
（1）使用构造方法
（2）使用 [ ：]
>>> l1 = [1,2,3,4] >>> l2 = list(l1) >>> l3 = l1[:]
深复制：副本不共享内部对象的引用
class Bus: def __init__(self,passengers=None): if passengers is None: self.passengers = [] else: self.passengers = list(passengers) def pick(self,name): self.passengers.append(name) def drop(self,name): self.passengers.remove(name) import copy bus1 = Bus([1,2,3,'David','Tom']) bus2 = copy.copy(bus1) bus3 = copy.deepcopy(bus1) print(id(bus1),id(bus2),id(bus3)) print(id(bus1.passengers),id(bus2.passengers),id(bus3.passengers)) bus1.drop('David') bus1.pick(998) print(bus1.passengers) print(bus2.passengers) print(bus3.passengers)
函数参数传递模式
函数参数作为引用时：
Python唯一支持的参数传递模式：共享传参（call by sharing）
共享传参：指函数各个形式参数获得实参中各个引用的副本。（函数内部的形参是实参的副本）
def f(a,b):
a += b
return a
a = 1
b = 2
c = f(a,b)
>>> print(c)
3
>>> print(a,b)
1,2
# ========
def f(a,b):
a += b
return a
a = [1,2]
b = [3,4]
c = f(a,b)
>>> print(c)
[1, 2, 3, 4]
>>> print(a,b)
[1, 2, 3, 4] [3, 4]
避免使用可变类型作为参数的默认值
bus_team = ['Sue','David','Pat','Maria']
bus = Bus(bus_team)
bus.drop('David')
bus.drop('Pat')
>>> bus_team
['Sue','Maria']
在类中直接把参数赋值给实例变量等于为参数对象创建别名。
class Bus:
def __init__(self,bus_team):
if bus_team is None:
self.bus_passengers = []
else:
self.bus_passengers = bus_team
# =============
class Bus:
def __init__(self,bus_team):
if bus_team is None:
self.bus_passengers = []
else:
self.bus_passengers = list(bus_team)
垃圾回收机制
del和垃圾回收：
del语句删除名称，而不是对象。
del命令可能会导致对象被当作垃圾回收，但是仅当删除的变量保存的是对象的最后一个引用，或者无法得到对象时。
在Cpython中，垃圾回收使用的主要算法是引用计数。实际上，每个对象都会统计有多少引用指向自己。
当引用计数归零时，对象立即就被销毁。Cpython会在对象上调用__del__方法，然后释放分配给对象的内存。
>>> import weakref
>>> s1 = {1,2,3}
>>> s2 = s1
>>> ender = weakref.finalize(s1,bye) # 注册一个回调函数
>>> ender.alive
True
>>> del s1
>>> ender.alive
True
>>> s2 = '123'
Gone with the wind
>>> ender.alive
False
弱引用：
正因为有引用，对象才会在内存中存在。
弱引用不会增加对象的引用数量。
引用的目标对象称为所指对象（referent），弱引用不会妨碍所指对象被当作垃圾回收。
WeakValueDictionary 类实现的是一种可变映射，里面的值是对象的弱引用。
被引用的对象在程序中的其他地方被当作垃圾回收后，对应的键会自动从WeakValueDictionary中删除。
class Cheese:
def __init__(self,kind):
self.kind = kind
>>> import weakref
>>> stock = weakref.WeakValueDictionary()
>>> catalog = [Cheese('Red Leicester'),Cheese('Tilsit'),Cheese('Parmesan')]
>>> for cheese in catalog:
stock[chess.kind] = cheese
>>> sorted(stock.keys())
['Parmesan','Red Leicester','Tilsit']
>>> del catalog
>>> sorted(stock.keys())
['Parmesan']
>>> del cheese
>>> sorted(stock.keys())
[]
▲ for循环中的变量cheese是全局变量，除非显式删除，否则不会消失。
weakref 模块还提供了WeakSet 类，如果一个类需要知道所有实例，一种好的方案是创建一个WeakSet 保存实例引用。
常规Set实例永远也不会被垃圾回收，因为类中有实例的强引用。而类存在的时间与Python进程一样长，除非显式删除类。
弱引用的局限：
基本的list和dict实例不能作为所指对象，但是他们的子类可以。set实例和用户自定义类型可以作为所指对象。
同时int和tuple实例不能作为弱引用的目标，甚至它们的子类也不行。
class Mylist(list):
...
a_list = Mylist(range(10))
wref_to_a_list = weakref.ref(a_list)