一、变量与对象
导语：a = 1
整数1为一个对象。而a是一个引用。利用赋值语句，引用a指向对象1。Python是动态类型的语言(参考动态类型)，对象与引用分离。Python像使用“筷子”那样，通过引用来接触和翻动真正的食物——对象。
1、变量
通过变量指针引用对象；变量指针指向具体对象的内存空间，取对象的值。
2、对象
类型已知，每个对象都包含一个头部信息（头部信息：类型标识符和引用计数器）【对象自带的类型标识符决定对象类型】
变量名没有类型，类型属于对象（因为变量引用对象，所以类型随对象），变量引用什么类型的对象，变量就是什么类型的。
In [32]: var1=object
In [33]: var2=var1
In [34]: id(var1)
Out[34]: 139697863383968
In [35]: id(var2)
Out[35]: 139697863383968
PS：id()是python的内置函数，用于返回对象的身份，即对象的内存地址。
In [39]: a=123
In [40]: b=a
In [41]: id(a)
Out[41]: 23242832
In [42]: id(b)
Out[42]: 23242832
Ps：a和b指向同一个对象的内存地址
In [43]: a=456
In [44]: id(a)
Out[44]: 33166408
In [45]: id(b)
Out[45]: 23242832
Ps：a变量重新指向（引用）了另一个对象，不同对象的内存地址当然不一样
注意：
对象引用对象，是Python最基本的构成方式。即使是a = 1这一赋值方式，实际上是让词典的一个键值"a"的元素引用整数对象1。该词典对象用于记录所有的全局引用。该词典引用了整数对象1。我们可以通过内置函数globals()来查看该词典。
from sys import getrefcount
a = [1, 2, 3]
print(getrefcount(a))
b = [a, a]
print(getrefcount(a))
由于对象b引用了两次a，a的引用计数增加了2
3、引用所指判断【is 判断的是两个变量指向的对象的内存地址是否是同一个地址，是同一个地址返回Ture，否则返回False】
衍生：在python中 is 和 == 的区别：
在 Python 中一切都是对象，对象之间比较是否相等可以用==，也可以用is。
①is：比较的是两个对象的id值是否也相等，也就是比较两个对象是否为同一个实例对象，是否指向同一个内存地址。
②==：双等于号比较的是两个对象的内容是否相等，默认会调用对象的 __eq__ 方法。
通过is进行引用所指判断，is是用来判断两个引用所指的对象是否相同。
为了检验两个引用指向同一个对象，我们可以用is关键字。is用于判断两个引用所指的对象是否相同。
整数
In [46]: a=1
In [47]: b=1
In [48]: print(a is b)
True
短字符串
In [49]: c="good"
In [50]: d="good"
In [51]: print(c is d)
True
长字符串：简单理解，纯字母、数字或者下划线的组合 就是短字符串，其他是长字符串
In [52]: e="very good"
In [53]: f="very good"
In [54]: print(e is f)
Ture
列表
In [55]: g=[]
In [56]: h=[]
In [57]: print(g is h)
False
由运行结果可知：
1、Python没有缓存列表及其他对象，可以由多个相同的对象，可以使用赋值语句创建出新的对象
2、在Python中，整数和短小的字符，Python都会缓存这些对象，以便重复使用。当我们创建多个等于1的引用时，实际上是让所有这些引用指向同一个对象。
3、由于Python缓存了整数和短字符串，因此每个对象只存有一份【对象在内存中的地址相同】。比如，所有整数1的引用都指向同一对象。即使使用赋值语句，也只是创造了新的引用，而不是对象本身。长的字符串和其它对象可以有多个相同的对象，可以使用赋值语句创建出新的对象。
二、引用计数
在Python中，每个对象都有存有指向该对象的引用总数，即引用计数(reference count)。
使用sys包中的getrefcount()，来查看某个对象的引用计数。需要注意的是，当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。
查看对象的引用计数：sys.getrefcount()
1、普通引用
In [2]: import sys
In [3]: a=[1,2,3]
In [4]: getrefcount(a)
Out[4]: 2
In [5]: b=a
In [6]: getrefcount(a)
Out[6]: 3
In [7]: getrefcount(b)
Out[7]: 3
Ps：当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。
2、容器对象
Python的一个容器对象(container)，比如列表、字典等，可以包含多个对象。实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。【可以理解为引用对象的变量】
In [12]: a=[1,2,3,4,5]
In [13]: b=a
In [14]: a is b
Out[14]: True
In [15]: a[0]=6
In [16]: a
Out[16]: [6, 2, 3, 4, 5]
In [17]: a is b
Out[17]: True
In [18]: b
Out[18]: [6, 2, 3, 4, 5]
由上可见，实际上，容器对象中包含的并不是元素对象本身，是指向各个元素对象的引用。
3、引用计数增加
1、对象被创建
In [39]: getrefcount(123)
Out[39]: 6
In [40]: n=123
In [41]: getrefcount(123)
Out[41]: 7
2、另外的别人被创建
In [42]: m=n
In [43]: getrefcount(123)
Out[43]: 8
3、作为容器对象的一个元素
In [44]: a=[1,12,123]
In [45]: getrefcount(123)
Out[45]: 9
4、被作为参数传递给函数：foo(x)
4、引用计数减少
1、对象的别名被显式的销毁
In [46]: del m
In [47]: getrefcount(123)
Out[47]: 8
2、对象的一个别名被赋值给其他对象
In [48]: n=456
In [49]: getrefcount(123)
Out[49]: 7
3、对象从一个窗口对象中移除，或，窗口对象本身被销毁
In [50]: a.remove(123)
In [51]: a
Out[51]: [1, 12]
In [52]: getrefcount(123)
Out[52]: 6
4、一个本地引用离开了它的作用域，比如上面的foo(x)函数结束时，x指向的对象引用减1。
总结：增加对象引用计数器和减少引用计数器的几种方式：
1、有4种方式，会增加引用计数器
①创建对象---如：X=1
②别名被创建---如：赋值 y=x【赋值给其他变量】
③做为参数传递给函数---如：参数名（x）
④成为容器对象的一个元素---如：List=[x, y,‘ss’]
2、什么情况下会减少引用???
①本地引用被赋值为其他对象---当对象1被创建并赋值给X，它的引用就为1，当增加了别名（应该也可以成为赋值），引用就变成了2（Y的引用就为2），不过当x被重新赋值2，x对应的引用计数就减1.
如果某个引用指向对象A，当这个引用被重新定向到某个其他对象B时，对象A的引用计数减少:
from sys import getrefcount
a = [1, 2, 3]
b = a
print(getrefcount(b))
a = 1
print(getrefcount(b))
②对象名被销毁---使用del x ,这是引用计数就为0
del也可以用于删除容器元素中的元素
a = [1,2,3]
del a[0]
print(a)
③对象从一个窗口对象移除---函数名.Remove()【窗口对象如列表，字典，元组等】
④窗口对象被销毁---如:List=[x,y,'ss'] Del list[]【窗口对象被销毁，代表窗口对象中包含的所有对象都被销毁】
三、垃圾回收【当某对象引用计数器变为0时，此时应该被垃圾回收】
当Python中的对象越来越多，占据越来越大的内存，启动垃圾回收(garbage collection)，将没用的对象清除。
1、原理
当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾。比如某个新建对象，被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。
In [74]: a=[321,123]
In [75]: del a
2、解析del
del a后，已经没有任何引用指向之前建立的[321,123]，该列表引用计数变为0，用户不可能通过任何方式接触或者动用这个对象，当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
3、注意
1、垃圾回收时，Python不能进行其它的任务，频繁的垃圾回收将大大降低Python的工作效率；
2、Python只会在特定条件下，自动启动垃圾回收（垃圾对象少就没必要回收）
3、当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
4、垃圾回收机制还有一个循环垃圾回收器, 确保释放循环引用对象(a引用b, b引用a, 导致其引用计数永远不为0。
In [93]: import gc
In [94]: gc.get_threshold() #gc模块中查看阈值的方法
Out[94]: (700, 10, 10)
阈值分析：
700即是垃圾回收启动的阈值；
每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收；
当然也是可以手动启动垃圾回收：
In [95]: gc.collect() #手动启动垃圾回收
Out[95]: 2
4、何为分代回收
Python将所有的对象分为0，1，2三代；
所有的新建对象都是0代对象；
当某一代对象经历过垃圾回收，依然存活，就被归入下一代对象。
四、内存池机制
Python中有分为大内存和小内存：（256K为界限分大小内存）【>256k为大内存，<256k为小内存】
1、大内存使用malloc进行分配
2、小内存使用内存池进行分配
3、Python的内存池(金字塔)
第3层：最上层，用户对Python对象的直接操作
第1层和第2层：内存池，有Python的接口函数PyMem_Malloc实现-----若请求分配的内存在1~256字节之间就使用内存池管理系统进行分配，调用malloc函数分配内存，但是每次只会分配一块大小为256K的大块内存，不会调用free函数释放内存，将该内存块留在内存池中以便下次使用。
第0层：大内存-----若请求分配的内存大于256K，malloc函数分配内存，free函数释放内存。
第-1，-2层：操作系统进行操作
Python垃圾回收的另一种讲解
垃圾回收：
1、吃太多，总会变胖，Python也是这样。当Python中的对象越来越多，它们将占据越来越大的内存。不过你不用太担心Python的体形，它会乖巧的在适当的时候“减肥”，启动垃圾回收(garbage collection)，将没用的对象清除。在许多语言中都有垃圾回收机制，比如Java和Ruby。尽管最终目的都是塑造苗条的提醒，但不同语言的减肥方案有很大的差异 (这一点可以对比本文和Java内存管理与垃圾回收)。
2、从基本原理上，当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾了。比如某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。比如下面的表:
a = [1, 2, 3]
del a
del a后，已经没有任何引用指向之前建立的[1, 2, 3]这个表。用户不可能通过任何方式接触或者动用这个对象。这个对象如果继续待在内存里，就成了不健康的脂肪。当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。
3、然而，减肥是个昂贵而费力的事情。垃圾回收时，Python不能进行其它的任务。频繁的垃圾回收将大大降低Python的工作效率。如果内存中的对象不多，就没有必要总启动垃圾回收。所以，Python只会在特定条件下，自动启动垃圾回收。当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。当两者的差值高于某个阈值时，垃圾回收才会启动。
我们可以通过gc模块的get_threshold()方法，查看该阈值:
import gc
print(gc.get_threshold())
返回(700, 10, 10)，后面的两个10是与分代回收相关的阈值，后面可以看到。700即是垃圾回收启动的阈值。可以通过gc中的set_threshold()方法重新设置。
我们也可以手动启动垃圾回收，即使用gc.collect()。
分代回收：
1、Python同时采用了分代(generation)回收的策略。这一策略的基本假设是，存活时间越久的对象，越不可能在后面的程序中变成垃圾。我们的程序往往会产生大量的对象，许多对象很快产生和消失，但也有一些对象长期被使用。出于信任和效率，对于这样一些“长寿”对象，我们相信它们的用处，所以减少在垃圾回收中扫描它们的频率。
2、Python将所有的对象分为0，1，2三代。所有的新建对象都是0代对象。当某一代对象经历过垃圾回收，依然存活，那么它就被归入下一代对象。垃圾回收启动时，一定会扫描所有的0代对象。如果0代经过一定次数垃圾回收，那么就启动对0代和1代的扫描清理。当1代也经历了一定次数的垃圾回收后，那么会启动对0，1，2，即对所有对象进行扫描。
这两个次数即上面get_threshold()返回的(700, 10, 10)返回的两个10。也就是说，每10次0代垃圾回收，会配合1次1代的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收。
3、同样可以用set_threshold()来调整，比如对2代对象进行更频繁的扫描。
import gc
gc.set_threshold(700, 10, 5)
孤立的引用环：
1、引用环的存在会给上面的垃圾回收机制带来很大的困难。这些引用环可能构成无法使用，但引用计数不为0的一些对象。
a = []
b = [a]
a.append(b)
del a
del b
上面我们先创建了两个表对象，并引用对方，构成一个引用环。删除了a，b引用之后，这两个对象不可能再从程序中调用，就没有什么用处了。但是由于引用环的存在，这两个对象的引用计数都没有降到0，不会被垃圾回收。
2、为了回收这样的引用环，Python复制每个对象的引用计数，可以记为gc_ref。假设，每个对象i，该计数为gc_ref_i。Python会遍历所有的对象i。对于每个对象i引用的对象j，将相应的gc_ref_j减1；在结束遍历后，gc_ref不为0的对象，和这些对象引用的对象，以及继续更下游引用的对象，需要被保留。而其它的对象则被垃圾回收。
总结：
1、Python作为一种动态类型的语言，其对象和引用分离。这与曾经的面向过程语言有很大的区别。为了有效的释放内存，Python内置了垃圾回收的支持。Python采取了一种相对简单的垃圾回收机制，即引用计数，并因此需要解决孤立引用环的问题。
2、Python与其它语言既有共通性，又有特别的地方。对该内存管理机制的理解，是提高Python性能的重要一步。
去期待陌生，去拥抱惊喜。
