python 列表-元组-集合-字典

1. 列表（List）的定义

列表（List） 是 Python 中一种可变（mutable）、有序的序列容器，可存储任意类型元素（包括不同类型）。

语法：用方括号 [] 包裹元素，元素间用逗号分隔。

# 定义列表
list1 = [1, 2, 3]                # 纯数字列表
list2 = ["a", 10, True, [4, 5]]  # 混合类型列表（支持嵌套）
list3 = []                       # 空列表

2. 列表的使用场景

(1) 动态数据集合

存储需要频繁增删或修改的数据集合。

user_ids = [1001, 1002, 1003]
user_ids.append(1004)  # 动态添加元素

(2) 批量处理元素

遍历或批量操作元素（如数据清洗、转换）。

prices = [10.5, 20.0, 15.3]
discounted = [p * 0.9 for p in prices]  # 所有价格打 9 折

(3) 栈或队列的简单实现

用列表模拟栈（后进先出）或队列（先进先出，但性能较低）。

stack = []
stack.append(1)          # 入栈 → [1]
stack.append(2)          # 入栈 → [1, 2]
top = stack.pop()        # 出栈 → top=2, 栈变为 [1]queue = []
queue.append("a")        # 入队 → ["a"]
queue.append("b")        # 入队 → ["a", "b"]
front = queue.pop(0)     # 出队 → front="a"（但效率低，建议用 deque）

(4) 多维数据表示

嵌套列表可表示矩阵、多维数组等。

matrix = [[1, 2, 3],[4, 5, 6],[7, 8, 9]
]

3. 列表的注意点

(1) 可变性带来的副作用

列表作为参数传递时，函数内修改会影响原始列表：

def modify(lst):lst.append(4)nums = [1, 2, 3]
modify(nums)
print(nums)  # [1, 2, 3, 4]（原列表被修改）

(2) 浅拷贝与深拷贝

直接赋值或切片操作是浅拷贝（嵌套对象共享引用）：

a = [1, [2, 3]]
b = a.copy()       # 浅拷贝
b[1][0] = 99      # 修改嵌套列表
print(a)           # [1, [99, 3]]（原列表被影响）import copy
c = copy.deepcopy(a)  # 深拷贝（完全独立）

(3) 性能问题

在列表头部或中间插入/删除元素时，时间复杂度为 O(n)，效率较低：

lst = [1, 2, 3, 4]
lst.insert(0, 0)   # 头部插入 → [0, 1, 2, 3, 4]（需移动所有元素）

(4) 列表推导式滥用

过于复杂的列表推导式会降低代码可读性：

# 不推荐：多层嵌套 + 条件判断
result = [x for x in range(10) if x % 2 == 0 if x > 5]
# 更清晰的写法：
result = []
for x in range(10):if x % 2 == 0 and x > 5:result.append(x)

4. 与其他数据类型的区别

特性	列表（List）	元组（Tuple）	集合（Set）	字典（Dict）
可变性	可变	不可变	可变	可变（键不可变）
有序性	有序	有序	无序	有序（Python 3.7+）
唯一性	允许重复	允许重复	元素唯一	键唯一
语法	`[]`	`()`	`{}` 或 `set()`	`{key: value}`
典型用途	动态数据集合	不可变数据保护	去重、集合运算	键值对映射

5. 列表的高级用法

(1) 列表推导式（List Comprehension）

快速生成列表，支持条件过滤和嵌套循环：

# 生成 0~9 中偶数的平方
squares = [x**2 for x in range(10) if x % 2 == 0]  # [0, 4, 16, 36, 64]# 嵌套循环（矩阵展开）
matrix = [[1, 2], [3, 4]]
flat = [num for row in matrix for num in row]      # [1, 2, 3, 4]

(2) 切片（Slicing）高级操作

灵活截取子列表，支持步长和负数索引：

