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。

Python编码规范

Python编码规范

Python编码规范Python是一种广泛使用的编程语言,它有着很多优点,比如易读易学、功能丰富、可扩展性强等等。

然而,有时候Python的代码规范并不容易被初学者理解,甚至有些有经验的开发者也可能犯一些错误。

因此,使用Python编程时,遵循一定的编码规范是非常重要的。

1.缩进和空格Python使用缩进来表示代码块,一般情况下,使用4个空格来进行缩进。

不要使用制表符进行缩进,因为不同编辑器对制表符的显示方式可能不同,这会导致代码可读性的下降。

在一行代码的结尾不要使用多余的空格,包括在括号、方括号、大括号、逗号之后。

2.行长和换行一行代码的最大长度建议不超过80个字符,如果超过了这个长度,应该使用换行。

Python中使用反斜杠\来进行多行语句的换行,如下面的例子所示:```s = "This is a very long string that \spans multiple lines"```另外,也可以使用括号来进行换行:```s = ("This is a very long string that ""spans multiple lines")```3.命名规范变量名、函数名和类名应该使用小写字母,不同的单词之间使用下划线_进行分割。

例如,变量名可以是`my_variable`,函数名可以是`my_function`,类名可以是`MyClass`。

常量应该使用大写字母,并且单词之间使用下划线_分割,如`MAX_LENGTH`。

避免使用单个字符作为变量名,除非是在循环中使用。

4.注释注释是代码中非常重要的一部分,它可以帮助其他人理解你的代码,也可以帮助你自己回顾代码时理解其中的逻辑。

在Python中,注释应该清晰准确,不应该包含无关的信息。

单行注释使用`#`开头,多行注释可以使用三引号`'''`或双引号`"""`包围。

python中的编码格式

python中的编码格式

python中的编码格式Python是一种强大的编程语言,广泛应用于许多领域。

在Python中,我们可以使用不同的编码格式来处理中文,例如UTF-8,GBK,GB2312等。

本文将介绍Python中的编码格式以及如何正确地处理中文。

一、编码格式介绍1. UTF-8UTF-8是Unicode编码的一种实现方式,是一种变长编码格式,它可以用来表示任何Unicode字符。

UTF-8最大的特点是兼容ASCII码,也就是说,只包含ASCII码的文本在UTF-8中可以保持原样。

在Python中,常用的字符串类型为Unicode字符串,因此使用UTF-8编码格式可以避免字符串转换的问题。

2. GBKGBK是一种汉字编码格式,它是国家标准GB2312的扩展版本。

GBK编码格式支持简体中文和繁体中文,可以表示21003个中文字符。

GBK编码格式是定长编码格式,每个字符占据两个字节的空间。

在GBK编码格式中,英文字符和数字仍然占据一个字节,而汉字则占据两个字节。

二、如何正确处理中文在Python中,为了正确处理中文,我们需要了解几个概念:字符集、编码格式和解码。

字符集是由一系列字符组成的集合,而编码格式则是将字符集表示为二进制数据的方式。

解码是将这些二进制数据转换成可读的字符。

在Python中,我们使用Unicode字符串来表示中文,因为Unicode是一种通用字符集,可以支持世界上所有的字符。

当我们需要在代码中使用中文时,我们需要在代码开头使用特殊注释来指定文件的编码格式,例如:#-*-coding:utf-8-*-这样我们就告诉Python解释器,这个文件中的文本使用UTF-8编码格式。

如果我们需要读取一个文件中的中文,我们可以使用文件读取函数来读取文件内容,然后使用decode()方法将编码格式为UTF-8的文本转换为Unicode字符串,例如:f = open("file.txt","r")text = f.read().decode("utf-8")需要注意的是,在使用GBK或GB2312编码格式的字符串时,我们要使用相应的字符集来解码,例如:text = "这是一段中文".decode("gbk")三、总结在Python中,Unicode字符串是表示中文的标准方式,而UTF-8编码格式是其中最常用的一种。

PEP8-Python编码规范

