一、推导式语法结构

1.1 基本组成

推导式由三个核心部分组成：

第一部分：表达式
对每个元素进行的操作或计算结果，这个表达式决定了最终生成的元素是什么样子。

第二部分：循环体
遍历可迭代对象的循环语句，用于取出每个元素进行处理。

第三部分：条件语句
可选的过滤条件，只有满足条件的元素才会被保留，不满足条件的会被过滤掉。

1.2 语法格式

完整语法格式和不带条件的简化语法

1.3 各部分说明

• 表达式：可以是简单的变量，也可以是复杂的运算或函数调用

• for 变量 in 可迭代对象：遍历获取每个元素

• if 条件：可选部分，用于筛选符合条件的元素

1.4 代码示例

完整语法（带条件）：

result, = [i for i in range(10) if i % 2 == 0]
# 结果：[0, 2, 4 6, 8]

简化语法（不带条件）：

result = [i**2 for i in range(5)]
# 结果：[0, 1, 4, 9, 16]

二、列表推导式

2.1 基本用法

# 传统方式（3行）
result = []
for i in range(10):
    if i % 2 == 0:
        result.append(i)
print(result)  # [0, 2, 4, 6, 8]

# 列表推导式（1行）
result = [i for i in range(10) if i % 2 == 0]
print(result)  # [0, 2, 4, 6, 8]

2.2 常见示例

# 1. 生成1-100的奇数
odd = [i for i in range(1, 100) if i % 2]
print(odd)  # [1, 3, 5, ..., 99]

# 2. 平方数列表
squares = [i**2 for i in range(10)]
print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# 3. 字符串处理
words = ["hello", "world", "python"]
upper_words = [word.upper() for word in words]
print(upper_words)  # ['HELLO', 'WORLD', 'PYTHON']

# 4. 带条件过滤
numbers = [1, 2, 3, 4, 5, 6, 7, 8]
even = [x for x in numbers if x % 2 == 0]
print(even)  # [2, 4, 6, 8]

2.3 多层循环

# 传统方式
result = []
for x in range(3):
    for y in range(3):
        result.append((x, y))

# 推导式
result = [(x, y) for x in range(3) for y in range(3)]
print(result)  # [(0,0), (0,1), (0,2), (1,0), (1,1), ...]

2.4 if-else 表达式

# 先if后else（在表达式中使用）
result = [x if x % 2 == 0 else -x for x in range(10)]
print(result)  # [0, -1, 2, -3, 4, -5, 6, -7, 8, -9]

# 后置if（仅过滤）
result = [x for x in range(10) if x % 2 == 0]
print(result)  # [0, 2, 4, 6, 8]

---

三、元组推导式（生成器）

元组推导式返回的是生成器对象，而不是元组。

# ❌ 错误：这不是元组推导式
t = (i for i in range(10))  # 这是生成器
print(type(t))  # <class 'generator'>

# ✅ 正确：使用 tuple() 转换为元组
t = tuple(i for i in range(10))
print(type(t))  # <class 'tuple'>

3.1 生成器的优势

# 列表：占用大量内存
lst = [i for i in range(100000)]
print(lst.__sizeof__())  # 较大内存

# 生成器：几乎不占用内存
gen = (i for i in range(100000))
print(gen.__sizeof__())  # 很小内存

# 生成器不能使用索引
# print(gen[0])  # ❌ TypeError

# 只能遍历一次
for item in gen:
    print(item)
    break  # 只能从头开始遍历

3.2 内存对比

# 列表内存占用
list_data = [i for i in range(1000)]
print(f"列表占用: {list_data.__sizeof__()} bytes")

# 生成器内存占用
gen_data = (i for i in range(1000))
print(f"生成器占用: {gen_data.__sizeof__()} bytes")

# 输出示例：
# 列表占用: 8856 bytes
# 生成器占用: 112 bytes

---

四、字典推导式

字典推导式返回 dict，表达式必须是 key: value 形式。

# 基本语法
{key_expression: value_expression for item in iterable if condition}

4.1 基本用法

# 1. 键值互换
d = {"a": 1, "b": 2, "c": 3}
new_d = {v: k for k, v in d.items()}
print(new_d)  # {1: 'a', 2: 'b', 3: 'c'}

# 2. 对值进行操作
d = {"a": 1, "b": 2, "c": 3}
new_d = {k: v**2 for k, v in d.items()}
print(new_d)  # {'a': 1, 'b': 4, 'c': 9}

# 3. 带条件过滤
d = {"a": 1, "b": 2, "c": 3, "d": 4}
new_d = {k: v for k, v in d.items() if v % 2 == 0}
print(new_d)  # {'b': 2, 'd': 4}

# 4. 从列表创建字典
keys = ["name", "age", "city"]
values = ["张三", 20, "北京"]
d = {k: v for k, v in zip(keys, values)}
print(d)  # {'name': '张三', 'age': 20, 'city': '北京'}

4.2 zip() 配合使用

keys = ["a", "b", "c", "d"]
values = [1, 2, 3, 4]

# 传统方式
d = {}
for i in range(len(keys)):
    d[keys[i]] = values[i]

# 推导式 + zip()
d = {k: v for k, v in zip(keys, values)}
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

---

五、集合推导式

集合推导式返回 set，表达式是单个元素，自动去重。

# 基本语法
{expression for item in iterable if condition}

5.1 基本用法

# 1. 生成集合（自动去重）
s = {i % 3 for i in range(10)}
print(s)  # {0, 1, 2}

# 2. 平方数集合
squares = {i**2 for i in range(5)}
print(squares)  # {0, 1, 4, 9, 16}

# 3. 带条件
s = {i for i in range(10) if i % 2 == 0}
print(s)  # {0, 2, 4, 6, 8}

# 4. 字符串处理
words = ["hello", "world", "python", "hello"]
unique_lengths = {len(word) for word in words}
print(unique_lengths)  # {5, 6}（自动去重）

---

六、enumerate() 与 zip()

6.1 enumerate()：获取索引和值

# 传统方式
names = ["a", "b", "c", "d"]
for i in range(len(names)):
    print(i, names[i])

# enumerate方式（推荐）
for index, name in enumerate(names):
    print(index, name)

# 推导式中使用
pairs = [(i, name) for i, name in enumerate(names)]
print(pairs)  # [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')]

6.2 zip()：并行遍历多个序列

keys = ["a", "b", "c", "d"]
values = [1, 2, 3, 4]

# 传统方式
for i in range(len(keys)):
    print(keys[i], values[i])

# zip方式（推荐）
for key, value in zip(keys, values):
    print(key, value)

# 推导式中使用
d = {k: v for k, v in zip(keys, values)}
print(d)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

# 多个序列
names = ["张三", "李四", "王五"]
ages = [20, 22, 19]
cities = ["北京", "上海", "广州"]

result = [{"name": n, "age": a, "city": c} 
          for n, a, c in zip(names, ages, cities)]
print(result)

---

七、性能对比

import time

# 传统循环 vs 推导式
n = 1000000

# 传统方式
start = time.time()
result = []
for i in range(n):
    if i % 2 == 0:
        result.append(i)
print(f"循环耗时: {time.time() - start:.4f}s")

# 推导式
start = time.time()
result = [i for i in range(n) if i % 2 == 0]
print(f"推导式耗时: {time.time() - start:.4f}s")

# 输出示例：
# 循环耗时: 0.1234s
# 推导式耗时: 0.0789s（更快）