python2和

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

常量：

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

你看到虫子了吗？也就是说，在每次调用之前不要为函数分配一个变量参数，并认为参数是默认值。例如，上面的代码，一个可能会多次调用foo（）returns'baz'when，每个调用foo（），为[ ]的价值吧，那是一个空的列表。

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

>；>；>；foo（）[“巴兹”] >；>；>；foo（）[“巴兹”、“Baz”] & gt；

嗯？你为什么要加上“巴兹”每次调用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：类变量的错误使用

代码示例：

>；>；>；类（对象）：…x＝1…>；>；>；B（A）：通…

结果没有问题。

>；>；>；b.x = 2 >；>；>；打印A.x，b.x，c.x121

结果也是正确的。

>；>；>；内= 3 >；>；>；打印A.x，b.x，c.x323

到底是什么？我们只改变了A.x.，C.x为什么要改变呢？

在Python中，类变量是以字典的形式在内部处理的，其次是解析的方法（方法解析顺序，MRO）。因此，在上面的代码中，因为在类C中找不到属性x，所以它从父类中查找x的值。虽然Python支持多重继承，上述代码，换句话说，只有一个父类A，C没有自己的X是独立的类，那么，C.x实际上指的是a.x.如果处理得当，它会使Python的错误。

如果您想深入了解Python的类特性，请盖章：

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

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

假设您有以下代码：

尝试：…l“A”，“B”…int（L [ 2 ]）除了ValueError，#误差系数…要捕获这两个异常，对吗？Traceback（最）…通过…最近的电话最后文件”）：；3号线，；误差系数：列表索引超出范围

这里的问题是，除语句不接受以这种方式指定的异常列表。在python2. x，变量在除了异常语句可以用来绑定异常信息的第二可选参数进一步查看异常。因此，在上面的代码中，除了声明不捕捉误差系数的例外；相反，例外的是绑定到参数误差系数。

在一个例外语句中同时捕获多个异常的正确方法是将第一个参数分配给元组，并编写要写入元组的异常类型。为了方便起见，您可以使用AS关键字、Python 2和Python 3来支持这种语法格式：

尝试：…L =“A”，“B”…int（l [ 2 ]）…除了（ValueError，IndexError）的…

常见错误4：错误理解Python中变量的范围

Python变量的范围如下legb规则。legb是缩写的地方，封闭，全球和内置。它分别代表本地范围、封闭范围、全局范围和内置范围。这条规则一目了然。事实上，Python中的这种工作更为独特，并导致一些编程错误，如：

（10）…1…X. ..>；>；>；foo（最）追踪（最近的电话上）：stdin文件；1号线，；；2号线：在foounboundlocalerror，当地variable'x'referenced之前分配

问题在哪里？

上述错误是因为在将变量分配给作用域时，Python自动将变量视为作用域中的局部变量，并屏蔽同名变量的外部定义。因此，正确的原代码，添加在一个函数的赋值语句后，意外地收到了unboundlocalerror错误消息。

请把更多关于UnboundLocalError：

http：/ /文档。Python。org / 2 /常/ HTML # why-am-i-getting-an-unboundlocalerror-when-the-variable-has-a-value编程。

当使用列表时，Python程序员更容易陷入这样的陷阱，例如：

>；>；>；1 = 2，[ 1, 3 ] >；>；>；DEF（匹配foo1）：（5）# lst.append…这个效果不错…& gt…；>；>；匹配foo1（& gt）；>；>；1 [ 1, 2, 3，5 ] >；>；>；1 = [ 1 2, 3 ] >，>；>；定义；Foo2（LST = [ 5 ]）：…#…但是这些炸弹！& gt…>；>；Foo2；Traceback（最）最近通话（上）：stdin文件；1号线，；；文件”线，2，在foounboundlocalerror：当地variable'lst'referenced之前分配

奇怪的是，为什么匹配foo1正常运行，和Foo2死机？

原因与前面的问题类似，但这里的错误更为微妙。功能匹配foo1不指定一个值的变量和函数的LST，Foo2有一个赋值操作。