lst = [0, 1, 2, 3, 4, 5]
print(lst[1:4])      # [1, 2, 3]（索引 1~3）
print(lst[::-1])     # [5, 4, 3, 2, 1, 0]（逆序）
print(lst[::2])      # [0, 2, 4]（每隔一个元素）

(3) 列表作为栈或队列

栈：用 append() 和 pop() 实现（高效）。

队列：用 append() 和 pop(0) 实现（低效），建议改用 collections.deque：

from collections import deque
queue = deque(["a", "b"])
queue.append("c")     # 入队 → deque(["a", "b", "c"])
front = queue.popleft()  # 出队 → "a"（高效）

(4) 列表合并与扩展

合并列表的多种方式：

a = [1, 2]
b = [3, 4]
c = a + b          # 新列表 → [1, 2, 3, 4]
a.extend(b)        # 原地扩展 → a 变为 [1, 2, 3, 4]

(5) 排序与自定义排序

内置排序方法：

nums = [3, 1, 4, 2]
nums.sort()                          # 原地排序 → [1, 2, 3, 4]
sorted_nums = sorted(nums, reverse=True)  # 降序 → [4, 3, 2, 1]# 自定义排序（按字符串长度）
words = ["apple", "kiwi", "banana"]
words.sort(key=lambda x: len(x))     # ["kiwi", "apple", "banana"]

(6) 生成器表达式与内存优化

生成器表达式节省内存（适合处理大数据）：

# 列表推导式（直接生成列表，占用内存）
squares_list = [x**2 for x in range(1000000)]  # 内存占用高# 生成器表达式（惰性计算）
squares_gen = (x**2 for x in range(1000000))   # 内存占用低

6. 总结

核心优势：动态修改、有序存储、灵活的操作方法。
适用场景：动态数据集合、批量处理、多维数据表示、临时栈/队列。
避免误区：
- 不要依赖列表的顺序性进行高频率的头部操作（用 deque）。
- 注意浅拷贝的副作用，必要时使用 deepcopy。
高级技巧：
- 利用切片和推导式简化代码。
- 结合排序和自定义逻辑处理复杂数据。
- 使用生成器表达式优化内存。

列表是 Python 中最常用的数据结构，掌握其特性可显著提升编码效率！—

1. 元组的定义

元组（Tuple） 是 Python 中一种不可变（immutable）、有序的序列容器。

语法：用逗号分隔元素，通常用圆括号 () 包裹（括号可省略，但逗号必须有）。

# 定义元组
t1 = (1, 2, 3)       # 标准写法
t2 = 4, 5, 6         # 括号可省略
t3 = (7,)            # 单元素元组必须加逗号，否则会被识别为普通变量
t4 = ()              # 空元组

2. 元组的使用场景

(1) 数据不可变性需求

当需要确保数据不被意外修改时（如配置参数、常量集合）。
```
RGB_COLORS = ("RED", "GREEN", "BLUE")  # 颜色常量
```

(2) 作为字典的键

元组的不可变性使其可以作为字典的键，而列表或其他可变类型不行。
```
location_map = {(40.7128, -74.0060): "New York",(51.5074, -0.1278): "London"
}
```

(3) 函数多返回值

函数返回多个值时，Python 默认将其打包为元组。

def get_user_info():name = "Alice"age = 30return name, age  # 返回元组 ("Alice", 30)user = get_user_info()

(4) 性能优化

元组的内存占用比列表更小，适用于存储大量静态数据。

import sys
print(sys.getsizeof((1, 2, 3)))  # 72 bytes（Python 3.11）
print(sys.getsizeof([1, 2, 3]))  # 88 bytes

3. 元组的注意点

(1) 不可变性

元组一旦创建，元素不可增删改：

t = (1, 2, 3)
t[0] = 10  # 报错：TypeError: 'tuple' object does not support item assignment

(2) 包含可变对象时的陷阱

如果元组元素是可变对象（如列表），这些对象的内容仍可修改：

t = (1, [2, 3], 4)
t[1].append(5)  # 合法操作 → t 变为 (1, [2, 3, 5], 4)

