1. 解压序列赋值给多个变量
任何的序列（或者可迭代对象）可以通过一个简单的赋值语句解压并赋值给多个变量。
唯一的前提就是变量的数量必须跟序列元素的数量是一样的
p = [4, 5, 6]
a, b, c = p
print(a, b, c)
4 5 6
2. 解压可迭代对象给多个变量
使用Python的星号（*）解决这个问题
解压出来的变量永远是列表类型
record = (1, 2, 3, 4, 5)
first, *number, end = record
print(first, number, end)
1 [2, 3, 4] 5
3. 保留最后N个元素
使用collections.deque
from collections import deque
# 构建一个固定长度为3的队列
q = deque(maxlen=3)
q.append(1)
q.append(2)
q.append(3)
q
deque([1, 2, 3])
q.append(4)
q
deque([2, 3, 4])
4. 保留最大或最小的N的元素
使用heapq模块的两个函数，nlargest()和nsmallest()
import heapq
nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]
print(heapq.nlargest(3, nums))
print(heapq.nsmallest(3, nums))
print(max(nums))
print(min(nums))
[42, 37, 23]
[-4, 1, 2]
42
-4
# 可以接受关键字参数，用于更复杂的数据结构
portfolio = [
{'name': 'IBM', 'shares': 100, 'price': 91.1},
{'name': 'AAPL', 'shares': 50, 'price': 543.22},
{'name': 'FB', 'shares': 200, 'price': 21.09},
{'name': 'HPQ', 'shares': 35, 'price': 31.75},
{'name': 'YHOO', 'shares': 45, 'price': 16.35},
{'name': 'ACME', 'shares': 75, 'price': 115.65}
]
cheap = heapq.nsmallest(3, portfolio, key=lambda s: s['price'])
expensive = heapq.nlargest(3, portfolio, key=lambda s: s['price'])
print(cheap)
print(expensive)
[{'name': 'YHOO', 'shares': 45, 'price': 16.35}, {'name': 'FB', 'shares': 200, 'price': 21.09}, {'name': 'HPQ', 'shares': 35, 'price': 31.75}]
[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}, {'name': 'IBM', 'shares': 100, 'price': 91.1}]
当要查找的元素个数相对比较小的时候，heapq.nsmallest()和heapq.nlargest()是很合适的
如果只是想找唯一的最大或最小就使用max()和min()函数
如果N的大小和集合大小接近的时候，则使用切片操作会更快一点sorted(items)[:N]或者sorted(items)[-N:]
5. 实现一个优先级队列
使用heapq模块的heappush()和heappop()
import heapq
class PriorityQueue:
def __init__(self):
self._queue = []
self._index = 0
def push(self, item, priority):
heapq.heappush(self._queue, (-priority, self._index, item))
self._index += 1
def pop(self):
return heapq.heappop(self._queue)[-1]
class Item:
def __init__(self, name):
self.name = name
def __repr__(self):
return 'Item({!r})'.format(self.name)
q = PriorityQueue()
q.push(Item('foo'), 1)
q.push(Item('bar'), 4)
q._queue
[(-4, 1, Item('bar')), (-1, 0, Item('foo'))]
q.pop()
Item('bar')
6. 字典中的键映射多个值
一个字典就是一个键对应一个单值的映射。
如果你想要一个值映射多个值，需要这多个值放到另外的容器中
d = {
'a' : [1, 2, 3]
}
d
{'a': [1, 2, 3]}
d = {
'a' : {1, 2, 3}
}
d
{'a': {1, 2, 3}}
# 或者可以使用collections.defaultdict
from collections import defaultdict
d = defaultdict(list)
d['a'].append(1)
d['a'].append(2)
d['b'].append(4)
d
defaultdict(list, {'a': [1, 2], 'b': [4]})
d = defaultdict(set)
d['a'].add(1)
d['a'].add(2)
d['b'].add(4)
d
defaultdict(set, {'a': {1, 2}, 'b': {4}})
7. 字典排序
使用collections模块OrderedDict类
在迭代的时候保存元素被插入时的顺序
注意，3.6 的 dict 是有序的，在此版本之前皆是无序
from collections import OrderedDict
d = OrderedDict()
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['aok'] = 4
for key in d:
print(key, d[key])
foo 1
bar 2
spam 3
aok 4
d = {}
d['foo'] = 1
d['bar'] = 2
d['spam'] = 3
d['aok'] = 4
for key in d:
print(key, d[key])
foo 1
bar 2
spam 3
aok 4
8. 字典的运算（求最大值，最小值，排序等等）
prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}
直接使用max函数，是对字典的key值进行操作
可以使用zip函数将键和值反转过来
注意：zip()函数创建的是一个只能访问一次的迭代器
min_price = min(zip(prices.values(), prices.keys()))
max_price = max(zip(prices.values(), prices.keys()))
min_price, max_price
((10.75, 'FB'), (612.78, 'AAPL'))
9. 查找两字典的相同点
可以简单的使用字典的keys()或者items()方法返回结果上执行集合操作
a = {
'x' : 1,
'y' : 2,
'z' : 3
}
b = {
'w' : 1,
'x' : 11,
'y' : 2
}
a.keys() & b.keys()
{'x', 'y'}
a.items() & b.items()
{('y', 2)}
字典的keys()方法返回一个展现键集合的键视图对象
字典的items()方法返回一个包含（键，值）对的元素视图对象
10. 删除序列相同元素并保持排序
def dedupe(items):
seen = set()
for item in items:
if item not in seen:
print('item is {}, seen is {}'.format(item, seen))
yield item
seen.add(item)
a = [1,3,4,5,6,1,3,5]
list(dedupe(a))
item is 1, seen is set()
item is 3, seen is {1}
item is 4, seen is {1, 3}
item is 5, seen is {1, 3, 4}
item is 6, seen is {1, 3, 4, 5}
[1, 3, 4, 5, 6]
def dedupe(items, key=None):
seen = set()
for item in items:
val = item if key is None else key(item)
print('item {} value {}'.format(item, val))
if val not in seen:
yield item
seen.add(val)
a = [ {'x':1, 'y':2}, {'x':1, 'y':3}, {'x':1, 'y':2}, {'x':2, 'y':4}]
list(dedupe(a, key = lambda d:(d['x'],d['y'])))
item {'x': 1, 'y': 2} value (1, 2)
item {'x': 1, 'y': 3} value (1, 3)
item {'x': 1, 'y': 2} value (1, 2)
item {'x': 2, 'y': 4} value (2, 4)
[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]
匿名函数： 将创建好的匿名函数通过一个变量去接收，使用变量去调用函数
简单使用set()方法构建一个集合，也可以实现消除重复元素，但是元素位置会被打乱
11. 命名切片
给切片命名，使得代码更加清晰可读
record = '....................100 .......513.25 ..........'
# 使用slice切片，并命名
SHARES = slice(20, 23)
PRICE = slice(31, 37)
cost = int(record[SHARES]) * float(record[PRICE])
cost
51325.0
12. 序列中出现次数最多的元素
collctions.Counter类，里面的most_common()
words = [
'look', 'into', 'my', 'eyes', 'look', 'into', 'my', 'eyes',
'the', 'eyes', 'the', 'eyes', 'the', 'eyes', 'not', 'around', 'the',
'eyes', "don't", 'look', 'around', 'the', 'eyes', 'look', 'into',
'my', 'eyes', "you're", 'under'
]
from collections import Counter
word_counts = Counter(words)
# 出现频率最高的3个单词
top_three = word_counts.most_common(3)
print(top_three)
[('eyes', 8), ('the', 5), ('look', 4)]
13. 通过某个关键字排序一个字典列表
operator.itemgetter函数
rows = [
{'fname': 'Brian', 'lname': 'Jones', 'uid': 1003},
{'fname': 'David', 'lname': 'Beazley', 'uid': 1002},
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001},
{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}
]
from operator import itemgetter
rows_by_fname = sorted(rows, key=itemgetter('fname'))
rows_by_uid = sorted(rows, key=itemgetter('uid'))
print(rows_by_fname)
print(rows_by_uid)
[{'fname': 'Big', 'lname': 'Jones', 'uid': 1004}, {'fname': 'Brian', 'lname': 'Jones', 'uid': 1003}, {'fname': 'David', 'lname': 'Beazley', 'uid': 1002}, {'fname': 'John', 'lname': 'Cleese', 'uid': 1001}]
[{'fname': 'John', 'lname': 'Cleese', 'uid': 1001}, {'fname': 'David', 'lname': 'Beazley', 'uid': 1002}, {'fname': 'Brian', 'lname': 'Jones', 'uid': 1003}, {'fname': 'Big', 'lname': 'Jones', 'uid': 1004}]
min(rows, key = itemgetter('uid'))
{'fname': 'John', 'lname': 'Cleese', 'uid': 1001}
14. 排序不支持原生比较的对象
operator.attagetter()函数
class User:
def __init__(self, user_id):
self.user_id = user_id
def __repr__(self):
return 'User({})'.format(self.user_id)
users = [User(23), User(3), User(99)]
from operator import attrgetter
sorted(users, key=attrgetter('user_id'))
[User(3), User(23), User(99)]
15. 通过某个字段将记录分组
itertools.groupby()
16. 过滤序列元素
最简单的办法是列表推导
17. 从字典中提取子集
最简单的办法是字典推导
prices = {
'ACME': 45.23,
'AAPL': 612.78,
'IBM': 205.55,
'HPQ': 37.20,
'FB': 10.75
}
p1 = {key: value for key, value in prices.items() if value > 200}
print(p1)
{'AAPL': 612.78, 'IBM': 205.55}
tech_names = {'AAPL', 'IBM', 'HPQ'}
p2 = {key: value for key, value in prices.items() if key in tech_names}
print(p2)
{'AAPL': 612.78, 'IBM': 205.55, 'HPQ': 37.2}
18. 映射名称到序列元素
collections.namedtuple()函数
19. 转换并同时计算数据
nums = [1, 2, 3, 4, 5]
s = sum(x * x for x in nums)
s
55
s = sum((x * x for x in nums)) # 显示的传递一个生成器表达式对象
s= sum((x * x for x in nums) # 更加优雅的实现方式，省略了括号
portfolio = [
{'name':'GOOG', 'shares': 50},
{'name':'YHOO', 'shares': 75},
{'name':'AOL', 'shares': 20},
{'name':'SCOX', 'shares': 65}
]
min_shares = min(s['shares'] for s in portfolio)
min_shares
20
20. 合成多个字典或映射
使用collections.ChainMap类