Python基础入门——数据结构

原创 已于 2025-10-27 14:51:28 修改 · 588 阅读 · 17 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #数据结构

于 2025-10-27 14:29:39 首次发布

前言

生活中我们会用不同的容器装东西——比如用购物袋装零食（可以随时加、随时拿）、用档案袋装合同（一旦装好就不轻易改）、用通讯录存联系人（名字对应电话，查起来快）。

编程里的“数据”也一样，需要不同的“容器”来管理，这些“容器”就是 数据结构。本文要学的列表、元组、字典、集合，就是 Python 里最常用的 4 种基础数据结构，学会它们，你就能轻松应对 80% 以上的日常数据处理场景。

一、列表（List）：最灵活的“动态购物袋”

列表是 Python 里最常用的数据结构，就像一个“能随时加减、修改物品的购物袋”——有序、可变、元素可重复，甚至能装不同类型的“物品”（比如同时装数字、文字）。

1. 怎么创建列表？

用 [] 包裹元素，元素之间用逗号分隔；也可以用 list() 函数转换其他数据（比如字符串、元组）。

# 1. 创建空列表（两种方式）
empty_list1 = []
empty_list2 = list()
print("空列表：", empty_list1, empty_list2)  # 输出：空列表： [] []

# 2. 创建有元素的列表（元素可以是不同类型）
fruit_list = ["苹果", "香蕉", "橙子"]  # 全是字符串
mix_list = [10, "Python", True, 3.14]  # 整数、字符串、布尔值、浮点数混放
print("水果列表：", fruit_list)  # 输出：水果列表： ['苹果', '香蕉', '橙子']
print("混合列表：", mix_list)    # 输出：混合列表： [10, 'Python', True, 3.14]

# 3. 用 list() 转换其他数据（比如字符串转列表，会拆成单个字符）
str_to_list = list("Hello")
print("字符串转列表：", str_to_list)  # 输出：字符串转列表： ['H', 'e', 'l', 'l', 'o']

2. 怎么访问列表里的元素？

列表是有序的，每个元素都有一个“编号”——叫做索引。索引从 0 开始（正向索引），也可以从 -1 开始（反向索引，方便取最后一个元素）。

还可以用切片（列表[起始:结束:步长]）一次性取多个元素，规则是“左闭右开”（包含起始位置，不包含结束位置）。

fruit_list = ["苹果", "香蕉", "橙子", "葡萄", "芒果"]

# 1. 正向索引（从 0 开始）
print("第 1 个元素（索引 0）：", fruit_list[0])  # 输出：第 1 个元素（索引 0）： 苹果
print("第 3 个元素（索引 2）：", fruit_list[2])  # 输出：第 3 个元素（索引 2）： 橙子

# 2. 反向索引（从 -1 开始，-1 是最后一个）
print("最后 1 个元素（索引 -1）：", fruit_list[-1])  # 输出：最后 1 个元素（索引 -1）： 芒果
print("倒数第 3 个元素（索引 -3）：", fruit_list[-3])  # 输出：倒数第 3 个元素（索引 -3）： 橙子

# 3. 切片（取多个元素，左闭右开）
# 取索引 1 到 3 的元素（包含 1，不包含 3 → 索引 1、2）
print("切片 1-3：", fruit_list[1:3])  # 输出：切片 1-3： ['香蕉', '橙子']
# 取前 3 个元素（起始省略，默认从 0 开始）
print("前 3 个元素：", fruit_list[:3])  # 输出：前 3 个元素： ['苹果', '香蕉', '橙子']
# 取从索引 2 到末尾的元素（结束省略）
print("索引 2 到末尾：", fruit_list[2:])  # 输出：索引 2 到末尾： ['橙子', '葡萄', '芒果']
# 步长为 2（隔一个取一个）
print("步长 2 取值：", fruit_list[::2])  # 输出：步长 2 取值： ['苹果', '橙子', '芒果']

3. 怎么修改列表？

列表是可变的，能直接修改元素、添加元素、删除元素。