(3) 单元素元组的定义

单元素元组必须加逗号，否则会被识别为普通变量：

not_a_tuple = (10)     # 类型是 int
a_tuple = (10,)        # 类型是 tuple

4. 与其他数据类型的区别

特性	元组（Tuple）	列表（List）	集合（Set）	字典（Dict）
可变性	不可变	可变	可变	可变（键不可变）
有序性	有序	有序	无序	有序（Python 3.7+）
语法	`()`	`[]`	`{}` 或 `set()`	`{key: value}`
元素唯一性	允许重复	允许重复	元素唯一	键唯一
典型用途	数据保护、字典键、返回值	动态数据集合	去重、集合运算	键值对映射

5. 元组的高级用法

(1) 元组解包（Unpacking）

快速将元组元素赋值给变量：

coordinates = (10, 20)
x, y = coordinates  # x=10, y=20

(2) 扩展解包（Extended Unpacking）

使用 * 捕获多个元素：

t = (1, 2, 3, 4, 5)
first, *middle, last = t  # first=1, middle=[2,3,4], last=5

(3) 命名元组（Named Tuple）

使用 collections.namedtuple 创建具有字段名的元组：

from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(10, y=20)
print(p.x, p.y)  # 输出 10 20（可通过字段名访问）

(4) 元组与函数参数

使用 * 将元组解包为函数参数：

def add(a, b):return a + bargs = (3, 5)
print(add(*args))  # 输出 8

(5) 元组生成式

生成器表达式生成元组：

t = tuple(i * 2 for i in range(5))  # (0, 2, 4, 6, 8)

6. 总结

元组的核心优势：不可变性、内存高效性、可哈希性（作为字典键）。
适用场景：保护数据安全、字典键、函数多返回值、性能敏感场景。
避免误区：不要误以为元组完全不可变（当元素为可变对象时）。
高级技巧：结合解包、命名元组、生成器表达式等提升代码可读性和效率。

元组是 Python 中简洁高效的工具，合理使用能提升代码的健壮性和性能。

1. 集合（Set）的定义

集合（Set） 是 Python 中一种无序、元素唯一的容器，支持数学中的集合运算（如并集、交集、差集等）。

语法：用大括号 {} 包裹元素（空集合必须用 set() 创建），元素间用逗号分隔。

# 定义集合
s1 = {1, 2, 3}          # 非空集合
s2 = set()              # 空集合（不能用 {}，否则是空字典）
s3 = {2, 2, 3, "a"}     # 重复元素自动去重 → {2, 3, "a"}

2. 集合的使用场景

(1) 数据去重

快速去除列表、元组等序列中的重复元素。

nums = [1, 2, 2, 3, 3, 3]
unique_nums = list(set(nums))  # 去重 → [1, 2, 3]

(2) 成员关系测试

集合的哈希表结构使得 in 操作的时间复杂度为 O(1)，远快于列表的 O(n)。

valid_users = {"Alice", "Bob", "Charlie"}
if "Alice" in valid_users:  # 高效判断print("Valid user")

(3) 集合运算

支持并集（|）、交集（&）、差集（-）、对称差集（^）等数学运算。

a = {1, 2, 3}
b = {2, 3, 4}
print(a | b)  # 并集 → {1, 2, 3, 4}
print(a & b)  # 交集 → {2, 3}
print(a - b)  # 差集（在 a 但不在 b） → {1}
print(a ^ b)  # 对称差集 → {1, 4}

(4) 过滤数据

结合集合运算筛选符合条件的元素。

all_products = {"A", "B", "C", "D"}
available_products = {"B", "C", "E"}
out_of_stock = all_products - available_products  # {"A", "D"}

3. 集合的注意点

(1) 元素必须是可哈希（Hashable）类型

集合元素只能是不可变类型（如整数、字符串、元组），不能是列表、字典等可变类型。

valid_set = {1, "a", (2, 3)}    # 合法
invalid_set = { [1, 2] }        # 报错：TypeError（列表不可哈希）

