AI教你学Python 第18天 ： 线性数据结构

Day18 ： 线性数据结构

线性数据结构是编程中非常基础且重要的概念，主要包括以下几种数据结构：

1. 列表 (List)
2. 元组 (Tuple)
3. 字典 (Dictionary)
4. 集合 (Set)
5. 队列 (Queue)
6. 栈 (Stack)

在本节中，我们将逐一探讨这些数据结构的特点、使用场景、操作方法以及示例代码。

---

1. 列表 (List)

1.1 概述

• 列表是Python中最常用的线性数据结构，可以存储多个项目。
• 列表是可变的，允许重复元素。

1.2 常用操作

操作	描述	示例代码
创建列表	使用中括号[]	my_list = [1, 2, 3, 4]
访问元素	用索引访问元素	my_list[0] # 1
修改元素	直接赋值	my_list[1] = 5
添加元素	使用append()	my_list.append(6)
删除元素	使用remove()	my_list.remove(2)
列表长度	使用len()	len(my_list) # 5

1.3 示例代码

# 创建和操作列表
my_list = [1, 2, 3, 4]
print("原始列表:", my_list)

# 添加元素
my_list.append(5)
print("添加元素后:", my_list)

# 删除元素
my_list.remove(2)
print("删除元素后:", my_list)

# 修改元素
my_list[0] = 10
print("修改元素后:", my_list)

# 访问元素
print("第一个元素:", my_list[0])
print("列表长度:", len(my_list))

1.4 代码运行流程图

+---------------------+
|     创建列表       |
|    my_list = [1, 2, 3, 4] |
+----------+----------+
           |
           v
+----------+----------+
|  print("原始列表:", my_list)|
+----------+----------+
           |
           v
+----------+----------+
|    添加元素        |
| my_list.append(5)  |
+----------+----------+
           |
           v
+----------+----------+
| print("添加元素后:", my_list) |
+----------+----------+

---

2. 元组 (Tuple)

2.1 概述

• 元组是不可变的序列，适用于存储固定的元素。

2.2 常用操作

操作	描述	示例代码
创建元组	使用小括号()	my_tuple = (1, 2, 3)
访问元素	用索引访问元素	my_tuple[0] # 1
合并元组	使用+	new_tuple = my_tuple + (4,)
元组长度	使用len()	len(my_tuple) # 3

2.3 示例代码

# 创建和操作元组
my_tuple = (1, 2, 3)
print("原始元组:", my_tuple)

# 访问元素
print("第一个元素:", my_tuple[0])

# 合并元组
new_tuple = my_tuple + (4,)
print("合并后元组:", new_tuple)

# 元组长度
print("元组长度:", len(my_tuple))

---

3. 字典 (Dictionary)

3.1 概述

• 字典是一种可变的键值对数据结构，用于存储数据（无序）。

3.2 常用操作

操作	描述	示例代码
创建字典	使用花括号{}	my_dict = {'a': 1, 'b': 2}
访问元素	用键访问值	my_dict['a'] # 1
添加或更新	直接赋值	my_dict['c'] = 3
删除元素	使用del	del my_dict['b']
字典长度	使用len()	len(my_dict) # 2

3.3 示例代码

# 创建和操作字典
my_dict = {'a': 1, 'b': 2}
print("原始字典:", my_dict)

# 访问元素
print("a的值:", my_dict['a'])

# 添加或更新元素
my_dict['c'] = 3
print("更新字典:", my_dict)

# 删除元素
del my_dict['b']
print("删除后字典:", my_dict)

# 字典长度
print("字典长度:", len(my_dict))

---

4. 集合 (Set)

4.1 概述

• 集合是无序的且不包含重复元素的线性结构，支持数学集合运算。

4.2 常用操作

操作	描述	示例代码
创建集合	使用set()或{}	my_set = {1, 2, 3}
添加元素	使用add()	my_set.add(4)
删除元素	使用remove()	my_set.remove(2)
集合长度	使用len()	len(my_set) # 3

4.3 示例代码

# 创建和操作集合
my_set = {1, 2, 3}
print("原始集合:", my_set)

# 添加元素
my_set.add(4)
print("添加后集合:", my_set)

# 删除元素
my_set.remove(2)
print("删除后集合:", my_set)

# 集合长度
print("集合长度:", len(my_set))

---

5. 队列 (Queue)

5.1 概述

• 队列是一种FIFO（先进先出）数据结构，常用于任务调度等场景。

5.2 常用操作

操作	描述	示例代码
创建队列	使用deque	from collections import deque
入队	使用append()	queue.append(1)
出队	使用popleft()	item = queue.popleft()
队列长度	使用len()	len(queue)

5.3 示例代码

from collections import deque

# 创建和操作队列
queue = deque()
print("原始队列:", queue)

# 入队
queue.append(1)
queue.append(2)
print("入队后队列:", queue)

# 出队
item = queue.popleft()
print("出队的元素:", item)
print("出队后队列:", queue)

# 队列长度
print("队列长度:", len(queue))

---

6. 栈 (Stack)

6.1 概述

• 栈是一种LIFO（后进先出）数据结构，适合用于撤销操作和递归等场景。

6.2 常用操作

操作	描述	示例代码
创建栈	使用list	stack = []
入栈	使用append()	stack.append(1)
出栈	使用pop()	item = stack.pop()
栈长度	使用len()	len(stack)

6.3 示例代码

# 创建和操作栈
stack = []
print("原始栈:", stack)

# 入栈
stack.append(1)
stack.append(2)
print("入栈后栈:", stack)

# 出栈
item = stack.pop()
print("出栈的元素:", item)
print("出栈后栈:", stack)

# 栈长度
print("栈长度:", len(stack))

---

7. 总结与练习

在本节中，我们涵盖了线性数据结构的基本概念和常用操作。接下来，您可以进行以下练习以加深理解：

7.1 练习题

1. 列表: 编写一个函数，接受一个列表并返回其中的最大值和最小值。
2. 元组: 编写一个函数，接受一个元组，返回元组中偶数位置上的元素。
3. 字典: 编写一个函数，接受一个字典，返回所有值的和。
4. 集合: 编写一个函数，接受两个集合，返回它们的交集。
5. 队列: 使用队列实现一个简单的任务调度程序，至少添加五个任务，并按顺序执行它们。
6. 栈: 实现一个基本的计算器，支持加法、减法、乘法和除法，使用栈来存储操作数。

通过这些练习，您将获得对线性数据结构的深入理解，进一步提升编程能力。

---

怎么样今天的内容还满意吗？再次感谢观众老爷的观看。
最后，祝您早日实现财务自由，还请给个赞，谢谢！

原文地址：https://blog.csdn.net/weixin_40780178/article/details/142447207

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！