• 周二. 8月 9th, 2022

5G编程聚合网

5G时代下一个聚合的编程学习网

热门标签

python通用规范-4

admin

11月 28, 2021

文章目录

4.1 `None`值比较
4.2 模块导入控制 __all__
4.3 字典取值的推荐方式(`get`)
4.4 列表切边不推荐负步长值
4.5 参数的类型检查推荐`isinstance`
4.6 使用列表推导式替换循环
4.7 功能代码应该封装在函数或类中
4.8 精确数值计算的场景使用`Decimal`模块
4.9 避免对不同对象使用同一个变量名
4.10 类方法的装饰
4.11 使用包(`package`)形式管理不同目录下的源码
4.12 避免在代码中修改`sys.path`列表
4.13 使用枚举替代`range`
4.14 避免重复定义变量名
4.1 None值比较

与None作比较要使用is或is not,不要使用等号

说明:
is判断是否指向同一个对象(判断两个对象的id是否相等),==会调用eq方法判断是否等价(判断两个对象的值是否相等)。
示例:同一个实例,使用“is”和“==”的判断结果不同。

>>> class Bad(object):
def __eq__(self, other):
return True
>>> bad_inst = Bad()
>>> bad_inst == None
True
>>> bad_inst is None
False
1
2
3
4
5
6
7
8
4.2 模块导入控制 all

定义一个all不会把本模块的所有内容都暴露在外部,将允许外部访问的变量、函数和类的名字放进去

说明:
在模块中定义了__all__之后,从外部from module import *只会import __all__中定义的内容。
示例:

# sample_package.py
__all__ = [“sample_external_function”]

def sample_external_function():
print(“This is an external function..”)

def sample_internal_function():
print(“This is an internal function..”)

# main.py
from sample_package import *

if __name__ == “__main__”:
sample_external_function()
sample_internal_function().

NameError: name ‘sample_internal_function’ is not defined
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
4.3 字典取值的推荐方式(get)

避免直接使用dict[key]的方式从字典中获取value,如果一定要使用,需要注意当key not in dict时的异常捕获和处理

说明:
Python的字典dict可以使用key获取其对应的value。但是当key在dict的key值列表中不存在时,直接使用dict[key]获取value会报KeyError,应当使用更为安全的dict.get(key)类型方法获取value。
# 错误示例:
sample_dict = {‘default_key’: 1}
sample_key = ‘sample_key’
sample_value = sample_dict[sample_key]

# 正确示例:
sample_dict = {‘default_key’: 1}
sample_key = ‘sample_key’
sample_value = sample_dict.get(sample_key)
1
2
3
4
5
6
7
8
9
4.4 列表切边不推荐负步长值

对序列使用切片操作时,不建议使用负步进值进行切片

说明:
Python提供了sample_list[start : end : stride]形式的写法,以实现步进切割,也就是从每stride个元素中取一个出来。但如果stride值为负,则会使代码难以理解,特定使用场景下还会造成错误。
# 错误示例:
# 如下写法,在start : end : stride都使用的情况下使用负的stride,会造成阅读困难。此种情况建议将“步进”切割过程和“范围”切割过程分开,使代码更清晰。
>>> a = [1,2,3,4,5,6,7,8]
>>> a[2::2]
[3,5,7]
>>> a[-2::-2]
[7,5,3,1]
>>> a[-2:2:-2]
[7,5]
>>> a[2:2:-2]
[]
1
2
3
4
5
6
7
8
9
10
11
4.5 参数的类型检查推荐isinstance

传递实例类型参数后,函数内应使用isinstance函数进行参数检查,不要使用type

说明:如果类型有对应的工厂函数,可使用它对类型做相应转换,否则可以使用isinstance函数来检测。使用函数/方法参数传递实例类型参数后,函数内对此参数进行检查应使用isinstance函数,使用is not None,len(para) != 0等其它逻辑方法都是不安全的。
# 错误示例:
# 下面的函数保护未能完成应有的检查功能,传入一个tuple就可以轻易绕过保护代码造成执行异常。
>>> def sample_sort_list(sample_inst):
… if sample_inst is []:
… return
… sample_inst.sort()
>>> fake_list = (2, 3, 1, 4)
>>> sample_sort_list(fake_list)
Traceback (most recent call last):
File “<pyshell#232>”, line 1, in <module>
sample_sort_list(fake_list)
File “<pyshell#230>”, line 4, in sample_sort_list
sample_inst.sort()
AttributeError: ‘tuple’ object has no attribute ‘sort’