首先，LST =【5】= 1＋1的缩写[ 5 ]，在Foo2功能在试图做一个分配给变量的LST（Python变量LST默认为局部变量）。然而，LST + = [ 5 ]声明是一变量自动赋值操作（在可变LST范围是一个功能，但功能Foo2 Foo2）不声明变量，所以他们叫你！

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

下面代码中的错误是显而易见的：

>；>；>；奇数=λx：bool（x 2）>；>；>；数= [ N N的范围（10）] >；>；>；我在范围（Len（数字）：奇（数）[我]）：如果…德尔数[我]：删除项目#坏…从listwhile迭代Traceback（最近的叫它…最后文件”）：；2号线，；误差系数：列表索引超出范围

有经验的程序员知道，在使用Python遍历列表或数组时，不应删除列表（数组）中的元素。虽然上述代码的错误是显而易见的，但是高级程序员在编写复杂代码时会犯这样的错误。

幸运的是，Python集成了大量经典编程范例，如果使用得当，可以大大简化代码并提高编程效率。简单的代码将减少错误的可能性。列表解析（列表推导式）是一种工具，将完美的避免了上述缺陷，以及解决方法如下：

>>> 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]

关于列表解析，更多详情请戳：http：/ /文档。Python。org / 2 /教程/数据结构。HTML #啧啧listcomps

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

代码示例：

