以下代码打印什么内容？
0.
[code]>>> def func():
pass
>>> print(type(func()))[/code]
当然是打印函数的类型，由于什么都没有返回，也就是”NoneType“
1.
[code]>>> print(type(1J))[/code]
排除法，没有u开题，所以不是”unicode“，不是整型，也不是字符串，那就是”混合型“
2.
[code]>>> print(type(lambda:None))[/code]
起初我以为是NoneType，结果发现是function，结果help(lambda)发现这么一句话：
the expression ``lambda arguments: expression`` yields a function object.
也就是无论lambda如何定义，返回的都是一个函数对象
3.
[code]>>> a = [1, 2, 3, "FishC", (‘a‘, ‘b‘, ‘c‘), [], None]
>>> print(len(a))[/code]
列表a的长度就是数最外面的逗号分隔的东西有几个，数数大学有7个，分别是3个整型数字、字符串一个、元祖一个、空列表一个加上空值一个。
4.
[code]class A:
def __init__(self, x):
x = x + 1
self.v1 = x
class B(A):
def __init__(self, x):
x = x + 1
self.v2 = x
>>> b = B(8)
>>> print("%d %d" % b.v1, b.v2)[/code]
首先，小甲鱼没有注意缩进问题，在类A的初始化函数那里（如果我没有理解错误的话）。
如果是这样的话，那么b作为类B的实例对象，应该与A无关呀，不然，怎么来的leiA的属性v1？应该抛出异常吧？而且还有一个语法错误在print语句那里，应该是%（b.v1, b.v2）不然就是只打印前者的意思了，除非py3改了语法，因为我用的是py2哈。
5.
[code]class A:
def __init__(self, x):
self.x = x
x = 666
>>> a = A()
>>> a = A(888)
>>> a.x[/code]
首先，A类在定义的时候是需要传入参数x的，所以，a=A()会报错，而且定义的时候x=666这个常数十无意义的，因为x只是参数，只有当调用A的时候，传入的参数会覆盖x，所以666这个常数的赋值时无意义的，结果只会是888.
6.
[code]values = [1, 1, 2, 3, 5]
nums = set(values)
def check(num):
if num in nums:
return True
else:
return False
for i in filter(checkit, values):
print(i, end=‘ ‘)[/code]
好吧，小甲鱼累了，里面的代码已经错别字的惨不忍睹，小甲鱼真的是千年的劳模，在此容许在下烧一炷香，实际上肯定是打印1 1 2 3 5，首先，set是一个集合，里面一般是列表这样的可迭代对象；其次，filter(function or None, sequence)这个函数返回”function“为真的序列。这里就是返回所有的values列表中的元素，其中元素之间以空格隔开。
7.
[code]values = [1, 1, 2, 3, 5]
def transform(num):
return num ** 2
for i in map(transform, values):
print(i, end=‘ ‘)[/code]
map函数用于讲参数列表”values“里面的每一个元素作为参数”transform“函数的参数最终返回一个列表，因此返回1 1 4 9 25
8.
[code]class A:
def __init__(self, x):
self.x = x
a = A(100)
a.__dict__[‘y‘] = 50
print(a.y + len(a.__dict__))[/code]
首先，__dict__用于定义类属性以及对于的值，类属性以及对应的值在类内通过字典方式存储，因此a.y为50，而一共有两个属性，分别是y和x；因此结果为52.
9.
[code]class A:
def __init__(self):
pass
def get(self):
print(__name__)
>>> a = A()
>>> a.get()[/code]
执行的是函数本身，因此打印__main__，当模块被调用的时候，__name__==模块名称
10.
[code]country_counter = {}
def addone(country):
if country in country_counter:
country_counter[country] += 1
else:
country_counter[country] = 1
addone(‘China‘)
addone(‘Japan‘)
addone(‘China‘)
addone("American")
print(len(country_counter))[/code]
打印字典的长度3，首先字典的键值对分别是addone函数的参数和参数出现的次数，因此长度就是3个不同的国家。
11.
[code]dict1 = {}
dict1[1] = 1
dict1[‘1‘] = 2
dict1[1.0] = 3
result = 0
for each in dict1:
result += dict1[each]
print(result)[/code]
由于字段中的元素重复键的赋值会被覆盖，因此1会被重新复制为3，结果是result=3+2=5
12.
[code]def dostuff(param1, *param2):
print type(param2)
dostuff(‘apples‘, ‘bananas‘, ‘cherry‘, ‘dates‘)[/code]
dostuff里面有两个参数，一个是param1=‘apples‘，另外一个带*的参数是一个序列类型的参数，*params2=(‘bananas‘, ‘cherry‘, ‘dates‘)，因此是第二个参数是一个元组类型。
13.
[code]class A:
def __init__(self, a, b, c):
self.x = a + b + c
a = A(1,2,3)
b = getattr(a, ‘x‘)
setattr(a, ‘x‘, b+1)
print a.x[/code]
首先，getattr实际上返回的是实例对象属性x的值b=1+2+3=6，setattr是重新定义实例对象的属性x的值为7，因此结果为7.
14.
[code]list1 = [1, 2]
list2 = [3, 4]
dict1 = {‘1‘:list1, ‘2‘:list2}
dict2 = dict1.copy()
dict1[‘1‘][0] = 5
result = dict1[‘1‘][0] + dict2[‘1‘][0]
print(result)[/code]
结果为5+5=10，实际上copy()函数只是将索引指向了dict1而已，dict1变了，那么dict2也会跟着变，是一种浅拷贝方式，没有断根的拷贝。与传统意义上的克隆不同，要知道克隆出来的可是单独的个体。
15.
[code]import copy
list1 = [1, 2]
list2 = [3, 4]
dict1 = {‘1‘:list1, ‘2‘:list2}
dict2 = copy.deepcopy(dict1)
dict1[‘1‘][0] = 5
result = dict1[‘1‘][0] + dict2[‘1‘][0]
print(result)[/code]
调用copy模块的deepcopy()函数才能达到传统意义上的克隆，结果是result=5+1=6