Python垃圾回收机制—Python Day 12

目录 

1.引用计数机制

2.Python中的循环数据结构及引用计数

3.Python中的GC模块

4.Python 内存优化

5.Python pep8规范

6.Python 命令行参数

---

 导读

垃圾回收的必要性

为什么现在电动车越来越多？

传统能源车排放的垃圾（二氧化碳、二氧化硫）无法回收

为什么大街上的垃圾箱都要分类?

便于垃圾回收，重复利用

为什么样电脑开时间长了，越来越卡?

程序占用的内存无法释放

程序的垃圾回收

电脑运行一段时间会变慢，大家是亲身体会过,相信大家对于这种情况的处理都有各自的方法，比如:

1.关闭不用的程序

2.结束掉进程

3.关闭一些服务

4.重启电脑

我们会发现，重启的效果是最明显的,原因就在于，程序永远不会完美，通过前三种方法无法释放内存资源，而垃圾回收就是为了尽可能的使程序完美

重点

引用计数机制

Python中GC模块

Python pep8规范

难点

Python中的循环数据结构及引用计数

Python 命令行参数

1.引用计数机制

 概述

Garbage collection(GC)

现在的高级语言如java，c#等，都采用了垃圾收集机制，而不再是c，c++里用户自己管理维护内存的方式。自己管理内存极其自由，可以任意申请内存，但如同一把双刃剑，为大量内存泄露，悬空指针等bug埋下隐患。

对于一个字符串、列表、类甚至数值都是对象，且定位简单易用的语言，自然不会让用户去处理如何分配回收内存的问题。

python里也同java一样采用了垃圾收集机制，不过不一样的是: python采用的是引用计数机制为主，标记-清除和分代收集两种机制为辅的策略

引用计数原型

python里每一个东西都是对象，它们的核心就是一个结构体：PyObject

PyObject是每个对象必有的内容，其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的obrefcnt就会增加，当引用它的对象被删除，它的ob_refcnt就会减少

当引用计数为0时，该对象生命就结束了

import sys
a=[]
print(sys.getrefcount(a))  # 2次
b=a
print(sys.getrefcount(a))  #3次
c=b
d=b
e=c
f=e
g=d
print(sys.getrefcount(a))  #8次
#统计的是a被引用释放的次数

引用计数优点 

1.简单

2.实时性：一旦没有引用，内存就直接释放了。不用像其他机制需要等到特定时机。实时性还带来一个好处：处理回收内存的时间分摊到了平时

引用计数缺点

1.维护引用计数会消耗资源

2.循环引用

list1 = []
list2 = []
list1.append(list2)
list2.append(list1)

list1与list2相互引用，如果不存在其他对象对它们的引用，list1与list2的引用计数也仍然为1，所占用的内存永远无法被回收，这将是致命的。 

对于如今的强大硬件，缺点1尚可接受，但是循环引用导致内存泄露，注定python还将引入新的回收机制。(标记清除和分代收集)

GC负责的主要任务

1.为新生成的对象分配内存

2.识别那些垃圾对象

3.从垃圾对象那回收内存。

​

如果将应用程序比作人的身体：所有你所写的那些优雅的代码，业务逻辑，算法，应该就是大脑。以此类推，垃圾回收机制应该是那个身体器官呢？

垃圾回收就象应用程序的心。像心脏为身体其他器官提供血液和营养物那样，垃圾回收器为你的应该程序提供内存和对象。如果心脏停跳，过不了几秒钟人就完了。如果垃圾回收器停止工作或运行迟缓,像动脉阻塞,你的应用程序效率也会下降，直至最终死掉。

2.Python中的循环数据结构及引用计数

 标记-清除机制

1.标记-清除机制，顾名思义，首先标记对象（垃圾检测），然后清除垃圾（垃圾回收）

​

首先初始所有对象标记为白色,并确定根节点对象（这些对象是不会被删除）,标记它们为黑色（表示对象有效）,将有效对象引用的对象标记为灰色（表示对象可达，但它们所引用的对象还没检查），检查完灰色对象引用的对象后，将灰色标记为黑色。重复直到不存在灰色节点为止。最后白色结点都是需要清除的对象。