（1）直接修改元素（通过索引赋值）
fruit_list = ["苹果", "香蕉", "橙子"]
fruit_list[1] = "草莓"  # 把索引 1 的“香蕉”改成“草莓”
print("修改后：", fruit_list)  # 输出：修改后： ['苹果', '草莓', '橙子']
（2）添加元素（3 种常用方法）
方法作用例子结果
append(元素)在列表末尾加 1 个元素fruit_list.append("葡萄")['苹果', '草莓', '橙子', '葡萄']
insert(索引, 元素)在指定索引前加 1 个元素fruit_list.insert(1, "芒果")['苹果', '芒果', '草莓', '橙子', '葡萄']
extend(列表)把另一个列表的元素“拆开放”到末尾fruit_list.extend(["西瓜", "菠萝"])['苹果', '芒果', '草莓', '橙子', '葡萄', '西瓜', '菠萝']
fruit_list = ["苹果", "草莓", "橙子"]
# 1. append：末尾加 1 个
fruit_list.append("葡萄")
print("append 后：", fruit_list)  # 输出：append 后： ['苹果', '草莓', '橙子', '葡萄']

# 2. insert：索引 1 前加“芒果”
fruit_list.insert(1, "芒果")
print("insert 后：", fruit_list)  # 输出：insert 后： ['苹果', '芒果', '草莓', '橙子', '葡萄']

# 3. extend：加另一个列表的元素（注意和 append 的区别：append 会把整个列表当一个元素加）
fruit_list.extend(["西瓜", "菠萝"])
print("extend 后：", fruit_list)  # 输出：extend 后： ['苹果', '芒果', '草莓', '橙子', '葡萄', '西瓜', '菠萝']
（3）删除元素（4 种常用方法）
方法作用注意事项
remove(元素值)按“值”删除（删第一个匹配的）如果元素不存在，会报错
pop(索引)按“索引”删除（默认删最后一个）返回被删除的元素；索引不存在会报错
del 列表[索引]按“索引”删除（和 pop 类似）不返回值；索引不存在会报错
clear()清空列表所有元素清空后列表变成空列表
fruit_list = ["苹果", "芒果", "草莓", "橙子", "葡萄"]

# 1. remove：删除“草莓”（按值删）
fruit_list.remove("草莓")
print("remove 后：", fruit_list)  # 输出：remove 后： ['苹果', '芒果', '橙子', '葡萄']

# 2. pop：删除索引 1 的元素（“芒果”），并返回它
deleted_fruit = fruit_list.pop(1)
print("pop 删的元素：", deleted_fruit)  # 输出：pop 删的元素： 芒果
print("pop 后：", fruit_list)          # 输出：pop 后： ['苹果', '橙子', '葡萄']

# 3. del：删除索引 0 的元素（“苹果”）
del fruit_list[0]
print("del 后：", fruit_list)  # 输出：del 后： ['橙子', '葡萄']

# 4. clear：清空列表
fruit_list.clear()
print("clear 后：", fruit_list)  # 输出：clear 后： []

4. 列表的其他常用方法

除了增删改查，列表还有几个高频方法：

  • index(元素)：找元素的第一个匹配的索引（元素不存在会报错）
  • count(元素)：统计元素出现的次数
  • sort()：对列表排序（默认升序，数字按大小，字符串按字母顺序；reverse=True 降序）
  • reverse()：反转列表（倒序排列）
num_list = [3, 1, 4, 1, 5, 9, 2]

# 1. index：找“1”的第一个索引
print("1 的第一个索引：", num_list.index(1))  # 输出：1 的第一个索引： 1

# 2. count：统计“1”出现的次数
print("1 出现的次数：", num_list.count(1))  # 输出：1 出现的次数： 2

# 3. sort：升序排序
num_list.sort()
print("升序排序后：", num_list)  # 输出：升序排序后： [1, 1, 2, 3, 4, 5, 9]

# 4. sort + reverse=True：降序排序
num_list.sort(reverse=True)
print("降序排序后：", num_list)  # 输出：降序排序后： [9, 5, 4, 3, 2, 1, 1]

# 5. reverse：反转列表（注意和 sort(reverse=True) 的区别：reverse 是直接倒序，不排序）
num_list.reverse()
print("反转后：", num_list)  # 输出：反转后： [1, 1, 2, 3, 4, 5, 9]

5. 列表的注意事项

  1. 索引不能越界：比如列表只有 3 个元素（索引 0、1、2），如果取 list[3] 会报错。
  2. 切片不会越界：比如 list[100:200] 不会报错，只会返回空列表。
  3. 列表是“引用类型”：赋值时要注意（比如 a = [1,2,3]; b = a; b[0] = 10，此时 a 也会变成 [10,2,3]），如果想复制一个新列表，要用 b = a.copy() 或 b = a[:]。

