Python面试题【BAT版】（02）

写在前面

今天给大家分享2018年BAT面试过程中的python的相关问题。所有的面试题和答案均来源于网络，如有侵权请及时联系，答案如有不正确还请各位及时指正。为面试而生希望各位都能化身offer收割机。

问题清单

Python语言特性

1.Python的函数参数传递 看两个如下例子，分析运行结果: 代码一：

1a = 1
2def fun(a):
3    a = 2
4fun(a)
5print(a)  # 1

代码二：

1a = []
2def fun(a):
3a.append(1)
4fun(a)
5print(a)  # [1]

所有的变量都可以理解是内存中一个对象的“引用”，或者，也可以看似c中void*的感觉。这里记住的是类型是属于对象的，而不是变量。而对象有两种,“可更改”（mutable）与“不可更改”（immutable）对象。在python中，strings, tuples, 和numbers是不可更改的对象，而list,dict等则是可以修改的对象。(这就是这个问题的重点)当一个引用传递给函数的时候,函数自动复制一份引用,这个函数里的引用和外边的引用没有半毛关系了.所以第一个例子里函数把引用指向了一个不可变对象,当函数返回的时候,外面的引用没半毛感觉.而第二个例子就不一样了,函数内的引用指向的是可变对象,对它的操作就和定位了指针地址一样,在内存里进行修改。

2.Python中的元类(metaclass)

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

3.@staticmethod和@classmethod

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

 1class A(object):
 2    def foo(self,x):
 3        print "executing foo(%s,%s)"%(self,x)
 4
 5    @classmethod
 6    def class_foo(cls,x):
 7        print( "executing class_foo(%s,%s)"%(cls,x))
 8
 9    @staticmethod
10    def static_foo(x):
11        print ("executing static_foo(%s)"%x)
12
13a=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)来调用。

4.类变量和实例变量

1class Person:
2    name="aaa"
3
4p1=Person()
5p2=Person()
6p1.name="bbb"
7print(p1.name)  # bbb
8print(p2.name)  # aaa
9print(Person.name)  # aaa

类变量就是供类使用的变量,实例变量就是供实例使用的。 这里p1.name="bbb"是实例调用了类变量,这其实和上面第一个问题一样,就是函数传参的问题,p1.name一开始是指向的类变量name="aaa",但是在实例的作用域里把类变量的引用改变了,就变成了一个实例变量,self.name不再引用Person的类变量name了. 可以看看下面的例子:

1class Person:
2    name=[]
3
4p1=Person()
5p2=Person()
6p1.name.append(1)
7print(p1.name)  # [1]
8print(p2.name)  # [1]
9print(Person.name)  # [1]

5.Python自省

这个也是python彪悍的特性.

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

6.字典推导式

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

1d = {key: value for (key, value) in iterable}

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

 1>>> class MyClass():
 2...     def __init__(self):
 3...             self.__superprivate = "Hello"
 4...             self._semiprivate = ", world!"
 5...
 6>>> mc = MyClass()
 7>>> print(mc.__superprivate)
 8Traceback (most recent call last):
 9  File "<stdin>", line 1, in <module>
10AttributeError: myClass instance has no attribute '__superprivate'
11>>> print(mc._semiprivate)
12, world!
13>>> print mc.__dict__
14{'_MyClass__superprivate': 'Hello', '_semiprivate': ', world!'}

__foo__:一种约定,Python内部的名字,用来区别其他用户自定义的命名,以防冲突. _foo:一种约定,用来指定变量私有.程序员用来指定私有变量的一种方式. __foo:这个有真正的意义:解析器用_classname__foo来代替这个名字,以区别和其他类相同的命名. 详情见: http://www.zhihu.com/question/19754941 8.字符串格式化:%和.format .format在许多方面看起来更便利.对于%最烦人的是它无法同时传递一个变量和元组.你可能会想下面的代码不会有什么问题: Python:

1"hi there %s" % name

但是,如果name恰好是(1,2,3),它将会抛出一个TypeError异常.为了保证它总是正确的,你必须这样做:

1hi there %s" % (name,)   # 提供一个单元素的数组而不是一个参数
2

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

1>>> def print_everything(*args):
2        for count, thing in enumerate(args):
3...         print '{0}. {1}'.format(count, thing)
4...
5>>> print_everything('apple', 'banana', 'cabbage')
60. apple
71. banana
82. cabbage

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

