Python数据结构

1.Lists

列表(Lists)是一种十分有用的数据结构，介绍一下Lists的常用方法。

lst = [1,2,3,4,5]   # 列表使用[]声明，元素之间使用逗号分割
# list.append(x) 向列表尾部添加一个元素，等价于a[len(a):] = x
lst.append(6)   # lst:[1, 2, 3, 4, 5, 6]
# list.extend(iterable) 将可迭代元素的每个元素依次添加到列表尾部
lst.extend([7,8])   # lst:[1, 2, 3, 4, 5, 6, 7, 8]
# list.insert(i,x) 向列表的第i个位置上插入元素x
lst.insert(0,0)   # lst:[0, 1, 2, 3, 4, 5, 6, 7, 8]
# list.remove(x) 删除列表中第一个等于x的元素，如果没有这种元素会引发ValueError
lst.remove(0)  # lst:[1, 2, 3, 4, 5, 6, 7, 8]
# list.pop([i]) 移除列表中第i个元素并返回这个元素，[]表示可选参数，若没有给出i，则删除并返回列表中最后一个元素
lst.pop(6)  # 返回7，lst：[1, 2, 3, 4, 5, 6, 8]
lst.pop()   # 返回8，lst:[1, 2, 3, 4, 5, 6]
# list.reverse()  将列表的元素反转
lst.reverse()   # lst：[6, 5, 4, 3, 2, 1]
# list.index(x[,start[,end]]) 返回下标从0开始的第一个值等于x元素的下标，如果没有这个元素，则引发ValueError
# start,end可选参数使用了切片的语法，用来限制索引范围
lst.index(5)   # 返回1
# list.count(x) 返回列表中x出现的次数
lst.count(2)  # 返回1
# list.sort(key=None,reverse=False) 将列表元素从小到大排序，排序的自定义参数可以参考sorted()的参数
lst.sort()  #lst：[1, 2, 3, 4, 5, 6]
# list.copy()  返回列表的一个浅复制，等价于a[:]
# 浅复制不会复制子对象，所以，复制出来的对象和原对象并非完全不想关。
# 深复制会递归的克隆子对象，所以，复制出来的对象和原对象完全不相关，但是深复制比浅复制会慢一些。
lst.copy()   # 返回[1, 2, 3, 4, 5, 6]
# list.clear() 清空列表，等价于del a[:]
lst.clear()  # lst:[]

像insert,remove,sort这些只修改列表的方法没有返回值，它们默认返回None，这是Python中可变数据结构的设计原则。

1.1 使用列表实现栈

列表提供的方法使得很适合用来实现栈，栈是一种后进先出的数据结构。可以使用list.append()方法模拟入栈操作，使用list.pop()模拟出栈操作。

stack = [1,2,3]   # 声明栈
stack.append(4)   # 入栈 stack:[1, 2, 3, 4]
stack.pop()  # 出栈，返回4  stack:[1, 2, 3]
len(stack)   # 返回3 获取栈中数据元素的个数

1.2 使用列表实现队列

使用列表也可以实现队列操作，队列是一种先进先出的数据结构。可以使用list.append()模拟入队列操作，使用list.pop(0)模拟出队列操作。

queue = [1,2,3]   # 声明队列
queue.append(4)  # 入队列 queue:[1, 2, 3, 4]
queue.pop(0)  # 出队列，返回1 queue:[2, 3, 4]
len(queue)   # 返回3 获取队列中数据元素的个数

不过实现队列可以使用collections.deque，这是python内置的，在实现队列的操作上更加高效。

from collections import deque  # 引入deque库
queue = deque([1,2,3])  # 声明队列
queue.append(4)  # 入队列，queue:deque([1, 2, 3, 4])
queue.popleft()  # 出队列，返回1  queue:deque([2, 3, 4])
len(queue)   # 返回3 获取队列中数据元素的个数

最近在遍历一个多层嵌套的json数据时使用到了BFS，这时需要使用队列进行实现，这里给出一个BFS的示例。

from collections import deque  # 引入deque库
data = {...}   # 这里假设遍历一个多层嵌套的字典
queue = deque([])   # 声明队列
queue.append(start)   # 根结点入队列
while len(queue) > 0:  # 当队列非空时进行操作
	top = queue.popleft()   # 队首元素出队列
	# ... 进行BFS的一些相关操作
	for child in top['child']:   # 将当前节点所有子节点入队列
		queue.append(child)

1.3 del语句

del语句可以删除队列中的指定元素，同时也可以删除一个切片或清空这个列表。

a = [1,2,3,4,5,6]
del a[0]   # 删除元素a[0] ,a:[2, 3, 4, 5, 6]
del a[1:3]  # 删除a[1:3],a:[2, 5, 6]
del a[:]  # 清空列表,a:[]

2.Tuples and Sequences

列表和字符串许多相同的属性，比如索引和切片，它们都属于序列数据类型。元组(tuple)也是一种标准的序列数据类型。

