面试题-Python高级

元类

Python 中类方法、类实例方法、静态方法有何区别？

类方法：是类对象的方法，在定义时需要在上方使用“@classmethod”进行装饰，形参为cls，

表示类对象，类对象和实例对象都可调用；

类实例方法：是类实例化对象的方法，只有实例对象可以调用，形参为self，指代对象本身；

静态方法：是一个任意函数，在其上方使用“@staticmethod”进行装饰，可以用对象直接调用，

静态方法实际上跟该类没有太大关系。

Python 中如何动态获取和设置对象的属性？

1. if hasattr(Parent，'x'):

2. print(getattr(Parent，'x'))

3. setattr(Parent，'x'，3)

4. print(getattr(Parent，'x'))

内存管理与垃圾回收机制

Python 的内存管理机制及调优手段？

内存管理机制：引用计数、垃圾回收、内存池。

引用计数：

引用计数是一种非常高效的内存管理手段， 当一个Python 对象被引用时其引用计数增加1， 当

其不再被一个变量引用时则计数减1. 当引用计数等于0 时对象被删除。

垃圾回收：

1. 引用计数

引用计数也是一种垃圾收集机制，而且也是一种最直观，最简单的垃圾收集技术。当Python 的某

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

某个新建对象，它被分配给某个引用，对象的引用计数变为1。如果引用被删除，对象的引用计数为0，

那么该对象就可以被垃圾回收。不过如果出现循环引用的话，引用计数机制就不再起有效的作用了

2. 标记清除

如果两个对象的引用计数都为1，但是仅仅存在他们之间的循环引用，那么这两个对象都是需要被

回收的，也就是说，它们的引用计数虽然表现为非0，但实际上有效的引用计数为0。所以先将循环引

用摘掉，就会得出这两个对象的有效计数。

3. 分代回收

从前面“标记-清除”这样的垃圾收集机制来看，这种垃圾收集机制所带来的额外操作实际上与系统

中总的内存块的数量是相关的，当需要回收的内存块越多时，垃圾检测带来的额外操作就越多，而垃圾

回收带来的额外操作就越少；反之，当需回收的内存块越少时，垃圾检测就将比垃圾回收带来更少的额

外操作。

举个例子：

当某些内存块M 经过了3 次垃圾收集的清洗之后还存活时，我们就将内存块M 划到一个集合

A 中去，而新分配的内存都划分到集合B 中去。当垃圾收集开始工作时，大多数情况都只对集合B 进

行垃圾回收，而对集合A 进行垃圾回收要隔相当长一段时间后才进行，这就使得垃圾收集机制需要处

理的内存少了，效率自然就提高了。在这个过程中，集合B 中的某些内存块由于存活时间长而会被转

移到集合A 中，当然，集合A 中实际上也存在一些垃圾，这些垃圾的回收会因为这种分代的机制而

被延迟。

内存池：

1. Python 的内存机制呈现金字塔形状，-1，-2 层主要有操作系统进行操作；

2. 第0 层是C 中的malloc，free 等内存分配和释放函数进行操作；

3. 第1 层和第2 层是内存池，有Python 的接口函数PyMem_Malloc 函数实现，当对象小于

256K 时有该层直接分配内存；

4. 第3 层是最上层，也就是我们对Python 对象的直接操作；

Python 在运行期间会大量地执行malloc 和free 的操作，频繁地在用户态和核心态之间进行切

换，这将严重影响Python 的执行效率。为了加速Python 的执行效率，Python 引入了一个内存池

机制，用于管理对小块内存的申请和释放。

Python 内部默认的小块内存与大块内存的分界点定在256 个字节，当申请的内存小于256 字节

时，PyObject_Malloc 会在内存池中申请内存；当申请的内存大于256 字节时，PyObject_Malloc 的

行为将蜕化为malloc 的行为。当然，通过修改Python 源代码，我们可以改变这个默认值，从而改

变Python 的默认内存管理行为。

调优手段（了解）

1.手动垃圾回收

2.调高垃圾回收阈值

3.避免循环引用（手动解循环引用和使用弱引用）

内存泄露是什么？如何避免？

指由于疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并非指内存在物理上的

消失，而是应用程序分配某段内存后，由于设计错误，失去了对该段内存的控制，因而造成了内存的浪

费。导致程序运行速度减慢甚至系统崩溃等严重后果。

有__del__() 函数的对象间的循环引用是导致内存泄漏的主凶。

不使用一个对象时使用:del object 来删除一个对象的引用计数就可以有效防止内存泄漏问题。

通过Python 扩展模块gc 来查看不能回收的对象的详细信息。

可以通过sys.getrefcount(obj) 来获取对象的引用计数，并根据返回值是否为0 来判断是否内存

泄漏。

函数

函数参数

Python 函数调用的时候参数的传递方式是值传递还是引用传递？

Python 的参数传递有：位置参数、默认参数、可变参数、关键字参数。

函数的传值到底是值传递还是引用传递，要分情况：

不可变参数用值传递：

像整数和字符串这样的不可变对象，是通过拷贝进行传递的，因为你无论如何都不可能在原处改变

不可变对象

