python中的self参数

一、ModelForm

自己定义的form--->Form--->BaseForm

自己定义的ModelForm--->ModelForm--->BaseModelForm--->BaseForm

从上面可以看出form和ModelForm都是继承BaseForm,所以在Form中有的方法在ModelForm中也是有的，包括is_valid(),cleaned_data,errors

下面是ModelForm的中Meta的使用方法

下面是关于Meta重要参数的使用的例子：

views.py中的代码为：

前端index.html中代码如下：

这样默认访问index页面效果如下：

关于labels参数

可以看出默认情况下输入框左边的lable显示的是列名，如果不在models.py的类中定义字段时添加verbose_name="用户名"参数，默认则是显示的列名，当然如果通过verbose_name="用户名"参数设定，则可以显示自定义的名字，当然这里如果不在models.py中定义的话，可以在ModelForm中通过lables参数指定，注意：lables后面的参数值是字典类型，代码如下：

这样当再次访问页面时效果如下：

关于help_texts参数

注意：help_texts后面的参数值是字典类型代码如下：

这样当再次访问页面时：

关于wigets参数

Modelform本身没有widgets，需要借助于forms,所以当在ModelForm中需要通过widgets参数自定义插件的时候，需要from django.forms import widgets as MFwidgets 这里通过as 将名字进行改变是因为和widgets参数冲突，注意：help_texts后面的参数值是字典类型，具体用法例子如下：

这样当再次访问页面时：

关于error_messages参数

error_messages用于自定义错误信息，注意：error_messages后面的参数值是字典类型，具体使用例子如下：

默认当点击页面提交时，页面的错误信息如下：

通过error_messages用于自定义错误信息后的代码如下：

这样当再次提交的时候，错误信息效果如下：

关于field_classes参数

在model.py的类中我们已经对字段类型进行了设置，当我们想在ModelForm中对字段类型进行修改的时候，首先需要导入from django.forms import fields as MFfields 这里通过通过as 改名防止冲突，注意：field_classes后面的参数值是字典类型，代码例子如下：

上述代码例子中将原本为email邮箱格式的字段更改为了URL字段

以上是关于生成html的用法，下面ModelForm在其他方面也可以方便

二、ModelForm对于数据库的操作

对多的数据的保存

我们将上述页面还原为如下：

我们需要实现的是当用户淑如用户名和邮箱以及选择用户类型后，点击提交后，将信息保存到数据库，并且这里实现了一对多数据库的数据的保存，我们需要将views.py中的index函数的代码进行更改：

这里用的是obj.save()方法，这样当页面信息正确后，点击提交就会将数据保存到数据库中

多对多数据的保存

在上面演示了通过obj.save()可以保存一对多的数据到数据库，同样的，也是可以将多对多数据保存到数据库

现在models.py文件中添加一个用户组的类，并创建多对多关系，修改后的代码如下：

这样页面显示效果如下：

这样当我们填写信息点击提交后，数据库中也就将数据保存在多对多关系

对obj.save()方法的详解

我们点击代码中obj后面的save,查看源码如下：

分析源码我们可以看出，默认参数commit=True,代码中if commit判断中，如果为commit=True，则执行self.instance.save()和self._save_m2m()

self.instance：为当前model的对象，所以可以保存当前表

Self._save_m2m():则表示保存多对多的数据

所以默认情况下commit=True,则当前表数据和多对多表的数据都会保存，当然在这里我们也可以进行拆分，如果commit=False,这个时候，else里只有self.save_m2m=self._save_m2m,进行了赋值，并没有执行任何操作,最终返回self.instance,下面演示拆开的代码例子：

修改后views.py中index函数：

这里instance=obj.save(False),instance.save()这样如果提交数据，就不会保存多对多表的数据，只保存当前表的数据，如果想要保存多对多的数据，则再添加obj.save_m2m()

所以这里我们可以看出

instance=obj.save(False)

instance.save()

obj.save_m2m()

就相当于obj.save()

关于select_related的一个知识点

当在页面中想要列出所有用户时：

Views.py中添加如下代码：

这里有个问题需要注意，这里用select_related时后面只能填写一对多的表跨表，不能填写多对多表进行跨表。

下面是对ModelForm使用的一个小例子：

Views.py中的代码为：

ModelForm.py中的代码为：

两个前端页面，user_edit.html和user_list.html

User_list.html代码如下：

user_edit.html代码如下：

