网站性能检测评分
注:本网站页面html检测工具扫描网站中存在的基本问题,仅供参考。
python中type
在Python 2.7即将停止支持时,我们为你准备了一份3.x迁移指南 推广视频课程
机器之心编译
目前,Python 科学栈中的所有主要项目都同时支持 Python 3.x 和 Python 2.7,不过,这种情况很快即将结束。去年 11 月,Numpy 团队的一份声明引发了数据科学社区的关注:这一科学计算库即将放弃对于 Python 2.7 的支持,全面转向 Python 3。Numpy 并不是唯一宣称即将放弃 Python 旧版本支持的工具,pandas 与 Jupyter notebook 等很多产品也在即将放弃支持的名单之中。对于数据科学开发者而言,如何将已有项目从 Python 2 转向 Python 3 成为了正在面临的重大问题。来自莫斯科大学的 Alex Rogozhnikov 博士为我们整理了一份代码迁移指南。
Python 3 功能简介
Python 是机器学习和其他科学领域中的主流语言,我们通常需要使用它处理大量的数据。Python 兼容多种深度学习框架,且具备很多优秀的工具来执行数据预处理和可视化。
但是,Python 2 和 Python 3 长期共存于 Python 生态系统中,很多数据科学家仍然使用 Python 2。2019 年底,Numpy 等很多科学计算工具都将停止支持 Python 2,而 2018 年后 Numpy 的所有新功能版本将只支持 Python 3。
为了使 Python 2 向 Python 3 的转换更加轻松,我收集了一些 Python 3 的功能,希望对大家有用。
使用 pathlib 更好地处理路径
pathlib 是 Python 3 的默认模块,帮助避免使用大量的 os.path.joins:
from pathlib importPath
dataset ='wiki_images'
datasets_root =Path('/path/to/datasets/')
train_path = datasets_root / dataset /'train'
test_path = datasets_root / dataset /'test'
for image_path in train_path.iterdir():
with image_path.open()as f:# note, open is a method of Path object
# do something with an image
Python 2 总是试图使用字符串级联(准确,但不好),现在有了 pathlib,代码安全、准确、可读性强。
此外,pathlib.Path 具备大量方法,这样 Python 新用户就不用每个方法都去搜索了:
p.exists()
p.is_dir()
p.parts()
p.with_name('sibling.png')# only change the name, but keep the folder
p.with_suffix('.jpg')# only change the extension, but keep the folder and the name
p.chmod(mode)
p.rmdir()
pathlib 会节约大量时间,详见:
文档:https://docs.python.org/3/library/pathlib.html;
参考信息:https://pymotw/3/pathlib/。
类型提示(Type hinting)成为语言的一部分
PyCharm 中的类型提示示例:
Python 不只是适合脚本的语言,现在的数据流程还包括大量步骤,每一步都包括不同的框架(有时也包括不同的逻辑)。
类型提示被引入 Python,以帮助处理越来越复杂的项目,使机器可以更好地进行代码验证。而之前需要不同的模块使用自定义方式在文档字符串中指定类型(注意:PyCharm 可以将旧的文档字符串转换成新的类型提示)。
下列代码是一个简单示例,可以处理不同类型的数据(这就是我们喜欢 Python 数据栈之处)。
def repeat_each_entry(data):
""" Each entry in the data is doubled
"""
index = numpy.repeat(numpy.arange(len(data)),2)
return data[index]
上述代码适用于 numpy.array(包括多维)、astropy.Table 和 astropy.Column、bcolz、cupy、mxnet.ndarray 等。
该代码同样可用于 pandas.Series,但是方式是错误的:
repeat_each_entry(pandas.Series(data=[0,1,2], index=[3,4,5]))# returns Series with Nones inside
这是一个两行代码。想象一下复杂系统的行为多么难预测,有时一个函数就可能导致错误的行为。明确了解哪些类型方法适合大型系统很有帮助,它会在函数未得到此类参数时给出提醒。
def repeat_each_entry(data:Union[numpy.ndarray, bcolz.carray]):
如果你有一个很棒的代码库,类型提示工具如 MyPy 可能成为集成流程中的一部分。不幸的是,提示没有强大到足以为 ndarrays/tensors 提供细粒度类型,但是或许我们很快就可以拥有这样的提示工具了,这将是 DS 的伟大功能。
类型提示 → 运行时的类型检查
默认情况下,函数注释不会影响代码的运行,不过它也只能帮你指出代码的意图。
但是,你可以在运行时中使用 enforce 等工具强制进行类型检查,这可以帮助你调试代码(很多情况下类型提示不起作用)。
@enforce.runtime_validation
def foo(text: str)->None:
print(text)
foo('Hi')# ok
foo(5)# fails
@enforce.runtime_validation
def any2(x:List[bool])->bool:
return any(x)
any ([False,False,True,False])# True
any2([False,False,True,False])# True
any (['False'])# True
any2(['False'])# fails
any ([False,None,"",0])# False
any2([False,None,"",0])# fails
函数注释的其他用处
如前所述,注释不会影响代码执行,而且会提供一些元信息,你可以随意使用。
例如,计量单位是科学界的一个普遍难题,astropy 包提供一个简单的装饰器(Decorator)来控制输入量的计量单位,并将输出转换成所需单位。
# Python 3
from astropy import units as u
@u.quantity_input()
def frequency(speed: u.meter / u.s, wavelength: u.m)->u.terahertz:
return speed / wavelength
frequency(speed=300_000 * u.km / u.s, wavelength=555* u.nm)
# output: 540.5405405405404 THz, frequency of green visible light
如果你拥有 Python 表格式科学数据(不必要太多),你应该尝试一下 astropy。你还可以定义针对某个应用的装饰器,用同样的方式来控制/转换输入和输出。
通过 @ 实现矩阵乘法
下面,我们实现一个最简单的机器学习模型,即带 L2 正则化的线性回归:
# l2-regularized linear regression: || AX - b ||^2 + alpha * ||x||^2 ->min
# Python 2
X = np.linalg.inv(np.dot(A.T, A)+ alpha * np.eye(A.shape[1])).dot(A.T.dot(b))
# Python 3
X = np.linalg.inv(A.T @ A + alpha * np.eye(A.shape[1]))@(A.T @ b)
下面 Python 3 带有 @ 作为矩阵乘法的符号更具有可读性,且更容易在深度学习框架中转译:因为一些如 X @ W + b[None, :] 的代码在 numpy、cupy、pytorch 和 tensorflow 等不同库下都表示单层感知机。
使用 ** 作为通配符
递归文件夹的通配符在 Python2 中并不是很方便,因此才存在定制的 glob2 模块来克服这个问题。递归 flag 在 Python 3.6 中得到了支持。
import glob
# Python 2
found_images = \
glob.glob('/path*.jpg') \
+ glob.glob('/path*.jpg') \
+ glob.glob('/path***.jpg')
# Python 3
found_images = glob.glob('/path*.jpg', recursive=True)
python3 中更好的选择是使用 pathlib:
# Python 3
found_images = pathlib.Path('/path/').glob('**/*.jpg')
Print 在 Python3 中是函数
Python 3 中使用 Print 需要加上麻烦的圆括弧,但它还是有一些优点。
使用文件描述符的简单句法:
print>>sys.stderr,"critical error"# Python 2
print("critical error", file=sys.stderr)# Python 3
在不使用 str.join 下输出 tab-aligned 表格:
# Python 3
print(*array, sep='\t')
print(batch, epoch, loss, accuracy, time, sep='\t')
修改与重新定义 print 函数的输出:
# Python 3
_print =print# store the original print function
defprint(*args,**kargs):
pass# do something useful, e.g. store output to some file
在 Jupyter 中,非常好的一点是记录每一个输出到独立的文档,并在出现错误的时候追踪出现问题的文档,所以我们现在可以重写 print 函数了。
在下面的代码中,我们可以使用上下文管理器暂时重写 print 函数的行为:
@contextlib.contextmanager
def replace_print():
import builtins
_print =print# saving old print function
# or use some other function here
builtins.print=lambda*args,**kwargs: _print('new printing',*args,**kwargs)
yield
builtins.print= _print
with replace_print():
上面并不是一个推荐的方法,因为它会引起系统的不稳定。
print 函数可以加入列表解析和其它语言构建结构。
# Python 3
result = process(x)if is_valid(x)elseprint('invalid item: ', x)
f-strings 可作为简单和可靠的格式化
默认的格式化系统提供了一些灵活性,且在数据实验中不是必须的。但这样的代码对于任何修改要么太冗长,要么就会变得很零碎。而代表性的数据科学需要以固定的格式迭代地输出一些日志信息,通常需要使用的代码如下:
# Python 2
print('{batch:3} {epoch:3} / {total_epochs:3} accuracy: {acc_mean:0.4f}±{acc_std:0.4f} time: {avg_time:3.2f}'.format(
batch=batch, epoch=epoch, total_epochs=total_epochs,
acc_mean=numpy.mean(accuracies), acc_std=numpy.std(accuracies),
avg_time=time / len(data_batch)
))
# Python 2 (too error-prone during fast modifications, please avoid):
print('{:3} {:3} / {:3} accuracy: {:0.4f}±{:0.4f} time: {:3.2f}'.format(
batch, epoch, total_epochs, numpy.mean(accuracies), numpy.std(accuracies),
time / len(data_batch)
))
样本输出:
12012/300 accuracy:0.8180±0.4649 time:56.60
f-strings 即格式化字符串在 Python 3.6 中被引入:
# Python 3.6+
print(f'{batch:3} {epoch:3} / {total_epochs:3} accuracy: {numpy.mean(accuracies):0.4f}±{numpy.std(accuracies):0.4f} time: {time / len(data_batch):3.2f}')
另外,写查询语句时非常方便:
query = f"INSERT INTO STATION VALUES (13, '{city}', '{state}', {latitude}, {longitude})"
「true pision」和「integer pision」之间的明显区别
对于数据科学来说这种改变带来了便利(但我相信对于系统编程来说不是)。
data = pandas.read_csv('timing.csv')
velocity = data['distance']/ data['time']
Python 2 中的结果依赖于『时间』和『距离』(例如,以米和秒为单位)是否被保存为整数。
在 Python 3 中,结果的表示都是精确的,因为除法的结果是浮点数。
另一个案例是整数除法,现在已经作为明确的运算:
n_gifts = money // gift_price # correct for int and float arguments
注意,该运算可以应用到内建类型和由数据包(例如,numpy 或 pandas)提供的自定义类型。
严格排序
# All these comparisons are illegal in Python 3
3<'3'
2 (3,4)<(3,None) (4,5)<[4,5] # False in both Python 2 and Python 3 (4,5)==[4,5] 防止不同类型实例的偶然性的排序。 sorted([2,'1',3])# invalid for Python 3, in Python 2 returns [2, 3, '1'] 在处理原始数据时帮助发现存在的问题。 旁注:对 None 的合适检查是(两个版本的 Python 都适用): if a isnotNone: pass if a:# WRONG check for None pass 自然语言处理的 Unicode s ='您好' print(len(s)) print(s[:2]) 输出: Python 2: 6\n Python 3: 2\n 您好. x = u'со' x +='co'# ok x +='со'# fail Python 2 在此失败了,而 Python 3 可以如期工作(因为我在字符串中使用了俄文字母)。 在 Python 3 中 strs 是 Unicode 字符串,对非英语文本的 NLP 处理更加方便。 还有其它有趣的方面,例如: 'a'< type < u'a'# Python 2: True 'a'< u'a'# Python 2: False from collections importCounter Counter('Mbelstück') Python 2: Counter({'\xc3': 2, 'b': 1, 'e': 1, 'c': 1, 'k': 1, 'M': 1, 'l': 1, 's': 1, 't': 1, '\xb6': 1, '\xbc': 1}) Python 3: Counter({'M': 1, '': 1, 'b': 1, 'e': 1, 'l': 1, 's': 1, 't': 1, 'ü': 1, 'c': 1, 'k': 1}) 这些在 Python 2 里也能正确地工作,但 Python 3 更为友好。 保留词典和**kwargs 的顺序 在 CPython 3.6+ 版本中,字典的默认行为类似于 OrderedDict(在 3.7+版本中已得到保证)。这在字典理解(和其他操作如 json 序列化/反序列化期间)保持顺序。 import json x ={str(i):i for i in range(5)} json.loads(json.dumps(x)) # Python 2 {u'1':1, u'0':0, u'3':3, u'2':2, u'4':4} # Python 3 {'0':0,'1':1,'2':2,'3':3,'4':4} 它同样适用于**kwargs(在 Python 3.6+版本中):它们的顺序就像参数中显示的那样。当设计数据流程时,顺序至关重要,以前,我们必须以这样繁琐的方式来编写: from torch import nn # Python 2 model = nn.Sequential(OrderedDict([ ('conv1', nn.Conv2d(1,20,5)), ('relu1', nn.ReLU()), ('conv2', nn.Conv2d(20,64,5)), ('relu2', nn.ReLU()) ])) # Python 3.6+, how it *can* be done, not supported right now in pytorch model = nn.Sequential( conv1=nn.Conv2d(1,20,5), relu1=nn.ReLU(), conv2=nn.Conv2d(20,64,5), relu2=nn.ReLU()) ) 注意到了吗?名称的唯一性也会被自动检查。 迭代地拆封 # handy when amount of additional stored info may vary between experiments, but the same code can be used in all cases model_paramteres, optimizer_parameters,*other_params = load(checkpoint_name) # picking two last values from a sequence *prev, next_to_last, last = values_history # This also works with any iterables, so if you have a function that yields e.g. qualities, # below is a simple way to take only last two values from a list *prev, next_to_last, last = iter_train(args) 默认的 pickle 引擎为数组提供更好的压缩 # Python 2 import cPickle as pickle import numpy print len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 23691675 # Python 3 import pickle import numpy len(pickle.dumps(numpy.random.normal(size=[1000,1000]))) # result: 8000162 节省 3 倍空间,而且速度更快。实际上,类似的压缩(不过与速度无关)可以通过 protocol=2 参数来实现,但是用户...
JS中的typeof和类型判断 公司视频课程
typeof
ECMAScript 有 5 种原始类型(primitive type),即 Undefined、Null、Boolean、Number 和 String。我们都知道可以使用typeof运算符求得一个变量的类型,但是对引用类型变量却只会返回object,也就是说typeof只能正确识别基本类型值变量。
var a = "abc";typeof a;// "string"var b = 123;typeof b;// "number"var c = true;typeof c;// "boolean"var d = null;typeof d;// "object"var f = undefined;typeof f;// "undefined"var g;typeof g;// "undefined"typeof x;// "object"
您也许会问,为什么 typeof 运算符对于 null 值会返回 "object"。这实际上是 JavaScript 最初实现中的一个错误,然后被 ECMAScript 沿用了。现在,null 被认为是对象的占位符,从而解释了这一矛盾,但从技术上来说,它仍然是原始值。
最后一个比较奇怪,typeof一个不存在的变量x居然返回了"object"而不是"undefined"。
我们在来如下代码
var a = function() {};typeof a; // "function"var b = [1,2,3];typeof b; // "object"var c = {};typeof c; // "object"
对于数组和对象都返回"object",因此我们日常开发中一个常见需求就是如何判断变量是数组还是对象。
类型判断
类型判断,一般就是判断是否是数组,是否是空对象。这是针对这个需求,我日常用过或见过的判断方法
判断是否是数组
有数组:var a = [1,2,3,4,5];
方法一:
toString.call(a); // "[object Array]"
方法二:
a instanceof Array; //true
方法三:
a.constructor == Array; //true
第一种方法比较通用,也就是Object.prototype.toString.call(a)的简写。
instanceof和constructor判断的变量,必须在当前页面声明的,比如,一个页面(父页面)有一个框架,框架中引用了一个页面(子页面),在子页面中声明了一个a,并将其赋值给父页面的一个变量,这时判断该变量,Array == object.constructor会返回false;
判断是否是空对象
有变量:var obj = {};
JSON.stringify(obj); // "{}"
通过转换成JSON对象来判断是否是空大括号
if(obj.id){ //如果属性id存在....}
这个方法比较土,大多数人都能想到,前提是得知道对象中有某个属性。
function isEmptyObject(e) { var t; for (t in e) return !1; return !0 } //trueisEmptyObject(obj); //falseisEmptyObject({ "a":1, "b":2});
这个方法是jQuery的isEmptyObject()方法的实现方式。
┏━━━━━━━━━━━━┓
┃打出“php”
┃选第一个
┃发到评论
┃看看你打出来的是什么
┗━━━━━━━━━━━━
Python中集合(set)类型的详细解释及操作 互联网视频课程
一、集合(set)类型的含义:
Set是一个无序不重复元素集,与列表和元组不同,集合是无序的,无法通过数字进行索引。
注意:下面所举例子在python3.6,IDE为pycharm2016.1中通过。
创建集合:用set()函数,或直接赋值。
例子:
x=set('Nike MM')
y=set(['w','a','m','a'])
print(x)
print(y)
输出:
{'M', 'N', 'e', 'k', ' ', 'i'}
{'w', 'm', 'a'}
可以看到,在输出中,是用一对{}号包住,里面重复的元素被去除。
再看一个例子:
s={'11','22','33'}
print(s)
print(type(s))
s={}
{'33', '11', '22'}
在定义不,不能用s={},这关创建的实际上是一个字典类型。
二、有关集合的操作:
1.增加操作
a=set('python')
a.add('why')
print(a)
b=set('python')
b.update('why')
print(b)
{'n', 'p', 'y', 'h', 'o', 't', 'why'}
{'n', 'p', 'y', 'h', 'o', 'w', 't'}
可能看到:add是单个元素的添加,并没有把元素再分拆为单个字符。Update是批量的增加,增加的元素如果是一个字符串(实际上,在Python中字符串也是一个系列),是作为一个系列增加的。在输出结果中,两个函数都是无序的,并且无重复,也非添加到尾部。
2.删除操作(remove,discard,pop)
例子1:
a=set('abcdefghijk')
a.remove('a')
a.remove('w')
输出 :
Traceback (most recent call last):
{'h', 'k', 'e', 'd', 'g', 'c', 'f', 'i', 'b', 'j'}
File "D:/python/temp3.py", line 4, in
KeyError: 'w'
例子2:
a.discard('a')
a.discard('w')
{'f', 'h', 'd', 'e', 'b', 'k', 'i', 'j', 'c', 'g'}
例子3:
b=a.pop()
print(b,type(b))
{'k', 'd', 'h', 'c', 'b', 'j', 'g', 'i', 'e', 'f'}
a
从以上例子可以看到,remove方法删除指定无素,如果要删除的元素的不在集合中,则报错;discard方法删除指定元素,如果要删除物元素不在集合中,则不报错,pop方法删除任意元素,并可将这个元素赋值给一个变量,但集合并没有把这个元素移除。
3.清空(clear)
例子:
a.clear()
set()
4.交集&,并集|,差集-,对称差集^,子集(被包含)<=,父集(包含)>=
a=set(['a','b','c','d','e','f'])
b=set(('d','e','f','g','h','i'))
d=set('def')
print('交集:',a.intersection(b))
print('交集:',a & b)
print('并集:',a.union(b))
print('并集:',a | b)
print('差集:',a.difference(b))
print('差集:',a-b)
#对称差集:
#把两个集合中相同的元素去掉,然后
#两个集合中剩下的元素组成一个新的集合
print('对称差集:',a.symmetric_difference(b) )
print('对称差集:',a ^ b )
print('子集:',a.issubset(d) )
print('子集:',a<=d )
print('父集:',a.issuperset(d) )
print('父集:',a>=d )
交集: {'f', 'e', 'd'}
并集: {'c', 'e', 'd', 'b', 'f', 'a', 'g', 'i', 'h'}
差集: {'a', 'c', 'b'}
对称差集: {'a', 'c', 'g', 'b', 'i', 'h'}
子集: False
父集: True
5.集合的其它一些操作
#如果a和d没有交集,返回True,有则返回False
print(a.isdisjoint(d) ) 输出:False
print(a print(a>d) 输出:True print(a!=b) 输出:True print(a.copy()) 输出:{'f', 'e', 'b', 'a', 'd', 'c'} #复制一个集合 print('a' in a) 输出:True #测试元素是否在集合中 print('a' not in a) 输出:False #测试元素是否不在集合中 print(len(a)) 输出:6 #返回集合的长度 6.集合计算: (1) #从a中减去a和b的交集,即从a集合中删除和b集合中相同的元素 a.difference_update(b) 即等于:a=a-b 或a-=b print(a) 输出:{'a', 'b', 'c'} (2) #修改a集合,仅仅保持a与b的交集,如果没有交集,则a变为空集合set() a.intersection_update(b) 即等于:a=a&b 或a&=b print(a ) 输出:{'e', 'd', 'f'} (3) #a集合中增加‘在b集合中除去a和b交集剩下的元素’ a.symmetric_difference_update(b) 即等于:a=a^b 或 a^=b print(a) 输出:{'i', 'g', 'a', 'c', 'b', 'h'}
Python代码风格:PEP8规则 笔记 流量视频课程
Python程序设计的代码风格应该遵循PEP8规则:
一、代码布局
1、缩进:
每级缩进4个空格(不用Tab,更不空格Tab混用)
1、续行应该与其包裹元素对齐,要么使用圆括号、方括号和花括号内的隐式行连接来垂直对齐,要么使用悬挂式缩进对齐。当使用悬挂缩进时,应该考虑到第一行不应该有参数,以及使用缩进以区分自己是续行。
2、缩进4个空格的规则对于续行是可选的。
3、当 if 语句的条件部分长到需要换行写的时候,注意可以在两个字符关键字的连接处(比如 if ),增加一个空格,再增加一个左括号来创造一个4空格缩进的多行条件。这会与 if 语句内同样使用4空格缩进的代码产生视觉冲突。PEP没有明确指明要如何区分i发的条件代码和内嵌代码。可使用的选项包括但不限于下面几种情况:
4、(可以参考下面关于是否在二进制运算符之前或之后截断的讨论)
在多行结构中的大括号/中括号/小括号的右括号可以与内容对齐单独起一行作为最后一行的第一个字符,如:
或者也可以与多行结构的第一行第一个字符对齐,如:
2、Tab还是空格?
空格是被首先推荐的缩进方式。
Tab应该只在现有代码已经使用tab进行缩进的情况下使用,以便和现有代码保持一致。
Python 3不允许再同一个代码块中Tab和空格混合使用。
混合使用制表符和空格缩进的Python2代码应该统一转成空格。
使用命令行运行Python 2时,使用-t选项,会出现非法混用tab和空格的警告。当使用-tt选项时,这些警告会变成错误。强烈推荐使用这些选项!
3、最大行长
每行最大长度79个字符。
对于连续大段的文字(比如文档字符串(docstring)或注释),每行应该被限制在72个字符长度内。
Python标准库比较传统,将行长限制在79个字符以内(文档字符串/注释为72个字符)。
一种推荐的换行方式是利用Python圆括号、方括号和花括号中的隐式续行。长行可以通过在括号内换行来分成多行。应该最好加上反斜杠来区别续行。
有时续行只能使用反斜杠才。例如,较长的多个 with 语句不能采用隐式续行,只能接受反斜杠表示换行:
另一个这样的例子是assert语句。要确保续行的缩进适当。
在二元运算符之前应该换行吗?
遵循数学的传统能产出更多可读性高的代码:
4、空行
顶层函数和类的定义,前后用两个空行隔开。
类里的方法定义用一个空行隔开。
相关的功能组可以用额外的空行(尽量少地)隔开。一堆相关的单行代码之间的空白行可以省略(例如,一组虚拟实现 dummy implementations)。
在函数中使用空行来区分逻辑段(尽量少地)。
Python接受control-L(即^L)换页符作为空格;许多工具把这些字符当作页面分隔符,所以你可以在文件中使用它们来分隔相关段落。请注意,一些编辑器和基于Web的代码阅读器可能无法识别control-L为换页,将在其位置显示另一个字形。
5、源文件编码
Python核心发布版本中的代码总是以UTF-8格式编码(或者在Python2中用ASCII编码)。
使用ASCII(Python 2)或者UTF-8(Python 3)的文件不应该添加编码声明。
在标准库中,只有用作测试目的,或者注释或文档字符串需要提及作者名字而不得不使用非ASCII字符时,才能使用非默认的编码。否则,在字符串文字中包括非ASCII数据时,推荐使用\x, \u, U或N等转义符。
对于Python 3.0及其以后的版本中,标准库遵循以下原则(参见PEP 3131):Python标准库中的所有标识符都必须只采用ASCII编码的标识符,在可行的条件下也应当使用英文词(很多情况下,使用的缩写和技术术语词都不是英文)。此外,字符串文字和注释应该只包括ASCII编码。只有两种例外:
(a) 测试情况下为了测试非ASCII编码的特性
(b) 作者名字。作者名字不是由拉丁字母组成的也必须提供一个拉丁音译名。
鼓励面向全球的开源项目都采用类似的原则。
6、导入
1、imports应该分行写,而不是都写在一行,例如:
这样写也是可以的:
导入(import)始终在文件的顶部,在模块注释和文档字符串之后,在模块全局变量和常量之前。
导入顺序如下:
imports应该按照下面的顺序分组来写:
1、标准库imports
2、相关第三方imports
3、本地应用/库的特定imports
不同组的imports之前用空格隔开。
将任何相关的 __all__ 说明(specification)放在imports之后。
推荐使用绝对(absolute)imports,因为这样通常更易读,在import系统没有正确配置的情况下,也会有更好的表现(或者至少会给出错误信息):
在绝对路径比较长的情况下,也可以使用相对导入:
Python 3中已经禁止隐式的相对导入。
导入类的方法,通常可以这样写:
如果和本地命名的拼写产生了冲突,应当使用绝对导入:
禁止使用通配符导入。
通配符导入(from import *)应该避免,因为它不清楚命名空间有哪些名称存,混淆读者和许多自动化的工具。唯一的例外是重新发布对外的API时可以考虑使用。
7、模块中前后具有双下划线的变量名
像__all__ , __author__ , __version__ 等这样的模块中的变量名(也就是名字里有两个前缀下划线和两个后缀下划线),应该放在文档字符串的后面,以及除from __future__ 之外的import表达式前面。Python要求将来在模块中的导入,必须出现在除文档字符串之外的其他代码之前。
比如:
二、字符串引号
Python中单引号字符串和双引号字符串都是相同的。注意尽量避免在字符串中的反斜杠以提高可读性。
根据PEP 257, 三个引号都使用双引号。
三、表达式和语句中的空格
在下列情况下,避免使用无关的空格:
1、紧跟在小括号,中括号或者大括号后。
2、紧贴在逗号、分号或者冒号之前。
3、然而,冒号在切片中就像二元运算符,在两边应该有相同数量的空格(把它当做优先级最低的操作符)。在扩展的切片操作中,所有的冒号必须有相同的间距。例外情况:当一个切片参数被省略时,空格就被省略了。
4、紧贴在函数参数的左括号之前。
5、紧贴索引或者切片的左括号之前。
6、为了和另一个赋值语句对齐,在赋值运算符附件加多个空格。
其他建议
1、避免在尾部添加空格。因为尾部的空格通常都看不见,会产生混乱:比如,一个反斜杠后面跟一个空格的换行符,不算续行标记。有些编辑器不会保留尾空格,并且很多项目(像CPython)在pre-commit的挂钩调用中会过滤掉尾空格。
总是在二元运算符两边加一个空格:赋值(=),增量赋值(+=,-=),比较(==,,!=,,=,in,not,in,is,is not),布尔(and, or, not)。
如果使用具有不同优先级的运算符,请考虑在具有最低优先级的运算符周围添加空格。有时需要通过自己来判断;但是,不要使用一个以上的空格,并且在二元运算符的两边使用相同数量的空格。
2、在指定函数 关键字参数 或者 默认参数 值的时候,不要在=附近加上空格。
3、功能型注释应该使用冒号的一般性规则,并且在使用 ->的时候要在两边加空格。(参考下面的功能注释得到能够多信息)
4、当给有类型备注的参数赋值的时候,在=两边添加空格(仅针对那种有类型备注和默认值的参数)。
5、复合语句(同一行中的多个语句)通常是不允许的。
6、虽然有时候将小的代码块和 if/for/while 放在同一行没什么问题,多行语句块的情况不要这样用,同样也要避免代码行太长!
四、注释
与代码自相矛盾的注释比没注释更差。修改代码时要优先更新注释!
注释是完整的句子。如果注释是断句,首字母应该大写,除非它是小写字母开头的标识符(永远不要修改标识符的大小写)。
如果注释很短,可以省略末尾的句号。注释块通常由一个或多个段落组成。段落由完整的句子构成且每个句子应该以点号(后面要有两个空格)结束,并注意断词和空格。
非英语国家的程序员请用英语书写你的注释,除非你120%确信代码永远不会被不懂你的语言的人阅读。
1、注释块
注释块通常应用在代码前,并和这些代码有同样的缩进。每行以 '# '(除非它是注释内的缩进文本,注意#后面有空格)。
注释块内的段落用仅包含单个 '#' 的行分割。
2、行内注释
慎用行内注释(Inline Comments) 节俭使用行内注释。 行内注释是和语句在同一行,至少用两个空格和语句分开。行内注释不是必需的,重复罗嗦会使人分心。
不推荐:
但是有时,很有必要:
加了以后对理解代码很有帮助的情况下,关键处才加。
3、文档字符串
文档字符串的标准参见:PEP 257。
为所有公共模块、函数、类和方法书写文档字符串。非公开方法不一定有文档字符串,建议有注释(出现在 def 行之后)来描述这个方法做什么。
更多参考:PEP 257 文档字符串约定。注意结尾的 """ 应该单独成行,例如:
单行的文档字符串,结尾的 """ 在同一行。
4、版本标签
如果你必须在源文件中包含git、Subversion、CVS或RCS crud信息,放置在模块的文档字符串之后,任何其他代码之前,上下各用一个空行:
五、命名规范
Python库的命名约定有点混乱,不可能完全一致。但依然有些普遍推荐的命名规范的。新的模块和包 (包括第三方的框架) 应该遵循这些标准。对不同风格的已有的库,建议保持内部的一致性。
1、最重要的原则
用户可见的API命名应遵循使用约定而不是实现。
2、命名风格
以下是常见的命名方式:
b(单个小写字母)
B(单个大写字母)
lowercase (小写字母)
lower_case_with_underscores (使用下划线分隔的小写字母)
UPPERCASE( 大写字母)
UPPER_CASE_WITH_UNDERSCORES (使用下划线分隔的大写字母)
CapitalizedWords(首字母大写的单词串或驼峰缩写)
注意: 使用大写缩写时,缩写使用大写字母更好。故 HTTPServerError 比 HttpServerError 更好。
mixedCase(不同于首字母大写,第一个单词的首字母小写)
Capitalized_Words_With_Underscores(带下划线,首字母大写,巨丑无比)
还有一种风格使用短前缀分组名字。这在Python中不常用, 但出于完整性提一下。例如,os.stat()返回的元组有st_mode, st_size, st_mtime等等这样的名字(与POSIX系统调用结构体一致)。
X11库的所有公开函数以X开头, Python中通常认为是不必要的,因为属性和方法名有对象作前缀,而函数名有模块名为前缀。
下面讲述首尾有下划线的情况:
_single_leading_underscore:(单前置下划线): 弱内部使用标志。 例如"from M import " 不会导入以下划线开头的对象。
single_trailing_underscore_(单后置下划线): 用于避免与 Python关键词的冲突。 例如:
__double_leading_underscore(双前置下划线): 当用于命名类属性,会触发名字重整。 (在类FooBar中,__boo变成 _FooBar__boo)。
__double_leading_and_trailing_underscore__(双前后下划线):用户名字空间的魔法对象或属性。例如:__init__ , __import__ or __file__,不要自己发明这样的名字。
3、命名约定规范
避免采用的名字:
决不要用字符'l'(小写字母el),'O'(大写字母oh),或 'I'(大写字母eye) 作为单个字符的变量名。一些字体中,这些字符不能与数字1和0区别。用'L' 代替'l'时。
包和模块名:
模块名要简短,全部用小写字母,可使用下划线以提高可读性。包名和模块名类似,但不推荐使用下划线。
模块名对应到文件名,有些文件系统不区分大小写且截短长名字,在 Unix上不是问题,但当把代码迁移到 Mac、Windows 或 DOS 上时,就可能是个问题。当然随着系统的演进,这个问题已经不是经常出现。
另外有些模块底层用C或C++ 书写,并有对应的高层Python模块,C/C++模块名有一个前置下划线 (如:_socket)。
类名:
遵循CapWord。
接口需要文档化并且可以调用时,可能使用函数的命名规则。
注意大部分内置的名字是单个单词(或两个),CapWord只适用于异常名称和内置的常量。
异常名:
如果确实是错误,需要在类名添加后缀 "Error"。
全局变量名:
变量尽量只用于模块内部,约定类似函数。
对设计为通过 "from M import " 来使用的模块,应采用 __all__ 机制来防止导入全局变量;或者为全局变量加一个前置下划线。
函数名:
函数名应该为小写,必要时可用下划线分隔单词以增加可读性。 mixedCase(混合大小写)仅被允许用于兼容性考虑(如: threading.py)。
函数和方法的参数:
实例方法第一个参数是 'self'。
类方法第一个参数是 'cls'。
如果函数的参数名与保留关键字冲突,通常在参数名后加一个下划线。
方法名和实例变量:
同函数命名规则。
非公开方法和实例变量增加一个前置下划线。
为避免与子类命名冲突,采用两个前置下划线来触发重整。类Foo属性名为__a, 不能以 Foo.__a访问。(执著的用户还是可以通过Foo._Foo__a。) 通常双前置下划线仅被用来避免与基类的属性发生命名冲突。
常量:
<...