Python 使用习惯
Python 使用习惯是指那些经常被使用的语法、语义和结构，这样写更加符合 Python 风格，看起来更像一个地道的 Pythoner.
本系列目的，分类整理 Python 使用习惯
1. if not x
直接使用 x 和 not x 判断 x 是否为 None 或空
x = [1,3,5]
if x:
print('x is not empty ')
if not x:
print('x is empty')
# 下面写法不够 Pythoner
if x and len(x) > 0:
print('x is not empty ')
if x is None or len(x) == 0:
print('x is empty')2. enumerate 枚举
直接使用 enumerate 枚举容器，第二个参数表示索引的起始值
x = [1, 3, 5]
for i, e in enumerate(x, 10): # 枚举
print(i, e)
# 下面写法不够 Pythoner:
i = 0
while i < len(x):
print(i+10, x[i])
i+=13. in
判断字符串是否包含某个子串，使用in明显更加可读：
x = 'zen_of_python'
if 'zen' in x:
print('zen is in')
# find 返回值 要与 -1 判断，不太符合习惯：
if x.find('zen') != -1:
print('zen is in')4 zip 打包
使用 zip 打包后结合 for 使用输出一对，更加符合习惯：
keys = ['a', 'b', 'c']
values = [1, 3, 5]
for k, v in zip(keys, values):
print(k, v)
# 下面不符合 Python 习惯：
d = {}
i = 0
for k in keys:
print(k, values[i])
i += 15 一对 '''
打印被分为多行的字符串，使用一对 ''' 更加符合 Python 习惯
print('''"Oh no!" He exclaimed.
"It's the blemange!"''')
# 下面写法就太不 Python 风格：
print('"Oh no!" He exclaimed.\n' +
'It\'s the blemange!"')6 交换元素
直接解包赋值，更加符合 Python 风格
a, b = 1, 3
a, b = b, a # 交换a,b
# 不要再用临时变量 tmp ，这不符合 Python 习惯：
tmp = a
a = b
b = tmp7 join 串联
串联字符串，更习惯使用 join
chars = ['P', 'y', 't', 'h', 'o', 'n']
name = ''.join(chars)
print(name)
# 下面不符合 Python 习惯：
name = ''
for c in chars:
name += c
print(name)8 列表生成式
列表生成式构建高效，符合 Python 习惯：
data = [1, 2, 3, 5, 8]
result = [i * 2 for i in data if i & 1] # 奇数则乘以2
print(result) # [2, 6, 10]
# 下面写法不够 Pythoner：
results = []
for e in data:
if e & 1:
results.append(e*2)
print(results)9 字典生成式
除了列表生成式，还有字典生成式：
keys = ['a', 'b', 'c']
values = [1, 3, 5]
d = {k: v for k, v in zip(keys, values)}
print(d)
# 下面写法不太 Pythoner：
d = {}
for k, v in zip(keys, values):
d[k] = v
print(d)10 __name__ == '__main__'有啥用
曾几何时，看这别人代码这么写，我们也就跟着这么用吧，其实还没有完全弄清楚这行到底干啥。
def mymain():
print('Doing something in module', __name__)
if __name__ == '__main__':
print('Executed from command line')
mymain()
"""
加入上面脚本命名为 MyModule，不管在 vscode 还是 pycharm 直接启动，则直接打印出：
Executed from command line
Doing something in module __main__
这并不奇怪，和我们预想一样，因为有无这句 __main__ ，都会打印出这些。
但是当我们 import MyModule 时，如果没有这句，直接就打印出：
In [2]: import MyModule
Executed from command line
Doing something in module MyModule
只是导入就直接执行 mymain 函数，这不符合我们预期。
如果有主句，导入后符合预期
In [6]: import MyModule
In [7]: MyModule.mymain()
Doing something in module MyModule
"""11 字典默认值
In[1]: d = {'a': 1, 'b': 3}
In[2]: d.get('b', []) # 存在键 'b'
Out[2]: 3
In[3]: d.get('c', []) # 不存在键 'c'，返回[]
Out[3]: []12 lambda 函数
lambda 函数使用方便，主要由入参和返回值组成，被广泛使用在 max, map, reduce, filter 等函数的 key 参数中。
如下，求 x 中绝对值最大的元素，key 函数确定abs(x)作为比较大小的方法:
x = [1, 3, -5]
y = max(x, key=lambda x: abs(x))
print(y) # -5 13 max
求 x 中绝对值最大的元素，key 函数确定abs(x)作为比较大小的方法：
x = [1, 3, -5]
y = max(x, key=lambda x: abs(x))
print(y) # -5 14. map
map 函数映射 fun 到容器中每个元素，并返回迭代器 x
x = map(str, [1, 3, 5])
for e in x:
print(e, type(e))
# 下面写法不够 Pythoner
for e in [1, 3, 5]:
print(e, str(e)) # '1','3','5'
15. reduce
reduce 是在 functools 中，第一个参数是函数，其必须含有 2 个参数，最后归约为一个标量。
from functools import reduce
x = [1, 3, 5]
y = reduce(lambda p1, p2: p1*p2, x)
print(y) # 15
# 下面写法不够 Pythoner:
y = 1
for e in x:
y *= e
print(y)
16. filter
使用 filter 找到满足 key 函数指定条件的元素，并返回迭代器
如下，使用 filter 找到所有奇数:
x = [1, 2, 3, 5]
odd = filter(lambda e: e % 2, x)
for e in odd: # 找到奇数
print(e)
# 还有另外一种方法，使用列表生成式，直接得到一个odd 容器，
odd = [e for e in x if e % 2]
print(odd) # [1,3,5]
# 下面写法最不符合 Python 习惯：
odd = []
for e in x:
if e % 2:
odd.append(e)
print(odd) # [1,3,5]
17 sorted
sorted 是内置函数，拿来即用，用于排序，key 参数指定排序使用的方法。
如下 key 参数确定abs(x)作为排序的方法
x = [4, -3, 1, -6, 2]
y = sorted(x, key=lambda x: abs(x))
print(y) # [1, 2, -3, 4, -6]18 位置变参
In [4]: def f(*a):
...: return a
In [5]: f(1,2,5) # 可传入多个参数
Out[5]: (1, 2, 5)19 字典变参
In [6]: def g(**a):
...: return a
In [7]: g(a=1,b=2)
Out[7]: {'a': 1, 'b': 2}20 习惯 yield
In [12]: def fg(n):
...: i = 0
...: a,b=0,1
...: while i