当登陆用户列表页面时：

点击编辑：

上述代码中有几个重要的地方：

当点击编辑的时候，编辑页面会将点击的当前行的用户信息显示出来。

Views.py代码中，当用户通过get访问页面时，

mf= ModelForm.UserInfoModelForm(instance=user_obj)

这里通过instance参数将用户对象传入到ModelForm中，从而显示将当前行的用户信息显示到form页面。

当用户更改用户信息后，点击提交，则可以将更改的用户信息保存到数据库中

mf = ModelForm.UserInfoModelForm(request.POST,instance=user_obj)

这里首先传入request.POST参数，这里是将用户的信息提交，而将用户信息提交到数据库中哪一行，则需要通过instance参数将用户对象user_obj传入，这样当用户更改用户信息后，点击提交则可以将更改后的用户信息保存到数据库中相应的行，如果没有instance参数，则会创建一条新的数据在数据库中

注意：代码中用的is_valid() 这里同样和Form一样预留有钩子：

_clean_fields()

_clean_from()

_post_clean()

注意：在ModelForm中可以定义额外的字段

ModelForm小结：

1、生成HTML标签：在ModelForm类中的class Meta中定义

2、Mf =xxxModelForm(instance=Modelobj)

3、额外的标签

4、和Form中存在的验证，预留的钩子

_clean_fields()

_clean_from()

_post_clean()

5、mf.save()保存数据

通过传入False参数将mf.save()进行分开

Instance = mf.save(False)

Instance.save()

Mf.save_m2m()。

自 2011 年以来，我一直是 Python 的重度用户和爱好者。当时，一位好朋友建议我抛弃 Perl（eeek）并尝试使用 Python 时，一个全新的世界向我敞开了大门。 这个世界的可读性高于其他所有语言，并且明确统一样式。

在使用 Python 大约7年之后，尽管我还和当时有一样的热情，但是，随着时间的推移，人们也在寻找新的冒险和挑战。 现在是我是该尝试另一种语言的时候了！

Python 的问题

首先，列举我在 Python 中遇到的一些问题：

打包：这方面是大多数解释型语言都会遇到的问题。打包成一个包括整个 virtualenv 的可安装程序，FPM 之类的工具可以让这个过程非常容易，但是它仍然缺少一个单一二进制程序的优雅。静态类型：就像一些人从开始使用 C++ 到完全喜爱它，我确实怀念我在 C++ 中用过的类型安全。这与编译时检查密切相关，它确实帮助我们保证我们的代码的质量，甚至在执行之前。速度：大多数解释型语言的又一个问题。Python 对于许多任务都足够快，但是仍然远远落后于编译型语言。冗长：我们只有在 Python 3.6 才有 f-strings ，它确实是一个解脱。然而，我们在类和结构中仍然有非常冗长的 self 语法，到处都是 self.var = var ，这可能会在 Python 3.7 的数据类中部分解决。隐式私有类成员：我说的私有就是那该死的私有！作为一个前 C++ 程序员，我发现 Python 的私有属性和方法的下划线前缀格式有一点…变态？:‘)

进一步来说，我不确定我真的喜爱 Python 在几个领域的发展方向，尤其是在异步和类型方面。

协程：尽管大受欢迎，Python 中新的异步方法让人感觉非常不友好而且很难掌握。现有代码在非阻塞之前也需要大量的工作。随着越来越多的库开放使用，以及随着我了解且会使用新的库越来越多，我觉得这种情况会随之改善。类型注解（和 mypy ）：说实话，类型注解很受欢迎…如果他们真的在 CPython 做了什么的话。如果没有主 CPython 发布版本主流支持的情况下，使用类型注解作为各式结构体（如数据类）这种想法看起来毫无意义。与此同时，mypy 目前还不是主流，但长远来看，作为一个 Python 类型校验展示了巨大的潜能，特别是在将 --strict 标识开启的时候。

我应该说明我仍然是 Python 的忠实粉丝和支持者，而且认为它仍然是当前最好的解释型语言之一；特别是当你考虑到它惊人的生态系统和成熟度。

我在寻找什么

我的出发点是 Python 和 Ruby 。 我经常在需要的地方使用 Ruby ，也非常喜欢它。 Ruby 解决了 Python 所具有的几个问题（适当的私有/受保护的属性，较少冗长的语法等等），但仍然存在性能问题，并且缺少静态类型。

因此，我开始寻找具有以下特点的新语言：

