《Python Cookbook v3.0.0》Chapter1 数据结构和算法

感谢：

https://github.com/yidao620c/python3-cookbook

如有侵权，请联系我整改。

本文章节会严格按照原书（以便和原书对照，章节标题可能会略有修改），内容会有增删。

1.1 解引、解引赋值

1.1.1 解引

通过*可以解引（书中翻译为解压，还是解引更舒服些），

示例，

>>> (4,5)

(4, 5)

>>> print(*(4,5))

4 5

>>> str='akdfjasl'

>>> str

'akdfjasl'

>>> print(*str)

a k d f j a s l

>>> d={'a':1,'b':2}

>>> d

{'a': 1, 'b': 2}

>>> print(*d)

a b

1.1.2 解引赋值

可以用占位符，丢弃不要的数据。

示例，

>>> data = [ 'ACME', 50, 91.1, (2012, 12, 21) ]

>>> _, shares, price, _ = data

>>> shares

50

>>> price

91.1

>>>

通过*可以赋值多个变量，

实例，

>>> *trailing, current = [10, 8, 7, 1, 9, 5, 10, 3]

>>> trailing

[10, 8, 7, 1, 9, 5, 10]

>>> current

3

1.3 只保留N个元素

from collections import deque

示例，

def search(lines, pattern, history=5):

  previous_lines = deque(maxlen=history)

  for line in lines:

    if pattern in line:

      yield line, previous_lines

    previous_lines.append(line)

1.4 最大/最小的N个元素

import heapq

示例，

>>> 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'])

>>> cheap

[{'name': 'YHOO', 'shares': 45, 'price': 16.35}, {'name': 'FB', 'shares': 200, 'price': 21.09}, {'name': 'HPQ', 'shares': 35, 'price': 31.75}]

堆数据结构最重要的特征是 heap[0] 永远是最小的元素。并且剩余的元素可以很

容易的通过调用 heapq.heappop() 方法得到，该方法会先将第一个元素弹出来，然后

用下一个最小的元素来取代被弹出元素（这种操作时间复杂度仅仅是 O(log N))

示例，

>>> nums = [1, 8, 2, 23, 7, -4, 18, 23, 42, 37, 2]

>>> import heapq

>>> heap = list(nums)

>>> heapq.heapify(heap)

>>> heap

[-4, 2, 1, 23, 7, 2, 18, 23, 42, 37, 8]

>>> heapq.heappop(heap)

-4

>>> heapq.heappop(heap)

1

>>> heapq.heappop(heap)

2

1.5 优先级队列

怎样实现一个按优先级排序的队列？并且在这个队列上面每次 pop 操作总是返回

优先级最高的那个元素

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]

注意这个index，作用是当item本身不支持比较的时候，在priority相同时，可以通过index

比较，即，按照插入顺序排序

1.6 multidict（多值字典）

from collections import defaultdict

比如，

d = {

  'a' : [1, 2, 3],

  'b' : [4, 5]

}

e = {

  'a' : {1, 2, 3},

  'b' : {4, 5}

}

值可用list、set等存储

d = defaultdict(list)

d['a'].append(1)

d['a'].append(2)

d['b'].append(4)

d = defaultdict(set)

d['a'].add(1)

d['a'].add(2)

d['b'].add(4)

用defaultdict维护非常便利

1.7 OrderedDict（顺序字典）

from collections import OrderedDict

如果想控制字典顺序，可以用OrderedDict

[TODO]

1.8 字典运算

可以用zip打包成元组，

prices = {

  'ACME': 45.23,

  'AAPL': 612.78,

  'IBM': 205.55,

  'HPQ': 37.20,

  'FB': 10.75

}

min_price = min(zip(prices.values(), prices.keys()))

# min_price is (10.75, 'FB')

也可以用key，

min(prices, key=lambda k: prices[k])

1.9 字典的异同

可以用keys()，items()方法

a = {

  'x' : 1,

  'y' : 2,

  'z' : 3

}

b = {

  'w' : 10,

  'x' : 11,

  'y' : 2

}

# Find keys in common

a.keys() & b.keys() # { 'x', 'y' }

# Find keys in a that are not in b

a.keys() - b.keys() # { 'z' }

# Find (key,value) pairs in common

a.items() & b.items() # { ('y', 2) }

# Make a new dictionary with certain keys removed

c = {key:a[key] for key in a.keys() - {'z', 'w'}}

# c is {'x': 1, 'y': 2}

注意，字典的values()并不支持上述操作，原因是，值并不一定是相同的形式，

确切的讲，值中的元素个数可能是不同的；而键虽然形式也可能不同，但个数永远是1

1.10 删除相同元素，但保持原顺序

set结合yield

def dedupe(items, key=None):

  seen = set()

  for item in items:

    val = item if key is None else key(item)

    if val not in seen:

      yield item

      seen.add(val)

加key方法的原因是，items并不一定是hashable的，比如dict

示例，

>>> 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'])))

[{'x': 1, 'y': 2}, {'x': 1, 'y': 3}, {'x': 2, 'y': 4}]

>>> list(dedupe(a, key=lambda d: d['x']))

[{'x': 1, 'y': 2}, {'x': 2, 'y': 4}]

注意，使用set()构造，或者使用set.add()都会改变顺序，后者还会排序

1.11 切片

>>> items = [0, 1, 2, 3, 4, 5, 6]

>>> a = slice(2, 4)

>>> items[a] = [10,11]

