new_list = copy.copy(existing_list)
浅拷贝,虽然生成一个新对象,但是对象内部的属性和内容仍然引用原对象,一旦修改一个,两个均被改变。new_list = copy.deepcopy(existing_list)
深拷贝,修改new_list同时不改变existing_list。这种拷贝会消耗相当的时间和内存。def list_get(L,i,v=None):
if -len(L)return L[i]
else:
return v
def list_get(L,i,v=None):
try:
return L[i]
except IndexError:
return v
#'获得原谅总是比获得许可容易(easier to get forgiveness than permission,EGFP)'
for i,j in enumerate(list)
d = dict(enumerate(L))
利用enumerate将列表生成字典def list_or_tuple(x):
return isinstance(x,(list,tuple))
def flatten(sequence,to_expand=list_or_tuple):
for item in sequence:
if to_expand(item):
for subitem in flatten(item,to_expand):
yield subitem
else:
yield item
l = [1,2,[3,4],5,[6]]
for i in flatten(l):
print i,
out:
1 2 3 4 5 6
1方案:
a = [[1,2,3],[4,5,6],[7,8,9],[10,11,12]]
print [[i[j] for i in a]for j in xrange(len(a[0]))]
out:
[[1,4,7,10],[2,5,8,11],[3,6,9,12]]
2方案:
print map(list,zip(*a))#达到目的,但晦涩难懂
d=dict(zip(the_keys,the_values))
the_keys是键的序列,the_values是键对应的值的序列,内建的zip函数创建并返回一个数对(key,value)构成的列表,内建的dict接受这个列表作为参数并创建相应的字典。适合短序列。import itertools
d = dict(itertools.izip(the_keys,the_values))
def dictFromList(d):
return dict(zip(d[::2],d[1::2]))
def pairwise(iterable):
itnext = iter(iterable).next
while True:
yield itnext(),itnext()
def dictFromSequence(seq):
return dict(pairwise(seq))
(key,value)
序列,并将其作为参数传递给dict。区别: (key,value)
序列。适合任何可迭代对象list、tuple、str,还包括其他生成器的结果、文件、字典等。且一次只生成一对(key,value)
,没有在内存中创建表,性能高。pairwise函数的实现:将内建函数iter应用于传入的iterable参数,获得一个迭代器,然后再将一个本地变量itnext绑定到这个迭代器的next方法。看上去有点奇怪,但这是python中一个很好的通用技巧:如果你有一个对象,你想对这个对象所做的事是在循环中不断调用它的一个方法,可以给它的这个被绑定的方法赋予一个本地的名字,然后就可以直接直接调用这个本地名字了,就像调用一个函数一样。def sub_dict(the_dict,somekeys,default=None):
return dict((k,the_dict.get(k,default)) for k in somekeys)
d = {'a': 1, 'c': 3, 'b': 2}
sub_dict(d,'ab'),d
out:
{'a': 1, 'b': 2}, {'a': 1, 'c': 3, 'b': 2}
def sub_dict_remove(the_dict,somekeys,default=None):
return dict((k,the_dict.pop(k,default)) for k in somekeys)
d = {'a': 1, 'c': 3, 'b': 2}
sub_dict_remove(d,'ab'),d
out:
{'a': 1, 'b': 2}, {'c': 3}
def sub_dict(the_dict,somekeys):
return dict((k,the_dict[k]) for k in somekeys)
def sub_dict_remove(the_dict,somekeys):
return dict((k,the_dict.pop(k) for k in somekeys)
def sub_dict(the_dict,somekeys):
return dict((k,the_dict[k]) for k in somekeys if k in the_dict)
def sub_dict_remove(the_dict,somekeys):
return dict((k,the_dict.pop(k) for k in somekeys if k in the_dict)
d1 = {}
d1.setdefault(key,[]).append(value)#list作为字典的值
d1[key].remove(value)#删除键对应的值
d2 = {}
d2.setdefault(key,{})[value1]=value2#子字典作为字典的值
del d2[key][value]
d3 = {}
d3.setdefault(key,set()).add(value)
d3[key]remove(value)
在解决多分支语句时,常使用的方法是多个case或者if和else或者if和else if。但这种方法效率比较低,可读性不高。在python中,字典可使得多分支语句更容易被解决。具体的作法就是把在某个条件下要执行的过程写成一个函数,然后把该条件本身和对应的函数作为一对Key-Value放入一个字典中,该字典相当于一个Map。在别的语言中,可能需要使用case、switch、或者if else语句,但在python中,都可以使用字典的这个功能来解决。
如:求一个数除以10的余数,并打印出来,可以这样写:
while True:
n = raw_input()
i = int(n) % 10
if i == 0:
print 0
elif i == 1:
print 1
elif i == 2:
print 2
elif i == 3:
print 3
elif i == 4:
print 4
elif i == 5:
print 5
elif i == 6:
print 6
elif i == 7:
print 7
elif i == 8:
print 8
elif i == 9:
print 9
使用字典来解决更方便:
def get0():
print 0
def get1():
print 1
def get2():
print 2
def get3():
print 3
def get4():
print 4
def get5():
print 5
def get6():
print 6
def get7():
print 7
def get8():
print 8
def get9():
print 9
dict = {0:get0, 1:get1, 2:get2, 3:get3, 4:get4,
5:get5, 6:get6, 7:get7, 8:get8, 9:get9}
while True:
n = raw_input()
i = int(n) % 10
dict[i]()
a = dict.fromkeys(xrange(10))#dict.fromkeys来创建不考虑键对应的值
b = dict.fromkeys(xrange(5,15))
union = dict(a,**b)#交集
inter = dict.fromkeys(x for x in a if x in b)#并集
a = set(xrange(10))
b = set(xrange(5,15))
union = a | b / union = a.union(b)#交集
inter = a & b / inter = a.intersection(b)#并集
for name in set(phones) & set(addresses):
print name,phones[name],addresses[name]
for name in set(phones).intersection(addresses):
print name,phones[name],addresses[name]
#如果使用intersection方法,就不需要将两个字典都转化为set,只需要其中一个,然后再对转化后的set调用intersection,并传入另一个dict作为intersection方法的参数。