Python必知必会：程序员必须知道的22个Python单行代码！

今天给大家分享24个每个Python程序员都必须知道的单行代码，帮你写出更简洁、更优雅、更高效的代码。
在这里插入图片描述

1. 列表推导式

列表推导式（List Comprehensions）可以提供一种简洁的方式创建列表。相较于传统的循环，列表推导式更高效、可读性更高。

# Bad   squares: list[int] = []   for i in range(1,11):       squares.append(i ** 2)   print(squares)   # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]      # Better   squares: list[int] = [i ** 2 for i in range(1,11)]   print(squares)   # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

2. 累积计算操作

Python的 reduce() 结合 operator 运算符模块可以实现数字的累积计算操作，比如累积求和、累积求积。

from operator import add, mul   from functools import reduce      cum_sum: int = reduce(add, range(1, 10))   print(cum_sum)      # 45      factorial: int = reduce(mul, range(1, 5))   print(factorial)    # 24

3. `lambda` 实现排序

lambda 函数是你可以在单行代码中使用的匿名函数，对于像排序这样的任务很实用。

names: list[tuple[int, str]] = [(1, 'Jack'), (2, 'Alex'), (3, 'Bob')]   sorted_names: list = sorted(names, key=lambda x: x[1])   print(sorted_names)   # [(2, 'Alex'), (3, 'Bob'), (1, 'Jack')]

这里，我们基于第二个元素（列表中的元组）对元组列表进行排序。类似地，将lambda 函数用作排序键，也可以基于字典的值对字典进行排序。

4. 字典合并

通过 ** 前缀可以将多个字典轻松合并为一个。

info1: dict = {'name': 'Jack', 'age': 28}   info2: dict = {'gender': 'Male', 'city': 'San Francisco'}   person_info: dict = {**info1, **info2}   print(person_info)   # {'name': 'Jack', 'age': 28, 'gender': 'Male', 'city': 'San Francisco'}

多个字典（2个以上）也可以通过这种方式合并，相较于循环或其他函数，这种方式更简洁、高效。

5. 字典推导式

通过字典推导式我们可以根据可迭代对象快速创建字典。

keys: list[str] = ['name', 'age', 'gender']   values: list[str | int] = ['Jackzhang', 28, 'Male']   person_info: dict = {key: value for key, value in zip(keys, values)}   print(person_info)   # {'name': 'Jackzhang', 'age': 28, 'gender': 'Male'}

相较于传统的循环方式，字典推导式更简洁和高效。

6. 获取字典的最大值

通过 lambda 函数可以轻松找到字典的最大值。

d: dict[str, int] = {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}   max_key: str = max(d, key=lambda x: d[x])   print(max_key)  # e

这个单行代码可以找到字典中找到最大值对应的键，这在像查找数据集中性能最佳的项目这样的任务中非常有用。

7. 子串成员关系检查

检测某个子串是否在目标字符串中使用一行代码即可搞定：

is_contain: bool = 'Python' in "I'm Jackzhang, I love Python"   print(is_contain)   # True

这个单行代码可以检测某个字串是否在目标字符串中，对于像文本搜索或过滤这样的任务非常有用。

8. 回文检测（通过切片）

你可以通过切片反转检测一个字符串是否为回文（正序和倒序均是同一个字符串）。

is_palindrome = lambda x : x == x[::-1]   print(is_palindrome("level"))   # True

这里，这个单行代码可以检测一个给定字符串是否为回文。切片操作 x[::-1] 会反转字符串，lambda 函数则会将其和原始字符串进行比较。

9. 字典反转

有时我们需要反转字典，即交换键和值。Python的字典推导可以优雅地处理这个任务。

d: dict = {'a': 1, 'b': 2, 'c': 3}   inverted_d: dict = dict(zip(d.values(), d.keys()))   print(inverted_d)   # {1: 'a', 2: 'b', 3: 'c'}

这里，我们通过字典推导式和 zip() 函数很轻松地实现了字典的反转。当然，zip() 函数也可以用循环替代：

inverted_d: dict = {v: k for k, v in d.items()}

很明显，使用 zip() 函数更简洁高效。这个单行代码可以轻松实现字典的反转，这对于像逆向查找这样的场景非常有用。

10. `zip()` 实现元素配对

细心的朋友应该注意到了，我们在前面的多个场景中都用到了 zip() 函数。它可以实现多个列表元素的一一配对（结果为元组），简化组合数据集的创建。

