python面试题100.docx

1、python面试题100Python语言特性1 Python的函数参数传递看两个如下例子，分析运行结果:代码一:a = 1def fun（a）: a = 2fun（a)print（a） 1代码二:a = def fun(a）：a.append（1)fun（a）print(a） # 1所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void的感觉。这里记住的是类型是属于对象的，而不是变量.而对象有两种，“可更改（mutable)与“不可更改（immutable)对象.在python中，strings， tuples, 和numbers是不可更改的对象，而list，dict等则

2、是可以修改的对象。（这就是这个问题的重点)当一个引用传递给函数的时候,函数自动复制一份引用，这个函数里的引用和外边的引用没有半毛关系了。所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉。而第二个例子就不一样了，函数内的引用指向的是可变对象，对它的操作就和定位了指针地址一样,在内存里进行修改.2 Python中的元类(metaclass）元类就是用来创建类的“东西”.你创建类就是为了创建类的实例对象，但是我们已经学习到了Python中的类也是对象。好吧,元类就是用来创建这些类(对象）的，元类就是类的类这个非常的不常用，详情请看:深刻理解Python中的元类(

3、metaclass)3 staticmethod和classmethodPython其实有3个方法,即静态方法（staticmethod），类方法(classmethod)和实例方法,如下:class A（object）:def foo（self,x）:print ”executing foo(%s，%s)”（self，x)classmethoddef class_foo（cls,x）：print( executing class_foo(%s，%s)(cls，x)staticmethoddef static_foo（x)：print （executing static_foo(s)”%x）a

4、=A（)这里先理解下函数参数里面的self和cls.这个self和cls是对类或者实例的绑定。对于实例方法,我们知道在类里每次定义方法的时候都需要绑定这个实例，就是foo（self, x),为什么要这么做呢？因为实例方法的调用离不开实例，我们需要把实例自己传给函数，调用的时候是这样的a。foo（x)（其实是foo(a， x）)。类方法一样，只不过它传递的是类而不是实例,A.class_foo（x）。注意这里的self和cls可以替换别的参数，但是python的约定是这俩,还是不要改的好.对于静态方法其实和普通的方法一样，不需要对谁进行绑定,唯一的区别是调用的时候需要使用a。static_foo

5、(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 类变量和实例变量class Person:name=”aaap1=Person（)p2=Person(）p1.name=”bbb”print（p1.name)# bbbprint（p2.name)# aaaprint(Person.name) aaa类变量就是供类使用的变量，实例变量就是供实例使用的.这里p1.name=”bbb”是实例调用了类变量,这其实和上面第一个问

6、题一样,就是函数传参的问题，p1。name一开始是指向的类变量name=”aaa”，但是在实例的作用域里把类变量的引用改变了，就变成了一个实例变量，self.name不再引用Person的类变量name了.可以看看下面的例子:class Person：name=p1=Person()p2=Person(）p1.name。append（1）print（p1。name)# 1print（p2.name)# 1print（Person.name） 15 Python自省这个也是python彪悍的特性。自省就是面向对象的语言所写的程序在运行时,所能知道对象的类型.简单一句就是运行时能够获得对象的类型.

7、比如type(）,dir（）,getattr（)，hasattr(）,isinstance（）。6 字典推导式可能你见过列表推导时，却没有见过字典推导式,在2.7中才加入的：d = key: value for (key, value) in iterable7 Python中单下划线和双下划线1234567891011121314 class MyClass()：。. def _init_（self）：。. self。_superprivate = ”Hello. self._semiprivate = ”， world!.。. mc = MyClass（） print(mc。_superp

8、rivate)Traceback (most recent call last）:File ”stdin”, line 1， in moduleAttributeError: myClass instance has no attribute _superprivate print(mc。_semiprivate）， world！ print mc._dict_MyClass_superprivate： Hello， _semiprivate： ， world！_foo_：一种约定，Python内部的名字,用来区别其他用户自定义的命名，以防冲突._foo:一种约定，用来指定变量私有.程序员用来

9、指定私有变量的一种方式。_foo:这个有真正的意义：解析器用_classname_foo来代替这个名字，以区别和其他类相同的命名。详情见：http：/www。zhihu。com/question/197549418 字符串格式化：%和。format。format在许多方面看起来更便利.对于最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题:Python:hi there s % name但是，如果name恰好是（1，2，3)，它将会抛出一个TypeError异常。为了保证它总是正确的,你必须这样做：”hi there s % （name，) # 提供一个单元素的数组而不

10、是一个参数9 迭代器和生成器在Python中，这种一边循环一边计算的机制,称为生成器：generator。可以被next()函数调用并不断返回下一个值的对象称为迭代器:Iterator。这个是stackoverflow里python排名第一的问题，值得一看： http：/10*argsand*kwargs用args和*kwargs只是为了方便并没有强制使用它们。当你不确定你的函数里将要传递多少参数时你可以用args。例如,它可以传递任意数量的参数:12345678 def print_everything(*args)：for count, thing in enumerate（args）：.

11、。. print 0. 1.format(count， thing)。.。 print_everything（apple, banana， cabbage)0. apple1. banana2. cabbage相似的,*kwargs允许你使用没有事先定义的参数名:1234567 def table_things(*kwargs)：.。 for name， value in kwargs.items（）:.。 print 0 = 1。format(name， value）. table_things（apple = fruit， cabbage = vegetable）cabbage = veg

12、etableapple = fruit你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给args和*kwargs。命名参数在列表的最前端.例如:1def table_things（titlestring, *kwargs)*args和*kwargs可以同时在函数的定义中,但是*args必须在*kwargs前面.当调用函数时你也可以用*和*语法.例如：1234567 def print_three_things（a， b, c）:.。 print a = 0， b = 1, c = 2.format(a,b,c)。. mylist = aardvark， baboon, cat p

