Python面试题总结

1、Python是如何进行内存管理的？

Python的内存管理主要有三种机制：引用计数机制、垃圾回收机制和内存池机制。

a. 引用计数

当给一个对象分配一个新名称或者将一个对象放入一个容器（列表、元组或字典）时，该对象的引用计数都会增加。
当使用del对对象显示销毁或者引用超出作用于或者被重新赋值时，该对象的引用计数就会减少。
可以使用sys.getrefcount()函数来获取对象的当前引用计数。多数情况下，引用计数要比我们猜测的大的 多。对于不可变数据（数字和字符串），解释器会在程序的不同部分共享内存，以便节约内存。

b. 垃圾回收

当一个对象的引用计数归零时，它将被垃圾收集机制处理掉。
当两个对象a和b相互引用时，del语句可以减少a和b的引用计数，并销毁用于引用底层对象的名称。然而由于每个对象都包含一个对其他对象的应用，因此引用计数不会归零，对象也不会销毁。（从而导致内存泄露）。为解决这一问题，解释器会定期执行一个循环检测器，搜索不可访问对象的循环并删除它们。

c. 内存池机制

Python提供了对内存的垃圾收集机制，但是它将不用的内存放到内存池而不是返回给操作系统。
1，Pymalloc机制。为了加速Python的执行效率，Python引入了一个内存池机制，用于管理对小块内存的申请和释放。
2，Python中所有小于256个字节的对象都使用pymalloc实现的分配器，而大的对象则使用系统的 malloc。
3，对于Python对象，如整数，浮点数和List，都有其独立的私有内存池，对象间不共享他们的内存池。也就是说如果你分配又释放了大量的整数，用于缓存这些整数的内存就不能再分配给浮点数。

2、什么是lambda函数？它有什么好处?

lambda 表达式，通常是在需要一个函数，但是又不想费神去命名一个函数的场合下使用，也就是指匿名函数
lambda函数：首要用途是指点短小的回调函数

f = lambda x: x**2 + 2*x - 5

Those things are actually quite useful. Python supports a style of programming called functional programming where you can pass functions to other functions to do stuff. Example:

mult3 = filter(lambda x: x % 3 == 0, [1, 2, 3, 4, 5, 6, 7, 8, 9])

sets mult3 to [3, 6, 9], those elements of the original list that are multiples of 3. This is shorter (and, one could argue, clearer) than

def filterfunc(x):    return x % 3 == 0mult3 = filter(filterfunc, [1, 2, 3, 4, 5, 6, 7, 8, 9])

Of course, in this particular case, you could do the same thing as a list comprehension:

mult3 = [x for x in [1, 2, 3, 4, 5, 6, 7, 8, 9] if x % 3 == 0]

(or even as range(3,10,3)) but there are other cases, like constructing functions as return values from other functions, where you can’t use a list comprehension and a lambda function may be the shortest way to write something out. Like

def transform(n):    return lambda x: x + nf = transform(3)f(4) # is 7

3、Python里面如何实现tuple和list的转换？

直接使用tuple和list函数就行了，type()可以判断对象的类型。

4、请写出一段Python代码实现删除一个list里面的重复元素。

这个地方用set可以实现，set的用法可以参考Python集合（set）类型的操作

>>> t = [1, 2, 3, 1, 2, 5, 6, 7, 8]>>> t[1, 2, 3, 1, 2, 5, 6, 7, 8]>>> list(set(t))[1, 2, 3, 5, 6, 7, 8]>>> s = [1, 2, 3]>>> list(set(t) - set(s))[8, 5, 6, 7]

5、Python里面如何拷贝一个对象？（赋值，浅拷贝，深拷贝的区别）

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用（如果用引用的方式修改其中一个对象，另外一个也会修改改变）{1,完全切片方法；2，工厂函数，如list()；3，copy模块的copy()函数}

Python 2:

a_copy = a_list[:]
a_copy = list(a_list)

Python 3:
a_copy = a_list.copy()

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象（修改其中一个，另外一个不会改变）{copy模块的deep.deepcopy()函数}

import copya_deep_copy = copy.deepcopy(a_list)

6、介绍一下except的用法和作用？

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

7、Python里面match()和search()的区别？