(2) 无序性

集合元素没有固定顺序，无法通过索引访问：

s = {3, 1, 2}
print(s)          # 可能输出 {1, 2, 3}（顺序不确定）
# print(s[0])     # 报错：'set' object is not subscriptable

(3) 动态修改

集合是可变类型，可以增删元素：

s = {1, 2}
s.add(3)          # 添加元素 → {1, 2, 3}
s.remove(2)       # 删除元素 → {1, 3}
s.discard(5)      # 删除不存在的元素不会报错

4. 与其他数据类型的区别

特性	集合（Set）	列表（List）	元组（Tuple）	字典（Dict）
有序性	无序	有序	有序	有序（Python 3.7+）
唯一性	元素唯一	允许重复	允许重复	键唯一
可变性	可变	可变	不可变	可变（键不可变）
语法	`{}` 或 `set()`	`[]`	`()`	`{key: value}`
典型用途	去重、集合运算、快速查找	动态数据序列	不可变数据序列	键值对映射

5. 集合的高级用法

(1) 集合推导式

类似列表推导式，生成集合：

s = {x**2 for x in range(5)}  # {0, 1, 4, 9, 16}

(2) 不可变集合（frozenset）

使用 frozenset 创建不可变集合，可作为字典的键或另一个集合的元素：
```
fs = frozenset([1, 2, 3])
d = {fs: "value"}  # 合法
```

(3) 批量更新操作

使用 update()、intersection_update() 等方法批量修改集合：

s = {1, 2}
s.update([3, 4])    # 添加多个元素 → {1, 2, 3, 4}
s.intersection_update({2, 3})  # 保留交集 → {2}

(4) 集合运算方法

使用内置方法替代运算符，支持更灵活的参数（如可迭代对象）：

a = {1, 2}
b = [2, 3]
print(a.union(b))      # {1, 2, 3}（参数可以是任意可迭代对象）

(5) 判断子集/超集

检查集合间的包含关系：

a = {1, 2}
b = {1, 2, 3}
print(a.issubset(b))    # True（a 是 b 的子集）
print(b.issuperset(a))  # True（b 是 a 的超集）

6. 总结

核心优势：元素唯一性、高效成员检测、集合运算。
适用场景：数据去重、关系测试、数学集合操作。
避免误区：
- 不要用集合存储重复数据或需要顺序的数据。
- 确保集合元素是不可变类型。
高级技巧：
- 利用 frozenset 实现不可变集合。
- 使用集合推导式简化代码。
- 结合运算符和方法灵活处理集合关系。

集合是处理唯一性数据和高效集合运算的利器，合理使用可大幅简化逻辑并提升性能。

1. 字典（Dictionary）的定义

字典（Dict） 是 Python 中一种键值对（Key-Value）形式的无序（Python 3.7+ 后有序）、可变容器。

语法：用大括号 {} 包裹键值对，键值间用冒号 : 分隔，键值对间用逗号 , 分隔。

# 定义字典
d1 = {"name": "Alice", "age": 25}          # 标准写法
d2 = dict(name="Bob", age=30)             # 使用 dict() 构造函数
d3 = {}                                   # 空字典

2. 字典的使用场景

(1) 高效键值映射

通过键快速查找、插入或更新值（时间复杂度 O(1)）。

user_info = {"id": 1001, "role": "admin"}
print(user_info["role"])  # 输出 "admin"

(2) 动态配置管理

存储程序配置参数或动态生成的数据结构。

config = {"debug_mode": True,"max_connections": 100,"allowed_ips": ["192.168.1.1", "10.0.0.1"]
}

(3) 数据聚合与统计

统计元素出现次数或分组数据。

words = ["apple", "banana", "apple", "orange"]
count = {}
for word in words:count[word] = count.get(word, 0) + 1  # {"apple": 2, "banana": 1, "orange": 1}

(4) JSON 数据交互