与 Python 和 Ruby 类似的语法单二进制分发编译，静态类型和快速面向对象（哦类，我多么爱你......）

候选项

下列语言被排除在外

GO：没有关键字参数、没有异常、没有类、没有泛型以及命名风格的可怕，这些都导致我拒绝了Go（尽管也许这种简单性吸引了很多人）。我实际上花了相当一段时间在 Go 的学习和编码上，我觉得这是最令人沮丧的。在 C 之后，像 C++ 这样的语言已经取得了很多进步，并为我们提供了更大的灵活性，但感觉 Go 似乎让我们回到了 C 语言的时代。Elixir：一种引人入胜的函数式语言，但缺少面向对象的功能，以及单个二进制分发不是此语言的目标的事实对我的用例来说有点失望。然而，我们团队中的许多人将 Elixir 作为他们所有新项目的主要语言，并且发现它在使用中非常出色。Elixir 拥有丰富且可靠的传统，如果你想要一种函数式语言，你一定要考虑它。Rust：这是个有趣的语言，我花了一些时间尝试学习。真的，我只是觉得 Rust 并不对症于我的用例。这是一种相当复杂的语言，我和其他很多人似乎都不喜欢它。Julia：这种语言实际上是针对科学计算的，而不是我的用例。它也缺乏我想要的面向对象能力。Pony：一种非常吸引人的语言，似乎借鉴了很多 Python ，但也借鉴了一些我不喜欢的东西（例如，强调前缀变量，缺乏对称性等）。我大体上感觉 Pony 与我的想法不一致，认为它不具有与其他语言一样的吸引力，这使得它现在相当原始。

我真正感兴趣并希望在未来进一步研究的语言有：

Nim：Nim 是最初我准备用来领跑的下一个语言，我希望将来能花更多的时间来研究它。Swift：另一种流行的面向对象语言，除了开发 iOS 和 Mac 应用程序外，绝对值得关注。

但是，最终，我决定致力于学习 Crystal ！

原因如下：

Crystal 很快就能熟悉，因为它大部分遵循 Ruby 的语法它编译成一个快速、单一的可执行文件整个标准库都是用 Crystal 编写的，可以在需要时很容易阅读它提供了与 Ruby 类似的完全面向对象的方法(包括真正的受保护的和私有的成员)Crystal 使用静态类型，但也提供了联合(能够定义可以具有多种类型的变量)它提供了开发类似于 Ruby 的 DSL 的能力（这是我一直感兴趣的）与 C 库的绑定完全原生，并且以 Crystal 编写（与 Python 中的 ctypes 类似，只不过更好）

注意事项

Crystal 是一个非常年轻的语言，仍然没有发布 1.0 版本。它通常会在版本中引入重大更改并且限制库。

不过，我打算仅在我的个人项目中使用这种语言，并且愿意成为早期使用者，因为我觉得这种语言有足够的前景值得使用。

经验

标准库

整个标准库非常容易阅读，我一直在引用它。库似乎也有一定的广泛性，是一个很好的基础教程。

以下是添加数组的示例：

这里是获取文件扩展名的函数：

如果你选择尝试 Crystal ，请确保让它的源码待在你身边; 它非常有价值和有用。

绑定到 C 库

这真的太神奇了！

下面是一个绑定从 Unix 系统获取用户信息的各种函数的例子：

异常处理

类似的异常处理提供给 Puby 和 Python ：

写你自己的异常很简单；只需要集成 Exception 类

导入系统和命名空间

这是来自 Python 的一些调整，但是因为 Ruby 遵循类似 C++ 的方法，把我带回到了 C++ 时代。

C++ 命名空间等同于你可以自定义 Ruby/Crystal 模块。要求任何库将导入它定义的所有项目，因此它总是完美的保证了你的整个库包含在模块中，以此来避免命名空间污染。

起初我还有点担心，但我发现它可以从任意数量的文件中轻松建立一个模块。然而，我得承认，找到事物的来源更像是一种挑战。

类

我最喜欢的有关 Crystal 的部分是它如何处理实例变量的赋值：

这将创建一个构造函数，它将自动用所提供的参数赋值给实例变量。Python 中的等价代码是：

虽然这涉及个人喜好，但我也非常喜欢 Ruby/Crystal 中 end 语句和两个空格缩进的对称性。我觉得它最终使得代码阅读起来更美观而优雅。当然，我们也有适当的 protected 和 private 成员以及抽象类；这两个功能是我从我的 C ++ 时代就已经错过的。