二、元组（Tuple）：不能改的“档案袋”

元组和列表很像，但它是有序、不可变、元素可重复的——就像一个“封好的档案袋”，一旦装了东西就不能改、不能增、不能删。

1. 怎么创建元组？

用 () 包裹元素，元素之间用逗号分隔；也可以用 tuple() 函数转换。注意：单个元素的元组必须加逗号（比如 (1,)，否则会被当成普通括号）。

# 1. 创建空元组（两种方式）
empty_tuple1 = ()
empty_tuple2 = tuple()
print("空元组：", empty_tuple1, empty_tuple2)  # 输出：空元组： () ()

# 2. 创建有元素的元组（多个元素）
fruit_tuple = ("苹果", "香蕉", "橙子")
mix_tuple = (10, "Python", True)
print("水果元组：", fruit_tuple)  # 输出：水果元组： ('苹果', '香蕉', '橙子')
print("混合元组：", mix_tuple)    # 输出：混合元组： (10, 'Python', True)

# 3. 单个元素的元组（必须加逗号！否则是整数）
single_tuple1 = (5,)  # 正确：元组
single_tuple2 = (5)   # 错误：是整数（不是元组）
print("单个元素元组：", single_tuple1, type(single_tuple1))  # 输出：单个元素元组： (5,) <class 'tuple'>
print("不是元组：", single_tuple2, type(single_tuple2))      # 输出：不是元组： 5 <class 'int'>

# 4. 用 tuple() 转换其他数据
list_to_tuple = tuple(["苹果", "香蕉"])
print("列表转元组：", list_to_tuple)  # 输出：列表转元组： ('苹果', '香蕉')

2. 怎么访问元组里的元素？

和列表完全一样——支持索引和切片（因为元组是有序的）。

fruit_tuple = ("苹果", "香蕉", "橙子", "葡萄")

# 1. 索引访问
print("第 2 个元素：", fruit_tuple[1])  # 输出：第 2 个元素： 香蕉
print("最后 1 个元素：", fruit_tuple[-1])  # 输出：最后 1 个元素： 葡萄

# 2. 切片访问
print("前 3 个元素：", fruit_tuple[:3])  # 输出：前 3 个元素： ('苹果', '香蕉', '橙子')
print("索引 1 到 3：", fruit_tuple[1:3])  # 输出：索引 1 到 3： ('香蕉', '橙子')

3. 元组的“不可变”是什么意思？

元组创建后，不能修改、不能添加、不能删除元素——任何试图修改的操作都会报错。

fruit_tuple = ("苹果", "香蕉", "橙子")

# 错误：试图修改元素（会报错）
# fruit_tuple[1] = "草莓"  # 运行后报错：TypeError: 'tuple' object does not support item assignment

# 错误：试图添加元素（元组没有 append 方法，会报错）
# fruit_tuple.append("葡萄")  # 运行后报错：AttributeError: 'tuple' object has no attribute 'append'

# 错误：试图删除元素（会报错）
# del fruit_tuple[0]  # 运行后报错：TypeError: 'tuple' object doesn't support item deletion

4. 元组的常用方法（很少，因为不可变）

元组只有 2 个常用方法：

  • index(元素)：找元素的第一个索引（和列表一样）
  • count(元素)：统计元素出现的次数（和列表一样）
num_tuple = (3, 1, 4, 1, 5)
print("1 的索引：", num_tuple.index(1))  # 输出：1 的索引： 1
print("1 出现次数：", num_tuple.count(1))  # 输出：1 出现次数： 2

5. 元组 vs 列表：什么时候用哪个？

很多初学者会问：既然列表这么灵活，为什么还要用元组？看下面的对比就懂了：

对比维度列表（List）元组（Tuple）
可变性可变（能改、增、删）不可变（不能改）
语法符号[]()（单个元素加,）
方法数量多（append、sort 等）少（只有 index、count）
内存占用大小（更节省内存）
安全性低（数据可能被意外修改）高（数据不会被改）
适用场景需动态修改的数据（比如购物车、待办清单）不需修改的数据（比如坐标 (x,y)、函数返回的多个值、字典的键）

举个实际例子：比如存储一个点的坐标 (10, 20)，用元组比列表好——因为坐标不会随便变，元组的不可变性能保证数据安全，而且元组可以作为字典的键（列表不行，因为列表可变）。

