1、下面这段代码的输出效果是什么？请诠释。
def extendList(val, list=[]):
list.append(val)
return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')
print "list1 = %s" % list1
print "list2 = %s" % list2
print "list3 = %s" % list3
怎样修正extendList的定义可以发生以下预期的行动?
上面代码输出效果将是：
list1 = [10, 'a'] list2 = [123] list3 = [10, 'a']
许多人都邑误认为list1=[10]，list3=[‘a’],因为他们认为每次extendList被挪用时，列表参数的默许值都将被设置为[].但实际上的状况是，新的默许列表只在函数被定义的那一刻建立一次。
当extendList被没有指定特定参数list挪用时，这组list的值随后将被运用。这是因为带有默许参数的表达式在函数被定义的时刻被盘算，不是在挪用的时刻被盘算。因而list1和list3是在同一个默许列表上举行操纵（盘算）的。而list2是在一个星散的列表上举行操纵（盘算）的。（经由过程通报一个自有的空列表作为列表参数的数值）。
extendList的定义可以作以下修正。
只管，建立一个新的列表，没有特定的列表参数。
下面这段代码能够可以发生想要的效果。
def extendList(val, list=None):
if list is None:
list = []
list.append(val)
return list
经由过程上面的修正，输出效果将变成：
list1 = [10] list2 = [123] list3 = ['a']
2、下面这段代码的输出效果将是什么？请诠释。
def multipliers(): return [lambda x : i * x for i in range(4)] print [m(2) for m in multipliers()]
你怎样修正上面的multipliers的定义发生想要的效果？
上面代码输出的效果是[6, 6, 6, 6] (不是我们想的[0, 2, 4, 6])。
上述题目发生的原因是Python闭包的耽误绑定。这意味着内部函数被挪用时，参数的值在闭包内举行查找。因而，当任何由multipliers()返回的函数被挪用时，i的值将在四周的局限举行查找。当时，不论返回的函数是不是被挪用，for轮回已完成，i被给予了终究的值3。
因而，每次返回的函数乘以通报过来的值3，因为上段代码传过来的值是2，它们终究返回的都是6(3*2)。恰巧的是，《The Hitchhiker’s Guide to Python》也指出，在与lambdas函数相干也有一个被普遍被误会的知识点，不过跟这个case不一样。由lambda表达式制造的函数没有什么特别的处所，它实际上是和def制造的函数式一样的。
下面是处理这一题目的一些要领。
一种处理要领就是用Python生成器。
def multipliers(): for i in range(4): yield lambda x : i * x
别的一个处理计划就是制造一个闭包，应用默许函数马上绑定。
def multipliers(): return [lambda x, i=i : i * x for i in range(4)]
还有种替换的计划是，运用偏函数：
from functools import partial from operator import mul def multipliers(): return [partial(mul, i) for i in range(4)]
3、下面这段代码的输出效果将是什么？请诠释。
class Parent(object):
x = 1
class Child1(Parent):
pass
class Child2(Parent):
pass
print Parent.x, Child1.x, Child2.x
Child1.x = 2
print Parent.x, Child1.x, Child2.x
Parent.x = 3
print Parent.x, Child1.x, Child2.x
输出效果将是：
1 1 1 1 2 1 3 2 3
让许多人疑心或惊奇的是末了一行输出为何是3 2 3 而不是 3 2 1.为何在转变parent.x的同时也转变了child2.x的值？但与此同时没有转变Child1.x的值？
此答案的症结是，在Python中，类变量在内部是以字典的情势举行通报。
假如一个变量名没有在当前类下的字典中发明。则在更高等的类（如它的父类）中经心搜刮直到援用的变量名被找到。（假如援用变量名在本身类和更高等类中没有找到，将会激发一个属性毛病。）
因而,在父类中设定x = 1,让变量x类(带有值1)可以在其类和其子类中被援用到。这就是为何第一个打印语句输出效果是1 1 1
因而，假如它的任何一个子类被覆写了值（比方说，当我们实行语句Child1.x = 2）,这个值只在子类中举行了修正。这就是为何第二个打印语句输出效果是1 2 1
终究，假如这个值在父类中举行了修正，（比方说，当我们实行语句Parent.x = 3）,这个转变将会影响那些还没有覆写子类的值（在这个例子中就是Child2）这就是为何第三打印语句输出效果是3 2 3
4、下面这段代码在Python2下输出效果将是什么？请诠释。
def div1(x,y):
print "%s/%s = %s" % (x, y, x/y)
def div2(x,y):
print "%s//%s = %s" % (x, y, x//y)
div1(5,2)
div1(5.,2)
div2(5,2)
div2(5.,2.)
在Python3下效果会有怎样的差别？（固然，假定上述打印语句被转换成Python3的语法）
在Python2中，上述代码输出将是
5/2 = 2 5.0/2 = 2.5 5//2 = 2 5.0//2.0 = 2.0
默许状况下，Python 2 自动实行整形盘算假如二者都是整数。因而,5/2 效果是2，而5./2效果是2.5
注重，在Python2中，你可以经由过程增添以下援用来覆写这个行动。
from future import division
同时要注重的是，//操纵符将老是实行整形除法，不论操纵符的范例。这就是为何纵然在Python 2中5.0//2.0的效果是2.0。但是在Python3中，没有此类特征，
比方，在两头都是整形的状况下，它不会实行整形除法
因而，在Python3中，将会是以下效果：
5/2 = 2.5 5.0/2 = 2.5 5//2 = 2 5.0//2.0 = 2.0
注： 在 Python 3 中，/ 操纵符是做浮点除法，而 // 是做整除（即商没有余数，比方 10 // 3 其效果就为 3，余数会被截撤除，而 (-7) // 3 的效果倒是 -3。这个算法与别的许多编程言语不一样，须要注重，它们的整除运算会向0的方向取值。而在 Python 2 中，/ 就是整除，即和 Python 3 中的 // 操纵符一样）
5、下面代码的输出效果将是什么？
list = ['a', 'b', 'c', 'd', 'e'] print list[10:]
下面的代码将输出[],不会发生IndexError毛病。就像所希冀的那样，尝试用超越成员的个数的index来猎取某个列表的成员。
比方，尝试猎取list[10]和以后的成员，会致使IndexError.
但是，尝试猎取列表的切片，最先的index超过了成员个数不会发生IndexError,而是仅仅返回一个空列表。
这成为特别让人恶心的疑难杂症，因为运转的时刻没有毛病发生，致使bug很难被追踪到。
6、斟酌以下代码片断：
list = [ [ ] ] * 5 list # output? list[0].append(10) list # output? list[1].append(20) list # output? list.append(30) list # output?
2,4,6,8即将输出什么效果？试诠释。
输出的效果以下：
[[], [], [], [], []] [[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]
诠释以下：
第一行的输出效果直觉上很轻易明白，比方 list = [ [ ] ] * 5 就是简朴的制造了5个空列表。但是，明白表达式list=[ [ ] ] * 5的症结一点是它不是制造一个包括五个自力列表的列表，而是它是一个建立了包括对同一个列表五次援用的列表。只要了解了这一点，我们才更好的明白接下来的输出效果。
list[0].append(10) 将10附加在第一个列表上。
但因为一切5个列表是援用的同一个列表，所以这个效果将是：
[[10], [10], [10], [10], [10]]
同理，list[1].append(20)将20附加在第二个列表上。但一样因为5个列表是援用的同一个列表，所以输出效果现在是：
[[10, 20], [10, 20], [10, 20], [10, 20], [10, 20]]
作为对照， list.append(30)是将全部新的元素附加在外列表上，因而发生的效果是： [[10, 20], [10, 20], [10, 20], [10, 20], [10, 20], 30].
7、Given a list of N numbers。
给定一个含有N个数字的列表。
运用单一的列表生成式来发生一个新的列表，该列表只包括满足以下前提的值：
(a)偶数值
(b)元素为原始列表中偶数切片。
比方，假如list[2]包括的值是偶数。那末这个值应该被包括在新的列表当中。因为这个数字同时在原始列表的偶数序列（2为偶数）上。但是，假如list[3]包括一个偶数，
谁人数字不该该被包括在新的列表当中，因为它在原始列表的奇数序列上。
对此题目的简朴处理要领以下：
[x for x in list[::2] if x%2 == 0]
比方，给定列表以下：
list = [ 1 , 3 , 5 , 8 , 10 , 13 , 18 , 36 , 78 ]
列表生成式[x for x in list[::2] if x%2 == 0] 的效果是，
[10, 18, 78]
这个表达式事情的步骤是，第一步掏出偶数切片的数字，
第二步剔除个中一切奇数。
8、给定以下字典的子类，下面的代码可以运转么？为何？
class DefaultDict(dict):
def __missing__(self, key):
return []d = DefaultDict()
d['florp'] = 127
可以运转。
当key缺失机，实行DefaultDict类，字典的实例将自动实例化这个数列。
以上就是python面试题细致总结（附答案）的细致内容，更多请关注ki4网别的相干文章！
