面试必备 - Python 垃圾回收机制

众所周知，Python 是一门面向对象语言，在 Python 的世界一切皆对象。所以一切变量的本质都是对象的一个指针而已。

让客户满意是我们工作的目标，不断超越客户的期望值来自于我们对这个行业的热爱。我们立志把好的技术通过有效、简单的方式提供给客户，将通过不懈努力成为客户在信息化领域值得信任、有价值的长期合作伙伴，公司提供的服务项目有：主机域名、网页空间、营销软件、网站建设、万全网站维护、网站推广。

Python 运行过程中会不停的创建各种变量，而这些变量是需要存储在内存中的，随着程序的不断运行，变量数量越来越多，所占用的空间势必越来越大，如果对变量所占用的内存空间管理不当的话，那么肯定会出现 out of memory。程序大概率会被异常终止。

因此，对于内存空间的有效合理管理变得尤为重要，那么 Python 是怎么解决这个问题的呢。其实很简单，对不不可能再使用到的内存进行回收即可，像 C 语言中需要程序员手动释放内存就是这个道理。但问题是如何确定哪些内存不再会被使用到呢？这就是我们今天要说的垃圾回收了。

目前垃圾回收比较通用的解决办法有三种，引用计数，标记清除以及分代回收。

引用计数也是一种最直观，最简单的垃圾收集技术。在 Python 中，大多数对象的生命周期都是通过对象的引用计数来管理的。其原理非常简单，我们为每个对象维护一个 ref 的字段用来记录对象被引用的次数，每当对象被创建或者被引用时将该对象的引用次数加一，当对象的引用被销毁时该对象的引用次数减一，当对象的引用次数减到零时说明程序中已经没有任何对象持有该对象的引用，换言之就是在以后的程序运行中不会再次使用到该对象了，那么其所占用的空间也就可以被释放了了。

我们来看看下面的例子。

函数 print_memory_info 用来获取程序占用的内存空间大小，在 foo 函数中创建一个包含一百万个整数的列表。从打印结果我们可以看出，创建完列表之后程序耗用的内存空间上升到了 55 MB。而当函数 foo 调用完毕之后内存消耗又恢复正常。

这是因为我们在函数 foo 中创建的 list 变量是局部变量，其作用域是当前函数内部，一旦函数执行完毕，局部变量的引用会被自动销毁，即其引用次数会变为零，所占用的内存空间也会被回收。

为了验证我们的想法，我们对函数 foo 稍加改造。代码如下：

稍加改造之后，即使 foo 函数调用结束其所消耗的内存也未被释放。

主要是因为我们将函数 foo 内部产生的列表返回并在主程序中接收之后，这样就会导致该列表的引用依然存在，该对象后续仍有可能被使用到，垃圾回收便不会回收该对象。

那么，什么时候对象的引用次数才会增加呢。下面四种情况都会导致对象引用次数加一。

同理，对象引用次数减一的情况也有四种。

引用计数看起来非常简单，实现起来也不复杂，只需要维护一个字段保存对象被引用的次数即可，那么是不是就代表这种算法没有缺点了呢。实则不然，我们知道引用次数为零的对象所占用的内存空间肯定是需要被回收的。那引用次数不为零的对象呢，是不是就一定不能回收呢？

我们来看看下面的例子，只是对函数 foo 进行了改造，其余未做更改。

我们看到，在函数 foo 内部生成了两个列表 list_a 和 list_b，然后将两个列表分别添加到另外一个中。由结果可以看出，即使 foo 函数结束之后其所占用的内存空间依然未被释放。这是因为对于 list_a 和 list_b 来说虽然没有被任何外部对象引用，但因为二者之间交叉引用，以至于每个对象的引用计数都不为零，这也就造成了其所占用的空间永远不会被回收的尴尬局面。这个缺点是致命的。

为了解决交叉引用的问题，Python 引入了标记清除算法和分代回收算法。

显然，可以包含其他对象引用的容器对象都有可能产生交叉引用问题，而标记清除算法就是为了解决交叉引用的问题的。