引用计数不能回收的案例分析(1)

如果一个数据结构引用了它自身，即如果这个数据结构是一个循环数据结构，那么某些引用计数值是肯定无法变成零的。为了更好地理解这个问题，让我们举个例子

class Node:
    def __init__(self,val):
        self.value=val
n1=Node('ABC')
n2=Node('EFG')

两个节点的引用计数都被初始化为1，因为各有两个引用指向各个节点(n1和n2)，现在，让我们在节点中定义两个附加的属性，next以及prev： 

我们设置 n1.next 指向 n2，同时设置 n2.prev 指回 n1

n1.next=n2
n2.prev=n1

​

引用计数不能回收的案例分析(2)

1.现在，我们的两个节点使用循环引用的方式构成了一个双端链表

2.同时请注意到 ABC 以及 DEF 的引用计数值已经增加到了2

3.这里有两个指针指向了每个节点：首先是 n1 以及 n2，其次就是 next 以及 prev

4.现在，假定我们的程序不再使用这两个节点了，我们将 n1 和 n2 都设置为null(Python中是None)

​

Python会像往常一样将每个节点的引用计数减少到1 

此时上面的例子成了一个“孤岛”或是一组未使用的、互相指向的对象，但是谁都没有外部引用。

换句话说，我们的程序不再使用这些节点对象了，所以我们希望Python的垃圾回收机制能够足够智能去释放这些对象并回收它们占用的内存空间。但是这不可能，因为所有的引用计数都是1而不是0。Python的引用计数算法不能够处理互相指向自己的对象

Python中的GC阈值

Python什么时候会进行这个标记过程？随着你的程序运行，Python解释器保持对新创建的对象，以及因为引用计数为零而被释放掉的对象的追踪。从理论上说，这两个值应该保持一致，因为程序新建的每个对象都应该最终被释放掉。

当然，事实并非如此。因为循环引用的原因，并且因为你的程序使用了一些比其他对象存在时间更长的对象，从而被分配对象的计数值与被释放对象的计数值之间的差异在逐渐增长。一旦这个差异累计超过某个阈值，则Python的收集机制就启动了，并且触发上边所说到的零代算法，释放“浮动的垃圾”，并且将剩下的对象移动到一代列表。

随着时间的推移，程序所使用的对象逐渐从零代列表移动到一代列表。而Python对于一代列表中对象的处理遵循同样的方法，一旦被分配计数值与被释放计数值累计到达一定阈值，Python会将剩下的活跃对象移动到二代列表。

通过这种方法，你的代码所长期使用的对象，那些你的代码持续访问的活跃对象，会从零代链表转移到一代再转移到二代。通过不同的阈值设置，Python可以在不同的时间间隔处理这些对象。Python处理零代最为频繁，其次是一代然后才是二代。

import sys
import psutil
import  os
def showMemSize(tag):
    pid=os.getpid()
    p=psutil.Process(pid)
    info=p.memory_full_info()
    memory=info.uss/1024/1024
    print('{} memory used:{} MB'.format(tag,memory))

#验证循环引用的情况
def func():
    showMemSize('初始化')
    a = [i for i in range(10000)]
    b = [i for i in range(10000)]
    a.append(b)
    b.append(a)
    showMemSize('创建对象a b之后')


func()
showMemSize('完成的时候')

 运行结果

初始化 memory used:8.14453125 MB
创建对象a b之后 memory used:9.0 MB
完成的时候 memory used:9.0 MB

3.Python中的GC模块

Python 垃圾回收机制

Python中的垃圾回收是以引用计数为主，分代收集为辅

导致引用计数+1的情况

1.对象被创建

2.对象被引用

3.对象被作为参数，传入到一个函数中

4.对象作为一个元素，存储在容器中

导致引用计数-1的情况

1.对象的别名被显式销毁

2.对象的别名被赋予新的对象

3.一个对象离开它的作用域，例如f函数执行完毕时，func函数中的局部变量（全局变量不会）

4.对象所在的容器被销毁，或从容器中删除对象

查看一个对象的引用计数

import sys
a='Hello world'
print(sys.getrefcount(a))

 可以查看a对象的引用计数，但是比正常计数大1，因为调用函数的时候传入a，这会让a的引用计数+1