# 正确示例:
# 使用instance函数对入参进行检查,检查后可以按照需求raise exception或return。
>>> def sample_sort_list(sample_inst):
… if not isinstance(sample_inst, list):
… raise TypeError(r”sample_sort_list in para type error %s” % type(sample_inst))
… sample_inst.sort()
>>> fake_list = (2, 3, 1, 4)
>>> sample_sort_list(fake_list)
Traceback (most recent call last):
File “<pyshell#235>”, line 1, in <module>
sample_sort_list(fake_list)
File “<pyshell#234>”, line 3, in sample_sort_list
raise TypeError(r”sample_sort_list in para type error %s” % type(sample_inst))
TypeError: sample_sort_list in para type error <type ‘tuple’>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
4.6 使用列表推导式替换循环

尽量使用推导式代替重复的逻辑操作构造序列。但推导式必须考虑可读性,不推荐使用两个以上表达式的列表推导

说明:
推导式(comprehension)是一种精炼的序列生成写法,在可以使用推导式完成简单逻辑,生成序列的场合尽量使用推导式,但如果逻辑较为复杂(> 两个逻辑表达式),则不推荐强行使用推导式,因为这会使推导式代码的可读性变差。
# 错误示例:
# 如下逻辑代码,逻辑较为简单,实现此逻辑的代码不但有循环,而且较为复杂,性能不佳。
odd_num_list = []
for i in range(100):
if i % 2 == 1:
odd_num_list.append(i)
# 正确示例:
odd_num_list = [i for i in range(100) if i % 2 == 1]
# 简单逻辑使用列表推导式实现,代码清晰精炼。
1
2
3
4
5
6
7
8
9
4.7 功能代码应该封装在函数或类中

说明:在Python中, 所有的顶级代码在模块导入时都会被执行. 容易产生调用函数, 创建对象等误操作。所以代码应该封装在函数或类中。即使是脚本类的代码,也建议在执行主程序前总是检查 if __name__ == ‘__main__’ , 这样当模块被导入时主程序就不会被执行.
正确示例:
def main():

if __name__ == ‘__main__’:
main()
1
2
3
4
5
4.8 精确数值计算的场景使用Decimal模块

说明:在Python中,注意不要用浮点数构造Decimal,因为浮点数本身不准确。
# 错误示例:
>>> from decimal import Decimal
>>> getcontext().prec = 28
>>> Decimal(3.14)
Decimal(‘3.140000000000000124344978758017532527446746826171875’)

# 正确示例:
>>> from decimal import Decimal
>>> Decimal(‘3.14’)
Decimal(‘3.14’)
>>> getcontext().prec = 6
>>> Decimal(1) / Decimal(7)
Decimal(‘0.142857’)
1
2
3
4
5
6
7
8
9
10
11
12
13
4.9 避免对不同对象使用同一个变量名

说明: Python是弱类型语言,允许变量被赋值为不同类型对象,但这么做可能会导致运行时错误,且因为变量上下文语义变化导致代码复杂度提升,难以调试和维护,也不会有任何性能的提升。
# 错误示例
items = ‘a,b,c,d’ # 字符串
items = items.split(‘,’) # 变更为列表

# 正确示例
items = ‘a,b,c,d’ # 字符串
itemList = items.split(‘,’) # 变更为列表
1
2
3
4
5
6
7
4.10 类方法的装饰

类的方法不需访问实例时,根据具体场景选择使用@staticmethod或者@classmethod进行装饰

说明: 一般的类方法要接收一个self参数表示此类的实例,但有些方法不需要访问实例,这时分为两种情况:
1、方法不需要访问任何成员,或者只需要显式访问这个类自己的成员。这样的方法不需要额外参数,应当用@staticmethod装饰。 在Python 3.X版本中,允许直接定义不含self参数的方法,并且允许不通过实例调用。但是一旦通过实例调用这个方法,就会因为参数不匹配而出错。 加上@staticmethod进行修饰,可以让Python解释器明确此方法不需要self参数,提前拦截问题,可读性也更好。

# 错误示例:
class MyClass:
def my_func(): # 没有用@staticmethod修饰,通过实例调用会出错
pass

MyClass.my_func() # Python 3.X中允许,2.X中出错
my_instance = MyClass()
my_instance.my_func() # Python 3.X和2.X中都会出错

# 正确示例:
class MyClass:
@staticmethod
def my_func(): # 用@staticmethod修饰后,解释器会将其解析为静态方法
pass

MyClass.my_func() # OK
my_instance = MyClass()
my_instance.my_func() # OK,但是不推荐,容易和普通方法混淆。最好写成MyClass.my_func()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2、方法不需要访问实例的成员,但需要访问基类或派生类的成员。这时应当用@classmethod装饰。装饰后的方法,其第一个参数不再传入实例,而是传入调用者的最底层类。 比如,下面这个例子,通过基类Spam的count方法,来统计继承树上每个类的实例个数:

class Spam:
numInstances = 0

