使用 Python 列表推导式进行条件过滤的 18 个例子-51CTO.COM

大家好！今天我们要聊一聊Python中的列表推导式（List Comprehensions）。列表推导式是一种简洁而强大的方式，可以在一行代码中创建列表，并且可以轻松地添加条件过滤。如果你还不熟悉列表推导式，不用担心，我们会从基础开始，一步步介绍更高级的概念。

1.基本列表推导式

首先，我们来看一个最简单的列表推导式，它只是将一个列表中的每个元素乘以2。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式
doubled_numbers = [num * 2 for num in numbers]

print(doubled_numbers)  # 输出: [2, 4, 6, 8, 10]# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式
doubled_numbers = [num * 2 for num in numbers]

print(doubled_numbers)  # 输出: [2, 4, 6, 8, 10]# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式
doubled_numbers = [num * 2 for num in numbers]

print(doubled_numbers)  # 输出: [2, 4, 6, 8, 10]

解释：这里，[num * 2 for num in numbers] 是一个列表推导式，它遍历 numbers 列表中的每个元素 num，并将每个 num 乘以2，最终生成一个新的列表 doubled_numbers。

22.添加条件过滤

接下来，我们加上一个条件过滤，只保留偶数。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
even_numbers = [num for num in numbers if num % 2 == 0]

print(even_numbers)  # 输出: [2, 4]

解释：这里，if num % 2 == 0 是一个条件过滤，只有当 num 是偶数时，才会被包含在新的列表 even_numbers 中。

3.多重条件过滤

我们可以添加多个条件过滤，例如只保留大于2且小于5的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加多重条件过滤
filtered_numbers = [num for num in numbers if num > 2 and num < 5]

print(filtered_numbers)  # 输出: [3, 4]

解释：这里，if num > 2 and num < 5 是一个多重条件过滤，只有当 num 大于2且小于5时，才会被包含在新的列表 filtered_numbers 中。

4.字符串列表的条件过滤

我们也可以对字符串列表进行条件过滤，例如只保留长度大于3的字符串。

# 原始字符串列表
words = ["apple", "banana", "cherry", "date"]

# 列表推导式加条件过滤
long_words = [word for word in words if len(word) > 3]

print(long_words)  # 输出: ['apple', 'banana', 'cherry']

解释：这里，if len(word) > 3 是一个条件过滤，只有当 word 的长度大于3时，才会被包含在新的列表 long_words 中。

5.嵌套列表推导式

我们可以嵌套多个列表推导式，例如生成一个二维列表，并过滤掉所有0。

# 原始二维列表
matrix = [[1, 0, 3], [4, 0, 6], [7, 8, 0]]

# 嵌套列表推导式加条件过滤
filtered_matrix = [[num for num in row if num != 0] for row in matrix]

print(filtered_matrix)  # 输出: [[1, 3], [4, 6], [7, 8]]

解释：这里，外层的列表推导式遍历 matrix 中的每一行 row，内层的列表推导式遍历 row 中的每个元素 num，并过滤掉所有为0的元素。

6.使用 and 和 or 进行条件过滤

我们可以使用 and 和 or 来组合多个条件，例如只保留大于2或小于4的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
filtered_numbers = [num for num in numbers if num > 2 or num < 4]

print(filtered_numbers)  # 输出: [1, 2, 3, 5]

解释：这里，if num > 2 or num < 4 是一个条件过滤，只有当 num 大于2或小于4时，才会被包含在新的列表 filtered_numbers 中。

7.使用 not 进行条件过滤

我们可以使用 not 来反转条件，例如只保留不是偶数的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
odd_numbers = [num for num in numbers if not num % 2 == 0]

print(odd_numbers)  # 输出: [1, 3, 5]

解释：这里，if not num % 2 == 0 是一个条件过滤，只有当 num 不是偶数时，才会被包含在新的列表 odd_numbers 中。

8.使用 in 和 not in 进行条件过滤

我们可以使用 in 和 not in 来检查元素是否存在于某个集合中，例如只保留存在于另一个列表中的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]
allowed_numbers = [2, 4, 6]

# 列表推导式加条件过滤
filtered_numbers = [num for num in numbers if num in allowed_numbers]

print(filtered_numbers)  # 输出: [2, 4]

解释：这里，if num in allowed_numbers 是一个条件过滤，只有当 num 存在于 allowed_numbers 中时，才会被包含在新的列表 filtered_numbers 中。

9.使用 lambda 函数进行条件过滤

我们可以使用 lambda 函数来定义复杂的条件，例如只保留平方后大于10的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
filtered_numbers = [num for num in numbers if (lambda x: x ** 2 > 10)(num)]

print(filtered_numbers)  # 输出: [4, 5]

解释：这里，(lambda x: x ** 2 > 10)(num) 是一个 lambda 函数，它计算 num 的平方，并检查是否大于10。只有当 num 的平方大于10时，才会被包含在新的列表 filtered_numbers 中。

10.使用 enumerate

进行条件过滤我们可以使用 enumerate 函数来获取元素的索引，例如只保留索引为偶数的元素。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
filtered_numbers = [num for i, num in enumerate(numbers) if i % 2 == 0]

print(filtered_numbers)  # 输出: [1, 3, 5]

解释：这里，for i, num in enumerate(numbers) 使用 enumerate 函数获取每个元素的索引 i 和值 num，if i % 2 == 0 是一个条件过滤，只有当 i 是偶数时，才会被包含在新的列表 filtered_numbers 中。

11.使用 zip 进行条件过滤

我们可以使用 zip 函数来同时遍历多个列表，并进行条件过滤，例如只保留两个列表中对应位置相等的元素。

# 原始列表
list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 6, 4, 7]

# 列表推导式加条件过滤
filtered_numbers = [a for a, b in zip(list1, list2) if a == b]

