如果把程序员比喻成厨师的话，那么数据结构就是初始最常用的工具，那就是锅碗瓢盆。这些也叫容器，因为能存放东西，不管是放切好的菜，还是煮开的水。
同样在代码的世界中，也需要一些容器来存放数据或者信息，供后续加工使用。不同的容器有不同的特点，对应不同的场景存放数据使用。
Python 中有四个内置数据结构（Built-in Data Structure）：分别是列表 list、元组 tuple、字典 dict、集合 set，它们也是容器，里面存放数据。下面我们来认识下这四个数据结构各自的特点及适用场景。
列表 List
特点：
- 列表使用
[]来表示，里面可以储存任意对象。 - 列表中的元素是可变的、可重复的，可以对每个元素修改、删除，也可以新增元素。
- 列表是有序的，可以通过索引访问每个元素。
常用操作
1. 创建列表
myList = ['a', 'b', 'c']
print(myList)
# 输出：['a', 'b', 'c']
2. 新增元素
默认是在列表尾添加：
myList.append("d")
print(myList)
# 输出：['a', 'b', 'c', 'd']
在指定位置添加元素，下标从 0 开始计：
myList.insert(2, "e")
print(myList)
# 输出：['a', 'b', 'e', 'c', 'd']
注意：append 方法是在末尾添加元素，insert 是在指定位置添加元素。insert 需要两个参数，如果只是传一个参数，并不是在末尾添加元素，而是报错 TypeError: insert expected 2 arguments, got 1。
如果添加多个元素怎么处理？或者说如何合并两个列表。
两个 list 合并：
方法 1：使用 extend() 方法
myList = ['a', 'b', 'c']
myList2 = [1, 2]
myList.extend(myList2)
print(myList)
# 输出：['a', 'b', 'c', 1, 2]
方法 2：直接使用 +，将两个 list 合并
myList3 = [3, 4]
myList = myList + myList3
print(myList)
# 输出：['a', 'b', 'c', 1, 2, 3, 4]
如果使用 append 添加一个 list 会完成两个 list 的合并吗？
myList4 = ["A", "B"]
myList.append(myList4)
print(myList)
# 输出：['a', 'b', 'c', 1, 2, 3, 4, ['A', 'B']]
所以 append 的参数如果是一个 list，那么它会将 list 作为一个对象进行添加，而不对 list 内的元素进行合并，这也正印证了在 Python 中一切皆对象。而且也可以看出来 list 里面啥都可以装，并不是限制对象类型，字符串、整数甚至 list 对象都可以存。
3. 修改元素
修改指定位置的元素：
myList = ['a', 'b', 'c', 'd']
myList[2] = "B"
print(myList)
# 输出：['a', 'B', 'c', 'd']
4. 删除元素
删除尾部元素：
myList.pop()
print(myList)
# 输出：['a', 'B', 'c']
删除指定位置（下标）元素：
myList.pop(2)
print(myList)
# 输出：['a', 'B']
删除列表中某个元素（按值）：
myList.remove("B")
print(myList)
# 输出：['a']
5. 遍历列表
for 循环 遍历列表：
myList = ['a', 'b', 'c']
for i in myList:
print(i)
# 运行结果：
# a
# b
# c
遍历列表是在数据处理中使用频率很高的场景，当然并不仅仅只有 for 循环，使用 while 循环也可以完成。
while 循环 遍历列表：
myList = ['a', 'b', 'c']
count = 0
while count < len(myList):
print(myList[count])
count = count + 1
# 运行结果：
# a
# b
# c
其实上述 while 循环本质上也是在使用下标来访问每一个元素，在简洁性不如 for 循环直接。除此之外还可以使用 Python 内置函数 iter() 来生成一个迭代器，遍历 list。
iter() 遍历列表：
myList = ['a', 'b', 'c']
for val in iter(myList):
print(val)
元组 Tuple
特点：
- 元组使用
( )来表示，里面可以储存任意对象。 - 元组中的元素是不可变的、可重复的。
- 元组是有序的，可以通过索引访问每个元素。
简单理解元组就是一个固定的列表，没有列表的增加删除修改的方法，只能查询。那元组存在的目的是什么呢？因为元组不可变，所以代码更安全。这就是跟 Java 中的 final 关键词修饰的常量是一个效果的。
问题：如果 Tuple 里的元素包含 list，那么 list 是可以修改的吗？
修改 Tuple 中的 list 的元素：
myTuple = ('a', 'b', ['A', 'B'])
print(myTuple)
# 输出：('a', 'b', ['A', 'B'])
myTuple[2][0] = "a"
myTuple[2].append("c")
print(myTuple)
# 输出：('a', 'b', ['a', 'B', 'c'])
可见 Tuple 中的 list 是可以修改的，还可以增加。那为什么还说 Tuple 是不可变的？注意这里变化的是什么，是 list，而不是 Tuple 本身。Tuple 的引用地址没有变，只是内部可变对象的属性变了。
集合 Set
特点：
- 集合使用
{}来表示，里面可以储存任意对象。 - 集合中的元素是不可重复的，可以增加删除修改。
- 集合是无序的。
Python 中的 set 跟 Java 中的 set 特点类似，都是不可重复，或者是存入的重复对象只是保留一个。也正是因为这一个特点，在数据分析中，经常用 set 来做数据去重。
Python 中的集合跟中学数学的集合功能比较像，支持 union(联合), intersection(交), difference(差) 和 symmetric difference (对称差集) 等数学运算。
常用操作
1. 创建集合
创建 set：
mySet = set('abcdabcd')
print(mySet)
# 输出：{'c', 'a', 'b', 'd'}
再次运行结果可能不同：
{'c', 'd', 'b', 'a'}
如果这一段代码运行两次，反而打印的结果并不一样，这就是因为集合是无序的。在 Python 中字典类型数据也是用 {} 来表示，但是内容不一样，后面会有详细讲解。不过如果仅仅一个空的 {} 表示的是一个空字典，而不是空集合。创建空集合只能使用 set() 函数，不传参数得到的结果就是一个空集合。
2. 集合运算
创建两个 set：
a = {'a', 'b', 'c'}
b = {'a', 'b', 'd'}
a 和 b 的并集：
print(a | b) # 也可以用 a.union(b)
# 输出：{'a', 'b', 'c', 'd'}
a 和 b 的交集：
print(a & b) # 也可以用 a.intersection(b)
# 输出：{'a', 'b'}
a 和 b 的差集：
print(a - b) # 也可以用 a.difference(b)
# 输出：{'c'}
b 和 a 的差集：
print(b - a)
# 输出：{'d'}
a 和 b 的对称差集（在 a 或者 b 中出现，但不能同时出现）：
print(a ^ b) # 也可以用 a.symmetric_difference(b)
# 输出：{'c', 'd'}
3. 添加元素
# 创建
mySet = {'a', 'b', 'c'}
# 添加一个元素
mySet.add("ad")
print(mySet)
# 输出：{'d', 'a', 'ad', 'b', 'c'}
# update 新增的时候，字符串会拆分成单个字符添加到 set 中
mySet.update("ad")
print(mySet)
# 输出：{'d', 'a', 'ad', 'b', 'c'}
从上面可以看出集合中有两个函数，add() 和 update()，两者的区别在于，add() 做新增时候，参数作为一个整体字符串添加，update() 新增的时候，字符串会拆分成当个字符添加到 set 中，也就是 update 会进行将对象迭代添加，这样 update() 的参数中必须是一个可迭代的对象。
注意：集合中可以添加 str、num、tuple 对象，不能添加 list、dict、set 对象。update() 的参数可以是 str 或 tuple，不能是 num，因为它不可迭代。
4. 删除元素
remove 方法删除一个元素：
mySet = {'a', 'b', 'c'}
mySet.remove("b")
print(mySet)
# 输出：{'c', 'a'}
mySet.remove("b")
print(mySet)
# 报错：KeyError: 'b'
discard 方法删除一个元素：
mySet = {'a', 'b', 'c'}
mySet.discard("b")
print(mySet)
# 输出：{'c', 'a'}
mySet.discard("b")
print(mySet)
# 输出：{'c', 'a'}
从上面代码中可以看出，remove() 和 discard() 的区别是，remove() 删除一个不存在的 key 会报 KeyError 的错误，discard() 如果删除一个 set 中本不存在的 key 时，将不进行任何操作。
5. 元素去重
由于集合中的元素不能重复的特性，经常用来给 list 去重，然后得到的集合还可以通过 list() 函数转回 list 对象，得到新的 list 是原来 list 去重数据。
myList = ['a', 'b', 'b', 'c', 'c']
mySet = set(myList)
print(mySet)
# 输出：{'a', 'b', 'c'}
# list 转 set 再转回 list
myNewList = list(mySet)
print(myNewList)
# 输出：['a', 'b', 'c'] (顺序可能不同)
6. 元素是否 (不) 包含在 Set 中
mySet = {'a', 'b', 'c'}
# 判断一个元素是否在集合中
if 'a' in mySet:
print(True)
else:
print(False)
# 判断一个元素是否不在集合中
if 'd' not in mySet:
print(True)
else:
print(False)
# 程序运行结果：
# True
# True
字典 Dict
字典（Dictionary）是一种以键值对作为元素的存储的容器，跟 Java 语言中的 map 集合大同小异，是使用频率很高的数据结构之一。
特点：
- 字典是一个可变的容器，且可存储任意类型对象。
- 整个字典包括在
{ }中。 - 字典的每个键值 key：value 对，中间用冒号 : 分割，每个键值对之间用逗号 , 分割。
- 值可以取任何数据类型，但键必须是不可变的对象，如字符串，数字或元组。
- 键（key）唯一，可以为空（None）。值可以空，可以为任意对象，可重复。
常用操作
1. 创建字典
# 创建 dict
myDict = { None: 1, "a": 2, "b": 3}
print(myDict)
# 输出：{None: 1, 'a': 2, 'b': 3}
# 参数赋值创建
myDict = dict(a=1, b=2)
print(myDict)
# 输出：{'a': 1, 'b': 2}
2. 添加元素
myDict = { "a": 1, "b": 2}
myDict['c'] = 3 # 根据键值对添加
print(myDict)
# 输出：{'a': 1, 'b': 2, 'c': 3}
temp = {'d': 4, 'e': 5}
myDict.update(temp) # 使用 update 方法添加
print(myDict)
# 输出：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
3. 删除元素
myDict = {'a': 1, 'b': 2, 'c': 3}
del myDict['a'] # 使用 del() 函数删除
print(myDict)
# 输出：{'b': 2, 'c': 3}
myDict.pop('b') # 使用 pop() 函数删除
print(myDict)
# 输出：{'c': 3}
myDict.clear() # 使用 clear () 函数清空字典
print(myDict) # 得到空字典 {}
pop 函数是功能是取出 key 返回值，并将其键值对删除，所以 pop() 函数是有返回值的。
4. 查询字典
myDict = {'a': 1, 'b': 2, 'c': 3}
print(myDict['a']) # 通过'键值对'访问 1
print(myDict.get('d', '没有 d')) # 使用 get() 访问没有 d
# 输出：1
# 输出：没有 d
字典 get() 函数为 dict.get(key, [default])，default 为可选项，用于指定当'键'不存在时 返回一个默认值，如果省略，默认返回 None。如果直接使用 myDict['a'] 取值方式会报 KeyError 的异常。
5. 遍历字典
myDict = {'a': 1, 'b': 2, 'c': 3}
# 使用字典对象的 dict.items() 方法获取字典的各个元素的元祖列表
for item in myDict.items():
print(item)
# 代码结果：('a', 1) ('b', 2) ('c', 3)
# key, value 可以分别获取每个键值对
for key, value in myDict.items():
print(key, value)
# 代码结果：a 1 b 2 c 3
# keys() 和 values() 方法获取字典的键和值列表
for key in myDict.keys ():
print(key)
# 代码结果：
# a
# b
# c
for value in myDict.values():
print(value)
# 代码结果：
# 1
# 2
# 3
字典的遍历是很常用的一个场景，尤其是在数据采集的时候，经常会将字符串数据转成字典对象来进行迭代或者取值。
数据结构对比与选型建议
在实际开发中，选择合适的数据结构对性能至关重要。以下是四种结构的对比总结：
| 特性 | 列表 (List) | 元组 (Tuple) | 集合 (Set) | 字典 (Dict) |
|---|---|---|---|---|
| 可变性 | 可变 | 不可变 | 可变 | 可变 |
| 有序性 | 有序 | 有序 | 无序 | 有序 (Python 3.7+) |
| 重复性 | 允许 | 允许 | 不允许 | Key 不允许 |
| 查找效率 | O(n) | O(n) | O(1) | O(1) |
| 典型用途 | 序列处理 | 固定配置 | 去重/集合运算 | 映射关系 |
选型指南：
- 列表：当你需要存储一组有序数据，并且可能需要频繁增删改时，首选列表。例如用户评论列表、待办事项清单。
- 元组：当你需要存储一组固定不变的数据，或者希望保护数据不被意外修改时，使用元组。例如数据库记录的行、坐标点 (x, y)。
- 集合：当你需要快速判断元素是否存在，或者需要对数据进行去重、求交集/并集运算时，使用集合。例如黑名单校验、标签系统。
- 字典：当你需要通过唯一的标识（Key）快速查找对应的值（Value）时，使用字典。例如用户 ID 到用户信息的映射、配置文件项。
注意事项：
- 哈希性：字典的 Key 和集合的元素必须是可哈希的（Hashable），即不可变类型（如字符串、数字、元组）。列表和字典不能作为 Key 或集合元素。
- 内存占用：元组通常比列表更节省内存，因为不需要预留扩容空间。
- 线程安全：虽然 Python 有 GIL，但在多线程环境下，不可变对象（元组）天然线程安全，无需额外加锁。
掌握这四种基础数据结构，能够显著提升编写 Python 代码的效率和质量。在实际项目中，灵活运用它们的特性，往往能解决复杂的业务逻辑问题。