标记清除算法是一种基于对象可达性分析的回收算法，该算法分为两个步骤，分别是标记和清除。标记阶段，将所有活动对象进行标记，清除阶段将所有未进行标记的对象进行回收即可。那么现在的为问题变为了 GC 是如何判定哪些是活动对象的？

事实上 GC 会从根结点出发，与根结点直接相连或者间接相连的对象我们将其标记为活动对象（该对象可达），之后进行回收阶段，将未标记的对象（不可达对象）进行清除。前面所说的根结点可以是全局变量，也可以是调用栈。

标记清除算法主要用来处理一些容器对象，虽说该方法完全可以做到不误杀不遗漏，但 GC 时必须扫描整个堆内存，即使只有少量的非可达对象需要回收也需要扫描全部对象。这是一种巨大的性能浪费。

由于标记清除算法需要扫描整个堆的所有对象导致其性能有所损耗，而且当可以回收的对象越少时性能损耗越高。因此 Python 引入了分代回收算法，将系统中存活时间不同的对象划分到不同的内存区域，共三代，分别是 0 代，1 代 和 2 代。新生成的对象是 0 代，经过一次垃圾回收之后，还存活的对象将会升级到 1 代，以此类推，2 代中的对象是存活最久的对象。

那么什么时候触发进行垃圾回收算法呢。事实上随着程序的运行会不断的创建新的对象，同时也会因为引用计数为零而销毁大部分对象，Python 会保持对这些对象的跟踪，由于交叉引用的存在，以及程序中使用了长时间存活的对象，这就造成了新生成的对象的数量会大于被回收的对象数量，一旦二者之间的差值达到某个阈值就会启动垃圾回收机制，使用标记清除算法将死亡对象进行清除，同时将存活对象移动到 1 代。 以此类推，当二者的差值再次达到阈值时又触发垃圾回收机制，将存活对象移动到 2 代。

这样通过对不同代的阈值做不同的设置，就可以做到在不同代使用不同的时间间隔进行垃圾回收，以追求性能最大。

事实上，所有的程序都有一个相识的现象，那就是大部分的对象生存周期都是相当短的，只有少量对象生命周期比较长，甚至会常驻内存，从程序开始运行持续到程序结束。而通过分代回收算法，做到了针对不同的区域采取不同的回收频率，节约了大量的计算从而提高 Python 的性能。

除了上面所说的差值达到一定阈值会触发垃圾回收之外，我们还可以显示的调用 gc.collect() 来触发垃圾回收，最后当程序退出时也会进行垃圾回收。

本文介绍了 Python 的垃圾回收机制，垃圾回收是 Python 自带的功能，并不需要程序员去手动管理内存。

其中引用计数法是最简单直接的，但是需要维护一个字段且针对交叉引用无能为力。

标记清除算法主要是为了解决引用计数的交叉引用问题，该算法的缺点就是需要扫描整个堆的所有对象，有点浪费性能。

而分代回收算法的引入则完美解决了标记清除算法需要扫描整个堆对象的性能浪费问题。该算法也是建立在标记清除基础之上的。

最后我们可以通过 gc.collect() 手动触发 GC 的操作。

题外话，如果你看过 JVM 的垃圾回收算法之后会发现 Python 的垃圾回收算法与其是如出一辙的，事实再次证明，程序语言设计时是会相互参考的。

Python 中经常看到 foo， 请问foo是什么意思呢？

一般来说是一个函数名或者是一个变量，没有什么特别的意思，大家都这么写。就像说某人时会叫他张三李四是一样的...

python问题。 编程语言？

你的意思是不是指如果 foo 这个函数里的 a 变量如果获取到的是 True 的时候，要让 foo 这个函数外面的传入的变量的 b 值变成 False？

如果是，那么代码如下（注意程序缩进）：

a=False

b=True

def foo():

global a # 将变量提档，使用公共变量而不是私有变量

global b

if a:

b=False

