python面试题100.docx

python面试题100.docx

《python面试题100.docx》由会员分享，可在线阅读，更多相关《python面试题100.docx（71页珍藏版）》请在冰豆网上搜索。

python面试题100

Python语言特性

1Python的函数参数传递

看两个如下例子，分析运行结果:

代码一:

a=1

deffun（a）:

a=2

fun（a）

print（a）＃1

代码二:

a=[]

deffun（a）：

a.append

（1）

fun（a）

print（a）#[1]

所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void＊的感觉。

这里记住的是类型是属于对象的，而不是变量.而对象有两种，“可更改"（mutable）与“不可更改"（immutable）对象.在python中，strings，tuples,和numbers是不可更改的对象，而list，dict等则是可以修改的对象。

（这就是这个问题的重点）

当一个引用传递给函数的时候,函数自动复制一份引用，这个函数里的引用和外边的引用没有半毛关系了。

所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉。

而第二个例子就不一样了，函数内的引用指向的是可变对象，对它的操作就和定位了指针地址一样,在内存里进行修改.

2Python中的元类（metaclass）

元类就是用来创建类的“东西”.你创建类就是为了创建类的实例对象，但是我们已经学习到了Python中的类也是对象。

好吧,元类就是用来创建这些类（对象）的，元类就是类的类

这个非常的不常用，详情请看:

《深刻理解Python中的元类（metaclass）》

3@staticmethod和＠classmethod

Python其实有3个方法,即静态方法（staticmethod），类方法（classmethod）和实例方法,如下:

classA（object）:

    deffoo（self,x）:

        print”executingfoo（%s，%s）”％（self，x）

    @classmethod

    defclass_foo（cls,x）：

        print（"executingclass_foo（%s，%s）"％（cls，x））

    ＠staticmethod

    defstatic_foo（x）：

        print（"executingstatic_foo（％s）”%x）

a=A（）

这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定。

对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例，就是foo（self,x）,为什么要这么做呢？

因为实例方法的调用离不开实例，我们需要把实例自己传给函数，调用的时候是这样的a。

foo（x）（其实是foo（a，x））。

类方法一样，只不过它传递的是类而不是实例,A.class_foo（x）。

注意这里的self和cls可以替换别的参数，但是python的约定是这俩,还是不要改的好.

对于静态方法其实和普通的方法一样，不需要对谁进行绑定,唯一的区别是调用的时候需要使用a。

static_foo（x）或者A。

static_foo（x）来调用.

\

实例方法

类方法

静态方法

a=A（）

a。

foo（x）

a.class_foo（x）

a.static_foo（x）

A

不可用

A.class_foo（x）

A.static_foo（x）

4类变量和实例变量

classPerson:

    name=”aaa"

p1=Person（）

p2=Person（）

p1.name=”bbb”

print（p1.name）  #bbb

print（p2.name）  #aaa

print（Person.name）  ＃aaa

类变量就是供类使用的变量，实例变量就是供实例使用的.

这里p1.name=”bbb”是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题，p1。

name一开始是指向的类变量name=”aaa”，但是在实例的作用域里把类变量的引用改变了，就变成了一个实例变量，self.name不再引用Person的类变量name了.

可以看看下面的例子:

classPerson：

    name=［]

p1=Person（）

p2=Person（）

p1.name。

append

（1）

print（p1。

name）  #[1]

print（p2.name）  #[1］

print（Person.name）  ＃［1］

5Python自省

这个也是python彪悍的特性。

自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.比如type（）,dir（）,getattr（），hasattr（）,isinstance（）。

6字典推导式

可能你见过列表推导时，却没有见过字典推导式,在2.7中才加入的：

d=｛key:

valuefor（key,value）initerable}

7Python中单下划线和双下划线

1

2

3

4

5

6

7

8

9

10

11

12

13

14

>〉>classMyClass（）：

。

..    def__init__（self）：

。

..            self。

__superprivate=”Hello"

...            self._semiprivate=”，world!

"

.。

.

>〉>mc=MyClass（）

>>>print（mc。

__superprivate）

Traceback（mostrecentcalllast）:

  File”〈stdin〉”,line1，in〈module〉

AttributeError:

myClassinstancehasnoattribute’__superprivate’

>〉>print（mc。

_semiprivate）

，world！

>〉>printmc.__dict__