内存泄漏

申请了某些内存，但是忘记了释放，那么这就造成了内存的浪费，久而久之内存就不够用了

内存泄露演示 

import gc
class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(id(self)))
def f2():
    while True:
        c1=ClassA()
        c2=ClassA()
        c1.t=c2
        c2.t=c1
        del c1
        del c2
#python默认是开启垃圾回收的，可以通过下面代码来将其关闭
gc.disable()
f2()

执行f2()，进程占用的内存会不断增大。

创建了c1，c2后这两块内存的引用计数都是1，执行c1.t=c2和c2.t=c1后，这两块内存的引用计数变成2.

在del c1后，引用计数变为1，由于不是为0，所以c1对象不会被销毁;同理，c2对象的引用数也是1。

python默认是开启垃圾回收功能的，但是由于以上程序已经将其关闭，会回收它们，所以就会导致内存泄露因此导致垃圾回收器都不能回收

手动调用gc回收垃圾

import gc
class ClassA():
    def __init__(self):
        print('object born,id:%s'%str(id(self)))
def f2():
    while True:
        c1=ClassA()
        c2=ClassA()
        c1.t=c2
        c2.t=c1
        del c1
        del c2
        gc.collect()#手动调用垃圾回收功能，这样在自动垃圾回收被关闭的情况下，也会进行回收
#python默认是开启垃圾回收的，可以通过下面代码来将其关闭
gc.disable()
f2()

有三种情况会触发垃圾回收：

1.当gc模块的计数器达到阀值的时候，自动回收垃圾

2.调用gc.collect()，手动回收垃圾

3.程序退出的时候，python解释器来回收垃圾

gc模块的自动垃圾回收触发机制(1)

1.在Python中，采用分代收集的方法。把对象分为三代，一开始，对象在创建的时候，放在一代中，如果在一次一代的垃圾检查中，该对象存活下来，就会被放到二代中，同理在一次二代的垃圾检查中，该对象存活下来，就会被放到三代中

2.gc模块里面会有一个长度为3的列表的计数器，可以通过gc.get_count()获取

3.例如(200, 8, 3)，其中200是指距离上一次一代垃圾检查，Python分配内存的数目减去释放内存的数目，注意是内存分配，而不是引用计数的增加。 8是指距离上一次二代垃圾检查，一代垃圾检查的次数，同理，3是指距离上一次三代垃圾检查，二代垃圾检查的次数。

gc模块的自动垃圾回收触发机制(2)

gc模快有一个自动垃圾回收的阀值，即通过gc.get_threshold函数获取到的长度为3的元组，例如(700,10,10) 每一次计数器的增加，gc模块就会检查增加后的计数是否达到阀值的数目，如果是，就会执行对应的代数的垃圾检查，然后重置计数器

1.当计数器从(699,3,0)增加到(700,3,0)，gc模块就会执行gc.collect(0),即检查一代对象的垃圾，并重置计数器为(0,4,0)

2.当计数器从(699,9,0)增加到(700,9,0)，gc模块就会执行gc.collect(1),即检查一、二代对象的垃圾，并重置计数器为(0,0,1)

3.当计数器从(699,9,9)增加到(700,9,9)，gc模块就会执行gc.collect(2),即检查一、二、三代对象的垃圾，并重置计数器为(0,0,0)

4.Python 内存优化

小整数与大整数对象池

Python为了优化速度，使用了小整数对象池， 避免为整数频繁申请和销毁内存空间。 Python 对小整数的定义是 [-5, 256] 这些整数对象是提前建立好的，不会被垃圾回收。

5.Python pep8规范

Python pep8原则

Guido的主要见解之一是代码读取的次数比写入次数多得多。这里提供的准则旨在提高代码的可读性并使其在各种Python代码中保持一致

代码布局

缩进：4个空格的缩进（编辑器都可以完成此功能），不要使用Tab，更不能混合使用Tab和空格。

缩进

每个缩进级别使用4个空格。

连续行应使用Python的隐式行连接括号，括号和大括号，或使用悬挂缩进 来垂直对齐包装元素.

符合：

