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类