改进python代码的30个小技巧

1. 切片

1a = "hello world"
2print(a[::-1])
3# dlrow olleh

2. 原地交换 / 同时赋值

1a = 1
 2b = 2
 3print(f"First: {a, b}")
 4# First: (1, 2)
 5
 6a, b = b, a + 2
 7print(f"Second: {a, b}")
 8# Second: (2, 3)
 9
10a, b* = 1, 2, 3
11print(a, b)
12# 1 [2, 3]

3. 列表和元组

1import sys
 2
 3a = [1, 2, 3, 4, 5]
 4b = (1, 2, 3, 4, 5)
 5
 6print(f"List size: {sys.getsizeof(a)} bytes")
 7print(f"Tuple size: {sys.getsizeof(b)} bytes")
 8
 9'''
10List size: 104 bytes
11Tuple size: 80 bytes
12'''

列表是可变的，元组不可变。在列表中，额外的内存会被分配以防我们扩展，被称为动态内存分配。而在不希望更改数据的场景中，出于内存方面原因，元组数据结构应该优先于列表，元组也比列表快。

4. 生成器

1a = [x * 2 for x in range(10)]
 2b = (x * 2 for x in range(10))
 3
 4print(a)
 5print(b)
 6
 7"""
 8[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
 9

列表解析是从另一个可迭代对象创建列表的Python方式--它比使用for循环快得多。但是如果不小心将方括号从[]改为（），将得到一个生成器对象。每个元素只在请求时使用，也就是惰性计算，使用生成器的主要好处是，它使用的内存较少，因为整个序列不是一次构建的。

5. 混叠

1a = [1, 2, 3, 4 ,5]
 2b = a
 3
 4b[4] = 7
 5
 6print(id(a))
 7print(id(b))
 8print(a) 
 9
10"""
112278459070720
122278459070720
13[1, 2, 3, 4, 7]
14"""

Python是一种面向对象的编程语言--一切都是对象。因此，将对象分配给标识符就是创建对该对象的引用。

当我们将一个标识符赋给另一个标识符时，我们最终得到引用同一对象的两个标识符。这是一个称为混叠的概念。更改一个别名将影响另一个别名。有时候，这种行为是我们想要的，但通常，它让我们措手不及。

一种解决方法是在使用可变对象时避免别名。另一个解决方案是创建原始对象的克隆，而不是引用。

创建克隆最直接的方法是利用切片：

1b = a[:]

6. 'not' 操作符

1a = []
2print(not a)
3
4"""
5True
6"""

下一个Python技巧是使用not操作符检查数据结构是否为空的最简单方法。Python内置的not是一个逻辑运算符，如果表达式不为真，它返回True，否则返回False

另一种使用方式是在if语句中：

1if not a:
2    # do something...

7. F-字符串

1first_name = "John"
2age = 19
3
4print(f"Hi, I'm {first_name} and I'm {age} years old!")
5
6"""
7Hi, I'm John and I'm 19 years old!
8"""

也可以使用：

1print("Hi, I'm {} and I'm {} years old!".format(first_name, age))

8. print函数中'end'参数

1a = ["english", "french", "spanish", "german", "twi"]
2for language in a:
3    print(language, end=" ")
4
5"""
6english french spanish german twi
7"""

使用print语句而不定义任何可选参数是很常见的。

我们可以更改的一个可选参数是end。end参数指定在调用print语句结束时应显示的内容。

end的默认值是“\\n”，它告诉Python开始一个新行。在上面的代码中，我们将其更改为空格。因此，返回的输出中列表的所有元素都打印在同一行上。

9. 追加数据到元组

1a = (1, 2, [1, 2, 3])
2a[2].append(4)
3print(a)
4
5"""
6(1, 2, [1, 2, 3, 4])
7"""

我们已经知道元组是不可变的。尝试更改元组的状态将引发TypeError。但是，如果您将元组对象看作是绑定到不能更改的对象的名称序列，元组的前两个元素是整数--它们是不可变的。元组的最后一个元素是一个列表，在Python中是一个可变对象。

如果我们认为列表只是序列中的另一个名称，它绑定到一个不能更改的对象，那么我们会意识到列表仍然可以从元组中修改。

10. 合并字典

1a = {"a": 1, "b": 2}
2b = {"c": 3, "d": 4}
3
4a_and_b = a | b
5print(a_and_b)
6
7"""
8{"a": 1, "b": 2, "c": 3, "d": 4}
9"""

在Python 3.9及更高版本中，可以使用 |。关于这个特殊的Python技巧，除了它是一个可读性更强的解决方案之外，没有什么可说的！

11. 三元运算符 / 条件表达式

1condition = True
2name = "John" if condition else "Doe"
3
4print(name)
5
6"""
7John
8"""

12. 从列表中去掉重复项

1a = [1, 1, 2, 3, 4, 5, 5, 5, 6, 7, 2, 2]
2print(list(set(a)))
3
4"""
5[1, 2, 3, 4, 5, 6, 7]
6"""

从列表中删除重复元素的最简单方法是将列表转换为集合（如果愿意，然后再转换回列表）。

集合和列表之间的关键区别是集合不能包含重复项。

13. 单独下划线

1>>> print(_)
2Traceback (most recent call last):
3  File "

下划线(_)是Python中的合法的标识符，因此，可以使用它来引用对象。但强调还有另一个责任：以存储最后的结果。文档指出，“交互式解释器使最后一次求值的结果在变量中可用。“

因为我们在第一行调用对象之前没有给它赋值下划线，所以我们得到了一个错误。但是，当我们计算1 + 2的输出时，交互式解释器为我们将结果存储在_中。

14. 用下划线表示忽略的值

1for _ in range(100):
2    print("The index doesn't matter")
3
4"""
5The index doesn't matter
6The index doesn't matter
7...
8"""

我们也可以用它来表示我们不关心的对象，或者在程序的后面不会使用的对象。

15. 尾部下划线

1list_ = [0, 1, 2, 3, 4]
2global_ = "Hi there"

继续前两个技巧，Python的下划线(_)用法，它的另一个目的是避免与Python关键字冲突。PEP8提到尾部下划线（）应该按照约定使用，以避免与Python关键字冲突。它还指出，“通常最好附加一个尾随下划线，而不是使用缩写。”因此list_优于lst。

16. 前置下划线

1class Example:
2    def __init__(self):
3        self._internal = 2
4        self.external = 20

你经常会发现有经验的Python程序员倾向于在标识符或方法名前面加上下划线--这是有原因的。

标识符或方法前面的下划线具有隐藏的含义：此变量或方法仅用于内部使用。本质上，它是对其他程序员的免责声明，这些程序员在PEP 8中已经定义，但Python没有强制执行。因此，前置下划线是弱指示符。

17. 下划线用于数字显示

1number = 1_500_000
2print(number)
3
4"""
515000000
6"""

我们可以使用下划线的另一种方式是作为整数、浮点数和复数常量中数字分组的可视分隔符--这是在Python 3.6中引入的。这样做的目的是为了提高长文本的可读性。

18. name == " main "

1if __name__ == "__main__":
2    print("Read on to understand what is going on when you do this.")
3
4"""
5print("Read on to understand what is going on when you do this.")
6"""

你很有可能在几个Python程序中见过这种语法;Python使用一个特殊的名称__main__，如果运行的Python文件是主程序，则将其设置为一个名为__name__的标识符。如果我们决定将当前显示的模块导入到另一个模块（Python文件）中并运行该文件，则代码中表达式的值将为false。这是因为当我们从另一个模块导入时，__name__标识符被设置为模块（Python文件）的名称。

19. setdefault 方法

1import pprint
 2
 3text = "It's the first of April. It's still cold in the UK. But I'm going to the museum so it should be a wonderful day"
 4
 5counts = {}
 6for word in text.split():
 7    counts.setdefault(word, 0)
 8    counts[word] += 1
 9
10pprint.pprint(counts)
11
12"""
13{'April.': 1,
14"It's": 2,
15'UK.': 1,
16...
17'still': 1,
18'the': 3,
19'to': 1,
20'wonderful': 1}
21"
22