13、rint_three_things（*mylist)a = aardvark, b = baboon, c = cat就像你看到的一样，它可以传递列表（或者元组）的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然，你也可以在函数定义或者函数调用时用*。http：/11 面向切面编程AOP和装饰器这个AOP一听起来有点懵,同学面试的时候就被问懵了装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计,有了装饰器，我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用.概括的讲，装饰器的作用就是为已

14、经存在的对象添加额外的功能。这个问题比较大,推荐： http:/stackoverflow。com/questions/739654/howcan-imake-a-chain-of-function-decoratorsin-python中文： http：/taizilongxu。gitbooks。io/stackoverflowaboutpython/content/3/README。html12 鸭子类型“当看到一只鸟走起来像鸭子、游泳起来像鸭子、叫起来也像鸭子，那么这只鸟就可以被称为鸭子.我们并不关心对象是什么类型，到底是不是鸭子,只关心行为。比如在python中，有很多filelike

15、的东西,比如StringIO，GzipFile,socket。它们有很多相同的方法，我们把它们当作文件使用。又比如list.extend()方法中,我们并不关心它的参数是不是list，只要它是可迭代的,所以它的参数可以是list/tuple/dict/字符串/生成器等。鸭子类型在动态语言中经常使用，非常灵活,使得python不想java那样专门去弄一大堆的设计模式.13 Python中重载引自知乎:http：/函数重载主要是为了解决两个问题.1.可变参数类型。2.可变参数个数。另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载，如果

16、两个函数的功能其实不同，那么不应当使用重载，而应当使用一个名字不同的函数.好吧，那么对于情况 1 ,函数功能相同,但是参数类型不同，python 如何处理？答案是根本不需要处理,因为 python 可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在 python 中很可能是相同的代码，没有必要做成两个不同函数。那么对于情况 2 ，函数功能相同,但参数个数不同,python 如何处理？大家知道，答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。好了，鉴于情况 1 跟 情况 2 都有了解决方案,python 自然就

17、不需要函数重载了。14 新式类和旧式类这个面试官问了,我说了老半天，不知道他问的真正意图是什么。这篇文章很好的介绍了新式类的特性： http：/新式类很早在2.2就出现了，所以旧式类完全是兼容的问题，Python3里的类全部都是新式类.这里有一个MRO问题可以了解下(新式类是广度优先，旧式类是深度优先)，里讲的也很多.15_new_和_init_的区别这个_new_确实很少见到,先做了解吧.1._new_是一个静态方法，而_init_是一个实例方法。2._new_方法会返回一个创建的实例,而_init_什么都不返回。3.只有在_new_返回一个cls的实例时后面的_init_才能被调用.4.当

18、创建一个新实例时调用_new_，初始化一个实例时用_init_。ps：_metaclass_是创建类时起作用。所以我们可以分别使用_metaclass_,_new_和_init_来分别在类创建，实例创建和实例初始化的时候做一些小手脚。16 单例模式这个绝对常考啊。绝对要记住12个方法,当时面试官是让手写的。1 使用_new_方法class Singleton(object）：def _new_（cls， args, *kw）：if not hasattr(cls, _instance):orig = super(Singleton, cls)cls。_instance = orig._new_

19、（cls， args， *kw)return cls。_instanceclass MyClass（Singleton）:a = 12 共享属性创建实例时把所有实例的_dict_指向同一个字典，这样它们具有相同的属性和方法。123456789class Borg(object）:_state = def _new_（cls, *args, kw)：ob = super（Borg， cls)。_new_（cls, *args, *kw)ob._dict_ = cls._statereturn obclass MyClass2(Borg）:a = 13 装饰器版本1234567891011def

20、singleton（cls, args, *kw):instances = def getinstance（)：if cls not in instances：instancescls = cls(*args, *kw)return instancesclsreturn getinstancesingletonclass MyClass：4 import方法作为python的模块是天然的单例模式# mysingleton.pyclass My_Singleton(object):def foo(self):passmy_singleton = My_Singleton() to usefrom