>>> del items[a]

1.12 次数最多的元素

from collections import Counter

示例，

word_counts = Counter(words)

top_three = word_counts.most_common(3)

# Outputs [('eyes', 8), ('the', 5), ('look', 4)]

其中words可以是list、tupple，当然set也可以，不过没有意义

Counter()返回的结果类似字典，形如，

Counter({'eyes':8,'the':5})

实际上，它的类型是<class 'collections.Counter'>

注意，虽然它看起来像字典，但某些操作和字典不同，比如，

update，在dict中，update意味着新值覆盖旧值，而在Counter中，

update意味着新增计数，在原有基础上增加

>>> d

{'a': 1, 'b': 2}

>>> d2

{'a': 1, 'b': 3}

>>> d.update(d2)

>>> d

{'a': 1, 'b': 3}

>>> w=dict(d)

>>> w

{'a': 1, 'b': 3}

>>> cw=Counter(w)

>>> cw

Counter({'b': 3, 'a': 1})

>>> w2=dict(w)

>>> cw.update(w2)

>>> cw

Counter({'b': 6, 'a': 2})

同时，Counter的update，入参也可以是另一个Counter，

除了update，Counter还支持+、-运算

1.13 通过关键字给字典列表排序

from operator import itemgetter

示例，

rows_by_lfname = sorted(rows, key=itemgetter('lname','fname'))

itemgetter的效率比lambda高，结果是等价的

1.14 通过关键字给结构体列表排序

这里和1.13的区别是，上面是dict，这里是class，

from operator import attrgetter

示例，

by_name = sorted(users, key=attrgetter('last_name', 'first_name'))

不限于sorted，min，max都可以用，同itemgetter一样，效率比lamdba高，

至于，为何class不能用itemgetter，是因为key必须是一个callable对象，即，

可()调用的，itemgetter一个class的属性，无法创建这样一个对象

1.15 通过某个字段分组

比如一堆记录，按日期进行分组。

from itertools import groupby

注意，groupby会按照顺序处理，所以在使用前，需要先进行排序

示例，

rows = [

  {'address': '5412 N CLARK', 'date': '07/01/2012'},

  {'address': '5148 N CLARK', 'date': '07/04/2012'},

  {'address': '5800 E 58TH', 'date': '07/02/2012'},

  {'address': '2122 N CLARK', 'date': '07/03/2012'},

  {'address': '5645 N RAVENSWOOD', 'date': '07/02/2012'},

  {'address': '1060 W ADDISON', 'date': '07/02/2012'},

  {'address': '4801 N BROADWAY', 'date': '07/01/2012'},

  {'address': '1039 W GRANVILLE', 'date': '07/04/2012'},

]

rows.sort(key=itemgetter('date'))

for date, items in groupby(rows, key=itemgetter('date')):

  print(date)

  for i in items:

    print(' ', i)

07/01/2012

  {'date': '07/01/2012', 'address': '5412 N CLARK'}

  {'date': '07/01/2012', 'address': '4801 N BROADWAY'}

07/02/2012

  {'date': '07/02/2012', 'address': '5800 E 58TH'}

  {'date': '07/02/2012', 'address': '5645 N RAVENSWOOD'}

  {'date': '07/02/2012', 'address': '1060 W ADDISON'}

groupby返回的是一个迭代器，内容类似一个tupple

1.16 列表推导

示例，

>>> mylist = [1, 4, -5, 10, -7, 2, 3, -1]

>>> import math

>>> [math.sqrt(n) for n in mylist if n > 0]         //过滤，并计算

>>> clip_neg = [n if n > 0 else 0 for n in mylist]  //值替代

>>> more5 = [n > 5 for n in counts]                 //返回true、false list

其中过滤，也可以用filter实现

true、false list可以结合from itertools import compress的compress来压缩表项

1.17 字典推导

prices = {

  'ACME': 45.23,

  'HPQ': 37.20,

  'FB': 10.75

}

p1 = {key: value for key, value in prices.items() if value > 200}

tech_names = {'AAPL', 'IBM', 'HPQ', 'MSFT'}

p2 = {key: value for key, value in prices.items() if key in tech_names}

推导，比dict()构造效率高

1.18 命名元组

from collections import namedtuple

不再通过下标访问，而是通过类似字典的方式访问

虽然是tupple，但提供了_replace方法来修改元素内容

示例，

Stock = namedtuple('Stock', ['name', 'shares', 'price', 'date', 'time'])

stock_prototype = Stock('', 0, 0.0, None, None)

# Function to convert a dictionary to a Stock

def dict_to_stock(s):

  return stock_prototype._replace(**s)

>>> a = {'name': 'ACME', 'shares': 100, 'price': 123.45}

>>> dict_to_stock(a)

Stock(name='ACME', shares=100, price=123.45, date=None, time=None)

这里的字典解引很有意思，它等效于

stock_prototype._replace(name='acmd',shares=999)

1.19 聚集函数的推导

原文标题是，转换并同时计算数据。但看起来，形式类似推导。

聚集函数，sum、min、max等。

示例，

s = sum(x * x for x in nums)

min_shares = min(s['shares'] for s in portfolio)

min、max中，效果等效使用key

1.20 合并多个字典或映射

前文有讲过普通字典dict以及Counter的update,

这里是另一种形式，

from collections import ChainMap

从名字上，它就是chain，链，将dict链起来，

当多个dict有键值重复时，返回首个值