#与开头分隔符对齐。
foo = long_function_name(var_one,var_two,
                         var_three,var_four)
#包含更多缩进以区别于此。
def long_function_name(
        var_one,var_two,var_three,
        var_four):
    print(var_one)
#悬挂缩进应该添加一个关卡
foo= long_function_name(
    var_one,var_two,
    var_three,var_four)

不符合：

#不使用垂直对齐时禁止第一行的参数。
foo = long_function_name(var_one,var_two,
  var_three,var_four)
#作为缩进所需的进一步缩进不可区分。
def long_function_name(
    var_one,var_two,var_three,
    var_four):
    print(var_one)

悬挂缩进不一定是4个空格

 if语句跨行时，两个字符关键字(比如if)加上一个空格，再加上左括号构成了很好的缩进。后续行暂时没有规定，至少有如下三种格式，建议使用第3种。

行宽

每行最大长度79，换行可以使用反斜杠，最好使用圆括号。换行点要在操作符的后边敲回车。 文本长块，比如文档字符串或注释，行长度应限制为72个字符。

空行

1.类和top-level函数定义之间空两行

2.类中的方法定义之间空一行

3.函数内逻辑无关段落之间空一行

4.其他地方尽量不要再空行

源文件编码

1.核心Python发行版中的代码应始终使用UTF-8（或Python 2中的ASCII）。

2.使用ASCII（在Python 2中）或UTF-8（在Python 3中）的文件不应该有编码声明。

3.Python标准库中的所有标识符必须使用纯ASCII标识符，并且应尽可能使用英文单词（在许多情况下，缩写和技术使用的术语不是英语）。

4.字符串文字和注释也必须使用ASCII。

5.这个主要是 鼓励全球受众开放源码项目采取类似的政策， 个人建议声明编码为utf-8。

模块导入 

# 导入始终在文件的顶部，在模块注释和文档字符串之后，在模块全局变量和常量之前。
# 不同模块分行导入，内置模块放在前面，第三方模块在在后面导入
import os
import sys
from subprocess import Popen, PIPE
# 不建议使用这种方式导入，因为它不清楚命名空间有哪些名称存，混淆读者和许多自动化的工具。
from xxx  import *

1.导入顺序进行分组

2.标准库导入

3.相关的第三方进口

4.本地应用程序/库特定的导入您应该在每组导入之间留出空行。

表达式和语句中的空格

1、在以下情况下避免无关的空白：括号或大括号内

#对的做法
spam(ham[1],{eggs:2})
#不对的做法
spam(  ham[ 1 ],{  eggs:  2  })

2、尾随逗号和后面的右括号之间

#对的做法
foo = (0,)
#不对的做法
bar = (0, )

3、在逗号，分号或冒号前面：

#对的做法
if x == 4: print x, y; x, y = y, x
#不对的做法
if x == 4 : print x , y ; x , y = y , x

4、在一个切片中，冒号的作用就像一个二元运算符，并且两边应该有相同的数量；在扩展切片中，两个冒号必须具有相同量的间距。例外：当省略切片参数时，空格被省略

#对的做法
ham[1:9], ham[1:9:3], ham[:9:3], ham[1::3], ham[1:9:]
ham[lower:upper], ham[lower:upper:], ham[lower::step]
ham[lower+offset : upper+offset]
ham[: upper_fn(x) : step_fn(x)], ham[:: step_fn(x)]
ham[lower + offset : upper + offset]
#不对的做法
ham[lower + offset:upper + offset]
ham[1: 9], ham[1 :9], ham[1:9 :3]
ham[lower : : upper]
ham[ : upper]

5、函数的调用，小括号之前

#对的做法
spam(1)
#不对的做法
spam (1)

6、在一个赋值（或其他）运算符周围的多个空间将其与另一个对齐

#对的做法
x = 1
y = 2
long_variable = 3

#不对的做法
x = 1
y =    2 
long_variable = 3

 7、二元运算符两边放置一个空格 涉及 = 符合操作符 ( += , -=等)、比较( == , < , > , != , <> , <= , >= , in , not in , is , is not )、布尔( and , or , not )。优先级高的运算符或操作符的前后不建议有空格

