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官方手册

评论

还没有登陆?评论请先登陆注册

还没有评论,抢个沙发吧!

 联系方式 contact me

Github
Email
QQ
Weibo