@classmethod
def count(cls): # 对每个类做独立计数
cls.numInstances += 1 # cls是实例所属于的最底层类

def __init__(self):
self.count() # 将self.__class__传给count方法

class Sub(Spam):
numInstances = 0

class Other(Spam):
numInstances = 0

x = Spam()
y1, y2 = Sub(), Sub()
z1, z2, z3 = Other(), Other(), Other()
x.numInstances, y1.numInstances, z1.numInstances # 输出:(1, 2, 3)
Spam.numInstances, Sub.numInstances, Other.numInstances # 输出:(1, 2, 3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
但是使用@classmethod时需要注意,由于在继承场景下传入的第一个参数并不一定是这个类本身,因此并非所有访问类成员的场景都应该用@classmethod。比如下面这个例子中,Base显式的想要修改自己的成员inited(而不是派生类的成员),这时应当用@staticmethod。

# 错误示例:
class Base:
inited = False
@classmethod
def set_inited(cls): # 实际可能传入Derived类
cls.inited = True # 并没有修改Base.inited,而是给Derived添加了成员

class Derived(Base):
pass

x = Derived()
x.set_inited()
if Base.inited:
print(“Base is inited”) # 不会被执行
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
4.11 使用包(package)形式管理不同目录下的源码

当多个Python源码文件分不同子目录存放时,用包(package)形式管理各个目录下的模块。

说明: 通过让子目录包含__init__.py文件,可以让Python代码在import和from语句中,将子目录作为包名,通过分层来管理各个模块,让模块间的关系更清楚。__init__.py文件中可以包含这个包所需要的初始化动作,也可以定义一个__all__列表来指定from *语句会包含哪些模块。对于不需要初始化的包,可以只在目录下放一个名为__init__.py的空文件,标识这个目录是一个包。
正确示例:
假设Python源码根目录是dir0,其下有子目录dir1,dir1下面又有个子目录dir2,dir2下面有个mod.py模块。 那么,在dir1和dir2下各放置一个__init__.py文件,然后在其他代码中可以这样使用mod.py模块:

import dir1.dir2.mod
dir1.dir2.mod.func() # 调用mod.py中的func函数
from dir1.dir2.mod import func # 把func函数添加到当前空间
func() # 可以省掉包名和模块名直接调用
1
2
3
4
4.12 避免在代码中修改sys.path列表

说明: sys.path是Python解释器在执行import和from语句时参考的模块搜索路径,由当前目录、系统环境变量、库目录、.pth文件配置组合拼装而成。用户通过修改系统配置,可以指定搜索哪个路径下的模块。sys.path只应该根据用户的系统配置来生成,不应该在代码里面直接修改。否则可能出现A模块修改了sys.path,导致B模块搜索出错,且用户难以定位。
正确示例: 如果要添加模块搜索路径,应当修改PYTHONPATH环境变量。如果是管理子目录,应当通过包(package)来组织模块。

4.13 使用枚举替代range

尽量不使用for i in range(x)的方式循环处理集合数据,而应使用for x in iterable的方式
说明: for i in range(x),然后在循环体内对集合用下标[i]获取元素是C语言的编程习惯,它有很多缺点:容易越界;在循环体内修改i容易出错;可读性差。Python语言建议尽量用for x in iterable的方式直接取集合的每一条数据进行处理。

# 错误示例:
for i in range(len(my_list)):
print(my_list[i])

# 正确示例:
for x in my_list:
print(x)
# 有些场合下,需要在处理时使用每个元素的序号,这时可以使用enumerate内置函数来给元素加上序号形成元组:
my_list = [‘a’, ‘b’, ‘c’]
for x in enumerate(my_list):
print(x)
# 运行结果为: (0, ‘a’) (1, ‘b’) (2, ‘c’)
1
2
3
4
5
6
7
8
9
10
11
12
4.14 避免重复定义变量名

避免在无关的变量或无关的概念之间重用名字,避免因重名而导致的意外赋值和错误引用

说明: Python的函数/类定义和C语言不同,函数/类定义语句实际上是给一个名字赋值。因此重复定义一个函数/类的名字不会导致错误,后定义的会覆盖前面的。但是重复定义很容易掩盖编码问题,让同一个名字的函数/类在不同的执行阶段具有不同的含义,不利于可读性,应予以禁止。 Python在解析一个被引用的名字时遵循LEGB顺序(Local – Enclosed – Global – Builtin),从内层一直查找到外层。内层定义的变量会覆盖外层的同名变量。在代码修改时,同名的变量容易导致错误的引用,也不利于代码可读性,应当尽量避免。
————————————————
版权声明:本文为CSDN博主「zhao12501」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.csdn.net/zhao12501/article/details/115455806

A thousand journey is started by taking the first step.

发表评论

您的电子邮箱地址不会被公开。