高阶Python----常用的数据结构与算法

前言

高阶Python系列文章是笔者想要突破自己目前的技术生涯瓶颈而作，不具有普适性。本文主要是介绍Python在数据结构和算法中常用的函数。这也是数据分析领域必备知识点。

也不是特地为了某些读者而作，想着提高自己的同时，能方便他人就更好了。懂分享的人，一定会快乐！

常用的四个模块应该是：collections，heapq，operator，itertools。其中，collections是日常工作中的重点/高频模块。

另外，正确学习这些技巧的姿势应该是：打开电脑，实现数遍，尝试不同解决办法和编程方式。

注：所有代码在Python3.5.1中测试。

collections模块

deque

from collections import deque

"""学习固定长度的deque"""
q = deque(maxlen=5)    # 创建一个固定长度的队列,当有新记录加入已满的队列时，会自动移除最老的记录。

q.append(1)    # 添加元素

"""学习不固定长度的deque，从队列两端添加或弹出元素的复杂度为o(1)."""
q = deque()    # 创建一个无界限的队列，可以在队列两端执行添加和弹出操作

q.append(1)    # 添加元素

q.appendleft(2)    # 向左边添加一个元素

q.pop()    # 弹出队列尾部的记录

q.popleft()    # 弹出队列头部的记录

defaultdict

用于创建有多个value对应一个key的字典。比如创建value可重复(list存储)的该字典：dic = {“a”: [1, 2 , 2, 3, 3], “b”: [1, 2]}。或创建value不可重复（set存储）的该字典：dic = {“a”: { 1, 2, 3}, “b”: {1, 2} }

from collections import defaultdict

d_list = defaultdict(list)    # list
d['a'].append(1)
d['a'].append(2)
d['a'].append(2)
d['a'].append(3)
d['a'].append(3)

d_set = defaultdict(set)    # set
d['a'].add(1)
d['a'].add(2)
d['a'].add(3)

OrderedDict

OrderedDict内部维护了一个双向链表，会根据元素加入的顺序来排列键的位置。一个新加入的元素被放在链表的末尾，然后，对已存在的键做重新赋值但不会改变键的顺序。作用：严格控制元素初始添加的顺序。

from collections import OrderedDict

d = OrderedDict()    # 实例化
d['a'] = 1
d['b'] = 2

Counter

作用：统计可哈希的序列中元素出现的次数。（可哈希：一种特性，具备该特性的对象在其生命周期内必须不可变。在Python中，有整数、浮点数、字符串、元组。）

from collections import Counter

test = ['a', 'a', 'b', 'c', 'b', 'd', 'a', 'c', 'e', 'f', 'd']    # 测试集

word_count = Counter(test)    # 调用，传参

print(word_count)    # 输出：Counter({'a': 3, 'b': 2, 'c': 2, 'd': 2, 'f': 1, 'e': 1})

word_count.most_common(3)    # 获取出现频次前3的单词

word_count['a']    # 获取某个单词的频次

Counter还可以将两个数据集进行数学运算。如下:

from collections import Counter

test = ['a', 'a', 'b', 'c', 'b', 'd', 'a', 'c', 'e', 'f', 'd']    # 测试集

test1 = ['a', 'b', 'c', 'd', 'e', 'f']    # 另一测试集

a = Counter(test)    # 统计test
b = Counter(test1)    # 统计test1

print(a)    # 输出：Counter({'a': 3, 'b': 2, 'c': 2, 'd': 2, 'f': 1, 'e': 1})
print(b)    # 输出：Counter({'b': 1, 'a': 1, 'f': 1, 'c': 1, 'd': 1, 'e': 1})

c = a + b    # 统计两个数据集
print(c)    # 输出：Counter({'a': 4, 'b': 3, 'c': 3, 'd': 3, 'f': 2, 'e': 2})

c = a - b    # Counter({'a': 2, 'b': 1, 'c': 1, 'd': 1})
c = b - a    # Counter()

heapq模块

heapq 模块提供了堆算法。heapq是一种子节点和父节点排序的树形数据结构。这个模块提供heap[k] <= heap[2*k+1] and heap[k] <= heap[2*k+2]。为了比较不存在的元素被人为是无限大的。堆最重要的特性就是heap[0]总是最小的那个元素。

nlargest/nsmallest

import heapq

"""简单的数据集"""
numbers = [11,22,33,-9,0,5,-11]    # 测试数据集

heapq.nlargest(3,numbers)    # 获得前3最大的元素

heapq.nsmallest(3,numbers)    # 获得前3最小的元素

"""复杂的数据集"""
people_info = [
{'name': "guzhenping", 'age':19, 'score':90},
{'name': "xiao gu", 'age':21, 'score':100}
]

max_age = heapq.nlargest(1,people_info, key=lambda people_info: people_info['age'])    # 获取最大年龄的个人

min_score = heapq.nsmallest(1, people_info, key=lambda info: info['score'])    # 获取最低分数的个人

heapify

作用：对元素进行堆排序。保证最小的元素在为第一个元素。

import heapq
nums = [11, 22, 33, 44, 0, -1,20,-12]     # 测试数据集

heapq.heapify(nums)    # 转化成堆排序的列表

print(nums)    # 输出：[-12, 0, -1, 22, 11, 33, 20, 44]。

heapq.heappop(nums)    # 弹出最小的元素，同时让第二小的元素变成第一小

heappop/heappush

heappop和heappush是在堆排序中常用的方法。heapq.heappop()作用：将第一个元素（最小的）弹出，然后将第二小的元素放在第一个。heapq.heappush()是插入操作。两者复杂度o(logN),N代表堆中元素的数量。

以一个优先级队列进行举例：

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):
data = heapq.heappop(self._queue)
print(data)
return data[-1]

if __name__ == '__main__':
q = PriorityQueue()

q.push("guzhenping", 1)
q.push("xiao gu", 3)
q.push("xiao ping",1)

# 打印测试
while len(q._queue) != 0:
print(q.pop())

结语

随便整理一下，发现内容已经很多了。如果你没有见过上述的常用函数，可以好好学习一下。

这里还有很多没说的内容：

operator.itemgetter()和operator.attrgetter()的使用，以及同lambda函数的区别。

collections中的namedtuple()、ChainMap()的使用

……

希望以后能再继续。

2年Python开发经验，但是，还有很多原理不懂。以前的不求甚解，变成了现在的知识瓶颈。所以，来啊，快活啊，一起进阶Python啊！

有兴趣和我一起提高Python技术的同学，欢迎加入微信群–高阶Python打卡群。扫码进入：



也欢迎关注我的微信公众平台号：