三、字典（Dictionary）：按“名字”查东西的“通讯录”

字典是 键值对（Key-Value） 结构，就像“通讯录”——通过“名字（Key）”快速找到“电话（Value）”。它的特点是：Python 3.7+ 后有序、可变、键唯一且不可变。

1. 怎么创建字典？

用 {} 包裹键值对，键和值用 : 分隔（键:值），键值对之间用逗号分隔；也可以用 dict() 函数创建。

# 1. 创建空字典（两种方式）
empty_dict1 = {}
empty_dict2 = dict()
print("空字典：", empty_dict1, empty_dict2)  # 输出：空字典： {} {}

# 2. 创建有键值对的字典（键唯一，且不可变）
# 键可以是字符串、整数、元组（不可变类型）；值可以是任何类型
student_dict = {
    "name": "小明",    # 键 "name"，值 "小明"
    "age": 18,        # 键 "age"，值 18
    "gender": "男",
    "scores": [90, 85, 95]  # 值可以是列表
}
print("学生字典：", student_dict)  # 输出：学生字典： {'name': '小明', 'age': 18, 'gender': '男', 'scores': [90, 85, 95]}

# 3. 用 dict() 函数创建（两种写法）
# 写法 1：键作为参数名（不用引号，只能是字符串风格的键）
dict1 = dict(name="小红", age=17)
# 写法 2：传列表（每个元素是 (键, 值) 元组）
dict2 = dict([("name", "小刚"), ("age", 19)])
print("dict1：", dict1)  # 输出：dict1： {'name': '小红', 'age': 17}
print("dict2：", dict2)  # 输出：dict2： {'name': '小刚', 'age': 19}

2. 字典的键有什么规则？

必须记住 2 条核心规则：

  1. 键必须唯一：如果有重复的键，后面的会覆盖前面的。
  2. 键必须不可变：可以用字符串、整数、元组（不可变类型），不能用列表、字典（可变类型）。
# 1. 键重复：后面的覆盖前面的
repeat_key_dict = {"name": "小明", "name": "小红"}
print("键重复：", repeat_key_dict)  # 输出：键重复： {'name': '小红'}（前面的“小明”被覆盖）

# 2. 键不能是可变类型（比如列表，会报错）
# error_dict = {[1,2]: "a"}  # 运行后报错：TypeError: unhashable type: 'list'

3. 怎么访问字典里的值？

有 2 种常用方式：通过键直接访问、用 get() 方法访问（推荐，更安全）。

还可以批量访问所有键、所有值、所有键值对。

student_dict = {"name": "小明", "age": 18, "scores": [90, 85, 95]}

# 1. 通过键直接访问（键不存在会报错）
print("姓名：", student_dict["name"])  # 输出：姓名： 小明
print("年龄：", student_dict["age"])   # 输出：年龄： 18
# print(student_dict["gender"])  # 键不存在，运行后报错：KeyError: 'gender'

# 2. 用 get() 方法访问（键不存在时返回默认值，不报错，推荐！）
# 格式：dict.get(键, 默认值)（默认值可选，不写则返回 None）
print("性别（默认未知）：", student_dict.get("gender", "未知"))  # 输出：性别（默认未知）： 未知
print("年龄（无默认值）：", student_dict.get("age"))            # 输出：年龄（无默认值）： 18

# 3. 批量访问
print("所有键：", student_dict.keys())    # 输出：所有键： dict_keys(['name', 'age', 'scores'])（可转成列表：list(...)）
print("所有值：", student_dict.values())  # 输出：所有值： dict_values(['小明', 18, [90, 85, 95]])
print("所有键值对：", student_dict.items())  # 输出：所有键值对： dict_items([('name', '小明'), ('age', 18), ('scores', [90, 85, 95])])

# 用 for 循环遍历所有键值对（最常用场景）
for key, value in student_dict.items():
    print(f"{key}：{value}")
# 输出：
# name：小明
# age：18
# scores：[90, 85, 95]

4. 怎么修改字典？

字典是可变的，能添加键值对、修改值、删除键值对。

（1）添加/修改键值对（同一操作）

如果键不存在，就是“添加”；如果键存在，就是“修改”。

student_dict = {"name": "小明", "age": 18}

# 1. 键不存在：添加键值对
student_dict["gender"] = "男"  # 加“gender:男”
student_dict["scores"] = [90, 85]  # 加“scores:[90,85]”
print("添加后：", student_dict)  # 输出：添加后： {'name': '小明', 'age': 18, 'gender': '男', 'scores': [90, 85]}