文档

我非常喜欢 Crystal 的文档。阅读它是如此的愉悦。但与任何新的语言一样，它可能是如其预期的那么全面。所提供的主要两个文档是：

Crystal Docs: 提供由该语言提供的大多数功能的非常愉快的概览。一定要点击屏幕顶部的小A图标来调整字体、字体大小和主题（很好体验）。我建议从这里开始。Crystal API 参考: 详细介绍所有提供的模块及其各自的类和函数。

另一个不错的有用资源是 Gitter 上的 Crystal chatroom 。该频道的每个人都非常热心和乐于助人。到目前为止，他们一直是我探索旅程中的重要信息来源。

性能

虽然现在确定性能增益还为时过早，但做个 Fibonacci 测试总是很有趣的：）

Ruby/Crystal

Python

C

用 -O3 编译以获得最佳性能。

C++

用 -O3 编译以获得最佳性能。

Go

结果

总结

尽管现在是我和 Crystal 的相处早期，我仍旧乐观地希望 Crystal 能尽快成为很多产品的选择。我想 Crystal 能像 Python 和 Ruby 一样顺其自然的发展。

在不久的将来，留心那些关于 Crystal 的帖子，它们将包含我的技巧与诀窍。

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。) 通常双前置下划线仅被用来避免与基类的属性发生命名冲突。

常量：

大数据文摘作品

编译：什锦甜、Gao Ning、小鱼

Python简介

Python是一种具有动态语义的、面向对象的解释型高级编程语言。因其内置了高级数据结构，并支持动态类型和动态绑定，使用Python进行快速应用程序开发十分便利。同时作为一门脚本语言，它兼容部分现有的组件和服务。Python还支持模块和各种库的扩展，有助于实现模块化编程和提高代码复用率。

关于本文

刚接触这门语言的新手可能会对Python简洁灵活的语法有些不适应，或是低估了Python强大的性能。鉴于此，本文列出了Python开发人员常犯的10个小错误，资深程序猿也难免会中招哦。

本文供Python高级开发人员参考，Python小白可以参考下面这篇文章：

http://onlamp/pub/a/python/2004/02/05/learn_python.html

常见错误1：滥用表达式作为函数参数的默认值

Python允许开发者指定函数参数的默认值，这也是Python的一大特色，但当默认值可变时，可能会给开发者带来一些困扰。例如下面定义的函数：

>>> def foo(bar=[]): # bar is optional and defaults to [] if not specified... bar.append("baz") # but this line could be problematic, as we'll see...... return bar

看出bug了吗？那就是在每次调用函数前没有对可变参数进行赋值，而认为该参数就是默认值。比如上面的代码，有人可能期望在反复调用foo()时返回'baz'，以为每次调用foo()时，bar的值都为[]，即一个空列表。

但是，让我们来看看代码运行结果：

>>> foo()["baz"]>>> foo()["baz", "baz"]>>> foo()["baz", "baz", "baz"]

嗯？为什么每次调用foo()后会不断把"baz"添加到已有的列表，而不是新建一个新列表呢？答案就是，函数参数的默认值仅在定义函数时执行一次。因此，仅在第一次定义foo()时，bar初始化为默认值（即空列表），此后，每次调用foo()函数时，参数bar都是第一次初始化时生成的列表。

常见的解决方案：

>>> def foo(bar=None):... if bar is None: # or if not bar:... bar = []... bar.append("baz")... return bar...>>> foo()["baz"]>>> foo()["baz"]>>> foo()["baz"]

常见错误2：错误地使用类变量

代码示例：

>>> class A(object):... x = 1...>>> class B(A):... pass...>>> class C(A):... pass...>>> print A.x, B.x, C.x1 1 1

运行结果没问题。

>>> B.x = 2>>> print A.x, B.x, C.x1 2 1

结果也正确。

>>> A.x = 3>>> print A.x, B.x, C.x3 2 3

什么鬼？我们只改变了A.x.，为什么C.x 也变了？

在Python中，类变量是以字典形式进行内部处理，遵循方法解析顺序（Method Resolution Order ，MRO）。因此，在上述代码中，因为在类C中没有找到属性x，它就会从父类中查找x的值（尽管Python支持多重继承，但上述代码只存在一个父类A）。换句话说，C没有独立于类A的属于自己的x。因此，C.x实际上指的是A.x。除非处理得当，否则就会导致Python出现错误。

