Python编码规范

合集下载

python编码规范

python编码规范

python编码规范Python是一种广泛使用的高级编程语言,编写出符合规范和易于阅读的代码对于代码的可维护性和可读性至关重要。

本文将介绍一些Python编码规范的准则,以帮助开发者编写出更规范的Python代码。

一、命名规范1. 变量和函数名应该以小写字母开始,如果变量名包含多个单词,可使用下划线(_)进行分隔,例如:my_variable。

2. 类名应该以大写字母开始,如果类名包含多个单词,单词间使用驼峰命名法,例如:MyClass。

3. 常量名应该全部使用大写字母,并用下划线进行分隔,例如:MAX_SIZE。

4. 私有属性或方法应以一个下划线(_)开头,例如:_private_variable。

二、缩进与空格1. 使用四个空格进行缩进,而不是制表符。

这样可以保持代码在不同编辑器和平台上的一致性。

2. 操作符之间应添加适当的空格,例如:a = b + c,而不是a=b+c。

3. 函数或类的定义与其后的代码块之间应该有两个空行,并且分别用一个空行将代码块内的逻辑分开。

三、注释规范1. 使用行注释(#)解释代码的意图或功能。

注释应该清晰明了,尽量避免使用废话或无关的描述。

2. 为函数和类编写文档字符串,其中包含其功能、输入参数、返回值等相关信息。

文档字符串应该简洁明了,并遵循一定的格式规范,如使用标准的reStructuredText或Google风格的文档字符串格式。

四、代码规范1. 每行代码的长度应不超过79个字符。

如果一行代码过长,可以使用括号或反斜杠进行换行。

对于括号换行,可以将括号内的内容换行并适当缩进,使代码更易读。

2. 避免一行代码包含多个语句,即每行代码只包含一个语句。

3. 在运算符的周围添加适当的空格,使代码更易读。

例如:a = b + c,而不是a=b+c。

4. 使用适当的空行将代码分组,提高可读性。

例如:可以在函数定义后使用一个空行进行分隔,将不同功能的代码块区分开来。

5. 避免使用魔法数字,应使用常量或变量来表示。

python-PEP8编码规范-中文简版

python-PEP8编码规范-中文简版

python-PEP8编码规范-中⽂简版
代码布局
缩进:每⼀⾏的缩进使⽤4个空格。

续⾏应该与其包裹的元素对齐,要么使⽤圆括号,⽅括号和花括号内的隐式⾏连接来垂直对齐,要么使⽤挂⾏缩进对齐。

当使⽤挂⾏缩进时,应该考虑到第⼀⾏不应该有参数,以及使⽤缩进以区分⾃⼰是续⾏。

推荐:
制表符还是空格?
空格是⾸选的缩进⽅式。

制表符追能⽤于同样使⽤制表符缩进的代码保持⼀致。

Python3不允许同时使⽤空格和制表符的缩进
混合使⽤制表符和空格的Python2代码应该统⼀转成空格。

当在命令中加⼊-t选项执⾏Python2时,它会发出关于⾮法混⽤制表符与空格的警告。

当使⽤-tt时,这些警告会变成错误,强烈建议使⽤这样的参数。

⾏的最⼤长度
所有⾏限制的最⼤字符数为79.
没有结构化限制的⼤块⽂本(⽂档字符或者注释),每⾏的最⼤字符数限制在72.
限制编辑器窗⼝宽度可以使多个⽂件并⾏打开,并且使⽤代码检查⼯具时⼯作的很好。

Python编程代码安全

Python编程代码安全

Python编程代码安全随着互联网的高速发展,代码编程已经成为了现代社会中蓬勃发展的一项技能。

而Python作为一种简单易学的高级编程语言,也在广泛应用于各个领域。

然而,随之而来的问题是如何保障Python编程代码的安全性。

本文将就这个问题进行探讨,并提出一些解决思路和方法。

一、编码规范在编写Python代码时,遵循良好的编码规范是确保代码安全性的第一步。

编码规范旨在提高代码的可读性和可维护性,并减少潜在的安全风险。

以下是一些常见的编码规范建议:1. 严格缩进:Python代码的缩进是十分重要的,它直接影响代码的执行结果。

建议使用四个空格来表示每一级缩进,而不是制表符或其他字符。

2. 注释说明:在代码中添加适当的注释可以帮助他人理解代码的意图和功能。

同时,注释也可以提醒自己在编写代码时要注意的问题,以及潜在的安全隐患。

3. 变量命名规范:命名变量时要遵循一定的规范,以保证代码的可读性。

建议使用有意义的变量名,避免使用无意义的缩写或符号。

二、输入验证输入验证是确保代码安全性的关键措施之一。

在使用Python编程时,必须对用户输入的数据进行验证和过滤,以防止恶意代码注入、跨站脚本攻击等安全威胁。

以下是一些输入验证的常用方法:1. 数据类型检查:对用户输入的数据进行类型检查,确保其符合预期的数据类型。

例如,如果用户需要输入一个整数,那么对输入进行类型检查,如果不是整数则给出错误提示。

2. 长度限制:对用户输入的数据进行长度限制,以防止缓冲区溢出等问题。

例如,在接收用户输入的密码时,可以设置其最大长度,以避免过长的密码导致的安全问题。

3. 限制特殊字符:对用户输入的数据进行特殊字符的限制,以防止SQL注入、命令注入等攻击。

可以使用正则表达式或特定函数对用户输入进行过滤,只接受合法的字符。

三、权限控制在Python编程中,合理的权限控制是保证代码安全性的重要措施之一。

以下是一些常用的权限控制方法:1. 用户认证:通过用户认证机制,限制只有授权用户才能访问和执行代码。

Python 编码规范(Google Python Style Guide)

Python 编码规范(Google Python Style Guide)

分号行长度括号foo_bar(self, width, height, color='black', design=None, x='foo',emphasis=None, highlight=0)if (width == 0 and height == 0 andcolor == 'red' and emphasis == 'strong'):x = ('这是一个非常长非常长非常长非常长 ''非常长非常长非常长非常长非常长非常长的字符串')# See details at# /us/developer/documentation/api/content/v2.0/csv_file_name_exte nsion_full_specification.html# See details at# /us/developer/documentation/api/content/\# v2.0/csv_file_name_extension_full_specification.html宁缺毋滥的使用括号除非是用于实现行连接, 否则不要在返回语句或条件语句中使用括号. 不过在元组两边使用括号是可以的.Yes:No:缩进用4个空格来缩进代码绝对不要用tab, 也不要tab 和空格混用. 对于行连接的情况, 你应该要么垂直对齐换行的元素(见 :ref:`行长度 <line_len gth>` 部分的示例), 或者使用4空格的悬挂式缩进(这时第一行不应该有参数):if foo: bar()while x: x = bar()if x and y: bar()if not x: bar()return foo for (x, y) in dict.items(): ...if (x): bar()if not(x): bar()return (foo)Yes: # 与起始变量对齐 foo = long_function_name(var_one, var_two, var_three, var_four)# 字典中与起始值对齐 foo = { long_dictionary_key: value1 + value2, ... }# 4 个空格缩进,第一行不需要 foo = long_function_name( var_one, var_two, var_three, var_four)# 字典中 4 个空格缩进 foo = { long_dictionary_key: long_dictionary_value, ... }No: # 第一行有空格是禁止的 foo = long_function_name(var_one, var_two, var_three, var_four)# 2 个空格是禁止的 foo = long_function_name( var_one, var_two, var_three, var_four)# 字典中没有处理缩进 foo = { long_dictionary_key: long_dictionary_value, ... }空行顶级定义之间空两行, 方法定义之间空一行顶级定义之间空两行, 比如函数或者类定义. 方法定义, 类定义与第一个方法之间, 都应该空一行. 函数或方法中, 某些地方要是你觉得合适, 就空一行.空格按照标准的排版规范来使用标点两边的空格括号内不要有空格.按照标准的排版规范来使用标点两边的空格Yes: spam(ham[1], {eggs: 2}, [])No: spam( ham[ 1 ], { eggs: 2 }, [ ] )不要在逗号, 分号, 冒号前面加空格, 但应该在它们后面加(除了在行尾).参数列表, 索引或切片的左括号前不应加空格.Yes: spam(1)no: spam (1)Yes: dict['key'] = list[index]No: dict ['key'] = list [index]在二元操作符两边都加上一个空格, 比如赋值(=), 比较(==, <, >, !=, <>, <=, >=, in, not in, is, is not), 布尔(and, o r, not). 至于算术操作符两边的空格该如何使用, 需要你自己好好判断. 不过两侧务必要保持一致.Yes: x == 1No: x<1当'='用于指示关键字参数或默认参数值时, 不要在其两侧使用空格.Yes: def complex(real, imag=0.0): return magic(r=real, i=imag)No: def complex(real, imag = 0.0): return magic(r = real, i = imag)不要用空格来垂直对齐多行间的标记, 因为这会成为维护的负担(适用于:, #, =等):Yes: if x == 4: print x, y x, y = y, xNo: if x == 4 : print x , y x , y = y , xYes: foo = 1000 # 注释 long_name = 2 # 注释不需要对齐dictionary = { "foo": 1, "long_name": 2, }No: foo = 1000 # 注释 long_name = 2 # 注释不需要对齐dictionary = {Shebang大部分.py 文件不必以#!作为文件的开始. 根据 PEP-394 , 程序的main 文件应该以 #!/usr/bin/python2或者 #!/usr/bin/python3开始.(译者注: 在计算机科学中, Shebang (也称为Hashbang)是一个由井号和叹号构成的字符串行(#!), 其出现在文本文件的第一行的前两个字符. 在文件中存在Shebang 的情况下, 类Unix 操作系统的程序载入器会分析Shebang 后的内容, 将这些内容作为解释器指令, 并调用该指令, 并将载有Shebang 的文件路径作为该解释器的参数. 例如, 以指令#!/bin/sh 开头的文件在执行时会实际调用/bin/sh 程序.)#!先用于帮助内核找到Python 解释器, 但是在导入模块时, 将会被忽略. 因此只有被直接执行的文件中才有必要加入#!.注释确保对模块, 函数, 方法和行内注释使用正确的风格文档字符串Python 有一种独一无二的的注释方式: 使用文档字符串. 文档字符串是包, 模块, 类或函数里的第一个语句. 这些字符串可以通过对象的__doc__成员被自动提取, 并且被pydoc 所用. (你可以在你的模块上运行pydoc 试一把, 看看它长什么样). 我们对文档字符串的惯例是使用三重双引号"""( PEP-257 ). 一个文档字符串应该这样组织: 首先是一行以句号, 问号或惊叹号结尾的概述(或者该文档字符串单纯只有一行). 接着是一个空行. 接着是文档字符串剩下的部分, 它应该与文档字符串的第一行的第一个引号对齐. 下面有更多文档字符串的格式化规范.模块每个文件应该包含一个许可样板. 根据项目使用的许可(例如, Apache 2.0, BSD, LGPL, GPL), 选择合适的样板.函数和方法下文所指的函数,包括函数, 方法, 以及生成器.一个函数必须要有文档字符串, 除非它满足以下条件:1、外部不可见2、非常短小3、简单明了文档字符串应该包含函数做什么, 以及输入和输出的详细描述. 通常, 不应该描述"怎么做", 除非是一些复杂的算法. 文档字符串应该提供足够的信息, 当别人编写代码调用该函数时, 他不需要看一行代码, 只要看文档字符串就可以了. 对于复杂的代码, 在代码旁边加注释会比使用文档字符串更有意义.关于函数的几个方面应该在特定的小节中进行描述记录, 这几个方面如下文所述. 每节应该以一个标题行开始. 标题行以冒号结尾. 除标题行外, 节的其他内容应被缩进2个空格.Args:列出每个参数的名字, 并在名字后使用一个冒号和一个空格, 分隔对该参数的描述.如果描述太长超过了单行80字符,使用2或者4个空格的悬挂缩进(与文件其他部分保持一致). 描述应该包括所需的类型和含义. 如果一个函数接受*foo(可变长度参数列表)或者**bar (任意关键字参数), 应该详细列出*foo 和**bar.Returns: (或者 Yields: 用于生成器)描述返回值的类型和语义. 如果函数返回None, 这一部分可以省略."foo" : 1, "long_name": 2, }Raises:列出与接口有关的所有异常.类类应该在其定义下有一个用于描述该类的文档字符串. 如果你的类有公共属性(Attributes), 那么文档中应该有一个属性(Attributes)段. 并且应该遵守和函数参数相同的格式.块注释和行注释最需要写注释的是代码中那些技巧性的部分. 如果你在下次 代码审查 的时候必须解释一下, 那么你应该现在就给它写注释. 对于复杂的操作, 应该在其操作开始前写上若干行注释. 对于不是一目了然的代码, 应在其行尾添加注释.def fetch_bigtable_rows(big_table, keys, other_silly_variable=None): """Fetches rows from a Bigtable.Retrieves rows pertaining to the given keys from the Table instance represented by big_table. Silly things may happen if other_silly_variable is not None.Args: big_table: An open Bigtable Table instance. keys: A sequence of strings representing the key of each table row to fetch. other_silly_variable: Another optional variable, that has a much longer name than the other args, and which does nothing.Returns: A dict mapping keys to the corresponding table row data fetched. Each row is represented as a tuple of strings. For example:{'Serak': ('Rigel VII', 'Preparer'), 'Zim': ('Irk', 'Invader'), 'Lrrr': ('Omicron Persei 8', 'Emperor')}If a key from the keys argument is missing from the dictionary, then that row was not found in the table.Raises: IOError: An error occurred accessing the bigtable.Table object. """ passclass SampleClass(object): """Summary of class here.Longer class information.... Longer class information....Attributes: likes_spam: A boolean indicating if we like SPAM or not. eggs: An integer count of the eggs we have laid. """def __init__(self, likes_spam=False): """Inits SampleClass with blah.""" self.likes_spam = likes_spam self.eggs = 0def public_method(self): """Performs operation blah."""# We use a weighted dictionary search to find out where i is in # the array. We extrapolate position based on the largest num # in the array and the array size and then do binary search to # get the exact number.if i & (i-1) == 0: # true iff i is a power of 2为了提高可读性, 注释应该至少离开代码2个空格.另一方面, 绝不要描述代码. 假设阅读代码的人比你更懂Python, 他只是不知道你的代码要做什么.# BAD COMMENT: Now go through the b array and make sure whenever i occurs # the next element is i+1类如果一个类不继承自其它类, 就显式的从object 继承. 嵌套类也一样.继承自 object 是为了使属性(properties)正常工作, 并且这样可以保护你的代码, 使其不受Python 3000的一个特殊的潜在不兼容性影响. 这样做也定义了一些特殊的方法, 这些方法实现了对象的默认语义, 包括 __new__, __init__, __de lattr__, __getattribute__, __setattr__, __hash__, __repr__, and __str__ .字符串避免在循环中用+和+=操作符来累加字符串. 由于字符串是不可变的, 这样做会创建不必要的临时对象, 并且导致二次方而不是线性的运行时间. 作为替代方案, 你可以将每个子串加入列表, 然后在循环结束后用 .join 连接列表. (也可以将每个子串写入一个 cStringIO.StringIO 缓存中.)在同一个文件中, 保持使用字符串引号的一致性. 使用单引号'或者双引号"之一用以引用字符串, 并在同一文件中沿用. 在字符串内可以使用另外一种引号, 以避免在字符串中使用. PyLint 已经加入了这一检查.Yes: class SampleClass(object): pass class OuterClass(object): class InnerClass(object): passclass ChildClass(ParentClass): """Explicitly inherits from another class already."""No: class SampleClass: passclass OuterClass: class InnerClass: passYes: x = a + b x = '%s, %s!' % (imperative, expletive) x = '{}, {}!'.format(imperative, expletive) x = 'name: %s; score: %d' % (name, n) x = 'name: {}; score: {}'.format(name, n)No: x = '%s%s' % (a, b) # use + in this case x = '{}{}'.format(a, b) # use + in this case x = imperative + ', ' + expletive + '!' x = 'name: ' + name + '; score: ' + str(n)Yes: items = ['<table>'] for last_name, first_name in employee_list: items.append('<tr><td>%s, %s</td></tr>' % (last_name, first_name)) items.append('</table>') employee_table = ''.join(items)No: employee_table = '<table>' for last_name, first_name in employee_list: employee_table += '<tr><td>%s, %s</td></tr>' % (last_name, first_name) employee_table += '</table>'Yes: Python('Why are you hiding your eyes?') Gollum("I'm scared of lint errors.") Narrator('"Good!" thought a happy Python reviewer.')多行字符串使用三重双引号"""而非三重单引号'''. 当且仅当项目中使用单引号'来引用字符串时, 才可能会使用三重'''文件和socketsLegacy AppEngine 中Python 2.5的代码如使用"with"语句, 需要添加 "from __future__ import with_statement".TODO 注释No: Python("Why are you hiding your eyes?") Gollum('The lint. It burns. It burns us.') Gollum("Always the great lint. Watching. Watching.")Yes: print ("This is much nicer.\n" "Do it this way.\n")No: print """This is pretty ugly. Don't do this. """with open("hello.txt") as hello_file: for line in hello_file: print lineimport contextlibwith contextlib.closing(urllib.urlopen("/")) as front_page: for line in front_page: print line导入格式总应该放在文件顶部, 位于模块注释和文档字符串之后, 模块全局变量和常量之前. 导入应该按照从最通用到最不语句访问控制Yes: import os import sysNo: import os, sysimport foo from foo import bar from foo.bar import baz from foo.bar import Quux from Foob import arYes:if foo: bar(foo)No:if foo: bar(foo) else: baz(foo)try: bar(foo) except ValueError: baz(foo)try: bar(foo) except ValueError: baz(foo)命名Main即使是一个打算被用作脚本的文件, 也应该是可导入的. 并且简单的导入不应该导致这个脚本的主功能(main functiona lity)被执行, 这是一种副作用. 主功能应该放在一个main()函数中.在Python 中, pydoc 以及单元测试要求模块必须是可导入的. 你的代码应该在执行主程序前总是检查 if __name__ == '__main__' , 这样当模块被导入时主程序就不会被执行.所有的顶级代码在模块导入时都会被执行. 要小心不要去调用函数, 创建对象, 或者执行那些不应该在使用pydoc 时执行的操作. def main(): ...if __name__ == '__main__': main()。

Python编程规范

Python编程规范

Python编程规范1,Python编程规范> 编码所有的 Python 脚本⽂件都应在⽂件头标上# -*- coding:utf-8 -*-⽤于设置编辑器,默认保存为 utf-8 格式。

> 注释业界普遍认同 Python 的注释分为两种,⼀种是由 # 开头的“真正的”注释,例如,⽤于表明为何选择当前实现以及这种实现的原理和难点另⼀种是 docstrings,例如,⽤于表明如何使⽤这个包、模块、类、函数(⽅法),甚⾄包括使⽤⽰例和单元测试坚持适当注释原则。

对不存在技术难点的代码坚持不注释,对存在技术难点的代码必须注释。

但与注释不同,建议对每⼀个包、模块、类、函数(⽅法)写docstrings,除⾮代码⼀⽬了然,⾮常简单。

> 缩进Python 依赖缩进来确定代码块的层次,⾏⾸空⽩符主要有两种:tab 和空格,但严禁两者混⽤。

如果使⽤ tab 缩进,设定tab 为4个空格。

> 空格空格在 Python 代码中是有意义的,因为 Python 的语法依赖于缩进,在⾏⾸的空格称为前导空格。

在这⼀节不讨论前导空格相关的内容,只讨论⾮前导空格。

⾮前导空格在 Python 代码中没有意义,但适当地加⼊⾮前导空格可以增进代码的可读性。

1)在⼆元算术、逻辑运算符前后加空格:如a =b + c;2)在⼀元前缀运算符后不加空格,如if !flg: pass;3) “:”⽤在⾏尾时前后皆不加空格,如分枝、循环、函数和类定义语⾔;⽤在⾮⾏尾时两端加空格,如:dict 对象的定义d = {'key' : 'value'}4)括号(含圆括号、⽅括号和花括号)前后不加空格,如:do_something(arg1, arg2)⽽不是do_something( arg1, arg2 )5)不要在逗号、分号、冒号前⾯加空格,但应该在它们后⾯加(除了在⾏尾)6)不要⽤空格来垂直对齐多⾏间的标记,因为这会成为维护的负担(适⽤于:,#,=等)> 空⾏适当的空⾏有利于增加代码的可读性,加空⾏可以参考如下⼏个准则:1)在类、函数的定义间加空⾏;2)在 import 不同种类的模块间加空⾏;3)在函数中的逻辑段落间加空⾏,即把相关的代码紧凑写在⼀起,作为⼀个逻辑段落,段落间以空⾏分隔;> 断⾏尽管现在的宽屏显⽰器已经可以单屏显⽰超过 256 列字符,但本规范仍然坚持⾏的最⼤长度不得超过 80 个字符的标准。

Python代码规范(命名、注释等)

Python代码规范(命名、注释等)

Python代码规范(命名、注释等)本来不应该把这个章节放在前⾯的,因为还没进⾏学习之前,直接看这个章节,会感觉有很多莫名其妙的东西。

但是把这个章节放在前⾯的⽤意,只是让⼤家预览⼀下,有个印象,⽽且在以后的学习中,也⽅便⼤家查阅。

⽬录⼀、简明概述1、编码如⽆特殊情况, ⽂件⼀律使⽤ UTF-8 编码如⽆特殊情况, ⽂件头部必须加⼊#-*-coding:utf-8-*-标识2、代码格式2.1、缩进统⼀使⽤ 4 个空格进⾏缩进2.2、⾏宽每⾏代码尽量不超过 80 个字符(在特殊情况下可以略微超过 80 ,但最长不得超过 120)理由:这在查看 side-by-side 的 diff 时很有帮助⽅便在控制台下查看代码太长可能是设计有缺陷2.3、引号单引号简单说,⾃然语⾔使⽤双引号,机器标⽰使⽤单引号,因此代码⾥多数应该使⽤代码⾥多数应该使⽤单引号使⽤双引号'...'⾃然语⾔⾃然语⾔使⽤双引号例如错误信息;很多情况还是 unicode,使⽤u'你好世界'使⽤单引号'...'例如 dict ⾥的 key机器标识使⽤单引号机器标识使⽤原⽣的双引号r'...'正则表达式使⽤原⽣的双引号正则表达式⽂档字符串 (docstring)使⽤三个双引号'''......'''2.4、空⾏模块级函数和类定义之间空两⾏;类成员函数之间空⼀⾏;可以使⽤多个空⾏分隔多组相关的函数函数中可以使⽤空⾏分隔出逻辑相关的代码3、import 语句import 语句应该分⾏书写# 正确的写法import osimport sys# 不推荐的写法import sys,os# 正确的写法from subprocess import Popen, PIPEimport语句应该使⽤absoluteimport# 正确的写法from foo.bar import Bar# 不推荐的写法from ..bar import Barimport语句应该放在⽂件头部,置于模块说明及docstring之后,于全局变量之前;import语句应该按照顺序排列,每组之间⽤⼀个空⾏分隔导⼊其他模块的类定义时,可以使⽤相对导⼊from myclass import MyClass如果发⽣命名冲突,则可使⽤命名空间4、空格在⼆元运算符两边各空⼀格[=,-,+=,==,>,in,is not, and]:函数的参数列表中,,之后要有空格函数的参数列表中,默认值等号两边不要添加空格左括号之后,右括号之前不要加多余的空格5、换⾏Python ⽀持括号内的换⾏。

pep8 python 编码规范

pep8 python 编码规范

pep8 python 编码规范
Python 编码规范是一种统一的编码规范,其旨在编写结构清晰、可操作的 Python 代码。

Python 编码规范,又被称为”PEP 8”,是Python 开发者在编码时应遵循的规范。

它产生的目的是要使编写的代
码能够在平台之间迁移时,尽可能的少出现兼容性的问题。

PEP 8包括缩进和格式的规则,能够让代码具有一致的看法和更
易阅读的外观。

它按照78比分的标准,把长行代码分割为两个或以上行,以合理形式缩进。

它还提供了建议性的文件命名规则,帮助程序
员们更容易记忆文件内容。

另外,它还明确了空行的使用及对注释的
规范,帮助程序员编写出具有较高可读性的代码。

Python编码规范还规定程序员应该使用4个空格表示一次缩进,规定使用空格和制表符结合进行代码格式化以及控制条件之间的空格,禁止在字符串和注释开始和结束处使用空格等。

PEP 8 规定的编码规范一定程度上可以提高程序员的编码水平,
使html代码块更整洁、模块之间的代码更清晰,发挥程序员工作效率
的同时,也能减少非必要的错误。

python的编码格式

python的编码格式

python的编码格式
Python的默认编码格式是UTF-8(Unicode Transformation Format-8),这是一种可变长度字符编码,能够表示世界上几乎所有的字符。

UTF-8编码可以在不同的操作系统和平台上进行交互,并且支持多种语言的文本处理。

在Python中,可以使用sys.getdefaultencoding()函数来查看当前的默认编码格式。

此外,还可以使用sys.setdefaultencoding(encoding)函数来设置默认编码格式,但需要注意的是,在Python 3中,sys.setdefaultencoding()函数被移除了,因为Python 3默认使用UTF-8编码。

另外,Python还提供了许多编码相关的模块和函数,例如encode()和decode()方法用于字符串的编码和解码操作,codecs模块用于处理不同编码格式的文件,以及locale模块用于处理与本地化相关的编码问题等。

这些工具可以帮助开发者在不同的编码环境中进行文本处理和转换。

1。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Python编码规范这篇文档改编自Guido最初的《Python风格指南》一文,并从《Barry's style guide》中添加了部分内容。

在有冲突的地方,Guide的风格规则应该是符合本PEP的意图(译注:指当有冲突时,应以Guido风格为准)。

这篇PEP仍然尚未完成(实际上,它可能永远都不会完成)。

在这篇风格指导中的一致性是重要的。

在一个项目内的一致性更重要。

在一个模块或函数内的一致性最重要。

但最重要的是:知道何时会不一致——有时只是没有实施风格指导。

当出现疑惑时,运用你的最佳判断,看看别的例子,然后决定怎样看起来更好。

并且要不耻下问!代码的布局缩进使用Emacs的Python-mode的默认值:4个空格一个缩进层次。

对于确实古老的代码,你不希望产生混乱,可以继续使用8空格的制表符(8-space tabs)。

Emacs Python-mode自动发现文件中主要的缩进层次,依此设定缩进参数。

制表符还是空格永远不要混用制表符和空格。

最流行的Python缩进方式是仅使用空格,其次是仅使用制表符,混合着制表符和空格缩进的代码将被转换成仅使用空格。

(在Emacs中,选中整个缓冲区,按ESC-x去除制表符。

)调用Python命令行解释器时使用-t选项,可对代码中不合法得混合制表符和空格发出警告,使用-tt时警告将变成错误。

这些选项是被高度推荐的。

对于新的项目,强烈推荐仅使用空格而不是制表符。

许多编辑器拥有使之易于实现的功能(在Emacs中,确认indent-tabs-mode是nil)。

行的最大长度周围仍然有许多设备被限制在每行80字符:而且,窗口限制在80个字符。

使将多个窗口并排放置成为可能。

在这些设备上使用默认的折叠方式看起来有点丑陋。

因此,请将所有行限制在最大79字符(Emacs准确得将行限制为长80字符),对顺序排放的大块文本(文档字符串或注释),推荐将长度限制在72字符。

折叠长行的首选方法是使用Pyhon支持的圆括号,方括号和花括号内的行延续。

如果需要,你可以在表达式周围增加一对额外的圆括号,但是有时使用反斜杠看起来更好,确认恰当得缩进了延续的行。

Emacs的Python-mode正确得完成了这些。

一些例子:#!Pythonclass Rectangle(Blob):def __init__(self,width,height,color='black',emphasis=None,highlight=0):if width == 0 and height == 0 and \color == 'red' and emphasis == 'strong' or \highlight > 100:raise ValueError, "sorry, you lose"if width == 0 and height == 0 and (color == 'red' oremphasis is None):raise ValueError,"I don't think so"Blob.__init__(self,width,height,color,emphasis,highlight)空行用两行空行分割顶层函数和类的定义,类内方法的定义用单个空行分割,额外的空行可被用于(保守的)分割相关函数组成的群,在一组相关的单句中间可以省略空行。

(例如:一组哑元素)。

当空行用于分割方法的定义时,在‘class’行和第一个方法定义之间也要有一个空行。

在函数中使用空行时,请谨慎的用于表示一个逻辑段落。

Python接受contol-L(即^L)换页符作为空格:Emacs(和一些打印工具),视这个字符为页面分割符,因此在你的文件中,可以用他们来为相关片段分页。

编码Python核心发布中的代码必须始终使用ASCII或Latin-1编码(又名ISO-8859-1),使用ASCII的文件不必有编码cookie,Latin-1仅当注释或文档字符串涉及作者名字需要Latin-1时才被使用:另外使用\x转义字符是在字符串中包含非ASCII(non-ASCII)数据的首选方法。

作为PEP 263实现代码的测试套件的部分文件是个例外。

导入通常应该在单独的行中导入(Imports),例如:No:import sys, osYes:import sysimport os但是这样也是可以的:from types import StringType, ListTypeImports 通常被放置在文件的顶部,仅在模块注释和文档字符串之后,在模块的全局变量和常量之前。

Imports应该有顺序地成组安放:1、标准库的导入(Imports )2、相关的主包(major package)的导入(即,所有的email包在随后导入)3、特定应用的导入(imports)你应该在每组导入之间放置一个空行,对于内部包的导入是不推荐使用相对导入的,对所有导入都要使用包的绝对路径。

从一个包含类的模块中导入类时,通常可以写成这样:from MyClass import MyClassfrom foo.bar.YourClass import YourClass如果这样写导致了本地名字冲突,那么就这样写import MyClassimport foo.bar.YourClass即使用"MyClass.MyClass"和"foo.bar.YourClass.YourClass"表达式和语句中的空格Guido不喜欢在以下地方出现空格:紧挨着圆括号,方括号和花括号的,如:"spam( ham[ 1 ],{ eggs:2 } )"。

要始终将它写成"spam(ham[1],{eggs: 2})"。

紧贴在逗号,分号或冒号前的,如:"if x == 4:print x,y:x,y = y,x"。

要始终将它写成"if x == 4:print x,y:x,y = y,x"。

紧贴着函数调用的参数列表前开式括号(open parenthesis )的,如"spam (1)"。

要始终将它写成"spam(1)"。

紧贴在索引或切片,开始的开式括号前的,如:"dict ['key'] = list [index]"。

要始终将它写成"dict['key'] = list[index]"。

在赋值(或其它)运算符周围的用于和其它并排的一个以上的空格,如:#!Pythonx= 1y= 2long_variable = 3要始终将它写成#!Pythonx = 1y = 2long_variable = 3(不要对以上任意一条和他争论——Guido 养成这样的风格超过20年了。

)其它建议始终在这些二元运算符两边放置一个空格:赋值(=),比较(==,<,>,!=,<>,<=, >=,in,not in,is,is not),布尔运算(and,or,not)。

