Python 数据结构知识汇总

Python 数据结构知识汇总

📌 前言

Python 作为一门优雅且功能强大的编程语言，其内置的数据结构是每个 Python 开发者必须掌握的基础知识。本文将系统性地介绍 Python 中五大核心数据结构：字符串（str）、列表（list）、元组（tuple）、字典（dict） 和 集合（set），帮助读者建立完整的知识体系。

---

一、字符串（str）

1.1 什么是字符串

字符串是 Python 中最常用的数据类型，用于表示文本信息。可以使用单引号、双引号或三引号来定义。

python

# 字符串定义
str1 = 'Hello World'
str2 = "Python"
str3 = """多行
字符串"""

1.2 字符串的常用操作

操作	方法	示例
长度	len()	len("hello") → 5
索引	[索引]	"hello"[1] → 'e'
切片	[开始:结束:步长]	"hello"[1:4] → 'ell'
拼接	+	"Hello" + "World" → 'HelloWorld'
重复	*	"Hi" * 3 → 'HiHiHi'
查找	find()	"hello".find("e") → 1
替换	replace()	"hello".replace("e", "a") → 'hallo'
分割	split()	"a,b,c".split(",") → ['a','b','c']
大写	upper()	"hello".upper() → 'HELLO'
小写	lower()	"HELLO".lower() → 'hello'
去除空格	strip()	" hi ".strip() → 'hi'
判断字母数字	isalnum()	"abc123".isalnum() → True

1.3 字符串的切片操作（重点）

python

s = "Python学习"

# 切片语法：s[开始:结束:步长]
print(s[0])      # P
print(s[-1])     # 习
print(s[0:6])    # Python
print(s[6:])     # 学习
print(s[::-1])   # 习学nohtyP（反转字符串）

1.4 字符串格式化

python

# 三种常用格式化方式

# 1. % 格式化（旧式）
name = "张三"
age = 18
print("姓名：%s，年龄：%d" % (name, age))

# 2. format() 方法
print("姓名：{}，年龄：{}".format(name, age))

# 3. f-string（Python 3.6+，推荐）
print(f"姓名：{name}，年龄：{age}")

---

二、列表（list）

2.1 什么是列表

列表是 Python 中最常用的可变容器类型，可以存储任意类型的元素，支持增删改查操作。

python

# 列表定义
list1 = []                           # 空列表
list2 = [1, 2, 3]                    # 整数列表
list3 = ["a", "b", "c"]              # 字符串列表
list4 = [1, "hello", 3.14, True]     # 混合类型

2.2 列表的增删改查

增加元素

方法	说明	示例
append()	在末尾添加一个元素	lst.append(4)
insert()	在指定位置插入	lst.insert(0, 0)
extend()	合并另一个列表	lst.extend([5,6])

python

lst = [1, 2, 3]
lst.append(4)        # [1, 2, 3, 4]
lst.insert(0, 0)     # [0, 1, 2, 3, 4]
lst.extend([5, 6])   # [0, 1, 2, 3, 4, 5, 6]

删除元素

方法	说明	示例
pop()	删除末尾元素（可指定索引）	lst.pop() → 返回删除的值
remove()	删除指定值的第一个匹配项	lst.remove(2)
del	删除指定索引或切片	del lst[0] 或 del lst[1:3]
clear()	清空列表	lst.clear()

python

lst = [1, 2, 3, 4, 5]
lst.pop()          # [1, 2, 3, 4]
lst.pop(0)         # [2, 3, 4]
lst.remove(3)      # [2, 4]
del lst[0]         # [4]

修改元素

python

lst = [1, 2, 3]
lst[0] = 100       # [100, 2, 3]
lst[1:3] = [200, 300]  # [100, 200, 300]

查询元素

python

lst = [10, 20, 30, 20, 40]

# 获取元素
print(lst[0])        # 10
print(lst[-1])       # 40
print(lst[1:4])      # [20, 30, 20]

# 查找索引
print(lst.index(20)) # 1（返回第一个匹配的索引）

# 统计次数
print(lst.count(20)) # 2

# 判断是否存在
print(30 in lst)     # True

# 遍历
for item in lst:
    print(item)

for i, item in enumerate(lst):
    print(f"索引{i}: {item}")

2.3 列表推导式（重点）

python

# 生成 1-10 的平方列表
squares = [i**2 for i in range(1, 11)]
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 带条件的列表推导式
even = [i for i in range(1, 21) if i % 2 == 0]
print(even)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

