Python Cook函数笔记 【第一章】

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

 参考文章：python中defaultdict方法的使用

• 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 相同的键和值