可能会碰到这种需求，检查元素是否存在一个字典中，存在当前值加1，不存在添加当前值并设置其为1，看起来如下：

1counts = {}
2for word in text.split():
3    if word in counts:
4        counts[word] += 1
5    else:
6      counts[word] = 1

更简洁的方法是在dictionary对象上使用setdefault（）方法。

传递给方法的第一个参数是我们要检查的键。传递的第二个参数是当键在字典中不存在时设置键的值-如果键存在，则方法将返回键值。因此，不会对其进行更改。

20. 正则匹配

1import re
 2
 3number = re.compile(r"(0?)(\\+44)?\\d(10)")
 4num_1 = number.search("My number is [phone]")
 5num_2 = number.search("My number is 07999999999")
 6
 7print(num_1.group())
 8print(num_2.group())
 9
10"""
11'[phone]'
12'07999999999'
13"""

21. 正则表达式管道‘|’使用

1import re
 2
 3heros = re.compile(r"Super(man|woman|human)")
 4
 5h1 = heros.search("This will find Superman")
 6h2 =  heros.search("This will find Superwoman")
 7h3 = heros.search("This will find Superhuman")
 8
 9print(h1.group())
10print(h2.group())
11print(h3.group())
12
13"""
14Superman
15Superwoman
16Superhuman
17"""

正则表达式有一个特殊字符，称为管道（|），它允许您匹配许多表达式中的一个，并且它们可以在任何地方使用。

22. print函数中‘sep’参数

1day = "04"
 2month = "10"
 3year = "2023"
 4
 5print(day, month, year)
 6print(day, month, year, sep = "")
 7print(day, month, year, sep = ".")
 8
 9"""
1004 10 2023
1104/10/2023
1204.10.2023
13"""

sep参数是print（）函数中的一个可选参数，它允许我们指定在包含多个对象时应该如何分隔对象。

默认情况下是用空格分隔它们。

23. Lambda 函数