# 元组包含一些使用逗号分割的值
t = 1,2,3,4,5   # 声明一个元组，t:(1, 2, 3, 4, 5)
a,b,c,d,e = t  # sequence unpacking,将元组的元素依次赋给每个变量
print(t[0])   # 元组支持索引，输出1
u = t , (6,7)  # 元组支持嵌套 u:((1, 2, 3, 4, 5), (6, 7))
# 不过元组的元素是不可变的
t[0] = 8  # 元组元素不可以进行赋值，否则会引发TypeError
# TypeError: 'tuple' object does not support item assignment
# 不过元组可以包含可变对象
v = ([1,2,3],[3,2,1])
v[0][1] = 3   # 元组中的可变对象的元素可以进行赋值

empty = ()  # 声明一个空元组使用'()'
len(empty)   # 空元组长度，返回0
single = "hello",  # 声明一个只有一个元组的元组，需要在结尾加逗号
len(single)   # 返回1

3.Sets

集合(set)是一种不包含重复元素的无序数据结构，集合对象同样也支持交集、并集、差集等数学操作。使用{}或set()可以声明集合，不过空集合只能使用set()声明，因为{}表示空字典。

nset = {1,2,1,2,3,1,3}  # 声明集合
print(nset)   #输出{1, 2, 3} ，集合中不含重复元素
# 使用in可以检查一个元素是否在集合中
1 in nset   # 返回True
5 in nset   # 返回False

# 演示一下集合的数学运算
a = set([1,2,3])  # 使用set()也可以生成集合，a:{1, 2, 3}
b = set([2,3,4])  # b:{2, 3, 4}
a - b  # 返回{1}, 差集：在a且不在b中的元素
a | b  # 返回{1, 2, 3, 4}，并集：在a或在b中的元素
a & b  # 返回{2, 3}，交集：在a且在b中的元素
a ^ b  # 返回{1, 4}，在a或在b但不同时在a和b中的元素

4.Dictionaries

字典(dictionary)是Python中的另一有用的数据类型。字典使用键值(key)进行索引，键值可以是字符串、数字等不可变类型的数据，只包含字符串、数字和元组的元组也可以做为键值，直接或间接包含可变对象的元组不可以作为键值。可以把字典看为一组键值对(key:value)，其中键是唯一的，用于索引。空字典使用{}声明，使用[]可以向字典中添加键值对。

tel = {'jack':123,'rose':567}  # 声明一个字典
tel['mike'] = 666   # 使用[]为字典添加一个键值对
print(tel) # 输出 {'jack': 123, 'rose': 567, 'mike': 666}
tel['jack']  # 输出123 ，使用[key]获取字典中对应的值
del tel['rose']  # 使用del删除一个键值对
print(tel)  # 输出 {'jack': 123, 'mike': 666}
# list(dic)返回字典的键组成的列表，顺序为插入键值对的顺序
list(tel)  # 返回 ['jack', 'mike']
sorted(tel)  # 返回 ['jack', 'mike']，返回排序后键列表
# 使用关键字'in'可以检查字典中是否有相应的key
'jack' in tel  # 返回 True
'rose' in tel  # 返回False
# 使用dict()构造函数可以直接以键值对形式构造字典
dict([('a',1),('b',2)])   # 返回 {'a': 1, 'b': 2}
# dic.get(key,default) 可以获取字典中键为key对应的值，若key不存在会返回default，而不会报错
tel.get('jack',0)   # 返回 123
tel.get('rose',0)   # 返回 0

5.对不同数据结构的遍历方法

5.1 遍历字典

遍历字典时如果需要同时获取键和值，可以使用items()方法。

tel = {'jack': 123, 'mike': 666}  # 声明字典
for key,val in tel.items():  # 遍历字典，key表示键，val表示值
     print(key,val)
# 输出内容如下：
# jack 123
# mike 666

5.2 遍历列表

使用in关键字可以直接遍历列表的元素。

lst = ['a','b','c']  # 声明列表
for l in lst:   # 遍历列表，l为列表中 的元素
	print(l)
# 输出内容如下：
# a
# b
# c

若遍历希望同时获取列表的下标和值，需要使用enumerate()函数。

lst = ['a','b','c']  # 声明列表
for index,val in enumerate(lst): # 遍历列表,index为索引,val为值
	print(index,val)
# 输出内容如下：
# 0 a
# 1 b
# 2 c

若希望同时遍历两个或更多的序列，这些条目可以使用zip()函数组合起来。

questions = ['name','age','favorite color']
answers = ['jack',20,'green']
for q,a in zip(questions,answers):  # 同时遍历两个列表
	print('What is your {0}? It is {1}.'.format(q,a))
# 输出内容如下：
# What is your name? It is jack.
# What is your age? It is 20.
# What is your favorite color? It is green.

逆序遍历一个序列，可以首先写出正向的序列，然后使用reversed()函数。

for i in reversed(range(1,5,2)):
	print(i)
# 输出内容如下：
# 3
# 1

希望遍历一个排序的序列，可以使用sorted()函数，其不会改变原序列。

lst = [3 ,5 ,2 ,1]
for l in sorted(lst):
	print(l)
# 输出内容如下
# 1
# 2
# 3
# 5
lst   # 返回 [3, 5, 2, 1]

refer: Python官方手册