最实用的20个Python小技巧完整攻略

在这篇文章中，我们将深入探讨20个实用的Python小技巧，这些技巧可以让你的Python编程更加高效、简洁和容易理解。这些技巧包括：

列表推导式
字典推导式
集合推导式
三元表达式
使用enumerate()函数遍历列表
通过zip()函数将两个列表合并为一个字典
通过any()和all()函数判断列表中的布尔值
对字典按值进行排序
使用默认字典处理缺少的键
使用zip_longest()函数对不等长的列表进行合并
使用sorted()函数对复杂对象进行排序
使用partial()函数创建部分函数
在异常处理块中使用with语句关闭文件
注释函数参数
使用collections.defaultdict()处理嵌套字典
使用装饰器简化函数调用
使用setdefault()方法更新字典
使用Python 3.8中的walrus运算符
使用zip()函数对多个列表进行操作
在循环中使用else语句

下面我们将详细介绍这些小技巧及其用法。

1. 列表推导式

列表推导式可以简化创建列表的过程。它是一种快速创建列表的方法，它使得代码更加简短，更易于阅读和理解。

示例：

a = [i for i in range(5)]
print(a)

输出：

[0, 1, 2, 3, 4]

在这个例子中，我们使用一个for循环和range()函数来创建一个从0到4的列表。然后我们使用列表推导式将其简化为一行代码。

2. 字典推导式

字典推导式可以简化创建字典的过程。它是一种快速创建字典的方法，它使得代码更加简短，更易于阅读和理解。

示例：

a = {i:i*2 for i in range(5)}
print(a)

输出：

{0: 0, 1: 2, 2: 4, 3: 6, 4: 8}

在这个例子中，我们使用一个for循环和range()函数来创建从0到4的键值对。然后，我们使用字典推导式将其简化为一行代码。

3. 集合推导式

集合推导式可以简化创建集合的过程。它是一种快速创建集合的方法，它使得代码更加简短，更易于阅读和理解。

示例：

a = {i for i in range(5)}
print(a)

输出：

{0, 1, 2, 3, 4}

在这个例子中，我们使用一个for循环和range()函数来创建一个从0到4的集合。然后，我们使用集合推导式将其简化为一行代码。

4. 三元表达式

三元表达式是一种简洁的条件语句，使得代码更加简化和容易理解。

示例：

b = 5
a = "b大于等于5" if b >= 5 else "b小于5"
print(a)

输出：

b大于等于5

在这个例子中，我们使用一个if/else语句来判断b是否大于等于5。然后，我们使用三元表达式将其简化为一行代码。

5. 使用enumerate()函数遍历列表

enumerate()函数可以同时遍历列表的索引和值，使得代码更加短小而简洁。

示例：

a = ["apple", "orange", "banana"]
for i, val in enumerate(a):
    print(i, val)

输出：

0 apple
1 orange
2 banana

在这个例子中，我们使用enumerate()函数来遍历列表a中的索引和值。然后，我们打印出索引和值的对应关系。

6. 通过zip()函数将两个列表合并为一个字典

zip()函数可以将两个列表按照索引对应起来，然后创建一个字典。

示例：

keys = ["a", "b", "c"]
values = [1, 2, 3]
my_dict = dict(zip(keys, values))
print(my_dict)

输出：

{'a': 1, 'b': 2, 'c': 3}

在这个例子中，我们使用zip()函数将keys和values两个列表按照索引对应起来，然后创建一个新的字典my_dict。

7. 通过any()和all()函数判断列表中的布尔值

any()函数返回列表中任意一个元素为True，则返回True。all()函数则返回列表中所有元素均为True，则返回True。

示例：

a = [True, False, True]
print(any(a))  # True
print(all(a))  # False

在这个例子中，我们使用any()和all()函数来判断列表a中的布尔值。

8. 对字典按值进行排序

可以使用sorted()函数和lambda表达式来按照字典值进行排序并返回一个字典。

示例：

a = {1: 2, 3: 4, 4: 3, 2: 1, 0: 0}
sorted_a = dict(sorted(a.items(), key=lambda item: item[1]))
print(sorted_a)

输出：

{0: 0, 2: 1, 1: 2, 4: 3, 3: 4}

在这个例子中，我们使用sorted()函数和lambda表达式来按照字典值进行排序。然后，我们使用dict()函数将其转换为一个新的字典。

9. 使用默认字典处理缺少的键

可以使用collections模块中的defaultdict()函数来处理缺少的键。

示例：

from collections import defaultdict
a = defaultdict(lambda: "missing")
a["key1"] = "value1"
print(a["key1"])
print(a["key2"])

输出：

value1
missing

在这个例子中，我们使用defaultdict()函数创建一个新的字典a。如果访问字典中缺少的键，它会返回默认值“missing”。

10. 使用zip_longest()函数对不等长的列表进行合并

zip_longest()函数可以将两个不等长的列表进行合并，然后用默认值填充缺少的部分。

示例：

from itertools import zip_longest
a = [1, 2, 3, 4]
b = ["a", "b", "c"]
zipped = list(zip_longest(a, b, fillvalue="missing"))
print(zipped)

输出：

[(1, 'a'), (2, 'b'), (3, 'c'), (4, 'missing')]

