对象不是个盒子

class Gizmo:    def __init__(self):        print('Gizmo id: %d' % id(self))x = Gizmo()print(x)y = Gizmo() * 10print(y)print(dir())

❶ 输出的 Gizmo id: ... 是创建 Gizmo 实例的副作用。

❷ 在乘法运算中使用 Gizmo 实例会抛出异常。

❸ 这里表明，在尝试求积之前其实会创建一个新的 Gizmo 实例。

❹ 但是，肯定不会创建变量 y，因为在对赋值语句的右边进行求值时抛出了异常。

　为了理解 Python 中的赋值语句，应该始终先读右边。对象在右边创建或获取，在此之后左边的变量才会绑定到对象上，

标识、相等性和别名

longe = {'name': 'longe', 'born': 1993}liang = longeprint(liang is longe)print(id(liang), id(longe))longe['balance'] = 950print(liang)## 冒充的longe信息other  = {'name': 'longe', 'born': 1993, 'balance': 950}print(other)print(other is longe)

❶ liang 是 longe 的别名。

❷ is 运算符和 id 函数确认了这一点。❸ 向 liang 中添加一个元素相当于向 longe 中添加一个元素。

在那段代码中，liang 和 longe 是别名，即两个变量绑定同一个对象。

而 other 不是 longe 的别名，因为二者绑定的是不同的对象。

other 和longe 绑定的对象具有相同的值（== 比较的就是值），但是它们的标识不同。

1. 每个变量都有标识、类型和值。对象一旦创建，它的标识绝不会变；
2. 你可以把标识理解为对象在内存中的地址。
3. is 运算符比较两个对象的标识；
4. id() 函数返回对象标识的整数表示。

在==和is之间选择

== 运算符比较两个对象的值（对象中保存的数据），而 is 比较对象的标识。

1. is 运算符比 == 速度快，因为它不能重载，所以 Python 不用寻找并调用特殊方法，而是 直接比较两个整数 ID
2. eq 方法，会考虑对象属性的值。相等性测试可能涉及大量处理工作，例如，比较大型集合或嵌套层级深的结构时。

元组的相对不可变性

元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关

1. 元组的值会随着引用的可变对象的变化而变。
2. 元组中不可变的是元素的标识。内存地址

>>> t1 = (1, 2, [30, 40]) ➊>>> t2 = (1, 2, [30, 40]) ➋>>> t1 == t2 ➌True>>> id(t1[-1]) ➍4302515784>>> t1[-1].append(99) ➎>>> t1(1, 2, [30, 40, 99])>>> id(t1[-1]) ➏4302515784>>> t1 == t2 ➐False

基础理解!!!还是可以的

默认浅复制

>>> l1 = [3, [55, 44], (7, 8, 9)]>>> l2 = list(l1) ➊>>> l2[3, [55, 44], (7, 8, 9)]>>> l2 == l1 ➋True>>> l2 is l1 ➌False

然而，构造方法或 [:] 做的是浅复制（即复制了最外层容器，副本中的元素是源容器中

元素的引用）。如果所有元素都是不可变的，那么这样没有问题，还能节省内存。

为任意对象做深复制和浅复制

import copyclass 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)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)

❸ 审查 passengers 属性后发现，bus1 和 bus2 共享同一个列表对象，因为 bus2 是

bus1 的浅复制副本。❹ bus3 是 bus1 的深复制副本，因此它的 passengers 属性指代另一个列表。

注意，一般来说，深复制不是件简单的事。如果对象有循环引用，那么这个朴素的算法会进入无限循环

深复制

>>> a = [10, 20]>>> b = [a, 30]>>> a.append(b)>>> a[10, 20, [[...], 30]]>>> from copy import deepcopy>>> c = deepcopy(a)>>> c[10, 20, [[...], 30]]

深复制有时可能太深了。例如，对象可能会引用不该复制的外部资源或单例值。我们可以实现特殊方法 __copy__() 和 __deepcopy__()，控制 copy 和 deepcopy 的行为

函数的参数作为引用时

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

是实参的别名。

def f(a, b):    a += b    return aa = [1, 2]b = [3, 4]print(f(a, b))print(a, b)

这里变量全都是引用,无论局部变量还是全局.