与 JSON 格式数据无缝转换（通过 json 模块）。

import json
data = '{"name": "Alice", "age": 25}'
dict_data = json.loads(data)  # 转为字典

3. 字典的注意点

(1) 键必须可哈希（Hashable）

字典的键必须是不可变类型（如整数、字符串、元组），不能是列表、字典等可变类型。

valid_key = ("ip", "port")    # 元组作为键（合法）
invalid_key = ["ip", "port"]  # 列表作为键（报错）

(2) 键的唯一性

同一字典中键不可重复，重复键会覆盖旧值：
```
d = {"a": 1, "a": 2}
print(d)  # 输出 {"a": 2}
```

(3) 无序性（Python 3.7 之前）

Python 3.7+ 后字典会保留插入顺序，但依赖顺序的逻辑需谨慎（建议用 collections.OrderedDict）。

(4) 访问不存在的键会报错

直接访问不存在的键会触发 KeyError，建议用 get() 方法或 in 检查：

d = {"a": 1}
print(d.get("b", 0))  # 输出 0（默认值）
if "b" in d:          # 安全检查print(d["b"])

4. 与其他数据类型的区别

特性	字典（Dict）	列表（List）	集合（Set）	元组（Tuple）
存储形式	键值对（Key-Value）	有序元素序列	无序唯一元素集合	不可变元素序列
访问方式	通过键访问（`d[key]`）	通过索引（`list[0]`）	无法直接索引访问	通过索引（`tuple[0]`）
可变性	可变	可变	可变	不可变
典型用途	映射关系、配置管理	动态数据集合	去重、集合运算	不可变数据保护

5. 字典的高级用法

(1) 字典推导式

快速生成字典：

squares = {x: x**2 for x in range(5)}  # {0:0, 1:1, 2:4, 3:9, 4:16}

(2) 合并字典

Python 3.5+ 使用 ** 或 | 运算符（Python 3.9+）：

d1 = {"a": 1}
d2 = {"b": 2}
merged = {**d1, **d2}          # {"a":1, "b":2}（Python 3.5+）
merged = d1 | d2               # Python 3.9+

(3) 处理缺失键

使用 defaultdict 自动处理缺失键：

from collections import defaultdict
dd = defaultdict(int)          # 缺失键默认值为 0
dd["count"] += 1               # 自动创建 "count":1

(4) 字典视图

通过 keys(), values(), items() 获取动态视图：

d = {"a": 1, "b": 2}
keys_view = d.keys()           # 键视图（动态反映字典变化）
d["c"] = 3
print(list(keys_view))         # ["a", "b", "c"]

(5) 嵌套字典

字典值可以是其他容器（如字典、列表）：

employees = {"Alice": {"age": 30, "role": "Engineer"},"Bob": {"age": 25, "role": "Designer"}
}
print(employees["Alice"]["role"])  # "Engineer"

(6) 有序字典（OrderedDict）

保留键的插入顺序（Python 3.7+ 普通字典已有序，但 OrderedDict 支持额外操作）：

from collections import OrderedDict
od = OrderedDict()
od["a"] = 1
od["b"] = 2
od.move_to_end("a")            # 将 "a" 移动到最后

(7) 字典解包

解包字典为函数参数：

def connect(host, port):print(f"Connecting to {host}:{port}")params = {"host": "localhost", "port": 8080}
connect(**params)  # 输出 "Connecting to localhost:8080"

6. 总结

核心优势：高效的键值映射、灵活的动态修改、与 JSON 的天然兼容。
适用场景：数据聚合、配置管理、JSON 交互、动态结构化数据存储。
避免误区：
- 不要用可变对象作为键。
- 访问不存在的键时使用 get() 或 in 检查。
- 注意 Python 版本对字典有序性的影响。
高级技巧：
- 利用推导式和 defaultdict 简化代码。
- 结合视图操作和嵌套结构处理复杂数据。
- 使用 OrderedDict 或 Python 3.7+ 的字典保留顺序。