PEP8-Python编码规范

PEP8-Python编码规范PEP8-Python编码规范PEP 8的官⽅⽂档:使⽤IDE:pycharm(默认检查代码规范)⼀:代码布局1. 缩进:每个缩进级别使⽤4个空格。

def __init__(self, key, **redis_kwargs):self.__db = redis.Redis(**redis_kwargs)self.key = key2 制表符or空格空格是⾸选的缩进⽅法。

Python 3不允许混合使⽤制表符和空格来缩进。

Python 2代码缩进与制表符和空格的混合应转换为使⽤空格专有。

有研究显⽰:使⽤空格缩进的程序员的薪资⽐使⽤制表符缩进的程序员的薪资多8%。

所以⼀定要⽤空格缩进呀。

3 每⾏代码的最⼤长度:将所有⾏限制为最多79个字符。

Python标准库是保守的,需要将⾏限制为79个字符(⽂档字符串/注释为72)。

4 空⽩⾏:⽤两个空⽩⾏分隔顶层函数和类定义。

类中的⽅法定义⽤⼀个空⾏分隔。

可以使⽤额外的空⽩⾏(节省空间)来分隔相关功能组。

在⼀堆相关的单⾏程序(例如⼀组虚拟执⾏程序)之间可能会省略空⽩⾏。

在函数中使⽤空⾏来节省逻辑部分。

恰当的使⽤空⽩⾏可以提⾼代码的可读性。

5 源⽂件编码:核⼼Python发⾏版中的代码应该始终使⽤UTF-8(或Python 2中的ASCII)。

使⽤ASCII(Python 2)或UTF-8(Python 3)的⽂件不应该有编码声明。

但是在Python 2中使⽤UTF-8编码就需要有编码声明:# -*- coding: utf-8 -*-#! /usr/bin/env python2上⾯两⾏代码常放在Python 2代码中的开头,第⼀⾏意思是指定源⽂件以utf-8格式编码,第⼆⾏意思是指定源⽂件的python解释器在环境变量中去寻找。

6 导⼊库函数:若是导⼊多个库函数,应该分开依次导⼊:import requestsimport csv导⼊总是放在⽂件的顶部,在任何模块注释和⽂档字符串之后,在模块全局变量和常量之前。

python3编码规范

python3编码规范

python3编码规范《Python 3 标准库实例教程》python 编码规范编码规范的好处:有助于增强代码的⼀致性和可读性。

代码被阅读的次数远⼤于它被编写的次数,良好的遵循编码规范可以保证代码在⼀个项⽬中,甚⾄多个项⽬之间保持⼀致性和可读性;有助于提⾼代码的可维护性和代码质量。

易于理解的变量名称,清晰的代码布局,风格⼀致的注释等,都有助于降低开发和维护的难度,减少由于不遵循规范⽽产⽣的晦涩难懂的代码,并降低 bug 出现的可能性;有助于提⾼软件团队的开发和协作效率。

团队成员之间可以快速的阅读和理解对⽅所编写的代码,将更多的时间和精⼒投⼊更加核⼼的业务中去;有助于提⾼项⽬和产品的交付质量。

团队的效率和代码的质量,往往影响着项⽬的最终结果,也是产品质量与市场竞争⼒的决定性因素之⼀。

PEP 的英⽂全称是 Python Enhancement Proposals,即 Python 增强提案它主要⽤于提出 Python 新特性、收集社区对于某些问题的讨论、记录 Python 核⼼的设计决策等。

在形式上来说,PEP 是⼀种技术⽂档;在内容上来说,⼀般会包括提供给 Python 社区的信息、新特性的功能及原理描述等内容pep 分类:标准类 PEP(Standards Track PEP):主要⽤于描述 Python 的新特性或实现等。

这类 PEP 的数量在所有 PEP 中占⽐最多,⽐如列表推导 PEP 202 以及引起争议的表达式内赋值 PEP 572 等。

信息类 PEP(Informational PEP):主要⽤于提供⼀般性的指导原则、信息等。

