第五章：Python 数据结构：列表、元组与字典(一)

Python 列表、元组与字典详解：从基础到实战

---

系列文章目录

第一章 Python语言基础与应用领域
第二章 Python 开发环境搭建与工具配置（一）
第二章 Python开发环境搭建与工具配置（二）
第三章：Python基本语法规则详解（一）
第三章：Python基本语法规则详解（二）

---

---

在 Python 编程中，数据结构是处理数据的核心。上一篇我们学习了数字和字符串，今天这篇文章将深入讲解列表、元组和字典这三种常用数据结构。

一、列表（List）：灵活的有序集合

1.1 列表的定义与创建

列表是 Python 中最常用的数据结构之一，它是可变、有序的元素集合，能容纳任意类型的数据（包括数字、字符串甚至其他列表）。

创建列表的两种主要方式：

# 直接赋值创建
empty_list = []  # 空列表
numbers = [1, 2, 3, 4, 5]  # 整数列表
mixed = [1, "apple", 3.14, True]  # 混合类型列表
nested = [[1, 2], [3, 4], [5, 6]]  # 嵌套列表（列表里包含列表）# 使用 list() 函数创建
from_tuple = list((1, 2, 3))  # 从元组转换
from_str = list("hello")  # 从字符串转换，结果为 ['h','e','l','l','o']

列表的核心特点：

• 有序性：元素按插入顺序排列，每个元素有固定位置

• 可变性：支持增删改操作

• 包容性：能包含不同类型数据

• 动态性：大小可自动调整，无需预先定义长度

1.2 列表的索引与切片

索引是访问列表元素的基本方式，从 0 开始计数，也支持负索引（从 -1 开始表示末尾）：

fruits = ["apple", "banana", "cherry", "date"]
print(fruits[0])   # 输出：apple（第一个元素）
print(fruits[-1])  # 输出：date（最后一个元素）

切片用于提取子列表，语法为 list[start:end:step]：

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(numbers[2:6])   # [2, 3, 4, 5]（从索引2到5，不包含6）
print(numbers[:5])    # [0, 1, 2, 3, 4]（从开头到索引4）
print(numbers[5:])    # [5, 6, 7, 8, 9]（从索引5到结尾）
print(numbers[::2])   # [0, 2, 4, 6, 8]（步长为2，间隔取元素）
print(numbers[::-1])  # [9,8,7,6,5,4,3,2,1,0]（逆序排列）

1.3 列表常用操作方法

添加元素：

• append()：在末尾添加单个元素

• insert(index, value)：在指定位置插入元素

• extend()：合并另一个列表的所有元素

fruits = ["apple", "banana"]
fruits.append("cherry")  # ["apple", "banana", "cherry"]
fruits.insert(1, "orange")  # ["apple", "orange", "banana", "cherry"]
fruits.extend(["grape", "mango"])  # 合并列表

删除元素：

• remove(value)：删除第一个匹配的元素

• pop(index)：删除并返回指定位置元素（默认最后一个）

• clear()：清空列表

fruits = ["apple", "banana", "cherry"]
fruits.remove("banana")  # ["apple", "cherry"]
removed = fruits.pop(0)  # removed 为 "apple"，列表变为 ["cherry"]

其他常用方法：

• index(value)：返回元素第一次出现的索引

• count(value)：统计元素出现次数

• sort()：原地排序（修改原列表）

• reverse()：原地反转列表

• copy()：复制列表（避免引用问题）

1.4 常见错误及解决

1. 索引越界：访问不存在的索引会报错

# 错误示例
fruits = ["apple", "banana"]
print(fruits[2])  # IndexError
# 解决：用 len() 检查长度，确保索引在 0~len-1 范围内

1. 混淆 append () 和 extend ()：

list1 = [1, 2, 3]
list2 = [4, 5]
list1.append(list2)  # [1, 2, 3, [4, 5]]（添加整个列表为元素）
list1.extend(list2)  # [1, 2, 3, 4, 5]（添加列表中的元素）

1. 列表复制陷阱：直接赋值是引用而非复制

# 错误示例
a = [1, 2, 3]
b = a  # b 和 a 指向同一个列表
b[0] = 0  # a 也会变成 [0, 2, 3]
# 解决：使用 copy() 或切片
b = a.copy()
b = a[:]  # 切片复制

二、元组（Tuple）：不可变的有序序列

2.1 元组的定义与特点

元组与列表类似，但核心区别是不可变性（创建后不能修改）。用圆括号 () 定义：

empty_tuple = ()  # 空元组
numbers = (1, 2, 3, 4, 5)
mixed = (1, "apple", 3.14, True)
nested = ((1, 2), (3, 4))  # 嵌套元组# 用 tuple() 函数创建
from_list = tuple([1, 2, 3])  # 从列表转换

注意：创建单元素元组必须加逗号，否则会被当作普通括号：

single_tuple = (5,)  # 正确的单元素元组
not_tuple = (5)      # 这是整数 5，不是元组

元组的特点：

• 不可变性：元素不能修改、添加或删除

• 有序性：支持索引和切片（同列表）

• 高效性：比列表占用内存更少，操作速度更快

• 安全性：保护数据不被意外修改

2.2 元组与列表的区别

特性	列表（List）	元组（Tuple）
定义符号	[] 或 list()	() 或 tuple()
可变性	可变（支持增删改）	不可变（创建后不能修改）
方法数量	丰富（append/insert 等）	有限（主要是 count/index）
内存占用	较高	较低
适用场景	需要频繁修改数据的场景	数据固定不变的场景

2.3 元组的常用操作

虽然元组不可变，但支持这些操作：

1. 索引和切片（同列表）：

numbers = (0, 1, 2, 3, 4)
print(numbers[2])      # 2
print(numbers[1:4])    # (1, 2, 3)

1. 连接与重复：

a = (1, 2)
b = (3, 4)
print(a + b)  # (1, 2, 3, 4)
print(a * 3)  # (1, 2, 1, 2, 1, 2)

1. 转换为列表（需要修改时）：

my_tuple = (1, 2, 3)
my_list = list(my_tuple)  # 转为列表后可修改
my_list.append(4)

1. 元组解包（非常实用）：

point = (3, 4)
x, y = point  # 解包后 x=3, y=4# 函数返回多值实际是返回元组
def get_info():return ("Alice", 30)
name, age = get_info()  # 直接解包赋值

2.4 元组的应用场景

• 存储不希望被修改的数据（如配置信息）

• 作为字典的键（列表不能作为字典键）

• 函数返回多个值时使用

• 保护数据完整性（防止意外修改）