1>>> def table_things(**kwargs):
2...     for name, value in kwargs.items():
3...         print '{0} = {1}'.format(name, value)
4...
5>>> table_things(apple = 'fruit', cabbage = 'vegetable')
6cabbage = vegetable
7apple = fruit

你也可以混着用.命名参数首先获得参数值然后所有的其他参数都传递给*args和**kwargs.命名参数在列表的最前端.例如:

1def table_things(titlestring, **kwargs)
2

*args和**kwargs可以同时在函数的定义中,但是*args必须在**kwargs前面.当调用函数时你也可以用*和**语法.例如:

1>>> def print_three_things(a, b, c):
2...     print 'a = {0}, b = {1}, c = {2}'.format(a,b,c)
3...
4>>> mylist = ['aardvark', 'baboon', 'cat']
5>>> print_three_things(*mylist)
6
7a = aardvark, b = baboon, c = cat

就像你看到的一样,它可以传递列表(或者元组)的每一项并把它们解包.注意必须与它们在函数里的参数相吻合.当然,你也可以在函数定义或者函数调用时用*. http://stackoverflow.com/questions/3394835/args-and-kwargs 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那样专门去弄一大堆的设计模式。

13.Python中重载 引自知乎: http://www.zhihu.com/question/20053359 函数重载主要是为了解决两个问题。 1.可变参数类型。 2.可变参数个数。 另外，一个基本的设计原则是，仅仅当两个函数除了参数类型和参数个数不同以外，其功能是完全相同的，此时才使用函数重载，如果两个函数的功能其实不同，那么不应当使用重载，而应当使用一个名字不同的函数。 好吧，那么对于情况 1 ，函数功能相同，但是参数类型不同，python 如何处理？答案是根本不需要处理，因为 python 可以接受任何类型的参数，如果函数的功能相同，那么不同的参数类型在 python 中很可能是相同的代码，没有必要做成两个不同函数。 那么对于情况 2 ，函数功能相同，但参数个数不同，python 如何处理？大家知道，答案就是缺省参数。对那些缺少的参数设定为缺省参数即可解决问题。因为你假设函数功能相同，那么那些缺少的参数终归是需要用的。 好了，鉴于情况 1 跟 情况 2 都有了解决方案，python 自然就不需要函数重载了。 14.新式类和旧式类 这篇文章很好的介绍了新式类的特性: http://www.cnblogs.com/btchenguang/archive/2012/09/17/2689146.html 新式类很早在2.2就出现了,所以旧式类完全是兼容的问题,Python3里的类全部都是新式类.这里有一个MRO问题可以了解下(新式类是广度优先,旧式类是深度优先),<Python核心编程>里讲的也很多. 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__方法

1class Singleton(object):
2    def __new__(cls, *args, **kw):
3        if not hasattr(cls, '_instance'):
4            orig = super(Singleton, cls)
5            cls._instance = orig.__new__(cls, *args, **kw)
6        return cls._instance
7
8class MyClass(Singleton):
9    a = 1

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

1class Borg(object):
2    _state = {}
3    def __new__(cls, *args, **kw):
4        ob = super(Borg, cls).__new__(cls, *args, **kw)
5        ob.__dict__ = cls._state
6        return ob
7
8class MyClass2(Borg):
9    a = 1

3.装饰器版本

 1def singleton(cls, *args, **kw):
 2    instances = {}
 3    def getinstance():
 4        if cls not in instances:
 5            instances[cls] = cls(*args, **kw)
 6        return instances[cls]
 7    return getinstance
 8
 9@singleton
10class MyClass:

4.import方法 作为python的模块是天然的单例模式

 1class My_Singleton(object):
 2    def foo(self):
 3        pass
 4
 5my_singleton = My_Singleton()
 6
 7# to use
 8from mysingleton import my_singleton
 9
10my_singleton.foo()

17.Python中的作用域

Python 中，一个变量的作用域总是由在代码中被赋值的地方所决定的。 当 Python 遇到一个变量的话他会按照这样的顺序进行搜索： 本地作用域（Local）→当前作用域被嵌入的本地作用域（Enclosing locals）→全局/模块作用域（Global）→内置作用域（Built-in）