⽐如著名的 Python 之禅 PEP 20 等。

流程类 PEP(Process PEP):主要围绕 Python 相关流程,适⽤于 Python 语⾔本⾝以外的领域编码规范属于此类规范PEP 8 的英⽂全称为 Style Guide for Python Code ,即 Python 编码风格指南(或称规范),这份指南涵盖三个⼤的⽅⾯,代码布局、注释⽂档以及命名规范代码的整体布局,⽐如缩进、⾏最⼤长度、换⾏与空⾏、导⼊语句的位置及组织结构、编码声明、dunder ⽅法位置等;代码中的引号以及空格、⾏尾部逗号;复合语句的基本结构;注释编写的基本规范,主要包括块注释、⾏内注释和⽂档字符串;针对变量、⽅法、函数、类等元素的命名规范。

python 中文编码格式

python 中文编码格式

在Python 中,字符编码是指将字符映射到二进制数据的规则。

在处理中文文本时,常见的字符编码包括 UTF-8、UTF-16、GB2312、GBK 等。

下面是一些常见的Python 中文编码相关的知识点:
1. 字符串和编码:
在 Python 3 中,字符串默认使用 Unicode 编码,这使得处理多语言字符变得更加方便。

你可以使用str.encode()方法将字符串编码为指定的字节序列,或者使用bytes.decode()方法将字节序列解码为字符串。

2. 文件编码:
在处理文件时,通常需要注意文件的编码。

打开文件时可以指定编码,例如:
3. Python 源代码文件编码:
在 Python 源代码文件的开头,可以使用特定的注释来指定源代码文件的编码,以
确保正确解析中文注释和字符串。

4. 处理不同编码之间的转换:
如果你需要在不同编码之间转换,可以使用encode()和decode()方法,同时注意处
理可能的编码错误。

5. 使用chardet库检测文件编码:
如果你不确定文件的编码,可以使用第三方库chardet来检测文件编码。

这是一些基本的关于 Python 中文编码的知识点,确保在处理中文字符时正确选择和使用编码是非常重要的。

python常用编码

python常用编码

python常用编码
Python是一种高级编程语言,它被广泛应用于数据分析、人工智能、Web开发等领域。

在Python编程中,编码是一个重要的问题,因为不同的编码会影响字符串、文件等数据的处理和存储。

以下是Python中常用的编码:
1. ASCII编码
ASCII编码是一种最早的字符编码,它只能表示128个字符,包括字母、数字、标点符号等。

ASCII编码是Python中默认的编码方式。

2. UTF-8编码
UTF-8编码是一种Unicode编码的实现方式,它可以表示所有Unicode字符,包括国际上的各种语言和符号。

UTF-8编码是Python 中最常用的编码方式。

3. GBK编码
GBK编码是一种用于中文的字符编码,它可以表示中文字符、标点符号等。

GBK编码是Python中常用的编码方式。

4. Unicode编码
Unicode编码是一种国际化字符编码,它可以表示所有文字符号,包括各种语言和符号。

Unicode编码在Python中也得到了广泛应用。

在Python编码中,我们可以使用encode()和decode()函数进行编码和解码操作,以处理不同编码的数据。

同时,在处理文件时,需要注意文件的编码格式,以免出现乱码等问题。

总之,Python编码是Python编程中不可避免的一个问题,我们需要了解不同的编码方式,并掌握相应的编码技巧,以保证程序的正确性和可读性。

python代码规范

python代码规范

python代码规范Python代码规范是一种约定俗成的编码规范,它旨在提高代码的可读性、可维护性和可共享性。

下面是Python代码规范的一些重要方面:1. 缩进与空格:- 使用4个空格来缩进代码块,不要使用制表符。

- 在括号、括号内和操作符周围添加适当的空格,以提高可读性。

2. 行长度:- 一行代码不应超过79个字符。

超过该长度时,应进行换行。

- 运算符的前部分应该放在换行之前,并在下一行进行缩进。

