python进阶-内部数据结构和算法

本文内容整理自《Python Cookbook》，仅用作本人学习笔记，若侵犯原著权益请尽快联系本人。

---

1.将序列分解为单独变量

• 理解多重赋值
• 丢弃元素方法

data = ('Kevin', 50, 100, (2017, 2, 28))
name, shares, _, date = data

# _ 变量理解为忽略该位置元素

2.从任意长度的可迭代对象中分离元素

• 理解*args为取序列

record = ('Kevin', 50, 100, (2017, 2, 28))
name, *_,(*_,year) = record

# *args会贪婪的获取元祖成员

3.保存最后N个元素

• 掌握collections.deque用法
• deque从两端增删元素复杂度为O（1），普通列表从头部删除元素复杂度为O（N）

from collections import deque
q = deque(maxlen=5)
q.append((1,2))
q.append(4)
q.appendleft(3)
print(q)
q.pop()
q.popleft()
print(q)
##print
# deque([3, (1, 2), 4], maxlen=5)
# deque([(1, 2)], maxlen=5)

4.找到最大或最小的N个元素

• 熟悉堆模块heapq
• heapq.nlargest(n, list, key)
• heapq.nsmallest(n, list, key) #key为可自定义函数
• heapq.heapify(list) #堆化，当list数目较小时比上面快
• max(),min()在取单个元素时较快
• 若待取元素数量接近于列表大小，则先排序再切片性能最好（nlargest和nsmallest也会自动判断这个问题）

5.实现优先级队列

• heapq.heappush(list,item)
• heapq.heappop(list)
• 注意默认生成的堆是以优先级小到大的顺序排序的

import heapq

class priorityList(object):
    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]

if __name__ == '__main__':
    q = priorityList()
    q.push(5,2)
    q.push(3,1)
    q.push(7,1)
    print(q.pop())
    print(q._queue)

6.生成一对多字典

• collections.defaultdict（type）会默认初始化字典key对应的值为“空”

from collections import defaultdict

d = defaultdict(list)
for key, value in pairs:
    d[key].append(value)

7.让字典保持有序

• collections.OrderedDict()

from collections import OrderedDict
d = OrderedDict()
##然后当字典用

8.与字典有关的计算问题

• zip(list1,list2)生成一个迭代器内容为list1与list2组合成的元组

min(zip(d.values(), d.keys()))
max(zip(d.values(), d.keys()))

9.两个字典的相同点

• dict.keys()返回keys-view对象
• dict.items()返回item-view对象
• 以上的对象可以进行集合操作 交集 |，差集 -，并集 &

a = {'a':1,'b':2}
c = {key:a[key] for key in a.keys() - ('b')}
# 字典解析

10.序列去重并顺序不变

• set()集合
• yield
• lambda

def depute(items, key=None):
    s = set()
    for item in items:
        val = item if key == None else key(item)
        if val not in s:
            yield item
            s.add(val)

c = [{'x':1,'y':2},{'x':1, 'y':3},{'x':2, 'y':3}]
print(list(depute(c, lambda d:(d['x']))))

11.对切片命名

• slice()可用于切片操作

PRICE = slice(2,4)
record = 'AA123456567899'
cost = int(record[PRICE]) * 2

12.找出序列中出现次数最多的元素

• collections.Counter()

words = ['i','am','i']
word_counts = Counter(words)
print(word_counts.most_common(3))
word_counts['i'] += 1
morewords = ['i','was']
word_counts.update(morewords)

13.通过公共键堆字典列表排序

• operator.itemgetter

from operator import itemgetter
sorted(d, key=itemgetter('lname'))

14.对不原生支持比较的对象排序

• sort的key参数
• lambda
• operator.attrgetter()

15.根据字段将字典列表分组

• itertools.groupby() and sort()
• collections.defaultdict()

from operator import itemgetter
from itertools import groupby

rows.sort(key=itemgetter('date'))
for date, items in groupby(rows, key=itemgetter('date')):
    for i in items:
        print(i)

16.筛选序列的元素

• 列表推导式[ n if n>10 else 0 for n in xrange(20)]
• 生成器表达式(n if n>10 else 0 for n in xrange(20))
• filter(function, list)
• itertools.compress(可迭代对象， 布尔序列)

17.从字典中提取子集

• 字典推导式{key:value for key,value in prices.items() if value > 200}

18.将名称映射到序列的元素中

• collections.namedtuple()命名元组

from collections import namedtuple

Subscribe = namedtuple('Subscribe',['addr', 'joined'])
sub = Subscribe('openex@qq.com','2016/1/1')
sub = sub._replace(joined=2) 
print(sub.addr)
print(sub.joined)

19.同时对数据做转换和换算

• 在函数参数中使用生成器表达式（函数指sum(),min()等可传入迭代元素函数）
• 注意max(生成器表达式) 比 max( [生成器表达式] ) 省内存

d= [{'name':'kevin', 'price':1},{'name':"openex", 'price':2}]
print(max(s['price'] * 2 for s in d))
###输出: 4
print(max(d, key=lambda s:s['price'] * -1) )
###输出: {'name': 'kevin', 'price': 1}

20.将多个字典映射为一个字典

• collections.ChainMap(*maps)
• map.update(map)
• ChainMap,在修改和查询时默认操作第一个字典