18.GIL线程全局锁 线程全局锁(Global Interpreter Lock),即Python为了保证线程安全而采取的独立线程运行的限制,说白了就是一个核只能在同一时间运行一个线程. 解决办法就是多进程和下面的协程(协程也只是单CPU,但是能减小切换代价提升性能).

19.协程 简单点说协程是进程和线程的升级版,进程和线程都面临着内核态和用户态的切换问题而耗费许多切换时间,而协程就是用户自己控制切换的时机,不再需要陷入系统的内核态. Python里最常见的yield就是协程的思想!可以查看第九个问题.

20.闭包 闭包(closure)是函数式编程的重要的语法结构。闭包也是一种组织代码的结构，它同样提高了代码的可重复使用性。 当一个内嵌函数引用其外部作作用域的变量,我们就会得到一个闭包. 总结一下,创建一个闭包必须满足以下几点: 1.必须有一个内嵌函数 2.内嵌函数必须引用外部函数中的变量 3.外部函数的返回值必须是内嵌函数 感觉闭包还是有难度的,几句话是说不明白的,还是查查相关资料. 重点是函数运行后并不会被撤销,就像16题的instance字典一样,当函数运行完后,instance并不被销毁,而是继续留在内存空间里.这个功能类似类里的类变量,只不过迁移到了函数上. 闭包就像个空心球一样,你知道外面和里面,但你不知道中间是什么样.

21.Python函数式编程 这个需要适当的了解一下吧,毕竟函数式编程在Python中也做了引用. python中函数式编程支持: filter 函数的功能相当于过滤器。调用一个布尔函数bool_func来迭代遍历每个seq中的元素；返回一个使bool_seq返回值为true的元素的序列。

1>>>a = [1,2,3,4,5,6,7]
2>>>b = filter(lambda x: x > 5, a)
3>>>print b
4>>>[6,7]

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

1>>> a = map(lambda x:x*2,[1,2,3])
2>>> list(a)
3[2, 4, 6]

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

1>>> reduce(lambda x,y:x*y,range(1,4))
26

22.Python里的拷贝

引用和copy(),deepcopy()的区别

 1import copy
 2a = [1, 2, 3, 4, ['a', 'b']]  #原始对象
 3
 4b = a  #赋值，传对象的引用
 5c = copy.copy(a)  #对象拷贝，浅拷贝
 6d = copy.deepcopy(a)  #对象拷贝，深拷贝
 7
 8a.append(5)  #修改对象a
 9a[4].append('c')  #修改对象a中的['a', 'b']数组对象
10
11print 'a = ', a
12print 'b = ', b
13print 'c = ', c
14print 'd = ', d
15
16输出结果：
17a =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
18b =  [1, 2, 3, 4, ['a', 'b', 'c'], 5]
19c =  [1, 2, 3, 4, ['a', 'b', 'c']]
20d =  [1, 2, 3, 4, ['a', 'b']]

23.read,readline和readlines

read 读取整个文件 readline 读取下一行,使用生成器方法 readlines 读取整个文件到一个迭代器以供我们遍历

24.到底什么是Python？你可以在回答中与其他技术进行对比 下面是一些关键点： Python是一种解释型语言。这就是说，与C语言和C的衍生语言不同，Python代码在运行之前不需要编译。其他解释型语言还包括PHP和Ruby。Python是动态类型语言，指的是你在声明变量时，不需要说明变量的类型。你可以直接编写类似x=111和x="I'm a string"这样的代码，程序不会报错。

Python非常适合面向对象的编程（OOP），因为它支持通过组合（composition）与继承（inheritance）的方式定义类（class）。Python中没有访问说明符（access specifier，类似C++中的public和private），这么设计的依据是“大家都是成年人了”。 在Python语言中，函数是第一类对象（first-class objects）。这指的是它们可以被指定给变量，函数既能返回函数类型，也可以接受函数作为输入。类（class）也是第一类对象。

Python代码编写快，但是运行速度比编译语言通常要慢。好在Python允许加入基于C语言编写的扩展，因此我们能够优化代码，消除瓶颈，这点通常是可以实现的。numpy就是一个很好地例子，它的运行速度真的非常快，因为很多算术运算其实并不是通过Python实现的。

Python用途非常广泛——网络应用，自动化，科学建模，大数据应用，等等。它也常被用作“胶水语言”，帮助其他语言和组件改善运行状况。 Python让困难的事情变得容易，因此程序员可以专注于算法和数据结构的设计，而不用处理底层的细节。