3. 命名规则:- 变量和函数名应该使用小写字母,并用下划线将多个单词连接起来(例如:my_variable)。

- 类名应使用驼峰命名法(例如:MyClass)。

4. 注释:- 代码中应该添加适当的注释,以解释代码的目的和功能。

- 注释应该尽量清晰和简明,并遵循约定俗成的注释风格。

5. 导入:- 导入语句应放在文件的顶部,并按照标准库、第三方库和本地库的顺序分组导入。

- 每个导入应该在独立的行上。

6. 空行:- 在类和函数的定义之间应该有两个空行。

- 在函数内部的不同逻辑块之间应该有一个空行。

7. 异常处理:- 使用try-except-else-finally结构来处理异常情况。

- 不要使用裸露的except语句,应该明确捕获特定类型的异常。

8. 字符串:- 使用单引号或双引号来表示字符串,但是在一个项目中保持一致性。

- 对于多行字符串,使用三重引号。

9. 模块级别的变量和函数:- 在模块的顶部定义全局变量和常量。

- 在模块的底部定义主要函数和逻辑。

10. 文件命名:- 文件名应该使用小写字母,并用下划线将多个单词连接起来(例如:my_module.py)。

以上是Python代码规范的一些基本要求,具体的规范可以参考PEP 8(Python Enhancement Proposals的第8号提案),它是Python社区关于代码规范的官方指南。

遵循这些规范将使你的代码更易读、易维护,并且更符合Python社区的共识。

Python编码规范

Python编码规范

Python编码规范Python是一种高级编程语言,其简单、易学、功能强大、灵活等特点使其在软件开发和数据科学领域得到广泛应用。

编写Python代码的质量和效率,不仅取决于编程者的经验和能力,更取决于编程规范的遵循程度。

本文将介绍Python编码规范的相关要点,以期对读者在编写Python代码时提供参考和指导。

一、命名规范在Python编程中,命名是代码可读性和可维护性的核心。

在命名时,我们需要遵循以下规范:1.变量名应该小写,不同的单词之间使用下划线(_)分割。

示例:name = "Tom"password_hash = "xxxxxx"2.类名应该采用驼峰命名法,即每个单词的首字母大写,不使用下划线。

示例:class Person:pass3.函数名应该使用小写字母,不同的单词之间使用下划线(_)分割。

示例:def add_numbers(x, y):return x + y4.常量名应该全部大写,单词之间用下划线(_)分割。

示例:MAX_NUMBER = 100二、缩进和空格Python不像其他编程语言有强制的大括号({})来表示代码块,而是基于缩进来识别代码块。

因此,缩进和空格的使用对Python代码的可读性和可维护性至关重要。

1.缩进应该使用四个空格,而不是制表符。

示例:if age > 18:print("成年人")2.在括号、中括号和花括号周围不应添加空格。

在操作符周围应该有一个空格。

示例:list1 = [1, 2, 3]if x == 10 and y > 20:z = x + y3.行长度应该限制在80个字符以内,如果行长度超过80个字符,在操作符后进行换行。

示例:if age >= 18 and country == "China" \and city == "Beijing":print("你已经成年了")三、注释规范在编写Python代码时,注释是非常重要的。

python 常用编码

python 常用编码

python 常用编码Python 是一种高级编程语言,它支持多种编码方式。

在 Python 中,常用的编码有以下几种:1. UTF-8 编码:UTF-8 是一种可变长度的编码方式,它可以表示世界上几乎所有的字符。

Python 3 默认使用 UTF-8 编码,因此在编写 Python 代码时无需指定编码方式。

2. ASCII 编码:ASCII 编码是最常用的字符编码方式之一,它可以表示 128 个字符。

在 Python 中,ASCII 编码常常用于处理英文字符集。

3. GBK 编码:GBK 是一种用于表示中文字符的编码方式,它包含了大量的中文字符。

在 Python 中,如果需要处理中文字符串,可以使用 GBK 编码。

4. Unicode 编码:Unicode 是一种通用的字符编码方式,它可以表示世界上几乎所有的字符。