names: list[str] = ['Jack', 'Alex', 'Jim']   ages: list[int] = [18, 25, 20]   combined_info: list[tuple] = list(zip(names, ages))   print(combined_info)   # [('Jack', 18), ('Alex', 25), ('Jim', 20)]

注意，若多个列表的长度不同，则结果列表的长度以最短列表为准。zip() 函数对于合并不同来源的数据任务非常有用。

11. 获取两个列表的交集

我们都知道，在数学中，集合不允许重复元素的存在。利用这一特性，我们可以轻松计算两个列表的交集。

list1: list[int] = [1, 2, 3, 4, 5]   list2: list[int] = [3, 4, 5, 6, 7]   intersection: list[int] = list(set(list1) & set(list2))   print(intersection)     # [3, 4, 5]

12. 简化多条件检查

any() 和 all() 可以有效简化多条件检查，避免多重 or（any()）和 and（all()）语句的使用。

values: list[int] = [1, 2, -3, 4, 5]   has_greater: bool = any([x > 4 for x in values])   all_positive: bool = all([x > 0 for x in values])   print(has_greater, all_positive)    # True False

13. 根据字典生成字典

在Python中，我们可以通过两个列表简单而直观的创建字典。

keys: list[str] = ['name', 'age', 'gender']   values: list[str | int] = ['Jackzhang', 28, 'Male']   person_info: dict = dict(zip(keys, values))   print(person_info)   # {'name': 'Jackzhang', 'age': 28, 'gender': 'Male'}

14. 使用 `map()` 转换列表

map() 可以将一个转换函数应用到可迭代对象中每个元素上，它非常适合用于批量转换的场景。

name: list[str] = ['jack', 'zhang']   capital_name: list[str] = list(map(str.capitalize, name))   print(capital_name) # ['Jack', 'Zhang']

这里，我们使用 map() 将列表中的字符串首字母转换为大写。相较于通过循环执行转换，map() 函数将 str.capitalize 方法应用到列表中的每个元素上，简化了转换过程，且内置函数底层经过优化，效率更高。

15. 获取可迭代对象元素的索引

通过 index(element) 方法可以轻松获取列表中元素的索引：

idx = [1, 2, 3, 4, 5].index(5)   print(index)  # 4

16. 单行代码实现嵌套循环

我们可以用一行代码通过列表推导式实现二级嵌套循环：

names: list[str] = ['Jack', 'Bob']   ages: list[int] = [18, 25, 20]   person_info: list[tuple[str, int]] = [(name, age)                                          for name in names for age in ages]   for name, age in person_info:       print(name, age)   # Output   Jack 18   Jack 25   Jack 20   Bob 18   Bob 25   Bob 20

17. 单行代码实现数据过滤

在编程中，数据过滤是一项常见的任务，Python允许你使用列表推导式来高效完成。比如，筛选偶数：

even_numbers: list[int] = [x for x in range(1, 11) if x % 2 == 0]   print(even_numbers) # [2, 4, 6, 8, 10]

18. 列表元素去重

利用数学中集合不包含重复元素的特性可以轻松对列表元素去重。

unique_numbers = list(set([1, 2, 2, 4, 5, 4, 3, 2]))   print(unique_numbers)   # [1, 2, 3, 4, 5]

这个单行代码可以去除列表中的重复值，确保只保留唯一值，这常常用在数据清洗任务中。

19. 列表→字符串

在Python中，使用 join() 方法可以轻松将字符串列表转换为单个字符串。

info: list[str] = ['I', 'love', 'Python', 'coding', 'programming!']   joined_info = ' '.join(info)   print(joined_info)   # I love Python coding programming!

这个方法在文本处理任务重非常有用，比如合并单词或句子。

20. 一次性读取文件内容

通过 readlines() 方法可以一次性读取文件内容：

lines: list = [line.strip() for line in open('test.txt')]   print(lines)   # ['line1', 'line2', 'line3']

这个单行代码可以读取文件的所有行，并且移除任意额外的空格，常常用在文件处理中。

21. 字串替换

通过 replace() 方法，Python可以轻松替换字符串中的部分子串：

exp_str: str = 'I love Java'.replace('Java', 'Python')   print(exp_str)  # I love Python

22. 嵌套列表展开

在处理嵌套列表时，通常我们需要将它们展开平铺为单个列表，Python提供了简单的方式实现这个需求：

nested_list: list[list[int]] = [[1, 2, 3], [4, 5, 6]]   flat_list: list[int] = [number for sublist in nested_list                           for number in sublist]   print(flat_list)    # [1, 2, 3, 4, 5, 6]