return '123'

if b:

return '456'

a=True

b=True

print(foo())

print('Now B is: ' + str(b))

主要问题是公共变量与私有变量的问题。

Python函数后面的参数可以跟实例化的对象是同一个吗？参数可以单独拿出来使用？

在Python中，万物皆对象，函数也是一个对象，也可以作为参数传递给别的函数。

foo这只是一个标识符，它可以指向任何东西，包括变量、类、函数、模块、流等。timer是一个返回函数的高阶函数，它的返回值是一个函数，赋值给foo之后，foo也就是一个函数。

python 函数参数的类型

1. 不同类型的参数简述

#这里先说明python函数调用得语法为：

复制代码

代码如下:

func(positional_args,

keyword_args,

*tuple_grp_nonkw_args,

**dict_grp_kw_args)

#为了方便说明,之后用以下函数进行举例

def test(a,b,c,d,e):

print a,b,c,d,e

举个例子来说明这4种调用方式得区别：

复制代码

代码如下:

#

#positional_args方式

test(1,2,3,4,5)

1 2 3 4 5

#这种调用方式的函数处理等价于

a,b,c,d,e = 1,2,3,4,5

print a,b,c,d,e

#

#keyword_args方式

test(a=1,b=3,c=4,d=2,e=1)

1 3 4 2 1

#这种处理方式得函数处理等价于

a=1

b=3

c=4

d=2

e=1

print a,b,c,d,e

#

#*tuple_grp_nonkw_args方式

x = 1,2,3,4,5

test(*x)

1 2 3 4

5

#这种方式函数处理等价于

复制代码

代码如下:

a,b,c,d,e = x

print

a,b,c,d,e

#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数

y

{'a': 1,

'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(*y)

a c b e d

#

#**dict_grp_kw_args方式

y

{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(**y)

1 2 6

1 1

#这种函数处理方式等价于

a = y['a']

b = y['b']

... #c,d,e不再赘述

print

a,b,c,d,e

2.

不同类型参数混用需要注意的一些细节

接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.

首先要明白,函数调用使用参数类型必须严格按照顺序,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,;

(*x,2,3)也会被当成非法.

其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为#keyword_args方式和**dict_grp_kw_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的顺序.因此,可以简单理解为只有#positional_args方式,#*tuple_grp_nonkw_args方式有逻辑先后顺序的.

最后,参数是不允许多次赋值的.

举个例子说明,顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的逻辑先后关系:

复制代码

代码如下:

#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系

#正确的例子1

x =

{3,4,5}

test(1,2,*x)

1 2 3 4 5

#正确的例子2

test(1,e=2,*x)

1 3 4 5 2

#错误的例子

test(1,b=2,*x)

Traceback (most recent call

last):

File "stdin", line 1, in module

TypeError: test()

got multiple values for keyword argument 'b'

#正确的例子1,处理等价于

a,b = 1,2 #顺序参数

c,d,e = x #列表参数

print a,b,c,d,e

#正确的例子2,处理等价于

a = 1 #顺序参数

e = 2 #关键字参数

b,c,d = x #列表参数

#错误的例子,处理等价于

a = 1 #顺序参数

b = 2 #关键字参数

b,c,d = x

#列表参数

#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系

函数声明区别

理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.

1. 函数声明中的参数类型说明

函数声明只有3种类型, arg, *arg , **arg 他们得作用和函数调用刚好相反.

调用时*tuple_grp_nonkw_args将列表转换为顺序参数,而声明中的*arg的作用是将顺序赋值(positional_args)转换为列表.

调用时**dict_grp_kw_args将字典转换为关键字参数,而声明中**arg则反过来将关键字参数(keyword_args)转换为字典.

特别提醒：*arg

和 **arg可以为空值.

以下举例说明上述规则:

复制代码

代码如下:

#arg, *arg和**arg作用举例

def

test2(a,*b,**c):

print a,b,c

#

#*arg 和

**arg可以不传递参数

test2(1)

1 () {}

#arg必须传递参数

test2()

Traceback (most recent call last):

File "stdin", line 1,

in module

TypeError: test2() takes at least 1 argument (0 given)

#

#*arg将顺positional_args转换为列表

test2(1,2,[1,2],{'a':1,'b':2})

1 (2, [1, 2], {'a': 1, 'b': 2})

{}

#该处理等价于

a = 1 #arg参数处理

b = 2,[1,2],{'a':1,'b':2} #*arg参数处理

c =

dict() #**arg参数处理

print a,b,c

#

#**arg将keyword_args转换为字典

test2(1,2,3,d={1:2,3:4}, c=12, b=1)

1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:

4}}

