今天,我将给大家分享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%免费】