为什么提这个问题： 如果你应聘的是一个Python开发岗位，你就应该知道这是门什么样的语言，以及它为什么这么酷。以及它哪里不好。

25.阅读下面的代码，写出A0，A1至An的最终值。

 1A0 = dict(zip(('a','b','c','d','e'),(1,2,3,4,5)))
 2A1 = range(10)
 3A2 = [i for i in A1 if i in A0]
 4A3 = [A0[s] for s in A0]
 5A4 = [i for i in A1 if i in A3]
 6A5 = {i:i*i for i in A1}
 7A6 = [[i,i*i] for i in A1]

 8答案
 9A0 = {'a': 1, 'c': 3, 'b': 2, 'e': 5, 'd': 4}
10A1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
11A2 = []
12A3 = [1, 3, 2, 5, 4]
13A4 = [1, 2, 3, 4, 5]
14A5 = {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
15A6 = [[0, 0], [1, 1], [2, 4], [3, 9], [4, 16], [5, 25], [6, 36], [7, 49], [8, 64], [9, 81]]

为什么提这个问题： 列表解析（list comprehension）十分节约时间，对很多人来说也是一个大的学习障碍。如果你读懂了这些代码，就很可能可以写下正确地值。其中部分代码故意写的怪怪的。因为你共事的人之中也会有怪人。

26.介绍一下except的用法和作用？

try…except…except…[else…][finally…] 执行try下的语句，如果引发异常，则执行过程会跳到except语句。对每个except分支顺序尝试执行，如果引发的异常与except中的异常组匹配，执行相应的语句。如果所有的except都不匹配，则异常会传递到下一个调用本代码的最高层try代码中。 try下的语句正常执行，则执行else块代码。如果发生异常，就不会执行 如果存在finally语句，最后总是会执行。

27.如何用Python来进行查询和替换一个文本字符串？

答：可以使用re模块中的sub()函数或者subn()函数来进行查询和替换， 格式：

sub(replacement, string[,count=0])

（replacement）是被替换成的文本，string是需要被替换的文本，count是一个可选参数，指最大被替换的数量）

1>>> import re
2>>>p=re.compile(‘blue|white|red’)
3>>>print(p.sub(‘colour’,'blue socks and red shoes’))
4colour socks and colourshoes
5>>>print(p.sub(‘colour’,'blue socks and red shoes’,count=1))
6colour socks and redshoes

7subn()方法执行的效果跟sub()一样，不过它会返回一个二维数组，包括替换后的新的字符串和总共替换的数量

28.用Python匹配HTML tag的时候，<.*>和<.*?>有什么区别？

答：术语叫贪婪匹配( <.*> )和非贪婪匹配(<.*?> ) 例如: test <.*> : test <.*?> :

29.有没有一个工具可以帮助查找python的bug和进行静态的代码分析？

答：PyChecker是一个python代码的静态分析工具，它可以帮助查找python代码的bug, 会对代码的复杂度和格式提出警告，Pylint是另外一个工具可以进行codingstandard检查。

30.Python和多线程（multi-threading）。这是个好主意码？列举一些让Python代码以并行方式运行的方法。 Python并不支持真正意义上的多线程。Python中提供了多线程包，但是如果你想通过多线程提高代码的速度，使用多线程包并不是个好主意。Python中有一个被称为Global Interpreter Lock（GIL）的东西，它会确保任何时候你的多个线程中，只有一个被执行。线程的执行速度非常之快，会让你误以为线程是并行执行的，但是实际上都是轮流执行。经过GIL这一道关卡处理，会增加执行的开销。这意味着，如果你想提高代码的运行速度，使用threading包并不是一个很好的方法。 不过还是有很多理由促使我们使用threading包的。如果你想同时执行一些任务，而且不考虑效率问题，那么使用这个包是完全没问题的，而且也很方便。但是大部分情况下，并不是这么一回事，你会希望把多线程的部分外包给操作系统完成（通过开启多个进程），或者是某些调用你的Python代码的外部程序（例如Spark或Hadoop），又或者是你的Python代码调用的其他代码（例如，你可以在Python中调用C函数，用于处理开销较大的多线程工作）。

为什么提这个问题 因为GIL就是个混账东西（A-hole）。很多人花费大量的时间，试图寻找自己多线程代码中的瓶颈，直到他们明白GIL的存在。