Python 中的列表推导式是一种简洁的方式来创建新的列表，它允许您通过对一个或多个可迭代对象中的元素进行操作，生成一个新的列表。
Python 列表推导式语法
语法： new_list = [expression for item in iterable if condition]
范围：
expression：定义了一个表达式，用于对可迭代对象中的每个元素进行操作，以生成新列表中的元素。item：代表可迭代对象中的每个元素，您可以在 expression 中使用它。iterable：可迭代对象，通常是列表、元组、集合或字符串等。condition：一个可选的条件，用于筛选可迭代对象中的元素。只有满足条件的元素才会包含在新列表中。
返回：列表推导式的返回值是一个新列表，其中包含满足给定条件的修改元素。
Python 列表推导式提供了一种更短的语法，用于根据现有列表的值创建新列表。
Python 示例中的列表推导式
下面是在 Python 中使用列表推导式求数字平方的示例。
numbers = [1, 2, 3, 4, 5]
squared = [x ** 2 for x in numbers]
print(squared)
输出：
[1,4,9,16,25]使用列表推导式进行迭代
在此示例中，我们将 1、2 和 3 分配给列表，并使用列表理解打印列表。
# 使用列表推导式迭代循环
List = [character for character in [1, 2, 3]]
# 显示列表
print(List)
输出：
[1,2,3]使用列表推导式创建矩阵（二维列表）
matrix = [[j for j in range(3)] for i in range(3)]
print(matrix)
输出：
[[0, 1, 2], [0, 1, 2], [0, 1, 2]]
列表推导式与 For 循环
有多种方法可以迭代列表。然而，最常见的方法是使用for循环。让我们看下面的例子：
此代码演示了使用传统的循环方法将字符串中的字符添加到空列表中。
# 创建一个空列表
List = []
# 使用传统的迭代方法
for character in 'Jkhxw 4 Geeks!':
List.append(character)
# 显示列表
print(List)
输出：
['J', 'k', 'h', 'x', 'w', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']上面是迭代列表、字符串、元组等的传统方法的实现。现在，Python 中的列表理解可以完成相同的任务，并且还使程序更加简单。
列表推导式将使用for 循环的传统迭代方法转化为简单的公式，从而使其易于使用。下面是在 Python 中使用列表理解来迭代列表、字符串、元组等的方法。
# 使用列表推导式迭代字符串中的字符
List = [character for character in 'Jkhxw 4 Geeks!']
# 显示列表
print(List)
输出：
['J', 'k', 'h', 'x', 'w', ' ', '4', ' ', 'G', 'e', 'e', 'k', 's', '!']列表推导式和循环中的时间分析
Python 中的列表推导式在计算以及编码空间和时间方面都比 for 循环更高效。通常，它们是用一行代码编写的。下面的程序根据性能描述了循环和列表推导式之间的差异。
# 导入所需的模块
import time
# 定义用于实现for循环的函数
def for_loop(n):
result = []
for i in range(n):
result.append(i**2)
return result
# 定义用于实现列表推导式的函数
def list_comprehension(n):
return [i**2 for i in range(n)]
# 主程序
# 计算 for_loop() 所花费的时间
begin = time.time()
for_loop(10**6)
end = time.time()
# 显示 for_loop() 所花费的时间
print('for_loop() 所花费的时间:', round(end - begin, 2))
# 计算 list_comprehension() 所花费的时间
begin = time.time()
list_comprehension(10**6)
end = time.time()
# 显示 list_comprehension() 所花费的时间
print('list_comprehension() 所花费的时间:', round(end - begin, 2))
输出：
for_loop() 所花费的时间: 0.28
list_comprehension() 所花费的时间: 0.25从上面的程序中，我们可以看到列表推导式比 for 循环要快得多。
嵌套列表推导式
嵌套列表推导式只不过是另一个列表推导式中的列表推导式，与嵌套 for 循环非常相似。下面是实现嵌套循环的程序：
matrix = []
for i in range(3):
# 在列表中添加一个空的子列表
matrix.append([])
for j in range(5):
matrix[i].append(j)
print(matrix)
输出：
[[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4]]以上代码创建了一个3×5的矩阵（二维列表），并使用嵌套的 for 循环填充矩阵的元素。
现在，通过使用嵌套列表推导式，可以用更少的代码行生成相同的输出。
# Nested list comprehension
matrix = [[j for j in range(5)] for i in range(3)]
print(matrix)
输出：
[[0,1,2,3,4],[0,1,2,3,4],[0,1,2,3,4]]列表推导式和 Lambda
Lambda 表达式只不过是 Python 函数的简写表示。将列表推导式与 lambda 结合使用可以创建有效的组合。让我们看看下面的例子：
在此示例中，我们在列表中插入 10 到 50 之间的数字并打印它。
numbers = []
for i in range(1, 6):
numbers.append(i * 10)
print(numbers)
输出：
[10、20、30、40、50]现在，我们仅使用列表推导式来显示包含10的倍数的列表。
numbers = list(map(lambda i: i * 10, [i for i in range(1, 6)]))
print(numbers)
输出：
[10、20、30、40、50]说明：在这段代码中，首先使用列表推导式 [i for i in range(1, 6)] 创建了包含数字1到5的列表。然后，map 函数将 lambda 函数应用于这个列表中的每个元素，lambda 函数将每个元素 i 转换为 i * 10，生成10的倍数。最后，使用 list() 将结果转换为列表，并打印出包含10的倍数的列表。
列表推导式中的条件
我们还可以向列表推导式添加条件语句。我们可以使用range()、运算符等创建列表，并且 cal 还使用if 语句对列表应用一些条件。
使用 If-else 的 Python 列表推导式
在示例中，我们检查从 0 到 7，如果数字是偶数，则将偶数插入到列表中，否则将奇数插入到列表中。
lis = ["偶数" if i % 2 == 0 else "奇数" for i in range(8)]
print(lis)
输出：
['偶数', '奇数', '偶数', '奇数', '偶数', '奇数', '偶数', '奇数']带有列表推导式的嵌套 IF
在此示例中使用列表推导式筛选出了在0到99范围内同时是5的倍数和10的倍数的数字，然后打印它。
lis = [num for num in range(100)
if num % 5 == 0 if num % 10 == 0]
print(lis)
输出：
[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]显示 1 到 10 之间的数字方块
在此示例中用列表推导式生成了1到10的数字的平方，并将这些平方数存储在列表中，然后打印列表。
# 生成1到10的数字的平方
squares = [n**2 for n in range(1, 11)]
# 显示偶数的平方
print(squares)
输出：
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]显示二维矩阵的转置
在此示例中，我们使用列表推导式对矩阵进行转置。
# 分配二维矩阵
twoDMatrix = [[10, 20, 30],
[40, 50, 60],
[70, 80, 90]]
# 生成转置矩阵
trans = [[i[j] for i in twoDMatrix] for j in range(len(twoDMatrix[0]))]
print(trans)
输出：
[[10, 40, 70], [20, 50, 80], [30, 60, 90]]切换字符串中每个字符的大小写
在此示例中，我们使用 XOR 运算符与 32 切换给定字符串中每个字符的大小写，并将结果存储在列表中。
# 初始化字符串
string = 'Jkhxw4Geeks'
# 切换每个字符的大小写
List = list(map(lambda i: chr(ord(i) ^ 32), string))
# 显示列表
print(List)
输出：
['j', 'K', 'H', 'X', 'W', '\x14', 'g', 'E', 'E', 'K', 'S']反转元组中的每个字符串
在此示例中，我们在 for 循环中反转字符串并将它们插入到列表中，然后打印列表。
# 对元组中的每个字符串进行反转
List = [string[::-1] for string in ('Jkhxw', 'for', 'Geeks')]
# 显示列表
print(List)
输出：
['wxhkJ', 'rof', 'skeeG']从两个单独的列表创建包含元组的列表
在此示例中，我们创建了两个姓名和年龄列表。我们在列表推导式中使用zip() ，并将姓名和年龄作为元组插入到列表中。最后，我们打印元组列表。
names = ["G", "G", "g"]
ages = [25, 30, 35]
person_tuples = [(name, age) for name, age in zip(names, ages)]
print(person_tuples)
输出：
[('G', 25), ('G', 30), ('g', 35)]显示列表中所有奇数元素的数字之和。
在这个例子中，我们创建了一个列表，我们正在查找列表中每个奇数元素的数字和。
# 显式函数
def digitSum(n):
dsum = 0
for ele in str(n):
dsum += int(ele)
return dsum
# 初始化列表
List = [367, 111, 562, 945, 6726, 873]
# 对列表中的奇数元素应用函数
newList = [digitSum(i) for i in List if i & 1]
# 显示新列表
print(newList)
输出：
[16, 3, 18, 18]列表推导式的优点
- 比循环更节省时间和空间。
- 需要更少的代码行。
- 将迭代语句转换为公式。
原创文章，作者：jkhxw，如若转载，请注明出处：https://www.jkhxw.com/python-list-comprehension/
