Python 内置数据结构详解：列表、元组、字典与集合

如果使用 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 集合大同小异，是使用频率很高的数据结构之一。

特点：

1. 字典是一个可变的容器，且可存储任意类型对象。
2. 整个字典包括在 { } 中。
3. 字典的每个键值 key：value 对，中间用冒号 : 分割，每个键值对之间用逗号 , 分割。
4. 值可以取任何数据类型，但键必须是不可变的对象，如字符串，数字或元组。
5. 键（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

字典的遍历是很常用的一个场景，尤其是在数据采集的时候，经常会将字符串数据转成字典对象来进行迭代或者取值。

数据结构对比与选型建议

在实际开发中，选择合适的数据结构对性能至关重要。以下是四种结构的对比总结：

选型指南：

1. 列表：当你需要存储一组有序数据，并且可能需要频繁增删改时，首选列表。例如用户评论列表、待办事项清单。
2. 元组：当你需要存储一组固定不变的数据，或者希望保护数据不被意外修改时，使用元组。例如数据库记录的行、坐标点 (x, y)。
3. 集合：当你需要快速判断元素是否存在，或者需要对数据进行去重、求交集/并集运算时，使用集合。例如黑名单校验、标签系统。
4. 字典：当你需要通过唯一的标识（Key）快速查找对应的值（Value）时，使用字典。例如用户 ID 到用户信息的映射、配置文件项。

注意事项：

• 哈希性：字典的 Key 和集合的元素必须是可哈希的（Hashable），即不可变类型（如字符串、数字、元组）。列表和字典不能作为 Key 或集合元素。
• 内存占用：元组通常比列表更节省内存，因为不需要预留扩容空间。
• 线程安全：虽然 Python 有 GIL，但在多线程环境下，不可变对象（元组）天然线程安全，无需额外加锁。

掌握这四种基础数据结构，能够显著提升编写 Python 代码的效率和质量。在实际项目中，灵活运用它们的特性，往往能解决复杂的业务逻辑问题。