re模块中match(pattern,string [,flags]),检查string的开头是否与pattern匹配。
re模块中re.search(pattern,string [,flags]),在string搜索pattern的第一个匹配值。

>>> print(re.match(‘super’, ‘superstition’).span())>>> (0, 5)>>> print(re.match(‘super’, ‘insuperable’))>>> None>>> print(re.search(‘super’, ‘superstition’).span())>>> (0, 5)>>> print(re.search(‘super’, ‘insuperable’).span())>>> (2, 7)

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

术语叫贪婪匹配( <.> )和非贪婪匹配( <.?> )

9、以下的代码的输出将是什么? 说出你的答案并解释

classParent(object):x=1classChild1(Parent):passclassChild2(Parent):passprint Parent.x,Child1.x,Child2.xChild1.x=2print Parent.x,Child1.x,Child2.xParent.x=3print Parent.x,Child1.x,Child2.x

输出：
111
121
323

使你困惑或是惊奇的是关于最后一行的输出是 3 2 3 而不是 3 2 1。为什么改变了 Parent.x 的值还会改变 Child2.x 的值，但是同时 Child1.x 值却没有改变？
这个答案的关键是，在 Python 中，类变量在内部是作为字典处理的。如果一个变量的名字没有在当前类的字典中发现，将搜索祖先类（比如父类）直到被引用的变量名被找到（如果这个被引用的变量名既没有在自己所在的类又没有在祖先类中找到，会引发一个 AttributeError 异常 ）。
因此，在父类中设置 x = 1 会使得类变量 X 在引用该类和其任何子类中的值为 1。这就是因为第一个 print 语句的输出是 1 1 1。
随后，如果任何它的子类重写了该值（例如，我们执行语句 Child1.x = 2），然后，该值仅仅在子类中被改变。这就是为什么第二个 print 语句的输出是 1 2 1。
最后，如果该值在父类中被改变（例如，我们执行语句 Parent.x = 3），这个改变会影响到任何未重写该值的子类当中的值（在这个示例中被影响的子类是 Child2）。这就是为什么第三个 print 输出是 3 2 3。

10、以下代码将输出什么?

list=['a','b','c','d','e']print list[10:]

答案:
以上代码将输出 []，并且不会导致一个 IndexError。
正如人们所期望的，试图访问一个超过列表索引值的成员将导致 IndexError（比如访问以上列表的 list[10]）。尽管如此，试图访问一个列表的以超出列表成员数作为开始索引的切片将不会导致 IndexError，并且将仅仅返回一个空列表。
一个讨厌的小问题是它会导致出现 bug ，并且这个问题是难以追踪的，因为它在运行时不会引发错误。

11、以下的代码的输出将是什么? 说出你的答案并解释？

def extendList(val,list=[]):    list.append(val)    return listlist1=extendList(10)list2=extendList(123,[])list3=extendList('a')print "list1=%s"%list1print "list2=%s"%list2print "list3=%s"%list3

你将如何修改 extendList 的定义来产生期望的结果

以上代码的输出为：
list1=[10,’a’]
list2=[123]
list3=[10,’a’]

许多人会错误的认为 list1 应该等于 [10] 以及 list3 应该等于 [‘a’]。认为 list 的参数会在 extendList 每次被调用的时候会被设置成它的默认值 []。
尽管如此，实际发生的事情是，新的默认列表仅仅只在函数被定义时创建一次。随后当 extendList 没有被指定的列表参数调用的时候，其使用的是同一个列表。这就是为什么当函数被定义的时候，表达式是用默认参数被计算，而不是它被调用的时候。
因此，list1 和 list3 是操作的相同的列表。而 `list2是操作的它创建的独立的列表（通过传递它自己的空列表作为list 参数的值）。
extendList 函数的定义可以做如下修改，但，当没有新的 list 参数被指定的时候，会总是开始一个新列表，这更加可能是一直期望的行为。

def extendList(val,list=None):    if list isNone:    list=[]    list.append(val)    return list

使用这个改进的实现，输出将是：
list1=[10]
list2=[123]
list3=[‘a’]

12、以下程序输出什么？

list=[[]]*5list#output?list[0].append(10)list#output?list[1].append(20)list#output?list.append(30)list#output?

答案：
[[], [], [], [], []]；
[[10], [10], [10], [10], [10]]；
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]];
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30]。