21、 mysingleton import my_singletonmy_singleton.foo（）17 Python中的作用域Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定的。当 Python 遇到一个变量的话他会按照这样的顺序进行搜索：本地作用域(Local)当前作用域被嵌入的本地作用域（Enclosing locals）全局/模块作用域（Global)内置作用域（Builtin）18 GIL线程全局锁线程全局锁(Global Interpreter Lock)，即Python为了保证线程安全而采取的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程。解决办

22、法就是多进程和下面的协程(协程也只是单CPU，但是能减小切换代价提升性能).19 协程简单点说协程是进程和线程的升级版，进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户自己控制切换的时机,不再需要陷入系统的内核态.Python里最常见的yield就是协程的思想!可以查看第九个问题。20 闭包闭包（closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。当一个内嵌函数引用其外部作作用域的变量，我们就会得到一个闭包。 总结一下,创建一个闭包必须满足以下几点：1.必须有一个内嵌函数2.内嵌函数必须引用外部函数中的变量3.外

23、部函数的返回值必须是内嵌函数感觉闭包还是有难度的,几句话是说不明白的,还是查查相关资料。重点是函数运行后并不会被撤销，就像16题的instance字典一样,当函数运行完后，instance并不被销毁,而是继续留在内存空间里.这个功能类似类里的类变量,只不过迁移到了函数上。闭包就像个空心球一样,你知道外面和里面，但你不知道中间是什么样.21 lambda函数其实就是一个匿名函数,为什么叫lambda？因为和后面的函数式编程有关。22 Python函数式编程这个需要适当的了解一下吧，毕竟函数式编程在Python中也做了引用。python中函数式编程支持:filter 函数的功能相当于过滤器。调用一

24、个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。a = 1,2，3，4，5,6,7b = filter（lambda x: x 5， a）print b6，7map函数是对一个序列的每个项依次执行函数，下面是对一个序列每个项都乘以2： a = map(lambda x:x2,1,2，3) list（a）2， 4， 6reduce函数是对一个序列的每个项迭代调用函数，下面是求3的阶乘： reduce(lambda x，y：x*y，range（1，4)623 Python里的拷贝引用和copy（）,deepcopy(）的区别1234

25、567891011121314151617181920import copya = 1, 2, 3, 4, a, b原始对象b = a赋值，传对象的引用c = copy.copy（a）#对象拷贝，浅拷贝d = copy。deepcopy（a）#对象拷贝，深拷贝a.append(5）#修改对象aa4。append（c)#修改对象a中的a， b数组对象print a = ， aprint b = ， bprint c = ， cprint d = ， d输出结果：a =1， 2, 3, 4， a, b, c, 5b =1， 2, 3, 4， a， b, c, 5c =1, 2, 3， 4, a，

26、b, cd =1， 2， 3， 4, a, b24 Python垃圾回收机制Python GC主要使用引用计数（reference counting）来跟踪和回收垃圾。在引用计数的基础上，通过“标记清除”（mark and sweep）解决容器对象可能产生的循环引用问题,通过“分代回收”（generation collection)以空间换时间的方法提高垃圾回收效率。1 引用计数PyObject是每个对象必有的内容,其中ob_refcnt就是做为引用计数。当一个对象有新的引用时，它的ob_refcnt就会增加,当引用它的对象被删除，它的ob_refcnt就会减少。引用计数为0时，该对象生命就结

27、束了。优点:1.简单2.实时性缺点:1.维护引用计数消耗资源2.循环引用2 标记清除机制基本思路是先按需分配，等到没有空闲内存的时候从寄存器和程序栈上的引用出发，遍历以对象为节点、以引用为边构成的图，把所有可以访问到的对象打上标记,然后清扫一遍内存空间,把所有没标记的对象释放。3 分代技术分代回收的整体思想是：将系统中的所有内存块根据其存活时间划分为不同的集合，每个集合就成为一个“代”，垃圾收集频率随着“代”的存活时间的增大而减小，存活时间通常利用经过几次垃圾回收来度量.Python默认定义了三代对象集合，索引数越大，对象存活时间越长。举例：当某些内存块M经过了3次垃圾收集的清洗之后还存活时,我们就将内存块M划到一个集合A中去，而新分配的内存都划分到集合B中去。当垃圾收集开始工作时，大多数情况都只对集合B进行垃圾回收，而对集合A进行垃圾回收要隔相当长一段时间后才进行,这就使得垃圾收集机制需要处理的内存少了，效率自然就提高了。在这个过程中，集合B中的某些内存块由于存活时间长而会被转移到集合A中,当