15分钟学Python 第18天：线性数据结构

news2025/10/28 3:39:50

Day18 ：线性数据结构

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

列表 (List)
元组 (Tuple)
字典 (Dictionary)
集合 (Set)
队列 (Queue)
栈 (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))