可变参数是引用传递的：

比如像列表，字典这样的对象是通过引用传递、和C 语言里面的用指针传递数组很相似，可变对象

能在函数内部改变。

对缺省参数的理解？

缺省参数指在调用函数的时候没有传入参数的情况下，调用默认的参数，在调用函数的同时赋值时，

所传入的参数会替代默认参数。

*args 是不定长参数，他可以表示输入参数是不确定的，可以是任意多个。

**kwargs 是关键字参数，赋值的时候是以键= 值的方式，参数是可以任意多对在定义函数的时候

不确定会有多少参数会传入时，就可以使用两个参数。

为什么函数名字可以当做参数用?
Python 中一切皆对象，函数名是函数在内存中的空间，也是一个对象。
Python 中pass 语句的作用是什么？
在编写代码时只写框架思路，具体实现还未编写就可以用pass 进行占位，使程序不报错，不会进
行任何操作。

有这样一段代码，print c 会输出什么，为什么？

1. a = 10

2. b = 20

3. c = [a]

4. a = 15

print  c

答：10 对于字符串、数字，传递是相应的值。 数据联动性和垃圾回收机制

内建函数

map 函数和reduce 函数？

①从参数方面来讲：

map()包含两个参数，第一个参数是一个函数，第二个是序列（列表或元组）。其中，函数（即map

的第一个参数位置的函数）可以接收一个或多个参数。

reduce()第一个参数是函数，第二个是序列（列表或元组）。但是，其函数必须接收两个参数。

②从对传进去的数值作用来讲：

map()是将传入的函数依次作用到序列的每个元素，每个元素都是独自被函数“作用”一次。

reduce()是将传人的函数作用在序列的第一个元素得到结果后，把这个结果继续与下一个元素作用

（累积计算）。

递归函数停止的条件？

递归的终止条件一般定义在递归函数内部，在递归调用前要做一个条件判断，根据判断的结果选择

是继续调用自身，还是return;返回终止递归。

终止的条件：

1. 判断递归的次数是否达到某一限定值

2. 判断运算的结果是否达到某个范围等，根据设计的目的来选择

回调函数，如何通信的?
回调函数是把函数的指针(地址)作为参数传递给另一个函数，将整个函数当作一个对象，赋值给调
用的函数。
Python 主要的内置数据类型都有哪些？ print dir( ‘a ’) 的输出？
内建类型：布尔类型、数字、字符串、列表、元组、字典、集合；
输出字符串‘a’的内建方法；
print(list(map(lambda x: x * x, [y for y in range(3)])))？
[0， 1， 4]

hasattr() getattr() setattr() 函数使用详解？

hasattr(object, name)函数：

判断一个对象里面是否有name 属性或者name 方法，返回bool 值，有name 属性(方法)返回True，

否则返回False。

注意：name 要使用引号括起来。

1. class function_demo(object):

2. name = 'demo'

3. def run(self):

4. return "hello function"

5. functiondemo = function_demo()

6. res = hasattr(functiondemo, 'name') #判断对象是否有name 属性，True

7. res = hasattr(functiondemo, "run") #判断对象是否有run 方法，True

8. res = hasattr(functiondemo, "age") #判断对象是否有age 属性，Falsw

9. print(res)

getattr(object, name[,default]) 函数：

获取对象object 的属性或者方法，如果存在则打印出来，如果不存在，打印默认值，默认值可选。

注意：如果返回的是对象的方法，则打印结果是：方法的内存地址，如果需要运行这个方法，可以在后

面添加括号()。

1. functiondemo = function_demo()

2. getattr(functiondemo, 'name') #获取name 属性，存在就打印出来--- demo

3. getattr(functiondemo, "run") #获取run 方法，存在打印出方法的内存地址---<bound method function_demo.run of

<__main__.function_demo object at 0x10244f320>>

4. getattr(functiondemo, "age") #获取不存在的属性，报错如下：

5. Traceback (most recent call last):

6. File "/Users/liuhuiling/Desktop/MT_code/OpAPIDemo/conf/OPCommUtil.py", line 39, in <module>

7. res = getattr(functiondemo, "age")

8. AttributeError: 'function_demo' object has no attribute 'age'

9. getattr(functiondemo, "age", 18) #获取不存在的属性，返回一个默认值

setattr(object,name,values)函数：

给对象的属性赋值，若属性不存在，先创建再赋值

1．class function_demo(object):

2． name = 'demo'

3． def run(self):

4． return "hello function"

5．functiondemo = function_demo()

6．res = hasattr(functiondemo, 'age') # 判断age 属性是否存在，False

7．print(res)

8．setattr(functiondemo, 'age', 18 ) #对age 属性进行赋值，无返回值

9．res1 = hasattr(functiondemo, 'age') #再次判断属性是否存在，True

综合使用：

1．class function_demo(object):

2． name = 'demo'

3． def run(self):

4． return "hello function"

5．functiondemo = function_demo()

6．res = hasattr(functiondemo, 'addr') # 先判断是否存在if res:

7． addr = getattr(functiondemo, 'addr')

8． print(addr)else:

