您应该知道的20个有用的Python提示和技巧

Python是一种流行的通用通用编程语言。它用于数据科学和机器学习，许多领域的科学计算，后端Web开发，移动和桌面应用程序等。许多知名公司都使用Python：Google，Dropbox，Facebook，Mozilla，IBM，Quora，Amazon，Spotify，NASA，Netflix，Reddit等。

Python是免费和开源的，以及与之相关的大多数产品。此外，它还有一个庞大，敬业且友好的程序员和其他用户社区。

它的语法在设计时考虑了简单性，可读性和优雅性。

本文介绍了20条可能有用的Python技巧和窍门。

1. Python之禅

Python的Zen（也称为PEP 20）是Tim Peters撰写的一小段文字，代表设计和使用Python的指导原则。可以在Python网站上找到它，但是也可以使用以下一条语句在终端机（控制台）或Jupyter笔记本中获取它：

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

2.区块链分配

如果需要多个变量来引用同一对象，则可以使用链式分配：

>>> x = y = z = 2
>>> x, y, z
(2, 2, 2)

逻辑优雅，对吗？

3.链式比较

您可以通过链接比较运算符将多个比较合并到一个Python表达式中。如果所有比较正确，则此表达式返回True，否则返回False：

>>> x = 5
>>> 2 < x ≤ 8
True
>>> 6 < x ≤ 8
False

这类似于（2

这也是合法的：

>>> 2 < x > 4
True

您可以链接两个以上的比较：

>>> x = 2
>>> y = 8
>>> 0 < x < 4 < y < 16
True

4.多重分配

您可以使用元组拆包在单个语句中分配多个变量：

>>> x, y, z = 2, 4, 8
>>> x
2
>>> y
4
>>> z
8

请注意，第一个语句中的2、4、8是一个等价于（2、4、8）的元组。

5.更高级的多重分配

普通的多重分配并不是所有Python都能做到的。您不需要在左右两侧使用相同数量的元素：

>>> x, *y, z = 2, 4, 8, 16
>>> x
2
>>> y
(4, 8)
>>> z
16

在这种情况下，x取第一个值（2），因为它排在第一位。 z是最后一个，并取最后一个值（8）。 y采用列表中盘点的所有其他值，因为它带有星号（* y）。

6.交易所变量

您可以应用多个分配以简洁简洁的方式交易所任何两个变量，而无需介绍第三个变量：

>>> x, y = 2, 8
>>> x
2
>>> y
8
>>> x, y = y, x
>>> x
8
>>> y 2

7.合并字典

合并两个或多个词典的一种方法是将它们分解成新的字典：

>>> x = {'u': 1}
>>> y = {'v': 2}
>>> z = {**x, **y, 'w': 4}
>>> z
{'u': 1, 'v': 2, 'w': 4}

8.连接字符串

如果需要连接多个字符串，而最终它们之间具有相同字符或一组字符，则可以使用str.join（）方法：

>>> x = ('u', 'v', 'w')
>>> y = '-*-'.join(x)
>>> y
'u-*-v-*-w'

9.高级迭代

如果要遍历序列，并且需要序列元素和相应的索引，则应使用enumerate：

>>> for i, item in enumerate(('u', 'v', 'w')):
... print('index:', i, 'element:', item)
...
index: 0 element: u
index: 1 element: v
index: 2 element: w

在每次迭代中，您都将获得一个带有索引和序列中相应元素的元组。

10.反向迭代

如果要以相反的顺序遍历序列，则应使用reversed：

>>> for item in reversed(('u', 'v', 'w')):
... print(item)
...
w
v
u

11.汇总元素

如果要汇总多个序列中的元素，则应使用zip：

>>> x = (1, 2, 4)
>>> y = ('u', 'v', 'w')
>>> z = zip(x, y)
>>> z

>>> list(z)
((1, 'u'), (2, 'v'), (4, 'w'))

您可以遍历获得的zip对象或将其转换为列表或元组。

12.转置矩阵

尽管人们在处理矩阵时通常会使用NumPy（或类似的库），但是您可以使用zip获得矩阵的转置：

>>> x = ((1, 2, 4), ('u', 'v', 'w'))
>>> y = zip(*x)
>>> z = list(y)
>>> z
((1, 'u'), (2, 'v'), (4, 'w'))

13.独特的价值观

