一 、作用域：

python中的作用域分4种情况：

L：local，局部作用域，即函数中定义的变量；E：enclosing，嵌套的父级函数的局部作用域，即包含此函数的上级函数的局部作用域，但不是全局的；G：globa，全局变量，就是模块级别定义的变量；B：built-in，系统固定模块里面的变量，比如int, bytearray等。 搜索变量的优先级顺序依次是：作用域局部>外层作用域>当前模块中的全局>python内置作用域，也就是LEGB。

x = int(2.9)  # int built-ing_count = 0  # globaldef outer():    o_count = 1  # enclosing    def inner():        i_count = 2  # local        print(o_count)    # print(i_count) 找不到    inner()outer()print(o_count) #找不到

当然，local和enclosing是相对的，enclosing变量相对上层来说也是local。

5.2 作用域产生

在Python中，只有模块（module），类（class）以及函数（def、lambda）才会引入新的作用域，其它的代码块（如if、try、for等）是不会引入新的作用域的，如下代码：

if 2>1:    x = 1print(x)  # 1

这个是没有问题的，if并没有引入一个新的作用域，x仍处在当前作用域中，后面代码可以使用。

def test():    x = 2print(x) # NameError: name 'x2' is not defined

def、class、lambda是可以引入新作用域的。

5.3 变量的修改

#################x=6def f2():    print(x)    x=5f2()

错误的原因在于print(x)时,解释器会在局部作用域找,会找到x=5(函数已经加载到内存),但x使用在声明前了,所以报错:local variable 'x' referenced before assignment.如何证明找到了x=5呢?简单:注释掉x=5,x=6报错为:name 'x' is not defined同理

x=6def f2():    x+=1 #local variable 'x' referenced before assignment.f2()

5.4 global关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，代码如下：

count = 10def outer():    global count    print(count)    count = 100    print(count)outer()#10#100

5.5 nonlocal关键字

global关键字声明的变量必须在全局作用域上，不能嵌套作用域上，当要修改嵌套作用域（enclosing作用域，外层非全局作用域）中的变量怎么办呢，这时就需要nonlocal关键字了

def outer():    count = 10    def inner():        nonlocal count        count = 20        print(count)    inner()    print(count)outer()#20#20　

5.6 小结

（1）变量查找顺序：LEGB，作用域局部>外层作用域>当前模块中的全局>python内置作用域；

（2）只有模块、类、及函数才能引入新作用域；

（3）对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；

（4）内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个关键字，就能完美的实现闭包了。

二、内存管理机制：

Python的内存管理机制：引入计数、垃圾回收、内存池机制

一、引入计数

1、变量与对象

变量赋值的时候才创建，它可以指向（引用）任何类型的对象python里每一个东西都是对象，它们的核心就是一个结构体：PyObject变量必须先赋值，再引用。比如，你定义一个计数器，你必须初始化成0，然后才能自增。每个对象都包含两个头部字段（类型标识符和引用计数器）关系图如下：

变量名没有类型，类型属于对象（因为变量引用对象，所以类型随对象），在Python中，变量是一种特定类型对象在一个特定的时间点的引用。

2、共享引用

1、id() 是 python 的内置函数，用于返回对象的标识，即对象的内存地址。

2、引用所指判断

通过is进行引用所指判断，is是用来判断两个引用所指的对象是否相同。

整数

>>> a = 256>>> b = 256>>> a is bTrue>>> c = 257>>> d = 257>>> c is dFalse>>>

短字符串

>>> e = "Explicit">>> f = "Explicit">>> e is fTrue>>>

长字符串

>>> g = "Beautiful is better">>> h = "Beautiful is better">>> g is hFalse>>>

列表

>>> lst1 = [1, 2, 3]>>> lst2 = [1, 2, 3]>>> lst1 is lst2False>>>

由运行结果可知：

1、Python缓存了整数和短字符串，因此每个对象在内存中只存有一份，引用所指对象就是相同的，即使使用赋值

语句，也只是创造新的引用，而不是对象本身；

2、Python没有缓存长字符串、列表及其他对象，可以由多个相同的对象，可以使用赋值语句创建出新的对象。

原理：

# 两种优化机制： 代码块内的缓存机制, 小数据池。# 代码块代码全都是基于代码块去运行的（好比校长给一个班发布命令），一个文件就是一个代码块。不同的文件就是不同的代码块。# 代码块内的缓存机制Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在文件执行时（同一个代码块）会把两个变量指向同一个对象，满足缓存机制则他们在内存中只存在一个，即：id相同。注意：# 机制只是在同一个代码块下！！！，才实行。# 满足此机制的数据类型：int str bool。# 小数据池（驻留机制，驻村机制，字符串的驻存机制，字符串的缓存机制等等）不同代码块之间的优化。# 适应的数据类型：str bool intint： -5 ~256str: 一定条件下的str满足小数据池。bool值 全部。# 总结：如果你在同一个代码块中，用同一个代码块中的缓存机制。如果你在不同代码块中，用小数据池。# 优点：1，节省内存。2，提升性能。

3、查看对象的引用计数

在Python中，每个对象都有指向该对象的引用总数 --- 引用计数

查看对象的引用计数：sys.getrefcount()

当对变量重新赋值时，它原来引用的值去哪啦？比如下面的例子，给 s 重新赋值 字符串 apple，6 跑哪里去啦？

>>> s = 6>>> s = 'apple'

答案是：当变量重新赋值时，它原来指向的对象（如果没有被其他变量或对象引用的话）的空间可能被收回（垃圾回收）

普通引用

>>> import sys>>>>>> a = "simple">>> sys.getrefcount(a)2>>> b = a>>> sys.getrefcount(a)3>>> sys.getrefcount(b)3>>>

