Effective Python

Effective Python

1.确认自己所用的Python版本

优先使用python3，抛弃python2

查看python版本信息： python --version

2.遵循PEP8风格指南

采用一致的编码风格令代码更加易读，利于多人协作

绝对应该遵守的规则

空格

（1）使用space来表示缩进，而不要使用tab

（2）和语法相关的每一层缩进都用4个空格来表示

（3）每行的字符不应超过79

（4）对于多行长表达式，除了首行之外的其余各行都应该在通常的缩进级别之上再加4个空格

（5）文件中的函数与类之间应该用两个空行隔开

（6）同一个类中的两个方法之间应该用一个空行隔开

（7）在使用下标获取列表元素、调用函数或给关键字参数赋值时，不要在两旁添加空格

（8）为变量赋值时，赋值符号两边各添加一个空格

命名

（1）函数、变量及属性应该用小写字母来拼写，各单词间用下划线连接，如bub_sort

（2）受保护的实例属性，应以单下划线开头，如_name

（3）私有的实例属性，应以双下划线开头，如__name

（4）类与异常，应以每个单词首字母大写的形式命名，如Note

（5）模块级别的常量，应全部采用大写字母拼写，单词之间用下划线连接，如ERR_CODE

（6）类中实例方法的首个参数，应该命名为self，表示该对象自身

（7）类方法的首个参数，应该命名为cls，表示该类自身

表达式和语句

（1）采用内联形式的否定词，不要把否定词放在整个表达式的前面，例如应该是 if a is not b 而不是if not a is b

（2）不要通过检测长度的办法，如len(list1) == 0来判断list1是否为[]或“”等空值，而是采用if not list1来判断，它会假定空值将自动评估为False

（3）检测list1是否为[1]或‘hi’等非空值，应用if list1语句会默认把非空的值判断为True

（4）不要编写单行的if语句、for循环、while循环及except复合语句，而是应该把这些语句分成多行来书写，以示清晰

（5）import语句应该总是放在文件开头

（6）引入模块的时候，总是应该使用绝对的名称，而不应该根据当前模块的路径来使用相对名称

　　例如，引入bar包中的foo模块时，应该完整的写出from bar import foo，而不应该写import foo

（7）如果一定要用相对名称来编写import语句，应该采用明确的写法：from .import foo

（8）文件中的import语句应该按顺序划分成三个部分，分别表示标准模块、第三方模块以及自用模块。

　　在每一个部分中，各import'语句应该按模块的顺序来排列

5.了解切割序列的办法

（1）不要写多余的代码；当从索引开头获取元素，应把起始索引留空；当一直取到索引末尾，应把终止索引留空。

nums = [0, 1, 2, 3, 4, 5]
res1 = nums[:] #[0, 1, 2, 3, 4, 5]
res2 = nums[:3] #[0, 1, 2]
res3 = nums[3:] #[3, 4, 5]
res4 = nums[1:3] #[1, 2]
res5 = nums[2:-1] #[2, 3, 4]
res6 = nums[:-1] #[0, 1, 2, 3, 4]
res7 = nums[-2:] #[4, 5]
res8 = nums[-3:-1] #[3, 4]

（2）切片操作不计较开始索引和结束索引是否越界。

 利用这一特性，我们可以限定输入序列的最大长度

nums = [_ for _ in range(30)]
first_ten_items = nums[:10]
#[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
last_ten_items = nums[-10:]
#[20, 21, 22, 23, 24, 25, 26, 27, 28, 29]

（3）对列表赋值时，如果使用切片操作，会把原列表中在相关范围内的值替换成新值，

位于切片之前和之后的值不变，列表会根据新值的个数相应的扩张和收缩。

nums = [0, 1, 2, 3, 4, 5]
nums_temp = nums
nums[:3] = ['a']
print(nums, nums is nums_temp) #['a', 3, 4, 5] True

来看个特殊的