在 Python 中,可以使用 Unicode 编码来表示字符串。

5. Base64 编码:Base64 是一种将二进制数据表示为 ASCII 字符的编码方式。

在Python 中,可以使用 Base64 编码来对数据进行加密、传输等操作。

6. URL 编码:URL 编码是一种将字符转换为 URL 安全字符的编码方式。

在Python 中,可以使用 urlencode() 函数来进行 URL 编码,将字符串转换为安全的URL 格式。

7. JSON 编码:JSON 是一种轻量级的数据交换格式,它使用 JavaScript 语法的子集来表示数据。

在 Python 中,可以使用 json 模块来进行 JSON 编码和解码操作。

以上是 Python 中常用的几种编码方式,根据不同的需求选择合适的编码方式可以有效地处理数据和文本。

python decode 常用编码格式

python decode 常用编码格式

python decode 常用编码格式
1.ASCII编码:ASCII编码是最基本的编码格式,它只包含英文字符和数字,不支持中文字符。

Python默认使用ASCII编码,因此在处理ASCII编码的文本时,不需要进行额外的解码操作。

2.UTF-8编码:UTF-8是一种通用的编码格式,它支持多种语言字符,包括中文字符。

在Python中,可以使用utf-8编码方式对UTF-8编码的文本进行解码。

3.GBK编码:GBK是一种用于简体中文字符的编码格式。

在Python中,可以使用gbk编码方式对GBK编码的文本进行解码。

4.GB2312编码:GB2312是一种用于简体中文字符的编码格式,它包含了更多的常用汉字。

在Python中,可以使用gb2312编码方式对GB2312编码的文本进行解码。

5.ISO-8859-1编码:ISO-8859-1是一种西欧语言的字符集,它不支持中文字符。

在Python中,可以使用iso-8859-1编码方式对ISO-8859-1编码的文本进行解码。

python命名规范

python命名规范

python命名规范Python的命名规范(Naming Conventions)是一个重要的编码规范,它有助于提高代码的可读性和可维护性。

以下是一个关于Python命名规范的1000字的总结:1. 变量命名:- 变量的命名应该使用小写字母,可以使用下划线 `_` 分隔单词,如 `my_variable`。

- 变量名应该具有描述性,能够清晰地表达变量的含义。

- 如果变量名由多个单词组成,使用下划线 `_` 来分隔单词。

- 避免使用单个字符或者单词的缩写作为变量名,除非在上下文中已经被广泛接受。

- 变量名不能与Python的关键字重名,如`if`、`for`、`def`等。

2. 常量命名:- 常量的命名应该全部使用大写字母,并且单词之间使用下划线 `_` 分隔,如 `MY_CONSTANT`。

- 常量是不可变的,一旦定义就不能修改。

3. 函数命名:- 函数的命名应该使用小写字母,并使用下划线`_` 分隔单词,如 `calculate_average`。

- 函数名应该具有描述性,能够清晰地表达函数的作用。

- 如果函数名由多个单词组成,使用下划线 `_` 来分隔单词。

- 通常,函数名应该以动词开头,以便清楚地表示函数执行的操作。

4. 类命名:- 类的命名应该使用驼峰命名法(Camel Case),即首字母大写,每个单词的首字母也大写,如 `MyClass`。

- 类名应该具有描述性,能够清晰地表达类的含义。

- 避免使用单个单词作为类名,除非在上下文中已经被广泛接受。

5. 模块命名:- 模块的命名应该使用小写字母,并使用下划线`_` 分隔单词,如 `my_module`。

- 模块名应该具有描述性,能够清晰地表达模块的作用。

- 如果模块名由多个单词组成,使用下划线 `_` 来分隔单词。

6. 包命名:- 包的命名应该使用小写字母,并使用下划线 `_` 分隔单词,如 `my_package`。

- 包名应该具有描述性,能够清晰地表达包的作用。

  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)包含在你的源文件中,按如下做。

相关文档
最新文档