{'_MyClass__superprivate'：

’Hello'，’_semiprivate'：

’，world！

'｝

__foo__：

一种约定，Python内部的名字,用来区别其他用户自定义的命名，以防冲突.

_foo:

一种约定，用来指定变量私有.程序员用来指定私有变量的一种方式。

__foo:

这个有真正的意义：

解析器用_classname__foo来代替这个名字，以区别和其他类相同的命名。

详情见：

http：

//www。

zhihu。

com/question/19754941

8字符串格式化：

%和。

format

。

format在许多方面看起来更便利.对于％最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:

Python:

"hithere％s"%name

但是，如果name恰好是（1，2，3），它将会抛出一个TypeError异常。

为了保证它总是正确的,你必须这样做：

”hithere％s"%（name，）  #提供一个单元素的数组而不是一个参数

9迭代器和生成器

在Python中，这种一边循环一边计算的机制,称为生成器：

generator。

可以被next（）函数调用并不断返回下一个值的对象称为迭代器:

Iterator。

这个是stackoverflow里python排名第一的问题，值得一看：

http：

//

10 *args and **kwargs

用＊args和*＊kwargs只是为了方便并没有强制使用它们。

当你不确定你的函数里将要传递多少参数时你可以用＊args。

例如,它可以传递任意数量的参数:

1

2

3

4

5

6

7

8

>〉>defprint_everything（*args）：

        forcount,thinginenumerate（args）：

.。

.        print'{0}.{1｝’.format（count，thing）

。

.。

〉>>print_everything（'apple',’banana'，'cabbage'）

0.apple

1.banana

2.cabbage

相似的,*＊kwargs允许你使用没有事先定义的参数名:

1

2

3

4

5

6

7

>>>deftable_things（＊*kwargs）：

.。

。

    forname，valueinkwargs.items（）:

..。

        print'{0｝={1｝’。

format（name，value）

...

>〉>table_things（apple=’fruit'，cabbage=’vegetable'）

cabbage=vegetable

apple=fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给＊args和＊*kwargs。

命名参数在列表的最前端.例如:

1

deftable_things（titlestring,**kwargs）

*args和*＊kwargs可以同时在函数的定义中,但是*args必须在＊*kwargs前面.

当调用函数时你也可以用*和**语法.例如：

1

2

3

4

5

6

7

>〉〉defprint_three_things（a，b,c）:

..。

    print’a=｛0｝，b=｛1｝,c=｛2}'.format（a,b,c）

。

。

.

〉〉>mylist=['aardvark’，'baboon','cat’］

〉〉〉print_three_things（*mylist）

a=aardvark,b=baboon,c=cat

就像你看到的一样，它可以传递列表（或者元组）的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然，你也可以在函数定义或者函数调用时用*。

http：

//

11面向切面编程AOP和装饰器

这个AOP一听起来有点懵,同学面试的时候就被问懵了…

装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。

装饰器是解决这类问题的绝佳设计,有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用.概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。

这个问题比较大,推荐：

http:

//stackoverflow。

com/questions/739654/how—can-i—make-a-chain-of-function-decorators—in-python

中文：

http：

//taizilongxu。

gitbooks。

io/stackoverflow—about—python/content/3/README。

html

12鸭子类型

“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子."

我们并不关心对象是什么类型，到底是不是鸭子,只关心行为。

比如在python中，有很多file—like的东西,比如StringIO，GzipFile,socket。

它们有很多相同的方法，我们把它们当作文件使用。

又比如list.extend（）方法中,我们并不关心它的参数是不是list，只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等。

鸭子类型在动态语言中经常使用，非常灵活,使得python不想java那样专门去弄一大堆的设计模式.

13Python中重载

引自知乎:

http：

//

函数重载主要是为了解决两个问题.

1.可变参数类型。

2.可变参数个数。

另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载，如果两个函数的功能其实不同，那么不应当使用重载，而应当使用一个名字不同的函数.

好吧，那么对于情况1,函数功能相同,但是参数类型不同，python如何处理？

答案是根本不需要处理,因为python可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在python中很可能是相同的代码，没有必要做成两个不同函数。

那么对于情况2，函数功能相同,但参数个数不同,python如何处理？

大家知道，答案就是缺省参数。

对那些缺少的参数设定为缺省参数即可解决问题。

因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。

好了，鉴于情况1跟情况2都有了解决方案,python自然就不需要函数重载了。

14新式类和旧式类

这个面试官问了,我说了老半天，不知道他问的真正意图是什么。

这篇文章很好的介绍了新式类的特性：

http：

//

新式类很早在2.2就出现了，所以旧式类完全是兼容的问题，Python3里的类全部都是新式类.这里有一个MRO问题可以了解下（新式类是广度优先，旧式类是深度优先），里讲的也很多.

15 __new__和__init__的区别

这个__new__确实很少见到,先做了解吧.

1.__new__是一个静态方法，而__init__是一个实例方法。

2.__new__方法会返回一个创建的实例,而__init__什么都不返回。

3.只有在__new__返回一个cls的实例时后面的__init__才能被调用.

4.当创建一个新实例时调用__new__，初始化一个实例时用__init__。

ps：

 __metaclass__是创建类时起作用。

所以我们可以分别使用__metaclass__,__new__和__init__来分别在类创建，实例创建和实例初始化的时候做一些小手脚。

16单例模式

这个绝对常考啊。

绝对要记住1～2个方法,当时面试官是让手写的。

1使用__new__方法

classSingleton（object）：

    def__new__（cls，＊args,*＊kw）：

        ifnothasattr（cls,’_instance'）:

            orig=super（Singleton,cls）

            cls。

_instance=orig.__new__（cls，＊args，＊*kw）

        returncls。

_instance

classMyClass（Singleton）:

    a=1

2共享属性

创建实例时把所有实例的__dict__指向同一个字典，这样它们具有相同的属性和方法。

1

2

3

4

5

6

7

8

9

classBorg（object）:

    _state=｛｝

    def__new__（cls,*args,＊＊kw）：

        ob=super（Borg，cls）。

__new__（cls,*args,**kw）

        ob.__dict__=cls._state

        returnob

classMyClass2（Borg）:

    a=1

3装饰器版本

1

2

3

4

5

6

7

8

9

10

11

defsingleton（cls,＊args,**kw）:

    instances=｛}

    defgetinstance（）：

        ifclsnotininstances：

            instances[cls]=cls（*args,*＊kw）

        returninstances[cls]

    returngetinstance