您可以从列表中删除重复项，如果元素的顺序不重要，则可以通过将其转换为集合来获得唯一值：

>>> x = (1, 2, 1, 4, 8)
>>> y = set(x)
>>> y
{8, 1, 2, 4}
>>> z = list(y)
>>> z
(8, 1, 2, 4)

14.排序顺序

默认情况下，序列按其首个元素排序：

>>> x = (1, 'v')
>>> y = (4, 'u')
>>> z = (2, 'w')
>>> sorted((x, y, z))
((1, 'v'), (2, 'w'), (4, 'u'))

但是，如果要根据它们的第二个（或其他）元素对它们进行排序，则可以使用参数key和适当的lambda函数作为相应的参数：

>>> sorted((x, y, z), key=lambda item: item(1))
((4, 'u'), (1, 'v'), (2, 'w'))

如果您想获得相反的顺序，则类似：

>>> sorted((x, y, z), key=lambda item: item(1), reverse=True)
((2, 'w'), (1, 'v'), (4, 'u'))

15.排序字典

您可以使用类似的方法对使用.items（）方法获得的字典的键值元组进行排序：

>>> x = {'u': 4, 'w': 2, 'v': 1}
>>> sorted(x.items())
(('u', 4), ('v', 1), ('w', 2))

它们根据键进行排序。如果要根据它们的值对它们进行排序，则应指定与key对应的参数，并最终反转：

>>> sorted(x.items(), key=lambda item: item(1))
(('v', 1), ('w', 2), ('u', 4))
>>> sorted(x.items(), key=lambda item: item(1), reverse=True)
(('u', 4), ('w', 2), ('v', 1))

16.原始格式的字符串

PEP 498和Python 3.6引入了所谓的格式化字符串或f字符串。您可以将表达式嵌入此类字符串中。将字符串视为原始字符串和格式化字符串都是可能且直接的。您需要同时包含两个前缀：fr。

>>> fr'u  n v w={2 + 8}'
'u \ n v w=10'

17.获取当前日期和时间

Python具有内置的日期时间模块，该模块在处理日期和时间方面通用。其方法之一.now（）返回当前日期和时间：

>>> import datetime
>>> datetime.datetime.now()
datetime.datetime(2019, 5, 20, 1, 12, 31, 230217)

18.获得最大（或最小）元素的索引

Python没有提供直接获取列表或元组中最大或最小元素索引的例程。幸运的是，有（至少）两种优雅的方式可以做到这一点：

>>> x = (2, 1, 4, 16, 8)
>>> max((item, i) for i, item in enumerate(x))(1)
3

如果存在两个或多个具有最大值的元素，则此方法返回最后一个元素的索引：

>>> y = (2, 1, 4, 8, 8)
>>> max((item, i) for i, item in enumerate(y))(1)
4

要获取第一次出现的索引，您需要稍微更改前一条语句：

>>> -max((item, -i) for i, item in enumerate(y))(1)
3

另一种方法可能更优雅：

>>> x = (2, 1, 4, 16, 8)
>>> max(range(len(x)), key=lambda i: x(i))
3
>>> y = (2, 1, 4, 8, 8)
>>> max(range(len(y)), key=lambda i: x(i))
3

要查找最小元素的索引，请使用函数min而不是max。

19.获得笛卡尔积

内置模块itertools提供了许多潜在有用的类。其中之一是用于获得笛卡尔积的乘积：

>>> import itertools
>>> x, y, z = (2, 8), ('u', 'v', 'w'), {True, False}
>>> list(itertools.product(x, y, z))
((2, 'u', False), (2, 'u', True), (2, 'v', False), (2, 'v', True),
(2, 'w', False), (2, 'w', True), (8, 'u', False), (8, 'u', True),
(8, 'v', False), (8, 'v', True), (8, 'w', False), (8, 'w', True))

20.矩阵乘法运算符

PEP 465和Python 3.5引入了专用的infix运算符，用于矩阵乘法@。您可以使用matmul，rmatmul和imatmul方法为您的班级实现它。这是用于向量或矩阵相乘的代码的优美之处：

>>> import numpy as np
>>> x, y = np.array((1, 3, 5)), np.array((2, 4, 6))
>>> z = x @ y
>>> z
44

结论

您已经看到20条使之有趣且优雅的Python技巧。还有许多其他语言功能值得探索。

编码愉快