# 嵌套列表推导式
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flatten = [num for row in matrix for num in row]
print(flatten)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

2.4 列表的常用函数

函数	说明	示例
len()	获取长度	len([1,2,3]) → 3
max()	获取最大值	max([1,5,3]) → 5
min()	获取最小值	min([1,5,3]) → 1
sum()	求和	sum([1,2,3]) → 6
sorted()	排序（返回新列表）	sorted([3,1,2]) → [1,2,3]
reverse()	反转列表	lst.reverse()

---

三、元组（tuple）

3.1 什么是元组

元组与列表类似，但一旦创建不可修改（不可变）。使用小括号 () 定义。

python

# 元组定义
t1 = ()                          # 空元组
t2 = (1, 2, 3)                   # 普通元组
t3 = (1,)                        # 单元素元组（注意逗号）
t4 = 1, 2, 3                     # 不加括号也可以

3.2 元组的特点

python

t = (10, 20, 30, 40, 50)

# ✅ 支持索引
print(t[0])     # 10
print(t[-1])    # 50

# ✅ 支持切片
print(t[1:4])   # (20, 30, 40)

# ✅ 支持遍历
for item in t:
    print(item)

# ✅ 支持成员判断
print(30 in t)  # True

# ❌ 不支持修改
t[0] = 100      # TypeError: 'tuple' object does not support item assignment

3.3 元组的应用场景

python

# 1. 函数返回多个值
def get_student():
    return "张三", 18, "男"

name, age, sex = get_student()
print(name, age, sex)  # 张三 18 男

# 2. 交换变量
a, b = 10, 20
a, b = b, a  # 本质是元组解包
print(a, b)  # 20 10

# 3. 作为字典的键（列表不行）
d = {(1, 2): "value"}  # ✅ 元组可以作为键
# d = {[1, 2]: "value"}  # ❌ 列表不可以作为键

---

四、字典（dict）

4.1 什么是字典

字典是 Python 中唯一的键值对（key-value）映射类型，通过键来访问值。键必须是不可变类型（字符串、数字、元组），值可以是任意类型。

python

# 字典定义
d1 = {}                          # 空字典
d2 = {"name": "张三", "age": 18}  # 普通字典
d3 = dict(name="张三", age=18)   # 使用 dict() 函数

4.2 字典的增删改查

增加/修改

python

d = {"name": "张三", "age": 18}

# 增加或修改
d["gender"] = "男"      # 新增键值对
d["age"] = 19           # 修改已有键的值

# update() 合并字典
d.update({"score": 90, "grade": "A"})
print(d)  # {'name': '张三', 'age': 19, 'gender': '男', 'score': 90, 'grade': 'A'}

删除

python

d = {"name": "张三", "age": 18, "gender": "男"}

# pop() 删除指定键并返回值
age = d.pop("age")
print(age)   # 18

# popitem() 删除并返回最后一个键值对
item = d.popitem()
print(item)  # ('gender', '男')

# del 删除指定键
del d["name"]

# clear() 清空
d.clear()

查询

python

d = {"name": "张三", "age": 18, "gender": "男"}

# 通过键取值（键不存在会报错）
print(d["name"])  # 张三

# get() 取值（键不存在返回 None 或默认值）
print(d.get("name"))       # 张三
print(d.get("score"))      # None
print(d.get("score", 0))   # 0

# 获取所有键
print(d.keys())    # dict_keys(['name', 'age', 'gender'])

# 获取所有值
print(d.values())  # dict_values(['张三', 18, '男'])

# 获取所有键值对
print(d.items())   # dict_items([('name', '张三'), ('age', 18), ('gender', '男')])

# 遍历字典
for key in d:
    print(f"{key}: {d[key]}")

for key, value in d.items():
    print(f"{key}: {value}")

4.3 字典推导式

python

