2017年4月28日 19:29:52
解压赋值给多个变量
可迭代的对象（list,tuple,string,文件对象，迭代器，生成器等），都可以进行解压赋值给多个对象。
#!/usr/bin/env python2 str = 'Hello'
a,b,c,_,e = str #a='H',b='e',c='l',e='o' #!/usr/bin/env python3
#python3中才支持* str = 'Hello'
a,*b,c=str #a='H',b=['e','l','l'],c='o'
deque()
内置模块collections中的一个函数。
1. deque(maxlen=N):构造一个固定大小的队列，加入新元素时，将自动剔除最老的元素
>>> from collections import deque
>>> alist = deque(maxlen=3)
>>> alist.append(1)
>>> alist.append(2)
>>> alist.append(3)
>>> alist
deque([1, 2, 3], maxlen=3)
>>> alist.append(4)
>>> alist
deque([2, 3, 4], maxlen=3)
2. deque()一个功能是两边都可以编辑（添加，删除）
>>> from collections import deque
>>> alist = deque([4,5,6])
>>> alist.appendleft(3) #左边添加
>>> alist
deque([3, 4, 5, 6])
>>> alist.extendleft([1,2]) #左边扩展，注意扩展顺序
>>> alist
deque([2, 1, 3, 4, 5, 6])
>>> alist.popleft() #左边删除，pop()不用传参，只能一个一个删除
2
>>> alist
deque([1, 3, 4, 5, 6])
- nlargest()和nsmallest()
查找最大或最小的N个元素列表
>>> import heapq
>>> nums=[25,32,12,6,8,4,76]
>>> heapq.nlargest(3,nums) #最大的三个原素
[76, 32, 25]
>>> heapq.nsmallest(3,nums) #最小的三个原素
[4, 6, 8]
如果N接近于列表大小，则应该使用sorted(), 这个函数不是heapq模块里的
>>> sorted(nums)
[4, 6, 8, 12, 25, 32, 76]
如果只查找最大或者最小的，则应使用max()和min()
>>> max(nums)
76
>>> min(nums)
4
附：关于heap模块请查阅：官方文档
设置字典默认的几种方法
1. 使用dict.setdefault()方法
>>>strings = ('puppy', 'kitten', 'puppy', 'puppy', 'weasel', 'puppy', 'kitten', 'puppy')
>>>counts=dict()
>>>for kw in strings:
counts.setdefault(kw, 0)
counts[kw] += 1
>>>counts
{'puppy': 5, 'weasel': 1, 'kitten': 2}
dict.setdefault(key,fault_value)方法接收两个参数，第一个参数是健的名称，第二个参数是默认值。
2. 使用collections.defaultdict类
>>> from collections import defaultdict
>>> dict_list = defaultdict(list) #字典中每个value都是一个列表
>>> dict_set = defaultdict(set) #字典中每个value都是一个集合，值不能重复
>>> def zero():
return 0
>>> dict_num1 = defaultdict(zero) #字典中每个键的默认都是0，参数只能是函数方法，不能是数值，也就是说不能写成defaultdict(0)
>>> dict_num2 =defaultdict(lambda:0) #字典每个键都是默认值0，和上面的效果一样，写法更简洁
>>> dict_list
defaultdict(<type 'list'>, {})
>>> dict_set
defaultdict(<type 'set'>, {})
>>> dict_num1
defaultdict(<function zero at 0x0000000002B3FB38>, {})
>>> dict_num2
defaultdict(<function <lambda> at 0x0000000002AEDAC8>, {}) >>> dict_list['a'].append('No1') #注意list只能用append添加
>>> dict_list['a'].append('No1')
>>> dict_list['a']
['No1', 'No1'] #是一个list，可以重复 >>> dict_set['b'].add('No1') #注意set只能用add添加
>>> dict_set['b'].add('No1')
>>> dict_set['b']
set(['No1']) #是一个set，不可以重复 >>> dict_num1['c']
0 >>> dict_num2['d']
0
zip()的使用
基本原理介绍
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> z = [7, 8, 9]
>>> new_list = zip(x,y,z)
>>> new_list
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
>>> new_list_1 = zip(*new_list)
>>> new_list_1
[(1, 2, 3), (4, 5, 6), (7, 8, 9)]
常用经典用法：反转字典
>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> m.keys()
['a', 'c', 'b', 'd']
>>> m.values()
[1, 3, 2, 4]
>>> re_list = zip(m.values(),m.keys())
>>> re_dict = dict(re_list)
>>> re_dict
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}
- 删除序列相同元素并保持顺序
1. 仅仅删除重复元素
>>> alist = [1,4,2,1,7,2,4]
>>> blist = set(alist)
>>> blist
set([1, 2, 4, 7])
2. 保持顺序（定义一个函数）
#第一种方法
>>> a = [1, 4, 2, 1, 7, 2, 4]
>>> b = list(set(a))
>>> b.sort(key=a.index)
>>> b
[1, 4, 2, 7] #第二种方法
>>> def dedupe(items):
... new_items = []
... for item in items:
... if item not in new_items:
... new_items.append(item)
... return new_items
...
>>> a = [1, 4, 2, 1, 7, 2, 4]
>>> print dedupe(a)
[1, 4, 2, 7]
查询序列中元素出现的频率
collections标准库中的Counter方法：collections.Counter
1. 创建实例，应用对象是所有可迭代对象：字符串,list,tuple,dict等
>>> from collections import Counter
>>> str_counter = Counter('hello') #字符串
>>> str_counter
Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
>>> list_counter = Counter(['Tom','Jay','Bill','Jay']) #list
>>> list_counter
Counter({'Jay': 2, 'Bill': 1, 'Tom': 1})
>>> tuple_counter = Counter(('Tom','Jay','Bill','Jay')) #tuple
>>> tuple_counter
Counter({'Jay': 2, 'Bill': 1, 'Tom': 1})
>>> dict_counter = Counter({'math':89,'english':76,'chinese':86}) #dict
>>> dict_counter
Counter({'math': 89, 'chinese': 86, 'english': 76})
2. 查询出现的频率
>>> list_counter['Jay'] #查询某元素出现的频率
2
>>> list_counter.most_common(2) #查询出现频率最高的两个
[('Jay', 2), ('Bill', 1)] >>> str_counter
Counter({'l': 2, 'h': 1, 'e': 1, 'o': 1})
>>> str_counter.update('length') #更新（添加），频率做加法
>>> str_counter
Counter({'l': 3, 'e': 2, 'h': 2, 'g': 1, 'o': 1, 'n': 1, 't': 1}) >>> str_counter.subtract('long') #更新（删除），频率做减法
>>> str_counter
Counter({'e': 2, 'h': 2, 'l': 2, 't': 1, 'g': 0, 'o': 0, 'n': 0}) #上面有元素频率为0，如若要删除，应使用del
>>> del str_counter['n']
>>> str_counter
Counter({'e': 2, 'h': 2, 'l': 2, 't': 1, 'g': 0, 'o': 0})
对字典的操作运算
1. 对字典的值排序，筛选，并找出相对应的键值
#coding:utf-8 import heapq
score={'Tom':75,'Jay':64,'Ben':94,'Micheal':84}
#找出成绩最好的那名同学名字
print max(zip(score.values(),score.keys()))
#(94, 'Ben') #找出成绩前两名的同学
print heapq.nlargest(2,zip(score.values(),score.keys()))
#[(94, 'Ben'), (84, 'Micheal')] #找出成绩在80-90区间的同学
def func(x):
return x[0]>80 and x[0]<90 print filter(func,zip(score.values(),score.keys()))
#[(84, 'Micheal')] 将成绩进行排序
print sorted(zip(score.values(),score.keys()))
#[(64, 'Jay'), (75, 'Tom'), (84, 'Micheal'), (94, 'Ben')]
上面的方法是一种方法，如果单纯要筛选最大值和最小值，还可以借助max和min的key实现：相关的可参考：max/min函数的用法
score={'Tom':75,'Jay':64,'Ben':94,'Micheal':84}
#找出成绩最好的那名同学名字
print max(score,key=lambda k:score[k])
#Ben
2. 找出两字典的相同点
2.1 相同的键和值