1def square(num:int) -> int:
 2    return num ** 2
 3
 4print(f"Function call: {square(4)}")
 5"""
 6Function call: 16
 7"""
 8
 9square_lambda = lambda x: x**2
10print(f"Lambda function: {square_lambda(4)}")
11"""
12Lambda functional: 16
13"""

本质上，lambda关键字允许我们在一行中创建小的、受限的、匿名的函数。它们的行为与使用def关键字声明的常规函数相同，只是这些函数没有名称。

24. swapcase方法

1string = "SoMe RaNDoM sTriNg"
2print(string.swapcase())
3
4"""
5sOmE rAndOm StRInG
6"""

swapcase（）方法应用于字符串对象，允许我们在一行代码中将大写字母改为小写字母，反之亦然。swapcase（）方法的用例并不多，但了解一下还是很不错的。

25. isalnum方法

1password = "ABCabc123"
2print(password.isalnum())
3
4"""
5True
6"""

假设我们正在创建一个程序，要求用户输入密码，但密码必须是数字和字母的组合。我们可以通过调用string实例上的isalnum（）在一行代码中完成此操作。

该方法检查所有字符是否都是字母表（A-Za-z）和数字（0 - 9）的一部分。空格或符号（!# %$&？等等）将返回False。

26. 异常处理

1def get_ration(x:int, y:int) -> int:
 2    try:
 3        ratio = x/y
 4    except: ZeroDivisionError:
 5        y = y + 1
 6        ratio = x/y
 7    return ratio
 8
 9print(get_ratio(x=400, y=0))
10
11"""
12400.0
13"""

Python程序在遇到错误时终止。

有时候，我们不希望出现这种行为，比如当最终用户与我们的代码交互时。如果我们的代码在这种情况下过早终止，会有多糟糕？

关于如何处理这种例外情况，有几种思路。大多数Python程序员通常都认为请求原谅比获得许可更容易。这意味着它们更愿意通过提供能够处理异常的周围上下文来捕获引发的错误。这种想法背后的思想是，浪费时间试图防范所有各种例外情况是没有意义的。

但这只有在问题发生后有一种处理机制的情况下才成立。

27. 比较两个的列表差异

1list_1 = [1, 3, 5, 7, 8]
 2list_2 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 3
 4solution_1 = list(set(list_2) - set(list_1))
 5solution_2 = list(set(list_1) ^ set(list_2))
 6solution_3 = list(set(list_1).symmetric_difference(set(list_2)))
 7
 8print(f"Solution 1: {solution_1}")
 9print(f"Solution 2: {solution_2}")
10print(f"Solution 3: {solution_3}")
11
12"""
13Solution 1: [9, 2, 4, 6]
14Solution 2: [2, 4, 6, 9]
15Solution 3: [2, 4, 6, 9]
16"""

这里有三种不同的方法来比较Python中两个列表之间的差异。

注意：除非你知道list_1是list_2的子集，否则solution 1和其他两个solution是不一样的。

28. Args & Kwargs

1def some_function(*args, **kwargs):
 2    print(f"Args: {args}")
 3    print(f"Kwargs: {kwargs}")
 4
 5some_function(1, 2, 3,  a=4, b=5, c=6)
 6
 7"""
 8Args: (1, 2, 3)
 9Kwargs: {'a': 4, 'b': 5, 'c': 6}
10"""

当我们不知道函数应该包含多少变量时，我们使用 *args和 **kwargs作为函数的参数。参数 *args允许我们在函数没有关键字时（即：我们传递的参数不需要相关联的名称）。另一方面，kwargs参数使我们能够向函数传递任意数量的关键字参数。

事实上，*args和 **kwargs这两个词并没有那么神奇：真正的魔力在于星号（）。这意味着我们可以在星号后面使用任何单词，但是使用args和kwargs是常见的做法。

29. 省略号

1print(...)
 2
 3"""
 4Ellipsis
 5"""
 6
 7def some_function():
 8    ...
 9
10# Alternative solution
11def another_function():
12    pass

省略号是一个Python对象，可以通过提供三个点（…）的序列来调用它。或者调用对象本身（省略号）。

它最值得注意的用法是访问NumPy中的多维数组并对其进行切片，例如：

1import numpy as np
 2
 3arr = np.array([[2,3], [1,2], [9,8]])
 4
 5print(arr[...,0])
 6"""
 7[2 1 9]
 8"""
 9print(arr[...])
10
11"""
12[[2 3]
13[1 2]
14[9 8]]
15"""

30. 列表推导式

1even_numbers = [x for x in range(10) if x % 2 == 0 and x != 0]
2print(even_numbers)
3
4"""
5[2, 4, 6, 8]
6"""

Python的最后一个技巧是列表解析，这是一种从另一个序列创建列表的优雅方法。它们允许您执行复杂的逻辑和过滤，就像我们在上面的代码中所做的那样。

还有其他方法可以达到同样的目的;例如，我们可以使用lambda函数，如下所示：

1even_numbers = list(filter(lambda x: x % 2 ==0 and x != 0, range(10)))
2print(even_numbers)
3"""
4[0, 2, 4, 6, 8]
5"""