print(filtered_numbers)  # 输出: [1, 2, 4]

解释：这里，for a, b in zip(list1, list2) 使用 zip 函数同时遍历 list1 和 list2，if a == b 是一个条件过滤，只有当 a 和 b 相等时，才会被包含在新的列表 filtered_numbers 中。

12.使用 filter 函数进行条件过滤

虽然 filter 函数不是列表推导式的一部分，但我们可以将其与列表推导式结合使用，例如只保留平方后大于10的数字。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 定义过滤函数
def is_square_greater_than_10(x):
    return x ** 2 > 10

# 列表推导式加条件过滤
filtered_numbers = [num for num in filter(is_square_greater_than_10, numbers)]

print(filtered_numbers)  # 输出: [4, 5]

13.使用 any 和 all 进行条件过滤

我们可以使用 any 和 all 函数来处理更复杂的条件，例如只保留包含至少一个元音字母的单词。

# 原始字符串列表
words = ["apple", "banana", "cherry", "date"]

# 列表推导式加条件过滤
vowel_words = [word for word in words if any(vowel in word for vowel in 'aeiou')]

print(vowel_words)  # 输出: ['apple', 'banana', 'cherry', 'date']

解释：这里，if any(vowel in word for vowel in 'aeiou') 是一个条件过滤，any 函数检查 word 中是否包含任何元音字母。如果 word 中包含至少一个元音字母，那么该单词会被包含在新的列表 vowel_words 中。

14.使用 map 和 filter 结合列表推导式

我们可以将 map 和 filter 函数与列表推导式结合使用，例如将所有数字转换为字符串，并只保留长度大于3的字符串。

# 原始列表
numbers = [1, 2, 3, 4, 5]

# 列表推导式加条件过滤
filtered_strings = [str(num) for num in map(str, numbers) if len(str(num)) > 3]

print(filtered_strings)  # 输出: []

解释：这里，map(str, numbers) 将 numbers 中的每个元素转换为字符串。[str(num) for num in map(str, numbers) if len(str(num)) > 3] 是一个列表推导式，它遍历转换后的字符串列表，并使用 if len(str(num)) > 3 过滤出长度大于3的字符串。在这个例子中，没有长度大于3的字符串，所以输出为空列表。

15.使用 set 进行条件过滤

我们可以使用 set 来去重并进行条件过滤，例如只保留唯一的偶数。

# 原始列表
numbers = [1, 2, 2, 3, 4, 4, 5]

# 列表推导式加条件过滤
unique_even_numbers = [num for num in set(numbers) if num % 2 == 0]

print(unique_even_numbers)  # 输出: [2, 4]

解释：这里，set(numbers) 将 numbers 转换为一个集合，去除了重复的元素。[num for num in set(numbers) if num % 2 == 0] 是一个列表推导式，它遍历去重后的集合，并使用 if num % 2 == 0 过滤出偶数。

16.使用 dict 进行条件过滤

我们可以使用 dict 来过滤字典中的键值对，例如只保留值大于10的键值对。

# 原始字典
data = {'a': 5, 'b': 15, 'c': 10, 'd': 20}

# 列表推导式加条件过滤
filtered_items = [(key, value) for key, value in data.items() if value > 10]

print(filtered_items)  # 输出: [('b', 15), ('d', 20)]

解释：这里，data.items() 返回字典中的键值对。[(key, value) for key, value in data.items() if value > 10] 是一个列表推导式，它遍历字典中的每个键值对，并使用 if value > 10 过滤出值大于10的键值对。

17.使用 try-except 进行条件过滤

我们可以使用 try-except 块来处理可能引发异常的情况，例如只保留可以转换为整数的字符串。

# 原始字符串列表
strings = ["1", "2", "three", "4", "five"]

# 列表推导式加条件过滤
valid_integers = [int(s) for s in strings if s.isdigit()]

print(valid_integers)  # 输出: [1, 2, 4]

解释：这里，if s.isdigit() 检查字符串 s 是否全部由数字组成。如果是，则使用 int(s) 将其转换为整数。[int(s) for s in strings if s.isdigit()] 是一个列表推导式，它遍历 strings 中的每个字符串，并使用 if s.isdigit() 过滤出可以转换为整数的字符串。

18.使用 sorted 进行条件过滤

我们可以使用 sorted 函数对列表进行排序，并结合条件过滤，例如只保留前3个偶数。

# 原始列表
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 列表推导式加条件过滤
top_three_evens = sorted([num for num in numbers if num % 2 == 0])[:3]

print(top_three_evens)  # 输出: [2, 4, 6]

解释：这里，[num for num in numbers if num % 2 == 0] 是一个列表推导式，它遍历 numbers 中的每个元素，并使用 if num % 2 == 0 过滤出偶数。sorted(...)[:3] 对过滤后的偶数进行排序，并取前3个元素。

实战案例：过滤并统计用户评分

假设我们有一个包含用户评分的列表，我们需要过滤出评分大于等于4的用户，并统计这些用户的数量。

# 原始评分列表
ratings = [3.5, 4.0, 4.5, 3.0, 5.0, 4.2, 3.8, 4.7]

# 列表推导式加条件过滤
high_ratings = [rating for rating in ratings if rating >= 4]

# 统计高评分的数量
high_rating_count = len(high_ratings)

print(f"高评分的数量: {high_rating_count}")
print(f"高评分的用户: {high_ratings}")

解释：

ratings 是一个包含用户评分的列表。
[rating for rating in ratings if rating >= 4] 是一个列表推导式，它遍历 ratings 中的每个评分，并使用 if rating >= 4 过滤出评分大于等于4的用户。
len(high_ratings) 计算高评分的数量。
最后，输出高评分的数量和具体的高评分用户。