每个程序员都必须知道的22个Python单行代码

最新推荐文章于 2025-04-23 11:38:43 发布

东眠的鱼

最新推荐文章于 2025-04-23 11:38:43 发布

阅读量949

点赞数 11

文章标签： python 数据库 redis 人工智能 Python基础 Python学习开发语言

本文链接：https://blog.youkuaiyun.com/2301_78217634/article/details/145746653

版权

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】！

---------------- 在这里插入图片描述

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]