nums = [0, 1, 2, 3, 4, 5]
nums_temp = nums
nums[:] = ['a', 'b', 'c']
print(nums, nums is nums_temp) #['a', 'b', 'c'] True

说明：把右侧的新值赋值一份去替换左侧列表的全部元素，但不会重新分配新的列表，这个从nums is nums_temp为True可知。

8.不要使用包含两个以上表达式的列表推导

列表支持多级循环，每一级循环也支持多项条件

超过两个表达式的 列表推导不易理解，应尽量避免

栗子1，遍历二维数组

list1 = [[1, 2], [3, 4], [5, 6]]
res1 = [x for row in list1 for x in row]
print(res1) #[1, 2, 3, 4, 5, 6]

栗子2，一维列表多条件

list2 = [1, 2, 3, 4, 5, 6]
res2 = [y for y in list2 if y > 4 and y % 2 == 0]
print(res2) #[6]

栗子3，根据二维数组来创建一个新的二维数组

list3 = [[1, 2], [3, 4]]
squares = [[x**2 for x in row] for row in list3]
print(squares)  #[[1, 4], [9, 16]]

10.尽量用enumerate取代range

1）range常用在一系列整数上的迭代

for i in range(10):
    print(i)

2）对于字符串列表，可直接使用for...in迭代

fruits = ["apple", "banana", "pear"]
for ele in fruits:
    print(ele)

3）对于迭代列表时，需要知道当前元素的索引

方式一：range

fruits = ["apple", "banana", "pear"]
for i in range(len(fruits)):
    print("%d: %s" % (i, fruits[i]))

说明：代码有些生硬，必须先获得序列的长度，再通过下标访问元素，代码难免有些臃肿

方式二：enumerate

fruits = ["apple", "banana", "pear"]
for i, ele in enumerate(fruits):
    print("%d: %s" % (i, ele))

要点

1.再需要用到所遍历序列的索引时，一般用enumerate遍历

2.enumerate可指定开始计数的索引

11.用zip函数同时遍历两个迭代器

栗子：平行的迭代两个长度相等的列表，并求fruits中长度最长的元素

fruits = ["apple", "banana", "pear"]
letters = [len(fruit) for fruit in fruits]

方式一：通过某个列表的长度来执行循环

fruits = ["apple", "banana", "pear"]
letters = [len(fruit) for fruit in fruits]

longest_name = None
max_letters = 0

for i in range(len(fruits)):
    if letters[i] > max_letters:
        max_letters = letters[i]
        longest_name = fruits[i]

print(max_letters)
print(longest_name)

方式二：通过enumerate来执行循环

fruits = ["apple", "banana", "pear"]
letters = [len(fruit) for fruit in fruits]

longest_name = None
max_letters = 0

for i, fruit in enumerate(fruits):
    if letters[i] > max_letters:
        max_letters = letters[i]
        longest_name = fruit

print(max_letters)
print(longest_name)

方式三：用zip函数来执行循环

fruits = ["apple", "banana", "pear"]
letters = [len(fruit) for fruit in fruits]

longest_name = None
max_letters = 0

for fruit, length in zip(fruits, letters):
    if length > max_letters:
        max_letters = length
        longest_name = fruit

print(max_letters)
print(longest_name)

zip工作原理

从每个迭代器中获取该迭代器的下一个元素，并将这些值汇聚成元祖，

zip中受封装的迭代器一般长度都相等，只要有一个耗尽，zip就不会再产生

元祖，所以zip中的迭代器一般长度都相等

要点

1.zip函数可以平行遍历多个迭代器

2.python3中的zip相等于生成器，会在遍历过程中逐次产生元祖

3.如果zip中提供的迭代长度不等，那么zip会自动提前终止

4.itertools内置模块中的zip_longest函数可以平行迭代多个迭代器，而不用在乎它们的长度是否相等

12.不要在for和while循环后写else代码块

原因

会令代码的可读性降低，不利于维护

要点

当整个循环主体都没遇到break语句时，循环后面的else代码块才会执行