9． addr = getattr(functiondemo, 'addr', setattr(functiondemo, 'addr', '北京首都'))

10． #addr = getattr(functiondemo, 'addr', '美国纽约')

11． print(addr)

一句话解决阶乘函数？
在Python2 中：
1．reduce(lambda x,y: x*y, range(1,n+1))
注意：Python3 中取消了该函数。

lambda

什么是lambda 函数？有什么好处？

lambda 函数是一个可以接收任意多个参数(包括可选参数)并且返回单个表达式值的函数
1、lambda 函数比较轻便，即用即仍，很适合需要完成一项功能，但是此功能只在此一处使用，
连名字都很随意的情况下；
2、匿名函数，一般用来给filter， map 这样的函数式编程服务;
3、作为回调函数，传递给某些应用，比如消息处理

下面这段代码的输出结果将是什么？请解释

1. def multipliers():

         return [lambda x : i * x for i in range(4)]

         print [m(2) for m in multipliers()]

上面代码输出的结果是[6， 6， 6， 6] (不是我们想的[0， 2， 4， 6])。

你如何修改上面的multipliers 的定义产生想要的结果？

上述问题产生的原因是Python 闭包的延迟绑定。这意味着内部函数被调用时，参数的值在闭包内

进行查找。因此，当任何由multipliers()返回的函数被调用时，i 的值将在附近的范围进行查找。那时，

不管返回的函数是否被调用，for 循环已经完成，i 被赋予了最终的值3。

下面是解决这一问题的一些方法。
一种解决方法就是用Python 生成器。
1. def multipliers():
2. for i in range(4): yield lambda x : i * x
另外一个解决方案就是创造一个闭包，利用默认函数立即绑定。
1. def multipliers():
2. return [lambda x， i=i : i * x for i in range(4)]

什么是lambda 函数？它有什么好处？写一个匿名函数求两个数的和？
1. f = lambda x，y:x+y
2. print(f(2017，2018))

装饰器

对装饰器的理解

装饰器本质上是一个Python 函数，它可以让其他函数在不需要做任何代码变动的前提下增加额外
功能，装饰器的返回值也是一个函数对象。

1. import time

2.     def timeit(func):

3.         def wrapper():

4.         　　start = time.clock()

5.            func() end =time.clock()

6.            print 'used:'， end - start

7.            return wrapper

8. @timeit

9. def foo():

10.     print 'in foo()'foo()

什么是闭包？

在函数内部再定义一个函数，并且这个函数用到了外边函数的变量，那么将这个函数以及用到的一些变量称之为

闭包。

函数装饰器有什么作用？

装饰器本质上是一个Python 函数，它可以在让其他函数在不需要做任何代码的变动的前提下增加额外的功能。装

饰器的返回值也是一个函数的对象，它经常用于有切面需求的场景。比如：插入日志、性能测试、事务处理、缓存、

权限的校验等场景有了装饰器就可以抽离出大量的与函数功能本身无关的雷同代码并发并继续使用。

生成器

生成器、迭代器的区别？

迭代器是一个更抽象的概念，任何对象，如果它的类有next 方法和iter 方法返回自己本身，对于string、list、

dict、tuple 等这类容器对象，使用for 循环遍历是很方便的。在后台for 语句对容器对象调用iter()函数，iter()

是python 的内置函数。iter()会返回一个定义了next()方法的迭代器对象，它在容器中逐个访问容器内元素，next()

也是python 的内置函数。在没有后续元素时，next()会抛出一个StopIteration 异常。

生成器（Generator）是创建迭代器的简单而强大的工具。它们写起来就像是正规的函数，只是在需要返回数

据的时候使用yield 语句。每次next()被调用时，生成器会返回它脱离的位置（它记忆语句最后一次执行的位置

和所有的数据值）

区别：生成器能做到迭代器能做的所有事,而且因为自动创建了iter()和next()方法,生成器显得特别简洁,而且

生成器也是高效的，使用生成器表达式取代列表解析可以同时节省内存。除了创建和保存程序状态的自动方法,当

发生器终结时,还会自动抛出StopIteration 异常。

X 是什么类型？

 X = (for i in ramg(10))

答：X 是generator 类型。

请尝试用“一行代码”实现将1-N 的整数列表以3 为单位分组，比如1-100

分组后为?

print([[x for x in range(1，100)][i:i+3] for i in range(0，len(list_a)，3)])

python中yield的用法？

yield 就是保存当前程序执行状态。你用for 循环的时候，每次取一个元素的时候就会计算一次。用yield 的函数

叫generator，和iterator 一样，它的好处是不用一次计算所有元素，而是用一次算一次，可以节省很多空间。generator

每次计算需要上一次计算结果，所以用yield，否则一return，上次计算结果就没了。

1. >>> def createGenerator():

2. ... mylist = range(3)

3. ... for i in mylist:

4. ... yield i*i

5. ...

6. >>> mygenerator = createGenerator() # create a generator

7. >>> print(mygenerator) # mygenerator is an object!

8. <generator object createGenerator at 0xb7555c34>

9. >>> for i in mygenerator:

10. ... print(i)

11. 0

12. 1

13. 4