如果想更深入了解Python的类特性，请戳：

https://toptal/python/python-class-attributes-an-overly-thorough-guide

常见错误3：错误指定异常代码块的参数

假设你有如下代码：

>>> try:... l = ["a", "b"]... int(l[2])... except ValueError, IndexError: # To catch both exceptions, right?... pass...Traceback (most recent call last):File "", line 3, in IndexError: list index out of range

这里的问题是except语句不接受以这种方式指定的异常列表。在Python2.x中，except Exception语句中变量e可用来把异常信息绑定到第二个可选参数上，以便进一步查看异常的情况。因此，在上述代码中，except语句并没有捕捉到IndexError异常；而是将出现的异常绑定到了参数IndexError中。

想在一个except语句同时捕捉到多个异常的正确方式是，将第一个参数指定为元组，并将要捕捉的异常类型都写入该元组中。为了方便起见，可以使用as关键字，Python 2 和Python 3都支持这种语法格式：

>>> try:... l = ["a", "b"]... int(l[2])... except (ValueError, IndexError) as e: ... pass...>>>

常见错误4：错误理解Python中变量的作用域

Python变量作用域遵循LEGB规则，LEGB是Local，Enclosing，Global，Builtin的缩写，分别代表本地作用域、封闭作用域、全局作用域和内置作用域，这个规则看起来一目了然。事实上，Python的这种工作方式较为独特，会导致一些编程错误，例如：

>>> x = 10>>> def foo():... x += 1... print x...>>> foo()Traceback (most recent call last):File "", line 1, in File "", line 2, in fooUnboundLocalError: local variable 'x' referenced before assignment

问题出在哪？

上面的错误是因为在作用域内对变量赋值时，Python自动将该变量视为该作用域的本地变量，并对外部定义的同名变量进行了屏蔽。因此，原本正确的代码，在某个函数内部添加了一个赋值语句后，却意外收到了UnboundLocalError的报错信息。

关于UnboundLocalError更多内容请戳：

https://docs.python.org/2/faq/programming.html#why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value

在使用列表时，Python程序员更容易掉入此类陷阱，例如：

>>> lst = [1, 2, 3]>>> def foo1():... lst.append(5) # This works ok......>>> foo1()>>> lst[1, 2, 3, 5]>>> lst = [1, 2, 3]>>> def foo2():... lst += [5] # ... but this bombs!...>>> foo2()Traceback (most recent call last):File "", line 1, in File "", line 2, in fooUnboundLocalError: local variable 'lst' referenced before assignment

奇怪，为什么foo1正常运行，而foo2崩溃了呢？

原因和上一个案例中出现的问题相似，但这里的错误更加细微。函数foo1没有对变量lst进行赋值操作，而函数foo2有赋值操作。

首先， lst += [5]是lst = lst + [5]的缩写形式，在函数foo2中试图对变量lst进行赋值操作（Python将变量lst默认为本地作用域的变量）。但是，lst += [5]语句是对lst变量自身进行的赋值操作（此时变量lst的作用域是函数foo2），但是在函数foo2中还未声明该变量，所以就报错啦！

常见错误5:在遍历列表时修改列表

下面代码中的错误很明显：

>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> for i in range(len(numbers)):... if odd(numbers[i]):... del numbers[i] # BAD: Deleting item from a list while iterating over it...Traceback (most recent call last):File "", line 2, in IndexError: list index out of range

有经验的程序员都知道，在Python中遍历列表或数组时不应该删除该列表（数组）中的元素。虽然上面代码的错误很明显，但是在编写复杂代码时，资深程序员也难免会犯此类错误。

幸好Python集成了大量经典的编程范式，如果运用得当，可以大大简化代码并提高编程效率。简单的代码会降低出现上述bug的几率。列表解析式（list comprehensions）就是利器之一，它将完美避开上述bug，解决方案如下：

>>> odd = lambda x : bool(x % 2)>>> numbers = [n for n in range(10)]>>> numbers[:] = [n for n in numbers if not odd(n)] # ahh, the beauty of it all>>> numbers[0, 2, 4, 6, 8]

更多有关列表解析式的详细内容，请戳：https://docs.python.org/2/tutorial/datastructures.html#tut-listcomps

常见错误6：不理解Python闭包中的变量绑定

代码示例：