@singleton

classMyClass：

4import方法

作为python的模块是天然的单例模式

#mysingleton.py

classMy_Singleton（object）:

    deffoo（self）:

        pass

my_singleton=My_Singleton（）

＃touse

frommysingletonimportmy_singleton

my_singleton.foo（）

17Python中的作用域

Python中，一个变量的作用域总是由在代码中被赋值的地方所决定的。

当Python遇到一个变量的话他会按照这样的顺序进行搜索：

本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosinglocals）→全局/模块作用域（Global）→内置作用域（Built—in）

18GIL线程全局锁

线程全局锁（GlobalInterpreterLock），即Python为了保证线程安全而采取的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程。

解决办法就是多进程和下面的协程（协程也只是单CPU，但是能减小切换代价提升性能）.

19协程

简单点说协程是进程和线程的升级版，进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户自己控制切换的时机,不再需要陷入系统的内核态.

Python里最常见的yield就是协程的思想!

可以查看第九个问题。

20闭包

闭包（closure）是函数式编程的重要的语法结构。

闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。

当一个内嵌函数引用其外部作作用域的变量，我们就会得到一个闭包。

总结一下,创建一个闭包必须满足以下几点：

1.必须有一个内嵌函数

2.内嵌函数必须引用外部函数中的变量

3.外部函数的返回值必须是内嵌函数

感觉闭包还是有难度的,几句话是说不明白的,还是查查相关资料。

重点是函数运行后并不会被撤销，就像16题的instance字典一样,当函数运行完后，instance并不被销毁,而是继续留在内存空间里.这个功能类似类里的类变量,只不过迁移到了函数上。

闭包就像个空心球一样,你知道外面和里面，但你不知道中间是什么样.

21lambda函数

其实就是一个匿名函数,为什么叫lambda？

因为和后面的函数式编程有关。

22Python函数式编程

这个需要适当的了解一下吧，毕竟函数式编程在Python中也做了引用。

python中函数式编程支持:

filter函数的功能相当于过滤器。

调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。

〉〉>a=［1,2，3，4，5,6,7]

>>〉b=filter（lambdax:

x〉5，a）

〉>〉printb

>>>[6，7］

map函数是对一个序列的每个项依次执行函数，下面是对一个序列每个项都乘以2：

〉>>a=map（lambdax:

x＊2,［1,2，3］）

>>>list（a）

[2，4，6]

reduce函数是对一个序列的每个项迭代调用函数，下面是求3的阶乘：

>>>reduce（lambdax，y：

x*y，range（1，4））

6

23Python里的拷贝

引用和copy（）,deepcopy（）的区别

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

importcopy

a=［1,2,3,4,[’a',’b’］]  ＃原始对象

b=a  ＃赋值，传对象的引用

c=copy.copy（a）  #对象拷贝，浅拷贝

d=copy。

deepcopy（a）  #对象拷贝，深拷贝

a.append（5）  #修改对象a

a[4]。

append（'c’）  #修改对象a中的［’a'，'b’]数组对象

print’a=’，a

print’b=’，b

print’c=’，c

print’d='，d

输出结果：

a=  [1，2,3,4，［’a’,’b’,’c'],5]

b=  ［1，2,3,4，['a’，'b’,’c'］,5]

c=  ［1,2,3，4,[’a'，’b’,’c'］］

d=  [1，2，3，4,［'a','b'］］

24Python垃圾回收机制

PythonGC主要使用引用计数（referencecounting）来跟踪和回收垃圾。

在引用计数的基础上，通过“标记—清除”（markandsweep）解决容器对象可能产生的循环引用问题,通过“分代回收”（generationcollection）以空间换时间的方法提高垃圾回收效率。

1引用计数

PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。

当一个对象有新的引用时，它的ob_refcnt就会增加,当引用它的对象被删除，它的ob_refcnt就会减少。

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

优点:

1.简单

2.实时性

缺点:

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

2.循环引用

2标记—清除机制

基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记,然后清扫一遍内存空间,把所有没标记的对象释放。

3分代技术

分代回收的整体思想是：

将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量.

Python默认定义了三代对象集合，索引数越大，对象存活时间越长。

举例：

当某些内存块M经过了3次垃圾收集的清洗之后还存活时,我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。

当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行,这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。

在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中,当