# 生成数字平方的字典
squares = {i: i**2 for i in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 筛选条件
even_squares = {i: i**2 for i in range(1, 11) if i % 2 == 0}
print(even_squares)  # {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}

4.4 字典的常用方法

方法	说明
get(key, default)	获取键的值，不存在返回默认值
setdefault(key, default)	如果键存在返回其值，否则插入键并设置默认值
pop(key)	删除键并返回其值
keys()	返回所有键的视图
values()	返回所有值的视图
items()	返回所有键值对的视图
update(dict2)	合并另一个字典

---

五、集合（set）

5.1 什么是集合

集合是无序的、元素唯一的容器类型，主要用于去重和集合运算（交集、并集等）。

python

# 集合定义
s1 = set()                       # 空集合（不能使用 {}，那是空字典）
s2 = {1, 2, 3}                   # 普通集合
s3 = set([1, 2, 2, 3, 3])       # [1, 2, 3]（自动去重）

5.2 集合的操作

添加元素

python

s = {1, 2, 3}

# add() 添加单个元素
s.add(4)        # {1, 2, 3, 4}
s.add(2)        # {1, 2, 3, 4}（不会重复）

# update() 添加多个元素
s.update([5, 6, 7])   # {1, 2, 3, 4, 5, 6, 7}

删除元素

python

s = {1, 2, 3, 4, 5}

# remove() 删除指定元素（不存在报错）
s.remove(3)    # {1, 2, 4, 5}

# discard() 删除指定元素（不存在不报错）
s.discard(10)  # 不会报错

# pop() 随机删除并返回一个元素
item = s.pop()

# clear() 清空
s.clear()

5.3 集合运算

python

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 交集
print(A & B)           # {4, 5}
print(A.intersection(B))

# 并集
print(A | B)           # {1, 2, 3, 4, 5, 6, 7, 8}
print(A.union(B))

# 差集（A 有 B 没有）
print(A - B)           # {1, 2, 3}
print(A.difference(B))

# 对称差集（不同时存在的）
print(A ^ B)           # {1, 2, 3, 6, 7, 8}
print(A.symmetric_difference(B))

# 判断子集
print({1, 2} <= A)     # True（{1,2} 是 A 的子集）

# 判断超集
print(A >= {1, 2})     # True（A 是 {1,2} 的超集）

5.4 集合的去重应用

python

# 去重
lst = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
unique = list(set(lst))
print(unique)  # [1, 2, 3, 4]

# 统计字符串中的不同字符
text = "hello world"
chars = set(text)
print(chars)  # {'h', 'e', 'l', 'o', ' ', 'w', 'r', 'd'}

---

六、数据结构对比总结

6.1 快速对比表

特性	列表 (list)	元组 (tuple)	字典 (dict)	集合 (set)
符号	[]	()	{}	{}
可变性	✅ 可变	❌ 不可变	✅ 可变	✅ 可变
有序性	✅ 有序	✅ 有序	✅ 有序（Python 3.7+）	❌ 无序
元素唯一性	❌ 可重复	❌ 可重复	✅ 键唯一	✅ 元素唯一
索引方式	整数索引	整数索引	键（key）	不支持索引
适用场景	存储有序数据	存储不可变数据	键值映射	去重、集合运算

6.2 使用场景速查

python

# 列表：需要频繁修改的有序数据
students = ["张三", "李四", "王五"]

# 元组：不需要修改的数据，或函数返回多个值
coordinates = (10, 20)

# 字典：需要键值映射的数据
user = {"name": "张三", "age": 18}

# 集合：去重或集合运算
unique_numbers = {1, 2, 3, 4, 5}

---

七、常见面试题

7.1 列表和元组的区别

区别	列表	元组
可变性	可变	不可变
性能	较慢（需要额外分配内存）	较快（固定大小）
使用场景	需要修改的数据	不需要修改的数据

7.2 字典和集合的区别

区别	字典	集合
元素类型	键值对	单个元素
键唯一性	键唯一	元素唯一
使用场景	映射关系	去重、集合运算

7.3 可变对象 vs 不可变对象

python

# 不可变对象（修改会创建新对象）
s = "hello"
s = s + " world"  # 创建了新字符串

# 可变对象（修改不会创建新对象）
lst = [1, 2, 3]
lst.append(4)     # 在原列表上修改

---

八、总结

本文系统介绍了 Python 中五大核心数据结构：

1. 字符串（str）：文本处理，不可变

2. 列表（list）：有序可变容器，最常用的序列类型

3. 元组（tuple）：有序不可变容器，安全性高

4. 字典（dict）：键值映射，高效查找

5. 集合（set）：无序不重复元素，去重与集合运算

掌握这些数据结构是学好 Python 的基础，建议在实际编码中多加练习，理解每种数据结构的特性和适用场景。

---

📌 本文首发于 优快云，欢迎点赞、收藏、转发！
📧 如有问题，欢迎在评论区留言交流。