>>> def create_multipliers():... return [lambda x : i * x for i in range(5)]>>> for multiplier in create_multipliers():... print multiplier(2)...

你以为运行结果会是：

02468

但实际输出结果是：8

8888

惊不惊喜！

这种情况是由于Python延迟绑定（late binding）机制造成的，也就是说只有在内部函数被调用时才会搜索闭包中变量的值。所以在上述代码中，每次调用create_multipliers()函数中的return函数时，会在附近作用域中查询变量i的值。（此时，return中循环已结束，所以i值为4）。

常见解决方案：

>>> def create_multipliers():... return [lambda x, i=i : i * x for i in range(5)]...>>> for multiplier in create_multipliers():... print multiplier(2)...02468

没错！我们利用了匿名函数lambda的默认参数来生成结果序列。有人觉得这种用法很简洁，有人会说它很巧妙，还有人会觉得晦涩难懂。如果你是Python开发人员，那么深刻理解上述语法对你而言非常重要。

常见错误7：模块之间出现循环依赖

假设你有两个文件，分别是a.py和b.py，两者相互导入，如下所示：

a.py模块中的代码：

import bdef f():return b.xprint f()

b.py模块中的代码：

import ax = 1def g():print a.f()

首先，我们尝试导入a.py：

>>> import a1

运行结果正确！这似乎有点出人意料，因为我们在这里进行循环导入，应该会报错呀！

答案是，在Python中如果仅存在一个循环导入，程序不会报错。如果一个模块已经被导入，Python会自动识别而不会再次导入。但是如果每个模块试图访问其他模块不同位置的函数或变量时，那么Error又双叒叕出现了。

回到上面的示例中，当导入a.py模块时，程序可以正常导入b.py模块，因为此时b.py模块未访问a.py中定义任何的变量或函数。b.py模块仅引用了a.py模中的a.f()函数。调用的a.f()函数隶属于g()函数，而a.py或b.py模块中并没有调用g()函数。所以程序没有报错。

但是，如果我们在未导入a.py模块之前先导入b.py模块，结果会怎样？

>>> import bTraceback (most recent call last):File "", line 1, in File "b.py", line 1, in import a File "a.py", line 6, in print f() File "a.py", line 4, in f return b.xAttributeError: 'module' object has no attribute 'x'

报错了！问题在于，在导入b.py的过程中，它试图导入a.py模块，而a.py模块会调用f()函数，f()函数又试图访问b.x变量。但此时，还未对变量b.x进行定义，所以出现了AttributeError异常。

稍微修改下b.py，即在g()函数内部导入a.py就可以解决上述问题。

修改后的b.py：

x = 1def g():

import a # This will be evaluated only when g() is calledprint a.f()

现在我们再导入b.py模块，就不会报错啦！

>>> import b>>> b.g()1 # Printed a first time since module 'a' calls 'print f()' at the end1 # Printed a second time, this one is our call to 'g'

常见错误8：文件命名与Python标准库模块的名称冲突

Python的优势之一就是其集成了丰富的标准库。正因为如此，稍不留神就会在为自己的文件命名时与Python自带标准库模块重名。例如，如果你的代码中有一个名为email.py的模块，恰好就和Python标准库中email.py模块重名了。）

上述问题比较复杂。举个例子，在导入模块A的时候，假如该模块A试图导入Python标准库中的模块B，但你已经定义了一个同名模块B，模块A会错误导入你自定义的模块B，而不是Python标准库中的模块B。这种错误很糟糕，因为程序员很难察觉到是因为命名冲突而导致的。

因此，Python程序员要注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易的多！当然你也可以写一份Python改善建议书（Python Enhancement Proposal，PEP）提议修改标准库的名称。

常见错误9：不熟悉Python2和Python3之间的差异

先来看看foo.py文件中的代码：

import sysdef bar(i):if i == 1: raise KeyError(1) if i == 2: raise ValueError(2)def bad(): e = None try: bar(int(sys.argv[1])) except KeyError as e: print('key error') except ValueError as e: print('value error') print(e)bad()

在Python 2中，上述代码运行正常

$ python foo.py 1key error1$ python foo.py 2value error2

但是在Python 3中运行时：

$ python3 foo.py 1key errorTraceback (most recent call last):File "foo.py", line 19, in bad() File "foo.py", line 17, in bad print(e)UnboundLocalError: local variable 'e' referenced before assignment