# 2. 键存在：修改值
student_dict["age"] = 19  # 把“age:18”改成“age:19”
student_dict["scores"][0] = 95  # 把 scores 列表的第一个元素改成 95
print("修改后：", student_dict)  # 输出：修改后： {'name': '小明', 'age': 19, 'gender': '男', 'scores': [95, 85]}
（2）删除键值对（3 种常用方式）
方法作用注意事项
pop(键)按“键”删除，返回对应的值键不存在会报错；可加默认值（pop(键, 默认值)）
del dict[键]按“键”删除，不返回值键不存在会报错
clear()清空字典所有键值对清空后字典变成空字典
student_dict = {"name": "小明", "age": 19, "gender": "男"}

# 1. pop：删除“age”键，返回值 19
deleted_age = student_dict.pop("age")
print("pop 删的值：", deleted_age)  # 输出：pop 删的值： 19
print("pop 后：", student_dict)    # 输出：pop 后： {'name': '小明', 'gender': '男'}

# 2. del：删除“gender”键
del student_dict["gender"]
print("del 后：", student_dict)  # 输出：del 后： {'name': '小明'}

# 3. clear：清空字典
student_dict.clear()
print("clear 后：", student_dict)  # 输出：clear 后： {}
（3）用 update() 批量更新

update(字典)：用另一个字典的键值对更新当前字典——键存在则覆盖，不存在则添加。

dict1 = {"name": "小明", "age": 18}
dict2 = {"age": 19, "gender": "男"}

# 用 dict2 更新 dict1
dict1.update(dict2)
print("更新后 dict1：", dict1)  # 输出：更新后 dict1： {'name': '小明', 'age': 19, 'gender': '男'}

5. 字典的注意事项

  1. Python 3.7 前字典是无序的：如果你的 Python 版本低于 3.7，字典的键值对顺序可能和创建时不一样（3.7+ 已修复，按插入顺序排列）。
  2. 值可以是任何类型：包括列表、元组、甚至字典（嵌套字典）。比如：
    nested_dict = {
    "student": {
        "name": "小明",
        "age": 18
    },
    "teacher": {
        "name": "李老师",
        "subject": "数学"
    }
}
print("学生姓名：", nested_dict["student"]["name"])  # 输出：学生姓名： 小明

四、集合（Set）：自动去重的“篮子”

集合就像一个“不允许装重复东西的篮子”——无序、可变、元素唯一且不可变。它最常用的场景是：去重、判断元素是否存在、集合运算（比如求两个列表的交集）。

1. 怎么创建集合？

用 set() 函数转换其他数据（比如列表、元组），或用 {} 包裹元素（注意：空集合不能用 {} 创建，因为 {} 是空字典）。

# 1. 创建空集合（只能用 set()，不能用 {}）
empty_set = set()
# empty_set = {}  # 错误：这是空字典，不是空集合
print("空集合：", empty_set, type(empty_set))  # 输出：空集合： set() <class 'set'>

# 2. 创建有元素的集合（用 {} 或 set()）
# 用 {}：自动去重（重复的“苹果”会被删掉）
fruit_set1 = {"苹果", "香蕉", "橙子", "苹果"}
# 用 set() 转换列表（列表里的重复元素会被去重）
fruit_list = ["苹果", "香蕉", "橙子", "苹果"]
fruit_set2 = set(fruit_list)

print("fruit_set1：", fruit_set1)  # 输出：fruit_set1： {'苹果', '香蕉', '橙子'}（去重了）
print("fruit_set2：", fruit_set2)  # 输出：fruit_set2： {'苹果', '香蕉', '橙子'}（和上面一样）

# 3. 元素必须不可变（不能用列表、字典当元素，会报错）
# error_set = {[1,2], "a"}  # 运行后报错：TypeError: unhashable type: 'list'

2. 怎么访问集合里的元素？

集合是无序的，没有索引，所以不能通过索引访问。只能用：

  • for 循环遍历元素
  • in 判断元素是否存在（效率很高，比列表快）
fruit_set = {"苹果", "香蕉", "橙子"}

# 1. for 循环遍历（顺序不固定，因为集合无序）
print("集合元素：")
for fruit in fruit_set:
    print(fruit)
# 输出（顺序可能不同）：
# 苹果
# 香蕉
# 橙子