#对的做法
i = i + 1
submitted += 1
x = x*2 - 1
hypot2 = x*x + y*y
c = (a+b) * (a-b)


#不对的做法
i=i+1
submitted +=1
x = x * 2 - 1
hypot2 = x * x + y * y
c = (a + b) * (a - b)   #优先级高的不建议加空格

8、关键字参数和默认值参数的前后不要加空格

#对的做法
def complex(real, imag=0.0):
    return magic(r=real, i=imag)



#不对的做法
def complex(real, imag = 0.0):
    return magic(r = real, i = imag)

注释 

1.与代码功能不符合的注释比没有注释更糟糕，在修改代码的时候要及时更改注释。

2.注释通常适用于跟随它们的一些（或全部）代码，并缩进到与该代码相同的级别。块注释的每一行都以＃和单个空格开头（除非它在注释内缩进文本）。

3.内联注释是对语句同一行的注释。内联注释应该与语句中的至少两个空格分隔。

内联注释

x = x + 1  # Increment x

内联注释如果不是必要添加，一般不要加注释，这样容易造成编码关注重心分离

命名规范

尽量不要用字符'l'(小写字母el)，'O'(大写字母oh)，或 'I'(大写字母eye) 作为单个字符的变量名。一些字体中，这些字符不能与数字1和0区别。用'L' 代替'l'时。

1、包和模块名： 

模块名要简短，全部用小写字母，可使用下划线以提高可读性。包名和模块名类似，但不推荐使用下划线。

2、类名称： 

类名通常使用 大驼峰命名方式

3、函数和方法参数：

总是使用self作为实例方法的第一个参数；总是使用cls作为类方法的第一个参数。

4、方法名称和实例变量：

使用函数命名规则：必要时用小写字母分隔下划线，以提高可读性

6.Python 命令行参数

命令行参数-sys模块（1）

在使用python开发脚本，作为一个运维工具，或者其他工具需要接受用户参数运行时，这里就可以用到命令行传参的方式，可以给使用者提供一个比较友好的交互体验。

Python可以 sys模块中的 sys.argv 来获取命令行参数

import sys
print('参数个数为：',len(sys.argv),'个参数')
print('参数列表',str(sys.argv))

输出结果

参数个数为： 1 个参数
参数列表 ['E:/pythonProject8/88.py']

 命令行参数-sys模块（2）

argv 返回命令行参数是一个列表，第一个元素就是 py文件的文件名。如果只想获取参数不需要获取文件名，sys.argv也支持python字符串中的切片 修改代码如下：

import sys
print('参数个数为：',len(sys.argv),'个参数')
print('参数列表',str(sys.argv[1:]))

sys.argv 只提供了比较简单的命令参数获取方式，并没有提供命令提示。无法做到像linux命令一样，可以给使用者提供help帮助。

命令行参数-argparse模块（1）

argparse 模块可以轻松编写用户友好的命令行界面。该程序定义了它需要的参数，argparse 并将找出如何解析这些参数sys.argv。该argparse 模块还会自动生成帮助和用法消息，并在用户给出程序无效参数时发出错误

命令行参数-argparse模块（2）

参数说明：

prog ：文件名，默认为sys.argv[0]，用来在help信息中描述程序的名称。

usage ：描述程序用途的字符串

description ：help信息前显示的信息

epilog ：help信息之后显示的信息

parents ：由ArgumentParser对象组成的列表，它们的arguments选项会被包含到新ArgumentParser对象中。(类似于继承)

formatter_class ：help信息输出的格式，为了美观…

prefix_chars ：参数前缀，默认为’-‘(最好不要修改)

fromfileprefixchars ：前缀字符，放在文件名之前

add_help ：是否增加-h/-help选项 (默认为True)，一般help信息都是必须的。设为False时，help信息里面不再显示-h –help信息

argument_default： - (default: None)设置一个全局的选项的缺省值，一般每个选项单独设置，基本没用

添加参数选项

metaver：帮助信息中显示的参数名称

const ：保存一个常量

default ：默认值

type ：参数类型，默认为str

choices ：设置参数值的范围，如果choices中的类型不是字符串，记得指定type

required ：该选项是否必选，默认为True

dest ：参数名