在 Python 中，列表推导式（List Comprehensions）是一种非常简洁且功能强大的语法，用于创建列表。嵌套循环的推导式可以用来处理多维数据或者需要多个迭代变量的情况。通过嵌套循环的推导式，可以将多层循环结构简化为一行代码。
以下是一个使用嵌套循环推导式的示例：
### 示例：生成二维数组的扁平化列表
```python
# 二维数组
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 使用嵌套循环推导式将二维数组转换为一维数组
flattened = [element for row in matrix for element in row]
print(flattened) # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9]
```
在上面的示例中，`element for row in matrix for element in row` 是嵌套循环推导式的核心部分。外层循环遍历 `matrix` 中的每一行 `row`，内层循环遍历每一行中的元素 `element`，最终将所有元素收集到一个新的列表 `flattened` 中。
### 示例：生成两个列表的笛卡尔积
```python
# 两个列表
list1 = [1, 2, 3]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积
cartesian_product = [(x, y) for x in list1 for y in list2]
print(cartesian_product) # 输出: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b')]
```
在上面的示例中，`[(x, y) for x in list1 for y in list2]` 表达式生成了两个列表的笛卡尔积，其中外层循环遍历 `list1` 的元素 `x`，内层循环遍历 `list2` 的元素 `y`，并将每一对 `(x, y)` 组合成一个元组。
### 示例：过滤二维数组中的元素
```python
# 二维数组
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 使用嵌套循环推导式并添加条件，筛选偶数
even_numbers = [element for row in matrix for element in row if element % 2 == 0]
print(even_numbers) # 输出: [2, 4, 6, 8]
```
在这个示例中，通过条件 `if element % 2 == 0` 过滤出所有偶数。
### 示例：生成三维数组的索引组合
```python
# 三维数组的维度
dim1 = 2
dim2 = 3
dim3 = 2
# 使用嵌套循环推导式生成所有索引组合
indices = [(i, j, k) for i in range(dim1) for j in range(dim2) for k in range(dim3)]
print(indices)
# 输出: [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (0, 2, 0), (0, 2, 1),
# (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1), (1, 2, 0), (1, 2, 1)]
```
这个示例展示了如何生成三维数组的所有索引组合，通过嵌套循环推导式遍历 `i`、`j` 和 `k` 的所有可能值。
### 示例：生成字符串的组合
```python
# 两个字符串列表
words1 = ["apple", "banana"]
words2 = ["red", "yellow"]
# 使用嵌套循环推导式生成字符串组合
combinations = [w1 + " is " + w2 for w1 in words1 for w2 in words2]
print(combinations) # 输出: ['apple is red', 'apple is yellow', 'banana is red', 'banana is yellow']
```
在这个示例中，通过嵌套循环推导式遍历两个列表中的字符串，并将它们组合成新的字符串。
### 示例：生成多个列表的组合
```python
# 三个列表
list1 = [1, 2]
list2 = ['a', 'b']
list3 = [True, False]
# 使用嵌套循环推导式生成三个列表的组合
combinations = [(x, y, z) for x in list1 for y in list2 for z in list3]
print(combinations)
# 输出: [(1, 'a', True), (1, 'a', False), (1, 'b', True), (1, 'b', False),
# (2, 'a', True), (2, 'a', False), (2, 'b', True), (2, 'b', False)]
```
这个示例展示了如何生成三个列表的所有组合。
### 示例：生成字典的键值对
```python
# 字典
data = {'fruits': ['apple', 'banana'], 'colors': ['red', 'yellow']}
# 使用嵌套循环推导式生成键值对的组合
key_value_pairs = [(key, value) for key in data for value in data[key]]
print(key_value_pairs) # 输出: [('fruits', 'apple'), ('fruits', 'banana'), ('colors', 'red'), ('colors', 'yellow')]
```
在这个示例中，嵌套循环推导式遍历了字典的键和对应的值，生成了键值对的组合。
### 示例：生成多个范围的组合
```python
# 生成两个范围的组合
range1 = range(1, 3)
range2 = range(10, 13)
# 使用嵌套循环推导式生成组合
combinations = [(x, y) for x in range1 for y in range2]
print(combinations) # 输出: [(1, 10), (1, 11), (1, 12), (2, 10), (2, 11), (2, 12)]
```
这个示例展示了如何生成两个范围的所有组合。
### 示例：生成多个列表的笛卡尔积并求和
```python
# 两个列表
list1 = [1, 2, 3]
list2 = [10, 20]
# 使用嵌套循环推导式生成笛卡尔积并求和
sum_combinations = [x + y for x in list1 for y in list2]
print(sum_combinations) # 输出: [11, 21, 12, 22, 13, 23]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并对每对元素进行了求和。
### 示例：生成多个列表的笛卡尔积并筛选特定条件
```python
# 两个列表
list1 = [1, 2, 3]
list2 = [10, 20]
# 使用嵌套循环推导式生成笛卡尔积，并筛选和大于 25 的组合
filtered_combinations = [(x, y) for x in list1 for y in list2 if x + y > 25]
print(filtered_combinations) # 输出: [(3, 20)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选特定的组合。
### 示例：生成多个列表的笛卡尔积并生成字符串
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成字符串
string_combinations = [f"Item {x} is {y}" for x in list1 for y in list2]
print(string_combinations) # 输出: ['Item 1 is a', 'Item 1 is b', 'Item 2 is a', 'Item 2 is b']
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并将每对元素组合成一个字符串。
### 示例：生成多个列表的笛卡尔积并生成字典
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成字典
dict_combinations = [{'id': x, 'letter': y} for x in list1 for y in list2]
print(dict_combinations)
# 输出: [{'id': 1, 'letter': 'a'}, {'id': 1, 'letter': 'b'},
# {'id': 2, 'letter': 'a'}, {'id': 2, 'letter': 'b'}]
```
这个示例展示了如何生成两个列表的笛卡尔积，并将每对元素组合成一个字典。
### 示例：生成多个列表的笛卡尔积并生成元组
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成元组
tuple_combinations = [(x, y) for x in list1 for y in list2]
print(tuple_combinations) # 输出: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并将每对元素组合成一个元组。
### 示例：生成多个列表的笛卡尔积并生成集合
```python
# 两个列表
list1 = [1, 2]
list2 = [2, 3]
# 使用嵌套循环推导式生成笛卡尔积，并生成集合
set_combinations = {(x, y) for x in list1 for y in list2}
print(set_combinations) # 输出: {(1, 2), (1, 3), (2, 2), (2, 3)}
```
这个示例展示了如何生成两个列表的笛卡尔积，并将每对元素组合成一个集合。
### 示例：生成多个列表的笛卡尔积并生成字符串列表
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成字符串列表
string_list_combinations = [[str(x), y] for x in list1 for y in list2]
print(string_list_combinations) # 输出: [['1', 'a'], ['1', 'b'], ['2', 'a'], ['2', 'b']]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并将每对元素组合成一个字符串列表。
### 示例：生成多个列表的笛卡尔积并生成嵌套列表
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成嵌套列表
nested_list_combinations = [[x, y] for x in list1 for y in list2]
print(nested_list_combinations) # 输出: [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]
```
这个示例展示了如何生成两个列表的笛卡尔积，并将每对元素组合成一个嵌套列表。
### 示例：生成多个列表的笛卡尔积并生成嵌套字典
```python
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成嵌套字典
nested_dict_combinations = [{'outer': x, 'inner': {'letter': y}} for x in list1 for y in list2]
print(nested_dict_combinations)
# 输出: [{'outer': 1, 'inner': {'letter': 'a'}}, {'outer': 1, 'inner': {'letter': 'b'}},
# {'outer': 2, 'inner': {'letter': 'a'}}, {'outer': 2, 'inner': {'letter': 'b'}}]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并将每对元素组合成一个嵌套字典。
### 示例：生成多个列表的笛卡尔积并生成自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Pair(x={self.x}, y={self.y})"
# 两个列表
list1 = [1, 2]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成自定义对象
object_combinations = [Pair(x, y) for x in list1 for y in list2]
print(object_combinations)
# 输出: [Pair(x=1, y='a'), Pair(x=1, y='b'), Pair(x=2, y='a'), Pair(x=2, y='b')]
```
这个示例展示了如何生成两个列表的笛卡尔积，并将每对元素组合成一个自定义对象。
### 示例：生成多个列表的笛卡尔积并生成带有条件的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y):
self.x = x
self.y = y
def __repr__(self):
return f"Pair(x={self.x}, y={self.y})"
# 两个列表
list1 = [1, 2, 3]
list2 = ['a', 'b']
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件的自定义对象
object_combinations = [Pair(x, y) for x in list1 for y in list2 if x > 1]
print(object_combinations)
# 输出: [Pair(x=2, y='a'), Pair(x=2, y='b'), Pair(x=3, y='a'), Pair(x=3, y='b')]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并通过条件筛选生成了自定义对象。
### 示例：生成多个列表的笛卡尔积并生成带有额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2]
list2 = [3, 4]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2]
print(object_combinations)
# 输出: [Pair(x=1, y=3, product=3), Pair(x=1, y=4, product=4),
# Pair(x=2, y=3, product=6), Pair(x=2, y=4, product=8)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并将每对元素组合成一个自定义对象，同时计算额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
在这个示例中，嵌套循环推导式生成了两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, 5]
# 使用嵌套循环推导式生成笛卡尔积，并生成带有条件和额外计算的自定义对象
object_combinations = [Pair(x, y, x * y) for x in list1 for y in list2 if x + y > 6]
print(object_combinations)
# 输出: [Pair(x=2, y=5, product=10), Pair(x=3, y=4, product=12), Pair(x=3, y=5, product=15)]
```
这个示例展示了如何生成两个列表的笛卡尔积，并通过条件筛选生成了自定义对象，同时计算了额外的属性。
### 示例：生成多个列表的笛卡尔积并生成带有条件和额外计算的自定义对象
```python
# 定义一个简单的类
class Pair:
def __init__(self, x, y, product):
self.x = x
self.y = y
self.product = product
def __repr__(self):
return f"Pair(x={self.x}, y={self.y}, product={self.product})"
# 两个列表
list1 = [1, 2, 3]
list2 = [4, ......
</think>
本文介绍Python中嵌套列表推导式的用法，通过示例展示如何使用嵌套列表推导来创建矩阵，对比传统嵌套for循环，提供了一种更简洁高效的编程方式。
扫一扫
1042
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