# 2. in 判断元素是否存在（常用场景）
print("'苹果'在集合里吗？", "苹果" in fruit_set)  # 输出：'苹果'在集合里吗？ True
print("'葡萄'在集合里吗？", "葡萄" in fruit_set)  # 输出：'葡萄'在集合里吗？ False

3. 怎么修改集合？

集合是可变的，能添加元素、删除元素，但不能修改元素（因为元素唯一且无序，没法定位要改的元素）。

（1）添加元素
方法作用例子
add(元素)加 1 个元素（重复加不会报错，也不会生效）fruit_set.add("葡萄")
update(可迭代对象)加多个元素（可迭代对象：列表、元组、字符串等）fruit_set.update(["葡萄", "西瓜"])
fruit_set = {"苹果", "香蕉", "橙子"}

# 1. add：加 1 个元素
fruit_set.add("葡萄")
print("add 后：", fruit_set)  # 输出：add 后： {'苹果', '香蕉', '橙子', '葡萄'}
fruit_set.add("苹果")  # 加重复元素，不生效
print("加重复元素后：", fruit_set)  # 输出：加重复元素后： {'苹果', '香蕉', '橙子', '葡萄'}

# 2. update：加多个元素（用列表）
fruit_set.update(["西瓜", "菠萝"])
print("update 后：", fruit_set)  # 输出：update 后： {'苹果', '香蕉', '橙子', '葡萄', '西瓜', '菠萝'}
# update 也可以传字符串（会拆成单个字符加进去）
fruit_set.update("草莓")
print("update 字符串后：", fruit_set)  # 输出会多 '草'、'莓' 两个元素
（2）删除元素
方法作用注意事项
remove(元素)删指定元素元素不存在会报错
discard(元素)删指定元素元素不存在不报错（推荐，比 remove 安全）
pop()随机删 1 个元素（因为无序）返回被删除的元素；空集合调用会报错
clear()清空集合清空后变成空集合
fruit_set = {"苹果", "香蕉", "橙子", "葡萄"}

# 1. remove：删“香蕉”（元素存在，成功）
fruit_set.remove("香蕉")
print("remove 后：", fruit_set)  # 输出：remove 后： {'苹果', '橙子', '葡萄'}
# fruit_set.remove("西瓜")  # 元素不存在，运行后报错：KeyError: '西瓜'

# 2. discard：删“橙子”（元素存在，成功）
fruit_set.discard("橙子")
print("discard 后：", fruit_set)  # 输出：discard 后： {'苹果', '葡萄'}
fruit_set.discard("西瓜")  # 元素不存在，不报错（推荐用这个）
print("discard 不存在元素后：", fruit_set)  # 输出：discard 不存在元素后： {'苹果', '葡萄'}

# 3. pop：随机删 1 个元素
deleted_fruit = fruit_set.pop()
print("pop 删的元素：", deleted_fruit)  # 输出：pop 删的元素： 苹果（或葡萄，随机）
print("pop 后：", fruit_set)          # 输出：pop 后： {'葡萄'}（或 {'苹果'}）

# 4. clear：清空集合
fruit_set.clear()
print("clear 后：", fruit_set)  # 输出：clear 后： set()

4. 集合的核心能力：集合运算

集合最强大的功能是做数学集合运算（并集、交集、差集、对称差集），比如求两个列表的共同元素、不同元素等。

假设有两个集合：

a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
（1）并集：两个集合的所有元素（去重）

符号：|；方法：a.union(b)

print("并集（|）：", a | b)          # 输出：并集（|）： {1, 2, 3, 4, 5, 6}
print("并集（union）：", a.union(b))  # 输出：并集（union）： {1, 2, 3, 4, 5, 6}
（2）交集：两个集合的共同元素

符号：&；方法：a.intersection(b)

print("交集（&）：", a & b)              # 输出：交集（&）： {3, 4}
print("交集（intersection）：", a.intersection(b))  # 输出：交集（intersection）： {3, 4}
（3）差集：a 有但 b 没有的元素

符号：-；方法：a.difference(b)

print("差集（a - b）：", a - b)          # 输出：差集（a - b）： {1, 2}
print("差集（difference）：", a.difference(b))  # 输出：差集（difference）： {1, 2}
（4）对称差集：a 和 b 各自独有的元素（并集 - 交集）

符号：^；方法：a.symmetric_difference(b)