#该处理等价于

a = 1 #arg参数处理

b= 2,3 #*arg参数处理

#**arg参数处理

c =

dict()

c['d'] = {1:2, 3:4}

c['c'] = 12

c['b'] = 1

print

a,b,c

2. 处理顺序问题

函数总是先处理arg类型参数,再处理*arg和**arg类型的参数.

因为*arg和**arg针对的调用参数类型不同,所以不需要考虑他们得顺序.

复制代码

代码如下:

def test2(a,*b,**c):

print

a,b,c

test2(1, b=[1,2,3], c={1:2, 3:4},a=1)

Traceback (most

recent call last):

File "stdin", line 1, in

module

TypeError: test2() got multiple values for keyword argument

'a'

#这里会报错得原因是,总是先处理arg类型得参数

#该函数调用等价于

#处理arg类型参数:

a = 1

a = 1

#多次赋值,导致异常

#处理其他类型参数

...

print a,b,c

def foo(x,y):

... def bar():

... print

x,y

... return bar

...

#查看func_closure的引用信息

a =

[1,2]

b = foo(a,0)

b.func_closure[0].cell_contents

[1, 2]

b.func_closure[1].cell_contents

b()

[1, 2] 0

#可变对象仍然能被修改

a.append(3)

b.func_closure[0].cell_contents

[1, 2, 3]

b()

[1, 2, 3] 0

python函数和方法区别

python中函数和方法的区别：

首先，从分类的角度来分析。

（1）函数的分类：

内置函数：python内嵌的一些函数。

匿名函数：一行代码实现一个函数功能。

递归函数

自定义函数：根据自己的需求，来进行定义函数。

（2）方法的分类：

普通方法：直接用self调用的方法。

私有方法：__函数名，只能在类中被调用的方法。

属性方法：@property，将方法伪装成为属性，让代码看起来更合理。

特殊方法(双下划线方法)：以__init__为例，是用来封装实例化对象的属性，只要是实例化对象就一定会执行__init方法，如果对象子类中没有则会寻找父类（超类），如果父类（超类）也没有，则直接继承object（python 3.x）类，执行类中的__init__方法。

类方法：通过类名的调用去操作公共模板中的属性和方法。

静态方法：不用传入类空间、对象的方法， 作用是保证代码的一致性，规范性，可以完全独立类外的一个方法，但是为了代码的一致性统一的放到某个模块（py文件）中。

其次，从作用域的角度来分析：

（1）函数作用域：从函数调用开始至函数执行完成，返回给调用者后，在执行过程中开辟的空间会自动释放，也就是说函数执行完成后，函数体内部通过赋值等方式修改变量的值不会保留，会随着返回给调用者后，开辟的空间会自动释放。

（2）方法作用域：通过实例化的对象进行方法的调用，调用后开辟的空间不会释放，也就是说调用方法中对变量的修改值会一直保留。

最后，调用的方式不同。

（1）函数：通过“函数名（）”的方式进行调用。

（2）方法：通过“对象.方法名”的方式进行调用。

class Foo(object):    def func(self):        pass#实例化obj = Foo()# 执行方式一:调用的func是方法obj.func() #func 方法# 执行方式二：调用的func是函数Foo.func(123) # 函数

分享题目：python函数foo,python函数for循环
文章源于：http://myzitong.com/article/hdcseh.html