上面这段代码的输入后果是什么？请解释
def exten``dList(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']上面这段代码的输入后果将是什么？请解释。
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)]
上面这段代码的输入后果将是什么？请解释
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。
因而，如果它的任何一个子类被覆写了值（例如说，当咱们执行语句 Child.x = 2）, 这个值只在子类中进行了批改。这就是为什么第二个打印语句输入后果是 1 2 1。
最终，如果这个值在父类中进行了批改，（例如说，当咱们执行语句 Parent.x = 3）, 这个扭转将会影响那些还没有覆写子类的值（在这个例子中就是 Child2）这就是为什么第三打印语句输入后果是 3 2 3。
上面这段代码在 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
上面代码的输入后果将是什么？list = ['a', 'b', 'c', 'd', 'e']
print list[10:]答案：
上面的代码将输入 [], 不会产生 IndexError 谬误。就像所冀望的那样，尝试用超出成员的个数的 index 来获取某个列表的成员。
例如，尝试获取 list[10] 和之后的成员，会导致 IndexError。
然而，尝试获取列表的切片，开始的 index 超过了成员个数不会产生 IndexError, 而是仅仅返回一个空列表。
这成为特地让人恶心的疑难杂症，因为运行的时候没有谬误产生，导致 bug 很难被追踪到。
思考下列代码片段：
1. list = [[] ] * 5
2. list # output?
3. list[0].append(10)
4. list # output?
5. list[1].append(20)
6. list # output?
7. list.append(30)
8. 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].
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]
这个表达式工作的步骤是，第一步取出偶数切片的数字，第二步剔除其中所有奇数。
给定以下字典的子类：
class DefaultDict(dict):
def __missing__(self, key):
return []
上面的代码可能运行么？为什么？d = DefaultDict()
d['florp'] = 127答案：
可能运行。当 key 缺失时，执行 DefaultDict 类，字典的实例将主动实例化这个数列。