print("对称差集（^）：", a ^ b)              # 输出：对称差集（^）： {1, 2, 5, 6}
print("对称差集（symmetric_difference）：", a.symmetric_difference(b))  # 输出同上

5. 集合 vs 列表：什么时候用哪个？

对比维度列表（List）集合（Set）
有序性是否
元素唯一性可重复唯一（自动去重）
索引访问支持不支持
元素存在判断效率低（数据多的时候慢）高（无论数据多少都快）
核心功能动态存储、有序遍历去重、集合运算、快速判存在
适用场景有序数据（比如时间序列、待办清单）去重（比如用户 ID 去重）、求共同/不同元素（比如两个用户的共同爱好）

举个实际例子：如果有一个列表 user_ids = [101, 102, 101, 103, 102]，要去重，用集合一句话搞定：

user_ids = [101, 102, 101, 103, 102]
unique_ids = list(set(user_ids))  # 先转集合去重，再转列表
print("去重后：", unique_ids)  # 输出：去重后： [101, 102, 103]（顺序可能不同）

五、4 种数据结构核心特点总结

最后用一张表格帮你快速记忆：

数据结构有序性可变性元素唯一性语法符号核心场景
列表（List）是是否[]有序存储、动态修改（购物车、待办）
元组（Tuple）是否否()（单个元素加,）不可变数据（坐标、字典键）
字典（Dict）是（3.7+）是键唯一{键:值}键值映射、快速查询（通讯录、配置）
集合（Set）否是是{元素} 或 set()去重、集合运算、快速判存在

到这里，Python 基础数据结构就讲完了。建议大家多动手敲代码——比如用列表存一个购物车，用字典存自己的信息，用集合给列表去重，只有实际操作才能真正掌握。