所以上面案例中,a会变化

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

class HauntedBus:    """备受幽灵乘客折磨的校车"""    def __init__(self, passengers=[]):  #别使用这种可变类型 作为默认参数        self.passengers = passengers

防御性编程(对待可变类型)

class TwilightBus:    """正常的校车"""    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)bus1 = TwilightBus(("sfs", 'sdf'))bus2 = TwilightBus(["sdfsdfsfd111"])bus1.pick("ppxia")bus1.drop("sfs")print(bus1.passengers)bus2.drop("sdfsdfsfd111")print(bus2.passengers)

尽量别用可变类型做默认参数值, 实在要用,必须使其产生副本

del和垃圾回收

• 有个 del 特殊方法，但是它不会销毁实例，不应该在代码中调用。
• 即将销毁实例时，Python 解释器会调用 del 方法，给实例最后的机会，释放外资源。
• 自己编写的代码很少需要实现 del 代码，有些 Python 新手会花时间实现，但却吃力不讨好，因为 del 很难用对。

垃圾计数器

1. 在 CPython 中，垃圾回收使用的主要算法是引用计数。
2. 实际上，每个对象都会统计有多少引用指向自己。
3. 当引用计数归零时，对象立即就被销毁：CPython 会在对象上调用__del__ 方法（如果定义了），然后释放分配给对象的内存。

为了演示对象生命结束时的情形，示例 8-16 使用 weakref.finalize 注册一个回调函数，在销毁对象时调用。

>>> import weakref>>> s1 = {1, 2, 3}>>> s2 = s1 ➊>>> def bye(): ➋... print('Gone with the wind...')...>>> ender = weakref.finalize(s1, bye) ➌>>> ender.alive ➍True>>> del s1>>> ender.alive ➎True>>> s2 = 'spam' ➏Gone with the wind...>>> ender.aliveFalse

❺ 如前所述，del 不删除对象，而是删除对象的引用。

❻ 重新绑定最后一个引用 s2，让 {1, 2, 3} 无法获取。对象被销毁了，调用了 bye 回调，ender.alive 的值变成了 False。

　弱引用

• 正是因为有引用，对象才会在内存中存在。当对象的引用数量归零后，垃圾回收程序会把对象销毁。但是，有时需要引用对象，而不让对象存在的时间超过所需时间。
• 弱引用不会增加对象的引用数量。引用的目标对象称为所指对象（referent）。因此我们说，弱引用不会妨碍所指对象被当作垃圾回收。
• 弱引用在缓存应用中很有用，因为我们不想仅因为被缓存引用着而始终保存缓存对象。

弱引用是可调用的对象，返回的是被引用的对象；

>>> import weakref>>> a_set = {0, 1}>>> wref = weakref.ref(a_set) ➊>>> wref
    
     >>> wref() ➋{0, 1}>>> a_set = {2, 3, 4} ➌>>> wref() ➍{0, 1}>>> wref() is None ➎False>>> wref() is None ➏True
    

❷ 调用 wref() 返回的是被引用的对象，{0, 1}。因为这是控制台会话，所以 {0, 1}

会绑定给 _ 变量。❸ a_set 不再指代 {0, 1} 集合，因此集合的引用数量减少了。但是 _ 变量仍然指代它。❹ 调用 wref() 依旧返回 {0, 1}。❺ 计算这个表达式时，{0, 1} 存在，因此 wref() 不是 None。但是，随后 _ 绑定到结果值 False。现在 {0, 1} 没有强引用了。❻ 因为 {0, 1} 对象不存在了，所以 wref() 返回 None。

弱引用到此为止,用到再来查 page 289

总结

1. 变量的不是盒子,是便利贴(就是c的指针)
2. ==是值相等 is是(内存地址相等)
3. 默认是浅复制,就内存地址复制.深复制会有一些过深危险(可以重写特殊方法 __copy__() 和 __deepcopy__())
4. 尽量别用可变类型做默认参数值, 实在要用,必须使其产生副本
5. 实际上，每个对象都会统计有多少引用指向自己。 Cpython中, 当引用计数归零时，对象立即就被销毁：CPython会在对象上调用__del__ 方法（如果定义了），然后释放分配给对象的内存