按你的看法在算术运算符周围插入空格。

始终保持二元运算符两边空格的一致。

一些例子:#!Pythoni = i+1submitted = submitted + 1x = x*2 - 1hypot2 = x*x + y*yc = (a+b) * (a-b)c = (a + b) * (a - b)不要在用于指定关键字参数或默认参数值的'='号周围使用空格,例如:#!Pythondef complex(real, imag=0。

0):return magic(r=real, i=imag)不要将多条语句写在同一行上:No: if foo == 'blah':do_blah_thing()Yes:if foo == 'blah':do_blah_thing()No:do_one():do_two():do_three()Yes: do_one()do_two()do_three()注释同代码不一致的注释比没注释更差。

当代码修改时,始终优先更新注释!注释应该是完整的句子,如果注释是一个短语或句子,首字母应该大写,除非他是一个以小写字母开头的标识符(永远不要修改标识符的大小写)。

如果注释很短,最好省略末尾的句号。

注释块通常由一个或多个由完整句子构成的段落组成,每个句子应该以句号结尾。

你应该在句末,句号后使用两个空格,以便使Emacs的断行和填充工作协调一致。

用英语书写时,断词和空格是可用的。

非英语国家的Python程序员:请用英语书写你的注释,除非你120%的确信这些代码不会被不懂你的语言的人阅读。