注意：当使用某个引用作为参数，传递给getrefcount()时，参数实际上创建了一个临时的引用。因此，getrefcount()所得到的结果，会比期望的多1。

三、垃圾回收

当Python中的对象越来越多，占据越来越大的内存，启动垃圾回收(garbage collection)，将没用的对象清除。

1、原理

当Python的某个对象的引用计数降为0时，说明没有任何引用指向该对象，该对象就成为要被回收的垃圾。

比如某个新建对象，被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，那么该对象就可以被垃圾回收。

2、解析del

del 可以使 对象的引用计数减 1，该表引用计数变为0，用户不可能通过任何方式接触或者动用这个对象，当垃圾回收启动时，Python扫描到这个引用计数为0的对象，就将它所占据的内存清空。

注意

1、垃圾回收时，Python不能进行其它的任务，频繁的垃圾回收将大大降低Python的工作效率；2、Python只会在特定条件下，自动启动垃圾回收（垃圾对象少就没必要回收）3、当Python运行时，会记录其中分配对象(object allocation)和取消分配对象(object deallocation)的次数。

当两者的差值高于某个阈值时，垃圾回收才会启动。

>>> import gc>>>>>> gc.get_threshold() #gc模块中查看垃圾回收阈值的方法(700, 10, 10)>>>

阈值分析：

700 即是垃圾回收启动的阈值；

每10 次 0代 垃圾回收，会配合 1次 1代 的垃圾回收；而每10次1代的垃圾回收，才会有1次的2代垃圾回收；

当然也是可以手动启动垃圾回收：

>>> gc.collect()       #手动启动垃圾回收52>>> gc.set_threshold(666, 8, 9) # gc模块中设置垃圾回收阈值的方法>>>

何为分代回收Python将所有的对象分为0，1，2三代；所有的新建对象都是0代对象；当某一代对象经历过垃圾回收，依然存活，就被归入下一代对象。

分代技术是一种典型的以空间换时间的技术，这也正是java里的关键技术。这种思想简单点说就是：对象存在时间越长，越可能不是垃圾，应该越少去收集。

这样的思想，可以减少标记-清除机制所带来的额外操作。分代就是将回收对象分成数个代，每个代就是一个链表（集合），代进行标记-清除的时间与代内对象存活时间成正比例关系。

从上面代码可以看出python里一共有三代，每个代的threshold值表示该代最多容纳对象的个数。默认情况下，当0代超过700,或1，2代超过10，垃圾回收机制将触发。

0代触发将清理所有三代，1代触发会清理1,2代，2代触发后只会清理自己。

标记-清除机制，顾名思义，首先标记对象（垃圾检测），然后清除垃圾（垃圾回收）。首先初始所有对象标记为白色，并确定根节点对象（这些对象是不会被删除），标记它们为黑色（表示对象有效）。将有效对象引用的对象标记为灰色（表示对象可达，但它们所引用的对象还没检查），检查完灰色对象引用的对象后，将灰色标记为黑色。重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。如何解决循环引用可能导致的内存泄露问题呢？

答案是：

弱引用 使用weakref 模块下的 ref 方法强制把其中一个引用变成 None

import gcimport objgraphimport sysimport weakrefdef quote_demo():    class Person:        pass    p = Person()  # 1    print(sys.getrefcount(p))  # 2  first    def log(obj):        # 4  second 函数执行才计数，执行完释放        print(sys.getrefcount(obj))    log(p)  # 3    p2 = p  # 2    print(sys.getrefcount(p))  # 3    del p2    print(sys.getrefcount(p))  # 3 - 1 = 2def circle_quote():    # 循环引用    class Dog:        pass    class Person:        pass    p = Person()    d = Dog()    print(objgraph.count("Person"))    print(objgraph.count("Dog"))    p.pet = d    d.master = p    # 删除 p, d之后, 对应的对象是否被释放掉    del p    del d    print(objgraph.count("Person"))    print(objgraph.count("Dog"))def solve_cirecle_quote():    # 1. 定义了两个类    class Person:        def __del__(self):            print("Person对象, 被释放了")        pass    class Dog:        def __del__(self):            print("Dog对象, 被释放了")        pass    p = Person()    d = Dog()    p.pet = d    d.master = p    p.pet = None  # 强制置 None    del p    del d    gc.collect()    print(objgraph.count("Person"))    print(objgraph.count("Dog"))def sovle_circle_quote_with_weak_ref():    # 1. 定义了两个类    class Person:        def __del__(self):            print("Person对象, 被释放了")        pass    class Dog:        def __del__(self):            print("Dog对象, 被释放了")        pass    p = Person()    d = Dog()    p.pet = d    d.master = weakref.ref(p)    del p    del d    gc.collect()    print(objgraph.count("Person"))    print(objgraph.count("Dog"))if __name__ == "__main__":    quote_demo()    circle_quote()    solve_cirecle_quote()    sovle_circle_quote_with_weak_ref()

四、内存池机制

Python中有分为大内存和小内存：（256K为界限分大小内存）

大内存使用malloc进行分配小内存使用内存池进行分配Python的内存池(金字塔)第+3层：最上层，用户对Python对象的直接操作第+1层和第+2层：内存池，有Python的接口函数PyMem_Malloc实现若请求分配的内存在1~256字节之间就使用内存池管理系统进行分配，调用malloc函数分配内存，但是每次只会分配一块大小为256K的大块内存，不会调用free函数释放内存，将该内存块留在内存池中以便下次使用第0层：大内存 -----> 若请求分配的内存大于256K，malloc函数分配内存，free函数释放内存。第-1，-2层：操作系统进行操作