什么情况？原来，在Python 3中，在except代码块作用域外无法访问异常对象。（原因是，Python 3会将内存堆栈中的循环引用进行保留，直到垃圾回收...

自 2011 年以来，我一直是 Python 的重度用户和爱好者。当时，一位好朋友建议我抛弃 Perl（eeek）并尝试使用 Python 时，一个全新的世界向我敞开了大门。 这个世界的可读性高于其他所有语言，并且明确统一样式。

在使用 Python 大约7年之后，尽管我还和当时有一样的热情，但是，随着时间的推移，人们也在寻找新的冒险和挑战。 现在是我是该尝试另一种语言的时候了！

Python 的问题

首先，列举我在 Python 中遇到的一些问题：

打包：这方面是大多数解释型语言都会遇到的问题。打包成一个包括整个 virtualenv 的可安装程序，FPM 之类的工具可以让这个过程非常容易，但是它仍然缺少一个单一二进制程序的优雅。静态类型：就像一些人从开始使用 C++ 到完全喜爱它，我确实怀念我在 C++ 中用过的类型安全。这与编译时检查密切相关，它确实帮助我们保证我们的代码的质量，甚至在执行之前。速度：大多数解释型语言的又一个问题。Python 对于许多任务都足够快，但是仍然远远落后于编译型语言。冗长：我们只有在 Python 3.6 才有 f-strings ，它确实是一个解脱。然而，我们在类和结构中仍然有非常冗长的 self 语法，到处都是 self.var = var ，这可能会在 Python 3.7 的数据类中部分解决。隐式私有类成员：我说的私有就是那该死的私有！作为一个前 C++ 程序员，我发现 Python 的私有属性和方法的下划线前缀格式有一点…变态？:‘)

进一步来说，我不确定我真的喜爱 Python 在几个领域的发展方向，尤其是在异步和类型方面。

协程：尽管大受欢迎，Python 中新的异步方法让人感觉非常不友好而且很难掌握。现有代码在非阻塞之前也需要大量的工作。随着越来越多的库开放使用，以及随着我了解且会使用新的库越来越多，我觉得这种情况会随之改善。类型注解（和 mypy ）：说实话，类型注解很受欢迎…如果他们真的在 CPython 做了什么的话。如果没有主 CPython 发布版本主流支持的情况下，使用类型注解作为各式结构体（如数据类）这种想法看起来毫无意义。与此同时，mypy 目前还不是主流，但长远来看，作为一个 Python 类型校验展示了巨大的潜能，特别是在将 --strict 标识开启的时候。

我应该说明我仍然是 Python 的忠实粉丝和支持者，而且认为它仍然是当前最好的解释型语言之一；特别是当你考虑到它惊人的生态系统和成熟度。

我在寻找什么

我的出发点是 Python 和 Ruby 。 我经常在需要的地方使用 Ruby ，也非常喜欢它。 Ruby 解决了 Python 所具有的几个问题（适当的私有/受保护的属性，较少冗长的语法等等），但仍然存在性能问题，并且缺少静态类型。

因此，我开始寻找具有以下特点的新语言：

与 Python 和 Ruby 类似的语法单二进制分发编译，静态类型和快速面向对象（哦类，我多么爱你......）

候选项

下列语言被排除在外

GO：没有关键字参数、没有异常、没有类、没有泛型以及命名风格的可怕，这些都导致我拒绝了Go（尽管也许这种简单性吸引了很多人）。我实际上花了相当一段时间在 Go 的学习和编码上，我觉得这是最令人沮丧的。在 C 之后，像 C++ 这样的语言已经取得了很多进步，并为我们提供了更大的灵活性，但感觉 Go 似乎让我们回到了 C 语言的时代。Elixir：一种引人入胜的函数式语言，但缺少面向对象的功能，以及单个二进制分发不是此语言的目标的事实对我的用例来说有点失望。然而，我们团队中的许多人将 Elixir 作为他们所有新项目的主要语言，并且发现它在使用中非常出色。Elixir 拥有丰富且可靠的传统，如果你想要一种函数式语言，你一定要考虑它。Rust：这是个有趣的语言，我花了一些时间尝试学习。真的，我只是觉得 Rust 并不对症于我的用例。这是一种相当复杂的语言，我和其他很多人似乎都不喜欢它。Julia：这种语言实际上是针对科学计算的，而不是我的用例。它也缺乏我想要的面向对象能力。Pony：一种非常吸引人的语言，似乎借鉴了很多 Python ，但也借鉴了一些我不喜欢的东西（例如，强调前缀变量，缺乏对称性等）。我大体上感觉 Pony 与我的想法不一致，认为它不具有与其他语言一样的吸引力，这使得它现在相当原始。

