Python是两门面向第一类的C语言，python中所有人皆为第一类，对每两个第一类分配缓存内部空间，python的缓存管理模式主要就主要就包括提及算数、废弃物拆解和缓存池监督机制。责任编辑概要如是说python第一类及缓存管理模式。
HTA
常用的HTA有值传达和提及传达
值传达是复本模块的值，接着传达给新表达式，这种原表达式和新表达式间相互分立，彼此间负面影响。提及传达指把模块的提及传予捷伊表达式，这种原表达式和新表达式对准同几块缓存地址。当中任何人两个表达式值发生改变，除此之外两个表达式也会骤然发生改变。Python HTA
Python 的HTA是表达式传达（pass by assignment），或是叫做第一类的提及传达（pass by object reference）。在展开HTA时，新表达式与原表达式对准完全相同的第一类。上面先上看呵呵Python中气门和不容变正则表达式表达式的范例。
1. 不容变正则表达式
auth（int）表达式：
a = 1 print(id(a)) b = aprint(id(b)) a = a + 1 print(id(a)) c = 1 print(id(c))继续执行结论：
140722100085136 140722100085136 140722100085168 140722100085136当中id()函数用于返回第一类的缓存地址。
可以看到b，c都对准了完全相同的第一类，而a = a + 1并不是让 a 的值增加 1，而是重新创建并对准了捷伊值为 2 的第一类。最终结论是a对准了2这个捷伊第一类，b对准1，值不变。
2. 气门正则表达式
以列表（list）为例：
l1 = [1, 2, 3] print(id(l1)) # l2 = l1 print(id(l2)) l1.append(4)print(id(l1)) print(l1) print(l2)继续执行结论：
1933202772296 1933202772296 1933202772296 [1, 2, 3, 4] [1, 2, 3, 4]l1 和 l2 对准完全相同的第一类，由于列表是气门（mutable）正则表达式，所以 l1.append(4)不会创建捷伊列表，仍然对准完全相同的第一类。 由于l1 和 l2 对准完全相同的第一类，所以列表变化也会导致l2的值变化。
气门第一类（列表，字典，集合等）的发生改变，会负面影响所有对准该第一类的表达式。对于不容变第一类（字符串、auth、元组等），所有对准该第一类的表达式的值总是一样的，也不会发生改变。
Python中的== 和 is
== 和 is是Python 第一类比较中常用的两种方式，== 比较第一类的值是否相等， is比较第一类的身份标识（ID）是否相等，是否是同两个第一类，是否对准同两个缓存地址。
a = 1 b = a print(id(a)) print(id(b)) print(a == b) print(a is b)继续执行结论：
140722100085136 140722100085136 True Truea和b的值相等，并对准同两个第一类。在实际应用中，通常使用== 来比较两个表达式的值是否相等。is 操作符常用来检查两个表达式是否为 None：
if a is None: print(“a is None”) if a is not None: print(“a is not None”)Python浅复本和深度复本
前面如是说了Python的表达式（第一类的提及传达），那么Python如何解决原始数据在函数传达后不受负面影响呢，Python提供了浅度复本（shallow copy）和深度复本（deep copy）两种方式。
浅复本(copy)：复本父第一类，不复本第一类内部的子第一类。深复本(deepcopy)：完全拷贝了父第一类及其子第一类。浅复本
1. 不容变正则表达式
上面对不容变第一类auth表达式和元组展开浅复本：
import copy a = 1 b = copy.copy(a) print(id(a)) print(id(b)) print(a == b) print(a is b) t1 = (1, 2, 3) t2 = tuple(t1) print(id(t1)) print(id(t2)) print(t1 == t2)print(t1 is t2)继续执行结论：
50622072 50622072 True True 55145384 55145384 True True不容变第一类的复本和第一类的提及传达一样，a、b对准完全相同的第一类，修改当中两个表达式的值不会负面影响除此之外的表达式，会开辟捷伊内部空间。
2. 气门正则表达式
对气门第一类list展开浅复本：
import copy l1 = [1, 2, 3] l2 = list(l1) l3 =copy.copy(l1) l4 = l1[:] print(id(l1)) print(id(l2)) print(l1 == l2) print(l1 is l2) print(id(l3)) print(id(l4)) l1.append(4) print(id(l1)) print(l1 == l2) print(l1 is l2)继续执行结论：
48520904 48523784 True False 48523848 48521032 48520904 False False可以看到，对气门第一类的浅复本会重新分配几块缓存，创建两个捷伊第一类，里面的元素是原第一类中子第一类的提及。发生改变l1的值不会负面影响l2，l3，l4的值，它们对准不同的第一类。
上面的范例比较简单，上面举两个相对复杂的数据结构：
import copy l1 = [[1, 2], (4, 5)] l2 = copy.copy(l1) print(id(l1))print(id(l2)) print(id(l1[0])) print(id(l2[0])) l1.append(6) print(l1) print(l2) l1[0].append(3) print(l1) print(l2)继续执行结论：
1918057951816 1918057949448 2680328991496 2680328991496 [[1, 2], (4, 5), 6] [[1, 2], (4, 5)] [[1, 2, 3], (4, 5), 6] [[1, 2, 3], (4, 5)]l2 是 l1 的浅复本，它们对准不同的第一类，因为浅复本里的元素是对原第一类元素的提及，因此 l2 中的元素和 l1 对准同两个列表和元组第一类（l1[0]和l2[0]对准的是完全相同的地址）。l1.append(6)不会对 l2 产生任何人负面影响，因为 l2 和 l1 作为整体是两个不同的第一类，不共享缓存地址。
l1[0].append(3)对 l1 中的第两个列表新增元素 3，因为 l2 是 l1 的浅复本，l2 中的第两个元素和 l1 中的第两个元素，共同对准同两个列表，因此 l2 中的第两个列表也会相对应的新增元素 3。
这里提两个小问题：如果对l1中的元组新增元素（l1[1] += (7, 8)），会负面影响l2吗？
到这里我们知道使用浅复本可能带来的副作用，要避免它就得使用深度复本。
深度复本
深度复本会完整地复本两个第一类，会重新分配几块缓存，创建两个捷伊第一类，并且将原第一类中的元素以递归的方式，通过创建捷伊子第一类复本到新第一类中。因此，新第一类和原第一类没有任何人关联，也是完全复本了父第一类及其子第一类。
import copy l1 = [[1, 2], (4, 5)] l2 = copy.deepcopy(l1) print(id(l1)) print(id(l2)) l1.append(6) print(l1) print(l2) l1[0].append(3) print(l1) print(l2)继续执行结论：
3026088342280 3026088342472 [[1, 2], (4, 5), 6] [[1, 2], (4, 5)] [[1, 2, 3], (4, 5), 6] [[1, 2], (4, 5)]可以看到，l1 变化不负面影响l2 ，l1 和 l2 完全分立，没有任何人联系。
在展开深度复本时，深度复本 deepcopy 中会维护两个字典，记录已经复本的第一类与其 ID。如果字典里已经存储了将要复本的第一类，则会从字典直接返回。
Python废弃物拆解
Python垃圾拆解主要就包括提及算数、标记清除和分代拆解
提及算数
提及算数是一种废弃物收集监督机制，当两个python第一类被提及时，提及算数加 1，当两个第一类的提及为0时，该第一类会被当做废弃物拆解。
from sys importgetrefcount l1 = [1, 2, 3] print(getrefcount(l1)) # 查看提及算数 l2 = l1 print(getrefcount(l2))继续执行结论：
2 3在使用 getrefcount()的时候，表达式作为模块传进去，会多一次提及。
del语句会删除第一类的两个提及。请看上面的范例
from sys import getrefcount class TestObjectA(): def __init__(self): print(“hello!!!”) def __del__(self): print(“bye!!!”) a = TestObjectA() b = a c = a print(getrefcount(c))del a print(getrefcount(c)) del b print(getrefcount(c)) delc print(“666”)继续执行结论：
hello!!! 4 3 2 bye!!! 666方法__del__ 的作用是当第一类被销毁时调用。当中del a删除了表达式a，但是第一类TestObjectA仍然存在，它还被b和c提及，所以不会被拆解，提及算数为0时会被拆解。上面的范例中，将a，b，c都删除后提及的第一类被拆解（打印“666”之前）。
除此之外重新表达式也会删除第一类的两个提及。
标记清除
如果出现了循环提及，提及算数方法就无法拆解，导致缓存泄漏。先上看上面的范例：
class TestObjectA(dict): def __init__(self): print(“A: hello!!!”) def __del__(self): print(“A: bye!!!”) class TestObjectB(dict): def __init__(self): print(“B: hello!!!”) def __del__(self):print(“B: bye!!!”) a = TestObjectA() b = TestObjectB() a[1] = b b[1] = a del a delb print(“666”)继续执行结论：
A: hello!!! B: hello!!! 666 A: bye!!! B: bye!!!上面的代码存在循环提及，删除a和b之后，它们的提及算数还是1，仍然大于0，不会被拆解（打印“666”之后）。
标记清除可解决循环提及问题，从根第一类（寄存器和程序栈上的提及）出发，遍历第一类，将遍历到的第一类打上标记（废弃物检测），接着在缓存中清除没有标记的第一类（废弃物拆解）。上面的范例中，a和b相互提及，如果与其他第一类没有提及关系就不会遍历到它，也就不会被标记，所以会被清除。
分代拆解
如果频繁展开标记清除会负面影响Python性能，有很多第一类，清理了很多次他依然存在，可以认为，这种的第一类不需要经常拆解，也是说，第一类存在时间越长，越可能不是废弃物。
将拆解第一类展开分代（一共三代），每代拆解的时间间隔不同，当中新创建的第一类为0代，如果两个第一类能在第0代的废弃物拆解过程中存活下来，那么它就被放入到1代中，如果1代里的第一类在第1代的废弃物拆解过程中存活下来，则会进入到2代。
gc模块
以下三种情况会启动废弃物拆解：
调用gc.collect()：强制对所有代继续执行一次拆解当gc模块的算数器达到阀值的时候。程序退出的时候gc 模块函数：
gc.enable() ：启用自动废弃物拆解gc.disable()：停用自动废弃物拆解gc.isenabled()：如果启用了自动拆解则返回 True。gc.collect(generation=2)：不设置模块会对所有代继续执行一次拆解gc.set_threshold(threshold0[, threshold1[, threshold2]])：设置废弃物拆解阈值gc.get_count()：当前拆解算数废弃物拆解启动的默认阈值
import gc print(gc.get_threshold())输出：
(700, 10, 10)700是废弃物拆解启动的阈值，第一类分配数量减去释放数量的值大于 700 时，就会开始展开废弃物拆解，每10次0代废弃物拆解，会导致一次1代拆解；而每10次1代的拆解，才会有1次的2代拆解。可以使用set_threshold()方法重新设置。
Python缓存管理模式：Pymalloc
Pymalloc
Python实现了两个缓存池(memory pool)监督机制，使用Pymalloc对小块缓存（小于等于256kb）展开申请和释放管理。
当 Python 频繁地创建和销毁一些小的第一类时，底层会多次重复调用 malloc 和 free 等函数展开缓存分配。这不仅会引入较大的系统开销，而且还可能产生大量的缓存碎片。
缓存池的概念是预先在缓存中申请一定数量的缓存内部空间，当有有满足条件的缓存请求时，就先从缓存池中分配缓存给这个需求，如果预先申请的缓存已经耗尽，Pymalloc allocator 会再申请捷伊缓存（不能超过预先设置的缓存池最大容量）。废弃物拆解时，拆解的缓存归还给缓存池。这种做最显著的优势是能够减少缓存碎片，提升效率。
如果应用的缓存需求大于 pymalloc 设置的阈值，那么解释器再将这个请求交给底层的 C 函数（malloc/realloc/free等）来实现。
python缓存池金字塔
第-1层和-2层：由操作系统操作。第0层：大缓存，若请求分配的缓存大于256kb，使用malloc、free 等函数分配、释放缓存。第1层和第2层：由python的接口函数Pymem_Malloc实现，若请求的缓存在小于等于256kb时使用该层展开分配。第3层(最上层）：用户对python第一类的直接操作m/article/memory-management-in-python/
总结
责任编辑主要就如是说了Python的HTA、浅复本、深复本，废弃物拆解和缓存池监督机制。
Python 中模块的传达既不是值传达，也不是提及传达，而是表达式传达，或是是叫第一类的提及传达。需要注意气门第一类和不容变第一类的区别。比较操作符==比较第一类间的值是否相等，而`is比较第一类是否对准同两个缓存地址。浅复本中的元素是对原第一类中子第一类的引用，如果父第一类中的元素是气门的，发生改变它的值也会负面影响复本后的第一类。深复本则会递归地复本原第一类中的每两个子第一类，是对原第一类的完全复本。Python废弃物拆解主要就包括提及算数、标记清除和分代拆解三种，可以使用gc模块来展开废弃物拆解的配置。为了减少缓存碎片，提升效率，Python使用了Pymalloc来管理小于等于256kb的小缓存。–THE END–