在这个例子中，我们使用zip_longest()函数将两个不等长的列表a和b进行合并。然后，我们使用fillvalue=”missing”来填充缺少的部分。

11. 使用sorted()函数对复杂对象进行排序

可以使用sorted()函数和key参数来对复杂对象进行排序。

示例：

a = [{"name":"John", "age":25}, 
     {"name":"Jack", "age":24}, 
     {"name":"Jane", "age":26}]
sorted_a = sorted(a, key=lambda x: x["age"])
print(sorted_a)

输出：

[{'name': 'Jack', 'age': 24}, {'name': 'John', 'age': 25}, {'name': 'Jane', 'age': 26}]

在这个例子中，我们使用sorted()函数和lambda表达式来对复杂对象进行排序。然后，我们使用key参数来指定按照哪个键进行排序。

12. 使用partial()函数创建部分函数

可以使用functools模块中的partial()函数来创建部分函数，从而减少重复代码。

示例：

from functools import partial
def multiply(a, b):
    return a * b
double = partial(multiply, b=2)
triple = partial(multiply, b=3)
print(double(5))
print(triple(5))

输出：

10
15

在这个例子中，我们使用partial()函数创建了两个部分函数double和triple，它们都调用了原始函数multiply。然后，我们分别使用double(5)和triple(5)来调用这些部分函数。

13. 在异常处理块中使用with语句关闭文件

可以在异常处理块中使用with语句来确保文件在使用后被关闭。

示例：

try:
    with open("file.txt") as f:
        lines = f.readlines()
except FileNotFoundError:
    print("file not found")

在这个例子中，我们使用with语句打开文件file.txt，然后读取文件中的所有行。如果文件不存在，我们就输出异常处理块中的信息。

14. 注释函数参数

在函数中添加注释可以提高代码的可读性和可维护性。

示例：

def foo(bar: int, baz: str) -> float:

在这个例子中，我们使用注释来说明函数foo的参数类型。（在 Python 3.5 之前，注释是函数定义的一部分，可以通过函数的 annotations 属性进行访问。在 Python 3.5 之后，注释已经成为函数定义的一个标准组成部分。）

15. 使用collections.defaultdict()处理嵌套字典

可以使用collections模块中的defaultdict()函数处理嵌套字典的情况。

示例：

from collections import defaultdict
a = defaultdict(lambda: defaultdict(int))
a["fruit"]["apple"] = 1
a["fruit"]["orange"] = 2
print(a)

输出：

defaultdict(<function <lambda> at 0x000001>, {'fruit': defaultdict(<class 'int'>, {'apple': 1, 'orange': 2})})

在这个例子中，我们使用defaultdict()函数处理a中的嵌套字典。默认情况下，我们可以将其设置为int类型。

16. 使用装饰器简化函数调用

可以使用装饰器来简化函数调用。

示例：

def my_decorator(func):
    def wrapper():
        print("Before the function is called.")
        func()
        print("After the function is called.")
    return wrapper
@my_decorator
def say_hello():
    print("Hello!")
say_hello()

输出：

Before the function is called.
Hello!
After the function is called.

在这个例子中，我们定义了一个简单的装饰器my_decorator。我们然后使用@my_decorator修饰say_hello函数。在调用say_hello函数时，会先执行装饰器中的代码，然后再执行原始函数中的代码。

17. 使用setdefault()方法更新字典

可以使用setdefault()方法更新字典，这将避免在没有找到键值（key）的情况下再次查询字典。

示例：

a = {"apple": 1, "banana": 2}
a.setdefault("orange", 3)
a.setdefault("apple", 4)
print(a)

输出：

{'apple': 1, 'banana': 2, 'orange': 3}

在这个例子中，我们使用setdefault()方法向字典a中添加键”orange”及其对应的值。由于键”apple”已经在字典中存在，因此setdefault()方法不会对其进行更改。

18. 使用Python 3.8中的walrus运算符

Python 3.8中新增加了walrus运算符:=，可以将表达式中的值分配给变量。

示例：

n = 5
while (n:=n-1) > 0:
    print(n)

输出：

在这个例子中，我们使用了walrus运算符:=来将表达式(n-1)的值分配给变量n。在循环中，变量n的值不断减小并打印输出。

19. 使用zip()函数对多个列表进行操作

zip()函数也可以对多个列表进行操作。

示例：

a = [1, 2, 3]
b = [4, 5, 6]
c = [7, 8, 9]
zipped = zip(a, b, c)
for i in zipped:
    print(i)

输出：

(1, 4, 7)
(2, 5, 8)
(3, 6, 9)

在这个例子中，我们使用zip()函数同时遍历列表a、b和c。然后，将它们打包成一个新的元组并输出。

20. 在循环中使用else语句

在Python中，可以在循环中使用else语句，在循环结束时执行一些操作。

示例：

a = [1, 2, 3, 4]
for i in a:
    if i == 5:
        break
else:
    print("No items were found.")

输出：

No items were found.

在这个例子中，我们使用else语句来在循环结束时输出一条信息。由于a中不存在值为5的元素，因此我们输出了相应的信息。

结论

在本文中，我们详细介绍了20个实用的Python小技巧，这些技巧可以让你的Python编程更加高效、简洁和容易理解。通过阅读这篇文章，您应该能够比较自如地使用这些技巧来提高您的编程水平。