我真正感兴趣并希望在未来进一步研究的语言有：

Nim：Nim 是最初我准备用来领跑的下一个语言，我希望将来能花更多的时间来研究它。Swift：另一种流行的面向对象语言，除了开发 iOS 和 Mac 应用程序外，绝对值得关注。

但是，最终，我决定致力于学习 Crystal ！

原因如下：

Crystal 很快就能熟悉，因为它大部分遵循 Ruby 的语法它编译成一个快速、单一的可执行文件整个标准库都是用 Crystal 编写的，可以在需要时很容易阅读它提供了与 Ruby 类似的完全面向对象的方法(包括真正的受保护的和私有的成员)Crystal 使用静态类型，但也提供了联合(能够定义可以具有多种类型的变量)它提供了开发类似于 Ruby 的 DSL 的能力（这是我一直感兴趣的）与 C 库的绑定完全原生，并且以 Crystal 编写（与 Python 中的 ctypes 类似，只不过更好）

注意事项

Crystal 是一个非常年轻的语言，仍然没有发布 1.0 版本。它通常会在版本中引入重大更改并且限制库。

不过，我打算仅在我的个人项目中使用这种语言，并且愿意成为早期使用者，因为我觉得这种语言有足够的前景值得使用。

经验

标准库

整个标准库非常容易阅读，我一直在引用它。库似乎也有一定的广泛性，是一个很好的基础教程。

以下是添加数组的示例：

这里是获取文件扩展名的函数：

如果你选择尝试 Crystal ，请确保让它的源码待在你身边; 它非常有价值和有用。

绑定到 C 库

这真的太神奇了！

下面是一个绑定从 Unix 系统获取用户信息的各种函数的例子：

异常处理

类似的异常处理提供给 Puby 和 Python ：

写你自己的异常很简单；只需要集成 Exception 类

导入系统和命名空间

这是来自 Python 的一些调整，但是因为 Ruby 遵循类似 C++ 的方法，把我带回到了 C++ 时代。

C++ 命名空间等同于你可以自定义 Ruby/Crystal 模块。要求任何库将导入它定义的所有项目，因此它总是完美的保证了你的整个库包含在模块中，以此来避免命名空间污染。

起初我还有点担心，但我发现它可以从任意数量的文件中轻松建立一个模块。然而，我得承认，找到事物的来源更像是一种挑战。

类

我最喜欢的有关 Crystal 的部分是它如何处理实例变量的赋值：

这将创建一个构造函数，它将自动用所提供的参数赋值给实例变量。Python 中的等价代码是：

虽然这涉及个人喜好，但我也非常喜欢 Ruby/Crystal 中 end 语句和两个空格缩进的对称性。我觉得它最终使得代码阅读起来更美观而优雅。当然，我们也有适当的 protected 和 private 成员以及抽象类；这两个功能是我从我的 C ++ 时代就已经错过的。

文档

我非常喜欢 Crystal 的文档。阅读它是如此的愉悦。但与任何新的语言一样，它可能是如其预期的那么全面。所提供的主要两个文档是：

Crystal Docs: 提供由该语言提供的大多数功能的非常愉快的概览。一定要点击屏幕顶部的小A图标来调整字体、字体大小和主题（很好体验）。我建议从这里开始。Crystal API 参考: 详细介绍所有提供的模块及其各自的类和函数。

另一个不错的有用资源是 Gitter 上的 Crystal chatroom 。该频道的每个人都非常热心和乐于助人。到目前为止，他们一直是我探索旅程中的重要信息来源。

性能

虽然现在确定性能增益还为时过早，但做个 Fibonacci 测试总是很有趣的：）

Ruby/Crystal

Python

C

用 -O3 编译以获得最佳性能。

C++

用 -O3 编译以获得最佳性能。

Go

结果

总结

尽管现在是我和 Crystal 的相处早期，我仍旧乐观地希望 Crystal 能尽快成为很多产品的选择。我想 Crystal 能像 Python 和 Ruby 一样顺其自然的发展。

在不久的将来，留心那些关于 Crystal 的帖子，它们将包含我的技巧与诀窍。

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。) 通常双前置下划线仅被用来避免与基类的属性发生命名冲突。

常量：