注释块注释块通常应用于跟随着一些(或者全部)代码并和这些代码有着相同的缩进层次。

注释块中每行以‘#’和一个空格开始(除非他是注释内的缩进文本)。

注释块内的段落以仅含单个‘#’的行分割。

注释块上下方最好有一空行包围(或上方两行下方一行,对一个新函数定义段的注释)。

行内注释一个行内注释是和语句在同一行的注释,行内注释应该谨慎适用,行内注释应该至少用两个空格和语句分开,它们应该以'#'和单个空格开始。

x = x+1 # Increment x如果语意是很明了的,那么行内注释是不必要的,事实上是应该被移除的。

不要这样写:x = x+1 # Increment xx = x+1 # Compensate for border但是有时,这样是有益的:x = x+1 # Compensate for border文档字符串应该一直遵守编写好的文档字符串的约定PEP 257 [3]。

为所有公共模块,函数,类和方法编写文档字符串。

文档字符串对非公开的方法不是必要的,但你应该有一个描述这个方法做什么的注释。

这个注释应该在"def"这行后。

PEP 257 描述了好的文档字符串的约定。

一定注意,多行文档字符串结尾的"""应该单独成行,例如:"""Return a foobangOptional plotz says to frobnicate the bizbaz first。

"""对单行的文档字符串,结尾的"""在同一行也可以。

版本注记如果你要将RCS或CVS的杂项(crud)包含在你的源文件中,按如下做。

相关文档
最新文档