Python的常用数据结构（一）
chisato的博客
03-03 1412
Python的常用数据结构（一）
Python中常用的数据结构详解与示例
涛哥聊Python
12-15 1536
在Python中，数据结构的选择对于程序的性能和可维护性至关重要。本文详细探讨了Python中常用的数据结构，包括列表、元组、集合、字典以及一些高级数据结构如堆、队列、栈、链表、树、图、字典树、哈希表、布隆过滤器、计数器、堆栈等。通过丰富的示例代码，可以深入了解这些数据结构的基本操作和使用方法。了解每种数据结构的特点和适用场景是选择合适数据结构的关键。例如，列表适用于有序元素的存储和灵活修改，而集合则适用于无序且不重复的元素。字典用于键值对的存储与检索，而树和图则用于处理更复杂的层级关系和网络结构。
【数据结构】python常见的数据结构
WeiY1的博客
01-04 236
python不常见的数据结构
Python常用数据结构
zy0412326的专栏
05-30 4418
Python常用数据结构
「Python系列」Python数据结构
m0_59236602的博客
02-22 1816
方法| 描述| |-------|-------| list.append(x)| 把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)。Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。元组中的元素之间用逗号分隔。
Python基础 1 - 数据结构
云端梦留白的博客
08-26 1070
Python 是面向对象的编译型语言。程序设计语言：机器语言 → 汇编语言 → 高级语言bool 类型的字面量： [不仅可以被定义，也可以通过比较运算符进行内容比较得到True 表示真，1False 表示假，0定义变量名 = bool 字面量；方式 2：比较运算符：num1=10num2=20num1 < num2 } ") print((num1 >= num2)) 打印： True False num1 < num2 = True False。
【Python入门基础】常用数据结构（二）——元组，集合及字典
01-20
数据结构 列表 元组  元组是可以用一个变量（）对象存储多个数据的容器数据类型，特殊之处在于元组的元素不能修改。事实上在项目中尤其是多线程环境中可能更喜欢使用的是那些不变对象，一方面因为对象状态不能修改...
Python入门——组合数据类型
12-21
【Python入门——组合数据类型】 Python 是一门高级编程语言，其强大的数据结构使得它易于学习和使用。在Python中，组合数据类型是指可以容纳多个不同类型数据的容器，主要包括列表（List）、元组（Tuple）、字典...
python爬虫入门——邓旭东课件.ppt
07-01
邓旭东课件中的“Python爬虫入门”详细介绍了Python爬虫的基础知识，旨在帮助初学者快速掌握网络爬虫的基本原理和技术要点。 首先，课件通过对邓旭东的个人背景介绍，让听众了解其学术和研究经历。邓旭东分别在...
python开发入门——列表生成式
12-17
**Python开发入门——列表生成式** 在Python编程中，列表生成式是一种简洁高效的方式来创建列表。它允许我们用一行代码来实现原本需要多行循环才能完成的任务，极大地提高了代码的可读性和执行效率。列表生成式是...
python dict 排序_学好Python，必须熟练掌握的几种数据结构【文末送书】
weixin_39593718的博客
12-20 275
导读伟大先辈尼古拉斯·沃斯曾这样说过：程序=数据结构+算法，这在程序员界堪称经典的公式，其意义不亚于物理学界中的E=mc2。实际上，其意在阐明编程的核心在于掌握数据结构与算法！如果把一名优秀的程序员比作武林高手，那么数据结构即为招式，算法则是内功，二者缺一不可。当下，Python语言非常火热，学好Python就必须掌握好这些数据结构的常用用法。python提供了多种数据结构可供选择，除了...
Python基础-数据结构
最新发布
猿榜编程的博客
08-15 1076
Python提供了四种主要数据结构：列表（可变有序序列）、元组（不可变有序序列）、字典（键值对映射）和集合（可变无序唯一元素）。本文详细介绍了列表和元组的使用方法，包括创建、访问、修改（列表）、删除（列表）等操作，并展示了各种内置方法和高级技巧。列表使用方括号[]，支持增删改查；元组使用圆括号()，创建后不可修改，常用于数据保护和解包操作。两种数据结构都支持索引、切片和多种内置方法，是Python编程中最基础且重要的数据结构。
Python基础之:Python的数据结构
程序那些事
03-19 5753
不管是做科学计算还是编写应用程序，都需要使用到一些基本的数据结构，比如列表，元组，字典等。 本文将会详细讲解Python中的这些基础数据结构。
10种 Python数据结构,从入门到精通
相信相信的力量
08-02 972
作者:郭震简介在这个专题中,我们将通过精简的文字和典型案例,盘点Python常用的数据结构。对于Python初学者来说,只需掌握list、tuple、set、dict等基本数据结构,做到灵活运用即可。然而,随着学习的深入,遇到的实际场景会变得复杂,此时了解Python内置的更强大数据结构,如deque、heapq、Counter、OrderedDict、defaultdict、ChainMap,将...
python教程（二）：python数据结构大全（附代码）
a8598671的博客
09-16 3471
Python 中数据结构的重要性不言而喻，它们是构建高效、可维护代码的基础。数据结构决定了如何存储、组织和操作数据。理解和使用合适的数据结构能够极大地提升程序的性能、简洁性以及代码的可读性。Python 的基础数据结构有 4 种，分别是 列表 (list)、元组 (tuple)、集合 (set) 和 字典 (dictionary)，它们都是 Python 内置的，并不需要额外导入模块。基础数据结构广泛用于存储和操作数据，支持常见的增删改查等操作。
数据结构（Python）
m0_68625595的博客
02-12 1516
二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质：非空左子树的所有键值小于其根结点的键值。非空右子树的所有键值大于其根结点的键值。左、右子树本身也都是二叉搜索树。下面哪些是二叉搜索树, 哪些不是?二叉搜索树的特点:二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上.那么利用这个特点, 我们可以做什么事情呢?
Python 基础（数据结构--列表与元组）
UncleMark
02-14 354
数据结构 数据结构基本上是那个—他们是结构，能够将一些数据融合（hold）在一起。换句话说，用他们存储相关复合数据。 Python有四种内置的数据结构，列表，元组，字典和集合。我们将学习如何运用他们，以及他们如何使我们的生活更简单。 列表 列表是有序元素结合在一起的数据结构。也就是说，你可以在列表里存储一个元素的序列。这个很容易想象，如果你想起购物清单—你有一个要购买的物品清单，你可能在购物清单上...
【入门系列一：Python数据分析基础之数据结构篇】
致力于成为一名data scientist 的奋斗者
06-08 930
Python数据分析的第一步是了解Python的数据结构及对应的数据常规操作。本节主要讲述数据基本结构及其常规操作。
Python语言入门——初学者必备指南
- Python的基本语法和结构：包括变量声明、数据类型、控制结构（if-else语句、循环结构）、函数定义、模块和包的使用。 - 面向对象编程：类的定义、对象的创建、继承、封装、多态等面向对象的基本概念和应用。 - ...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值