>；>；>；create_multipliers（DEF）：…返回[λx：i x，i（5）；”；“；”；“；”；“gt”：…

你认为运行结果会是：

02468

但实际产出结果如下：8

八千八百八十八

没有惊喜！

这种情况是由Python延迟绑定（后期绑定）机制引起的，也就是说，只有在调用内部函数时，才会搜索闭包中的变量的值。所以在上面的代码中，每次在create_multipliers回归函数（）函数被调用时，该变量的值我是在附近的范围查询。（此时，返回的循环结束，所以i值为4）。

常见的解决方案：

>；>；>；DEF create_multipliers（）：返回[λx，我=我：我×××，我（5）]；…；”；“；”；“；“；”；“诗”：“02468”…

是的，我们使用匿名函数lambda的默认参数生成结果序列。有些人认为它很简单，有人会说它很聪明，其他人会觉得很难理解。如果您是Python开发人员，对语法有深刻的理解是非常重要的。

常见错误7：模块之间的循环依赖关系

假设你有两个文件，a.py和b.py，并互相介绍，如下图所示：

在a.py模块代码：

进口bdef f（）：返回b.xprint f（）

在b.py模块代码：

进口AX = 1def G（）：打印A.f（）

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

进口A1

运行结果正确！这似乎有点意外，因为我们在这里进行循环介绍，应该报错了！

答案是，如果Python中只有一个循环导入，程序就不会出错。如果导入了一个模块，Python将自动识别并不再次导入。但如果每个模块的功能或变量以不同的位置访问其他模块，那么错误易出现双倍。

回到上面的例子中，输入a.py模块时，程序可以导入b.py模块正常，因为b.py模块不当时参观a.py任何变量或函数。的b.py模块只引用A.f（）在a.py模块功能。调用A.f（）函数属于G（）函数，和G（）函数不叫在a.py或b.py模块。所以程序没有错。

但是，如果我们进口的b.py模块导入前的a.py模块，结果会怎样？

>；>；>；进口btraceback（最后调用文件”）：；1号线，；文件”b.py”线，1，在& lt；模块& gt进口；文件a.py，6号线，在；F（文件）”a.py”，4号线，在freturn b.xattributeerror：'module'object没有attribute'x”

错了！问题是，在进口b.py过程，它试图进口a.py模块，和a.py模块调用f（）函数，和f（）函数试图访问b.x变量。但在这一点上，b.x变量未定义，那么还有一个意思是例外。

上述问题可以通过稍微修改b.py，即解决，进口在G a.py（）函数。

改性b.py：

x = 1def g（）：

进口这将只计算#当G（是）calledprint（A.f）

现在我们进入b.py模块，不给你！

>；>；>；进口B >；>；>；（1）不到印刷# module'a'calls'print以来第一次（F）在可以印刷#”了一次，这是我们的电话to'g”

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

Python的优点之一是它集成了一个丰富的标准库。因此，稍微关注一下Python标准库模块名和文件名。例如，如果有一个模块的代码中的命名email.py，只是email.py模块和Python标准库中的名字。）

上述问题更为复杂。例如，当导入模块A时，如果模块A试图在Python标准库中导入模块B，但您定义了一个同名的模块B，模块A将错误地将您的自定义模块B替换为Python标准库中的模块B。这是一个严重的错误，因为程序员很难意识到它是由命名冲突引起的。

因此，Python程序员应该注意避免与Python标准库模块的命名冲突。毕竟，修改自己模块的名称比修改标准库的名称要容易得多！当然，您还可以编写一个Python改进建议（Python增强建议，PEP），用于修改标准库的名称。

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

首先看代码在叫foo.py文件：

进口系统定义的酒吧（我）：如果我= = 1：提高KeyError（1）如果我= = 2（2）：提高ValueError DEF坏（nonetry：）：E =酒吧（int（sys. argv [ 1 ]））除了KeyError E：打印（关键错误”）作为除ValueError E：打印（币值误差）打印（E（坏））

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

Python 1key错误值1美元美元叫foo.py Python叫foo.py 2value 2

但在Python 3中运行时：

1key Python3美元叫foo.py errortraceback（最后调用）：文件“foo。PY”，19行，叫foo.py；”、“，”*（”）、“17”、“于”、“于”、“

发生了什么事？结果表明，在Python 3中，除了代码块操作区域外，不能访问异常对象。（原因是Python 3将循环引用保存在内存堆栈中，直到垃圾收集器在垃圾收集器运行之后在内存中清除。）

更多内容，请戳：

http：/ /文档。Python。org / 3 /参考/ compound_stmts HTML #除外。

一种解决方案是，在除代码块的范围之外，可以通过对异常对象的引用来访问异常对象。以下是处理代码和运行结果python2和Python3是一致的：

进口系统定义的酒吧（我）：如果我= = 1：提高KeyError（1）如果我= = 2（2）：提高ValueError DEF好（nonetry：）：例外=酒吧（int（sys. argv [ 1 ]））除了KeyError E：例外= E打印（关键错误”）除了E = E：ValueError异常打印（币值误差）打印（例外）（好的）

再次，在Python3运行代码：

1key错误值1美元美元叫foo.py Python3 Python3叫foo.py 2value 2

问题解决了！

更多关于python2和Python3的区别，请戳：

http：/ / toptal。COM / Python #招聘指南

常见错误10：_del_误用的方法

假设文件名为mod.py有以下代码：

进口fooclassbar（对象）：…DEF __del__（自我）：foo.cleanup（自我。myhandle）

那么，你想在another_mod.py文件做如下：

进口modmybar = MOD吧（）。

如果你尝试运行another_mod.py，会有一个意思是例外。

为什么？因为当Python解释器关闭时，模块全局变量的值设置为。因此，在上面的例子中，当__del__函数被调用foo的值已经没有。

有关Python解释器的更多信息，请盖章：

https://mail.python.org/pipermail/python-bugs-list/2009-january/069209.html

调用atexit.register（）函数可以解决以上Python高阶编程问题。atexit.register（）函数调用后，当你的代码运行时，它将运行解释器关闭之前。

利用上述方法，修改后的mod.py文件如下：

进...

Mac OSX本身系统自带Python2.7，但 不建议直接使用、删除和更改 ，因为可能有些程序是需要依赖系统自带的python 2.*，盲目修改后可能会导致系统产生未知错误。

所以建议在 不修改系统的python条件下 搭建Python双版本环境。在给大家分享之前呢，小编推荐一下一个挺不错的交流宝地，里面都是一群热爱并在学习Python的小伙伴们，大几千了吧，各种各样的人群都有，特别喜欢看到这种大家一起交流解决难题的氛围，群资料也上传了好多，各种大牛解决小白的问题，这个Python群：330637182 欢迎大家进来一起交流讨论，一起进步，尽早掌握这门Python语言。

Mac OSX在系统自带的python之外，可以 安装Python2.7和Python3.5/3.6版本 ，并且双版本兼容。

本文下方，防止原文链接失效】

在参考的安装流程中，我发现了一些问题并进行了解决，列出问题及解决方法如下：

1.Python2.7安装后，按原文博主的安装方法无法修改系统默认的Python命令为自己安装Python路径和版本：

解决方法：

打开系统配置文件：

vi ~/.bash_profile

添加入自己的安装的Python2.7的路径地址：

PATH="/usr/local/Cellar/python/2.7.14/bin:${PATH}"

让PATH变量生效：

source ~/.bash_profile

我们看到，命令行输入 which python2.7 时，路径地址改变，不再是系统默认地址：

python2.7

我们前往路径地址修改添加 python

文件：（复制一个python2.7然后重命名为python即可）

前往路径地址修改添加`python`文件

这样默认的python即修改为我们所安装的python2.7版本，而非系统自带的python路径，命令行输入 which python

查看：

查看所安装的python2.7版本

这样，我们就将系统的默认python命令链接到了我们所安装的python目录下，而非系统自带的python路径。

2.Python2.7和Python3.6安装后，pip2和pip3下载的包仍在Mac OSX系统自带的Python2.7的包目录下，而非Python2.7和Python3.6的安装目录：

问题图示如下：

pip的version都是系统自带python的包下载路径：

pip的version都是系统自带python的路径

pip的路径都是系统自带python的路径，而非我们的安装路径：

python的路径

添加入自己的安装的Python2.7和Python3.6的路径地址：

我们看到，命令行输入 which pip 和 pip --version 时，pip的路径地址改变，pip下载的包的地址也改变，不再是系统默认地址：

pip版本显示

这样，即可保证使用pip下载的包路径正确，且和我们所安装的两个版本python分别对应。

3.Pip总是不能正常下载包，安装模块包ConnectTimeoutError错误：

我们在使用pip无法正常下载包的时候可以使用国内镜像服务，如用豆瓣的源下载安装 selenium 包：

pip install selenium -i http://pypi.douban/simple --trusted-host pypi.douban

如果是要给python3下载依赖，注意pip和python版本对应，同理：

pip3 install selenium -i http://pypi.douban/simple --trusted-host pypi.douban

这样，即可正常的使用pip来下载安装包了。

安装流程

主要就这几个步骤而已，不会太困难的（或许有些你本来就装好了）

Step 2 安装套件管理工具Homebrew

Step 4 设定路径$PATH（不跟系统Python 打架）

Step 5 完成啰！确认安装结果～

Step 1 安装Xcode

可以到App Store搜寻Xcode并安装安装好了之后就把Xcode打开～第一次开启的时候会需要同意他的License Agreement之类的东西。然后到terminal输入来安装Xcode command line tool：

xcode-select--install

安装Xcode 就到此结束啰，要进入下一个步骤了！

Step 2安装套件管理工具： Homebrew

可以到官网或是在terminal 里贴上：

ruby-e"$(curl -fsSL https://raw.githubusercontent/Homebrew/install/master/install)"

安装好后可以跑一下

brew doctor

如果出现

Your system is ready to brew.

代表万事OK，那如果有Warning的话，也不用太担心，可以按照里面的步骤去修正就好啰！

如果有出现Warning的话，虽然会在上面看到一句

If everything you use Homebrew for is working fine: please don't worry and just ignore them.

不过还是建议大家把东西装好，才不会到时候忘记自己到底什么东西还没设定好。

Step 3 安装Python

接下来要正式进入安装Python的步骤了！

首先，输入

python --version

天哪！都还没开始装Python，电脑里面怎么已经有了？

这是Mac系统要使用的Python，所以平常没适不要去乱动比较好唷！

所以现在我们要用homebrew来安装平常可以（乱搞？）使用的Python。

利用homebrew 搜寻Python

brew search python

这时候，会看到python和python3。

因为我已经装了，所以旁边会写(installed)。要安装Python啰！

brew install python

这样就开始安装了。

装完之后在输入

brew install python3

在安装的时候，Python 会被安装在

/usr/local/Cellar

那就来看看这个资料夹吧

open /usr/local/Cellar/

就可以看到你正在安装的Python出现了！

除了Python之外，也有可能会装一些其他的东西，例如sqlite。

总之，不用太担心，homebrew会自己搞定。

（因为我装了很多哩哩抠抠，所以你的资料夹里可能不会有这么多东西）

什么是路径$PATH 呢？

还记得我们在装Python的时候，输入了brew，

系统就自动会知道要开始跑homebrew。

系统到底怎么知道我们的brew在哪里？

这就是$PATH的用途了！

echo $PATH

接下来就会看到一串类似这样的东西

/usr/bin**:**/bin**:**/usr/sbin**:**/sbin**:**/usr/local/bin

分号(:)是 分隔 的意思

所以当你在terminal里面输入brew时

系统就会开始从/usr/bin找起

如果在/usr/bin里面找不到的话

就会往下一个/bin去搜寻，以此类推

现在，我们回到资料夹去看

brew其实就在/usr/local/bin里面！

所以现在的问题就是，系统在/usr/bin里面也有一份Python

现在我们在/usr/local/Cellar里面也装了Python

这样在terminal打上python指令时，谁会被开启呢？

因为路径有 顺序 ，所以它会先找到系统的Python

现在就要来解决这个问题

sudo emacs/etc/paths

sudo让我们取得管理员权限

用emacs这个程式编辑路径档案

terminal会要求输入密码

（就是平常装东西也需要输入的密码）现在要把/usr/local/bin移到上面去control + k：把一行字剪下来control + y：把字贴上control + x + s：存档control + x + c：关掉emacs

这时，再打一次

为什么没有变！？

因为要 开一个新的terminal 才会更新唷！

开新式窗后再输入一次就会看到我们刚刚修改的结果了。

这样就完成啰！

其实python3本身比较不会跟其他人打架

因为他就是独立的python3

所以我们主要是要确认是不是读到我们用brew装的python

which python

这时候看到

/usr/local/bin/python

再来看看python3 吧

which python3

应该会是

/usr/local/bin/python3

就代表读到刚刚装好的python啰！

当然如果你要跑系统本身的python

（应该是用不到啦～）

就输入

/usr/bin/python

总之就是…大功告成啰！

谢谢阅读！原文链接：

python2和python3的差异

如果你是一个初学者，或许你曾经触摸过其他的编程言语，你可能不知道，在开端学习python的时分都会遇到一个比较让人很头疼的问题：版别问题！！是学习python2 仍是学习 python3 ？这是十分让人纠结的！

查找一下便会发现python3 和 python2 是不兼容的，并且差异比较大，究竟学习哪个版别呢？

所以先学 Python2 仍是 Python3 都不是问题，或许说都是问题。可是现在总算不必纠结这个问题了！哈哈，好开心

因为一个开发者已经发布了一个网站来倒计时Python 2.7的“退休”。

能够看出，Python 2.7有望在两年后退休。

开发商表明，因为官方的日期没有发布，估计Python 2.7会在2020年4月12日退休，这是时刻的时分，pycon将举办。

Python 2，感谢您多年的忠诚服务。

巨蟒3，现在你在舞台上。

Python 2.7是2 x系列的最终一个版别。它的继任者Python 3在2008年12月发布，但它与2。X系列不兼容。3的3的特征和语法被移植回2.6和2.7。2.7的支撑时刻至少为10年，并将在2020之前供给过错批改。

怎么转换为Python 3？

如果您的主代码仍然根据Python 2，这是完全能够了解的。最流行的包PyPI上现在能够运转在Python 2和Python 3，添加更多的日常。为了简化转换，官方搬迁指南供给了在Python 3中运转Python 2代码的主张。

所以我主张：

1. 如果是你在企业中，需求用到python而学习python的话，那就要看企业的使用python的版别进行学习；

2. 如果想要更多的老练解决方案，最少的bug，最安稳的使用那就用python2 ；

3. 如果你是在读大学的学生，那我主张你学习python3，比及结业的时分或许python已经成为了干流。

另外，选2仍是3一般都是编程小白才会考虑。考虑的起点是作为一个初学者，有时候在学习的过程中会出现一些问题或者会参考一些项目去学习，这个时候会想一下，2是干流或者是3。已然刚学何不找个干流的。其实不管是2仍是3，只需照这一个学，就可以了。中心的差异在学习的时候也能更好的去加深一些形象