原文地址，并删除了部分太简单的内容，添加了我认为有用的一些技巧。
本文介绍了20种可能有用的python小技巧。
1.Python之禅（The Zen of Python）
Python之禅（也称为PEP 20）是Tim Peters撰写的一小段文字，代表设计和使用Python的指导原则。可以在Python网站上找到它，但是也可以在控制台中输入以下代码获得：
>>> import this
'''
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 way not be obvious at first unless you’re Dutch.
#虽然一开始这种方法并不是显而易见的，但谁叫你不是Python之父呢。
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.链式赋值（Chained Assignment）
如果需要多个变量来引用同一对象，则可以使用链式赋值：
>>> x = y = z = 2
>>> x, y, z
(2, 2, 2)逻辑优雅，对吗？
这种方法被称为序列解包（tuple unpacking），你也可以在一条语句中为多个变量赋值：
>>> x, y, z = 2, 4, 8
>>> x
2
>>> y
4
>>> z
8请注意，第一个语句中的2,4,8是一个等价于（2,4,8）的元组。
3.更高级的多重赋值（More Advanced Multiple Assignment）
在普通的多重赋值之外，python还有更强大的赋值方法，您不需要在左右两侧使用相同数量的元素：
>>> x, *y, z = 2, 4, 8, 16
>>> x
2
>>> y
[4, 8]
>>> z
16在这种情况下，x取第一个值（2），因为它排在第一位。 z是最后一个，取最后一个值（8）。 y变成列表，包含其他所有元素，因为它带有星号（* y）
4.链式对比（Chained Comparison）
您可以通过将多个比较运算符合并到一个Python表达式中。如果所有比较正确，则此表达式返回True，否则返回False：
>>> x = 5
>>> 2 < x ≤ 8
True
>>> 6 < x ≤ 8
False它类似于（2 <x）和（x≤8）和（6 <x）和（x≤8），但更简洁，并且只需要对x求一次值即可。
下面的代码也是合法的：
>>> 2 < x > 4
True你甚至可以写更多的比较：
>>> x = 2
>>> y = 8
>>> 0 < x < 4 < y < 16
True5.链式函数调用
你可以在一行代码内调用多个函数。
def add(a, b):
return a + b
def subtract(a, b):
return a - b
a, b = 4, 5
print((subtract if a > b else add)(a, b)) # 9 6.交换变量（Swap Variables）
您可以以简洁的方式直接交换变量，而无需引入第三个变量。
>>> x, y = 2, 8
>>> x
2
>>> y
8
>>> x, y = y, x
>>> x
8
>>> y
27.合并字典（Merge Dictionaries）
合并两个或多个词典的一种方法是在新的字典中将它们解包：
>>> x = {'u': 1}
>>> y = {'v': 2}
>>> z = {**x, **y, 'w': 4}
>>> z
{'u': 1, 'v': 2, 'w': 4}8.列表展开
def spread(arg):
ret = []
for i in arg:
if isinstance(i, list):
ret.extend(i)
else:
ret.append(i)
return ret
def deep_flatten(lst):
result = []
result.extend(
spread(list(map(lambda x: deep_flatten(x) if type(x) == list else x, lst))))
return result
deep_flatten([1, [2], [[3], 4], 5]) # [1,2,3,4,5]9.高级迭代（Advance Iteration）
如果要遍历序列，并且需要序列元素和相应的索引，则应使用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 Iteration）
如果要以相反的顺序遍历序列，则应使用reversed：
>>> for item in reversed(['u', 'v', 'w']):
... print(item)
...
w
v
u11.聚和元素（Aggregate Elements）
如果要汇总多个序列中的元素，则应使用zip：
>>> x = [1, 2, 4]
>>> y = ('u', 'v', 'w')
>>> z = zip(x, y)
>>> z
>>> list(z)
[(1, 'u'), (2, 'v'), (4, 'w')]您可以遍历zip对象或将其转换为列表或元组。
12.转置矩阵（Transpose Matrices）
尽管人们在处理矩阵时通常会使用NumPy（或类似的库），但是您也可以使用zip获得矩阵的转置：
>>> x = [(1, 2, 4), ('u', 'v', 'w')]
>>> y = zip(*x)
>>> z = list(y)
>>> z
[(1, 'u'), (2, 'v'), (4, 'w')]13.唯一值（Unique Values）
如果元素的顺序不重要，则可以通过将其转换为集合来删除列表中的重复项：
>>> x = [1, 2, 1, 4, 8]
>>> y = set(x)
>>> y
{8, 1, 2, 4}
>>> z = list(y)
>>> z
[8, 1, 2, 4]14.序列排序（Sort Sequences）
默认情况下，序列按其首个元素排序：
>>> 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.字典排序（Sort Dictionaries）
您可以使用和上面类似的方法，对通过.items（）方法获得的字典的键值元组进行排序：
>>> x = {'u': 4, 'w': 2, 'v': 1}
>>> sorted(x.items())
[('u', 4), ('v', 1), ('w', 2)]如果想根据值对它们进行排序，则应该指定key的值为item[1]（因为item[0]是键），也可以反向排序
>>> 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.原始的格式化字符串（Raw Formatted Strings）
Python 3.6引入了所谓的格式化字符串（ formatted strings，f-strings）。您可以将表达式嵌入此类字符串中，它可以同时输出原始字符串和格式化的字符串。您需要同时包含两个前缀：fr。
>>> fr'u \ n v w={2 + 8}'
'u \\ n v w=10'17.检查两个字符串的组成元素是不是一样的
from collections import Counter
def anagram(first, second):
return Counter(first) == Counter(second)18.获得最大（或最小）元素的索引（Obtain the Index of the Maximal (or Minimal) Element）
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。
19.获得笛卡尔乘积（Obtain the Cartesian Product）
内置模块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.矩阵乘法运算符（The Operator for Matrix Multiplication）
Python 3.5引入了专用的矩阵乘法运算符@，它简单优雅：
>>> import numpy as np
>>> x, y = np.array([1, 3, 5]), np.array([2, 4, 6])
>>> z = x @ y
>>> z
44这一点是我尤其想要推荐的，受到之前知识的影响，我一直以为用@的就是装饰器，但其实不是的。python中用@的还有矩阵乘法！我说之前看机器学习代码的时候，有个@怎么也看不懂，原来是我理解错了。
版权属于：作者名称
本文链接：https://www.sitstars.com/archives/52/
转载时须注明出处及本声明