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\. 子串成员关系检查
------------

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

```python
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]

最后的话

感谢你的阅读，希望从这篇文章中，你能学到一些新的东西，对你有所帮助。

---

最后这里免费分享给大家一份Python全台学习资料，包含视频、源码、课件,希望能帮到那些不满现状，想提升自己却又没有方向的朋友，也可以和我一起来学习交流呀。

可以微信扫描下方CSDNA官方认证二维码领取【保证100%免费】