View page source
Next
Docs » Python 入门指南
Python 入门指南
Release:
3.6.0
Date:
Feb 18, 2017
Python 是一门简单易学且功能强大的编程语言。它拥有高效的高级数据结构，并且能够用简单而又高效的
方式进行面向对象编程。Python 优雅的语法和动态类型，再结合它的解释性，使其在大多数平台的许多领
域成为编写脚本或开发应用程序的理想语言。
你可以自由地从 Python 官方点: http://www.python.org，以源代码或二进制形式获取 Python 解释器及其标
准扩展库，并可以自由的分发。此站点同时也提供了大量的第三方 Python 模块、程序和工具，及其附加文
档。
你可以很容易的使用 C 或 C++（其他可以通过 C 调用的语言）为 Python 解释器扩展新函数和数据类型。
Python 还可以被用作定制应用程序的一门扩展语言。
本手册非正式的向读者介绍了 Python 语言及其体系相关的基本知识与概念。在学习实践中结合使用
Python 解释器是很有帮助的，不过所有的例子都是完整的，所以本手册亦可离线阅读。
如果需要了解相关标准库或对象的详细介绍，请查阅 Python 参考文档 。Python 参考手册 提供了更多语言
相关的正式说明。如果想要使用 C 或 C++ 编写扩展，请查阅 Python 解释器扩展和集成章节 和 C API 参考
手册 。当然也可阅读一些深入介绍 Python 知识的图书。
本手册不会尝试涵盖 Python 的全部知识和每个特性，甚至不会涵盖所有常用的特性。相反地，它介绍了
Python 中许多最引人瞩目的特性，并且会给你一个关于语言特色和风格的认识。读完之后，你将能够阅读
和编写 Python 模块或程序，并为以后使用 Python 参考手册 继续学习诸多 Python 模块库做好准备。
词汇表 也值得浏览一下。
1. 开胃菜
2. 使用 Python 解释器
2.1. 调用 Python 解释器
2.1.1. 参数传递
2.1.2. 交互模式
2.2. 解释器及其环境
2.2.1. 源程序编码
3. Python 简介
3.1. 将 Python 当做计算器
3.1.1. 数字
3.1.2. 字符串
3.1.3. 列表
3.2. 编程的第一步
4. 深入 Python 流程控制
4.1. if 语句
4.2. for 语句
4.3. range() 函数
4.4. break 和 continue 语句, 以及循环中的 else 子句
4.5. pass 语句
4.6. 定义函数
4.7. 深入 Python 函数定义
4.7.1. 默认参数值
4.7.2. 关键字参数
4.7.3. 可变参数列表
4.7.4. 参数列表的分拆
4.7.5. Lambda 形式
4.7.6. 文档字符串
4.7.7. 函数注解
4.8. 插曲：编码风格
5. 数据结构
5.1. 关于列表更多的内容
5.1.1. 把列表当作堆栈使用
5.1.2. 把列表当作队列使用
5.1.3. 列表推导式
5.1.4. 嵌套的列表推导式
5.2. del 语句
5.3. 元组和序列
5.4. 集合
5.5. 字典
5.6. 循环技巧
5.7. 深入条件控制
5.8. 比较序列和其它类型
6. 模块
6.1. 深入模块
6.1.1. 作为脚本来执行模块
6.1.2. 模块的搜索路径
6.1.3. “编译的” Python 文件
6.2. 标准模块
6.3. dir() 函数
6.4. 包
6.4.1. 从 * 导入包
6.4.2. 包内引用
6.4.3. 多重目录中的包
7. 输入和输出
7.1. 格式化输出
7.1.1. 旧式的字符串格式化
7.2. 文件读写
7.2.1. 文件对象方法
7.2.2. 使用 json 存储结构化数据
8. 错误和异常
8.1. 语法错误
8.2. 异常
8.3. 异常处理
8.4. 抛出异常
8.5. 用户自定义异常
8.6. 定义清理行为
8.7. 预定义清理行为
9. 类
9.1. 术语相关
9.2. Python 作用域和命名空间
9.2.1. 作用域和命名空间示例
9.3. 初识类
9.3.1. 类定义语法
9.3.2. 类对象
9.3.3. 实例对象
9.3.4. 方法对象
9.3.5. 类和实例变量
9.4. 一些说明
9.5. 继承
9.5.1. 多继承
9.6. 私有变量
9.7. 补充
9.8. 异常也是类
9.9. 迭代器
9.10. 生成器
9.11. 生成器表达式
10. Python 标准库概览
10.1. 操作系统接口
10.2. 文件通配符
10.3. 命令行参数
10.4. 错误输出重定向和程序终止
10.5. 字符串正则匹配
10.6. 数学
10.7. 互联网访问
10.8. 日期和时间
10.9. 数据压缩
10.10. 性能度量
10.11. 质量控制
10.12. “瑞士军刀”
11. 标准库浏览 – Part II
11.1. 输出格式
11.2. 模板
11.3. 使用二进制数据记录布局
11.4. 多线程
11.5. 日志
11.6. 弱引用
11.7. 列表工具
11.8. 十进制浮点数算法
12. 虚拟环境和包
12.1. 简介
12.2. 创建虚拟环境
12.3. 使用 pip 管理包
13. 接下来？
14. 交互式输入行编辑历史回溯
14.1. Tab 补全和历史记录
14.2. 其它交互式解释器
15. 浮点数算法：争议和限制
15.1. 表达错误
16. 附录
16.1. 交互模式
16.1.1. 错误处理
16.1.2. 可执行 Python 脚本
16.1.3. 交互式启动文件
16.1.4. 定制模块
© Copyright 2013, D.D.
Built with Sphinx using a theme provided by Read the Docs.
Python tutorial
View page source
Next
Docs » 1. 开胃菜
1. 开胃菜
如果你要用计算机做很多工作，最后你会发现有一些任务你更希望用自动化的方式进行处理。比如，你想
要在大量的文本文件中执行查找/替换，或者以复杂的方式对大量的图片进行重命名和整理。也许你想要编
写一个小型的自定义数据库、一个特殊的 GUI 应用程序或一个简单的小游戏。
如果你是一名专业的软件开发者，可能你必须使用几种 C/C++/JAVA 类库，并且发现通常编写/编译/测试/
重新编译的周期是如此漫长。也许你正在为这些类库编写测试用例，但是发现这是一个让人烦躁的工作。
又或者你已经完成了一个可以使用扩展语言的程序，但你并不想为此重新设计并实现一套全新的语言。
那么 Python 正是你所需要的语言。
虽然你能够通过编写 Unix shell 脚本或 Windows 批处理文件来处理其中的某些任务，但 Shell 脚本更适合移
动文件或修改文本数据，并不适合编写 GUI 应用程序或游戏；虽然你能够使用 C/C++/JAVA 编写程序，但
即使编写一个简单的 first-draft 程序也有可能耗费大量的开发时间。相比之下，Python 更易于使用，无论
在 Windows、Mac OS X 或 Unix 操作系统上它都会帮助你更快地完成任务。
虽然 Python 易于使用，但它却是一门完整的编程语言；与 Shell 脚本或批处理文件相比，它为编写大型程
序提供了更多的结构和支持。另一方面，Python 提供了比 C 更多的错误检查，并且作为一门 高级语言，它
内置支持高级的数据结构类型，例如：灵活的数组和字典。因其更多的通用数据类型，Python 比 Awk 甚至
Perl 都适用于更多问题领域，至少大多数事情在 Python 中与其他语言同样简单。
Python 允许你将程序分割为不同的模块，以便在其他的 Python 程序中重用。Python 内置提供了大量的标
准模块，你可以将其用作程序的基础，或者作为学习 Python 编程的示例。这些模块提供了诸如文件 I/O、
系统调用、Socket 支持，甚至类似 Tk 的用户图形界面（GUI）工具包接口。
Python 是一门解释型语言，因为无需编译和链接，你可以在程序开发中节省宝贵的时间。Python 解释器可
以交互的使用，这使得试验语言的特性、编写临时程序或在自底向上的程序开发中测试方法非常容易。你
甚至还可以把它当做一个桌面计算器。
Python 让程序编写的紧凑和可读。用 Python 编写的程序通常比同样的 C、C++ 或 Java 程序更短小，这是
因为以下几个原因:
*高级数据结构使你可以在一条语句中表达复杂的操作；
*语句组使用缩进代替开始和结束大括号来组织；
*变量或参数无需声明。
Python 是 可扩展 的：如果你会 C 语言编程便可以轻易地为解释器添加内置函数或模块，或者为了对性能
瓶颈作优化，或者将 Python 程序与只有二进制形式的库（比如某个专业的商业图形库）连接起来。一旦你
真正掌握了它，你可以将 Python 解释器集成进某个 C 应用程序，并把它当作那个程序的扩展或命令行语
言。
顺便说一句，这个语言的名字来自于 BBC 的 “Monty Python’s Flying Cirecus” 节目，和爬行类动物没有任
何关系。在文档中引用 Monty Python 的典故不仅可行，而且值得鼓励！
现在你已经为 Python 兴奋不已了吧，大概想要领略一些更多的细节！学习一门语言最好的方法就是使用
它，本指南推荐你边读边使用 Python 解释器练习。
下一节中，我们将解释 Python 解释器的用法。这是很简单的一件事情，但它有助于试验后面的例子。
本手册剩下的部分将通过示例介绍 Python 语言及系统的诸多特性，开始是简单的语法、数据类型和表达
式，接着介绍函数与模块，最后涉及异常和自定义类这样的高级内容。
Previous
© Copyright 2013, D.D.
Built with Sphinx using a theme provided by Read the Docs.
Python tutorial
View page source
Next
Docs » 2. 使用 Python 解释器
2. 使用 Python 解释器
2.1. 调用 Python 解释器
Python 解释器通常被安装在目标机器的 /usr/local/bin/python3.5 目录下。将
/usr/local/bin 目录包含进
Unix shell 的搜索路径里，以确保可以通过输入:
python3.5
命令来启动他。
[1]
由于 Python 解释器的安装路径是可选的，这也可能是其它路径，你可以联系安装
Python 的用户或系统管理员确认（例如，
/usr/local/python 就是一个常见的选择）。
在 Windows 机器上，Python 通常安装在
C:\Python35 位置，当然你可以在运行安装向导时修改此值。要想
把此目录添加到你的 PATH 环境变量中，你可以在 DOS 窗口中输入以下命令:
setpath=%path%;C:\python35
通常你可以在主窗口输入一个文件结束符（Unix 系统是
Control‐D ，Windows 系统是
Control‐Z ）让解释
器以 0 状态码退出。如果那没有作用，你可以通过输入
quit() 命令退出解释器。
Python 解释器具有简单的行编辑功能。在 Unix 系统上，任何 Python 解释器都可能已经添加了 GNU
readline 库支持，这样就具备了精巧的交互编辑和历史记录等功能。在 Python 主窗口中输入 Control-P 可
能是检查是否支持命令行编辑的最简单的方法。如果发出嘟嘟声（计算机扬声器），则说明你可以使用命
令行编辑功能；更多快捷键的介绍请参考 交互式输入行编辑历史回溯。如果没有任何声音，或者显示
^P
字符，则说明命令行编辑功能不可用；你只能通过退格键从当前行删除已键入的字符并重新输入。
Python 解释器有些操作类似 Unix shell：当使用终端设备（tty）作为标准输入调用时，它交互的解释并执
行命令；当使用文件名参数或以文件作为标准输入调用时，它读取文件并将文件作为 脚本 执行。
第二种启动 Python 解释器的方法是
python‐ccommand[arg]... ，这种方法可以在 命令行 执行 Python 语
句，类似于 shell 中的 -c 选项。由于 Python 语句通常会包含空格或其他特殊 shell 字符，一般建议将 命令
用单引号包裹起来。
有一些 Python 模块也可以当作脚本使用。你可以使用
python‐mmodule[arg]... 命令调用它们，这类似在
命令行中键入完整的路径名执行 模块 源文件一样。
使用脚本文件时，经常会运行脚本然后进入交互模式。这也可以通过在脚本之前加上 -i 参数来实现。
2.1.1. 参数传递
调用解释器时，脚本名和附加参数传入一个名为
sys.argv 的字符串列表。你能够获取这个列表通过执行
importsys ，列表的长度大于等于1；没有给定脚本和参数时，它至少也有一个元素：
sys.argv[0] 此时为
空字符串。脚本名指定为
'‐' （表示标准输入）时，
sys.argv[0] 被设定为
'‐' ，使用 -c 指令
时，
sys.argv[0] 被设定为
'‐c' 。使用 -m 模块 参数时，
sys.argv[0] 被设定为指定模块的全名。-c 指令 或
者 -m 模块 之后的参数不会被 Python 解释器的选项处理机制所截获，而是留在
sys.argv 中，供脚本命令操
作。
2.1.2. 交互模式
从 tty 读取命令时，我们称解释器工作于 交互模式。这种模式下它根据主提示符来执行，主提示符通常标
识为三个大于号(
>>> )；继续的部分被称为 从属提示符，由三个点标识(
... )。在第一行之前，解释器打印
欢迎信息、版本号和授权提示:
$python3.5
Python3.5.2(default,Mar162014,09:25:04)
[GCC4.8.2]onlinux
Type"help","copyright","credits"or"license"formoreinformation.
>>>
输入多行结构时需要从属提示符了，例如，下面这个 if 语句:
>>>the_world_is_flat=1
>>>ifthe_world_is_flat:
...print("Becarefulnottofalloff!")
...
Becarefulnottofalloff!
关于交互模式更多的内容，请参见 交互模式。
2.2. 解释器及其环境
2.2.1. 源程序编码
默认情况下，Python 源文件是 UTF-8 编码。在此编码下，全世界大多数语言的字符可以同时用在字符串、
标识符和注释中 — 尽管 Python 标准库仅使用 ASCII 字符做为标识符，这只是任何可移植代码应该遵守的约
定。如果要正确的显示所有的字符，你的编辑器必须能识别出文件是 UTF-8 编码，并且它使用的字体能支
持文件中所有的字符。
你也可以为源文件指定不同的字符编码。为此，在
#! 行（首行）后插入至少一行特殊的注释行来定义源
文件的编码:
#‐*‐coding:encoding‐*‐
通过此声明，源文件中所有的东西都会被当做用 encoding 指代的 UTF-8 编码对待。在 Python 库参考手册
codecs 一节中你可以找到一张可用的编码列表。
例如，如果你的编辑器不支持 UTF-8 编码的文件，但支持像 Windows-1252 的其他一些编码，你可以定义:
#‐*‐coding:cp‐1252‐*‐
这样就可以在源文件中使用 Windows-1252 字符集中的所有字符了。这个特殊的编码注释必须在文件中的
第一或第二 行定义。
Footnotes
[1] 在 Unix 系统上，Python 3.X 解释器默认未被安装成名为
python 的命令，所以它不会与同时安装在系统中的
Python 2.x 命令冲突。
Previous
© Copyright 2013, D.D.
Built with Sphinx using a theme provided by Read the Docs.
Python tutorial
View page source
Next
Docs » 3. Python 简介
3. Python 简介
下面的例子中，输入和输出分别由大于号和句号提示符（ >>> 和 ... ）标注：如果想重现这些例子，就要
在解释器的提示符后，输入（提示符后面的）那些不包含提示符的代码行。需要注意的是在练习中遇到的
从属提示符表示你需要在最后多输入一个空行，解释器才能知道这是一个多行命令的结束。
本手册中的很多示例——包括那些带有交互提示符的——都含有注释。Python 中的注释以 # 字符起始，直
至实际的行尾（译注——这里原作者用了 physical line 以表示实际的换行而非编辑器的自动换行）。注释可
以从行首开始，也可以在空白或代码之后，但是不出现在字符串中。文本字符串中的 # 字符仅仅表示 #
。代码中的注释不会被 Python 解释，录入示例的时候可以忽略它们。
如下示例:
#thisisthefirstcomment
spam=1#andthisisthesecondcomment
#...andnowathird!
text="#Thisisnotacommentbecauseit'sinsidequotes."
3.1. 将 Python 当做计算器
我们来尝试一些简单的 Python 命令。启动解释器然后等待主提示符 >>> 出现（不需要很久）。
3.1.1. 数字
解释器表现得就像一个简单的计算器：可以向其录入一些表达式，它会给出返回值。表达式语法很直白：
运算符 + ， ‐ ， * 和 / 与其它语言一样(例如：Pascal 或 C)；括号 ( () ) 用于分组。例如:
>>>2+2
4
>>>50‐5*6
20
>>>(50‐5*6)/4
5.0
>>>8/5#divisionalwaysreturnsafloatingpointnumber
1.6
整数(例如， 2 ， 4 ， 20 )的类型是 int，带有小数部分的数字(例如， 5.0 ， 1.6 )的类型是 float。在本教
程的后面我们会看到更多关于数字类型的内容。
除法( / )永远返回一个浮点数。如要使用 floor 除法 并且得到整数结果（丢掉任何小数部分），你可以使用
// 运算符；要计算余数你可以使用 %
>>>17/3#classicdivisionreturnsafloat
5.666666666666667
>>>
>>>17//3#floordivisiondiscardsthefractionalpart
5
>>>17%3#the%operatorreturnstheremainderofthedivision
2
>>>5*3+2#result*divisor+remainder
17
通过 Python，还可以使用 ** 运算符计算幂乘方
[1]
:
>>>5**2#5squared
25
>>>2**7#2tothepowerof7
128
等号( '=' )用于给变量赋值。赋值之后，在下一个提示符之前不会有任何结果显示:
>>>width=20
>>>height=5*9
>>>width*height
900
变量在使用前必须 “定义”(赋值)，否则会出错:
>>>#trytoaccessanundefinedvariable
...n
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
NameError:name'n'isnotdefined
浮点数有完整的支持；整数和浮点数的混合计算中，整数会被转换为浮点数:
>>>3*3.75/1.5
7.5
>>>7.0/2
3.5
交互模式中，最近一个表达式的值赋给变量 _ 。这样我们就可以把它当作一个桌面计算器，很方便的用于
连续计算，例如:
>>>tax=12.5/100
>>>price=100.50
>>>price*tax
12.5625
>>>price+_
113.0625
>>>round(_,2)
113.06
此变量对于用户是只读的。不要尝试给它赋值 —— 你只会创建一个独立的同名局部变量，它屏蔽了系统内
置变量的魔术效果。
除了 int 和 float，Python 还支持其它数字类型，例如 Decimal 和 Fraction。Python 还内建支持 复数 ，使用
后缀 j 或 J 表示虚数部分（例如， 3+5j ）。
3.1.2. 字符串
相比数值，Python 也提供了可以通过几种不同方式表示的字符串。它们可以用单引号 ( '...' ) 或双引号
( "..." ) 标识
[2]
。 \ 可以用来转义引号:
>>>'spameggs'#singlequotes
'spameggs'
>>>'doesn\'t'#use\'toescapethesinglequote...
"doesn't"
>>>"doesn't"#...orusedoublequotesinstead
"doesn't"
>>>'"Yes,"hesaid.'
'"Yes,"hesaid.'
>>>"\"Yes,\"hesaid."
'"Yes,"hesaid.'
>>>'"Isn\'t,"shesaid.'
'"Isn\'t,"shesaid.'
在交互式解释器中，输出的字符串会用引号引起来，特殊字符会用反斜杠转义。虽然可能和输入看上去不
太一样，但是两个字符串是相等的。如果字符串中只有单引号而没有双引号，就用双引号引用，否则用单
引号引用。print() 函数生成可读性更好的输出, 它会省去引号并且打印出转义后的特殊字符：
>>>'"Isn\'t,"shesaid.'
'"Isn\'t,"shesaid.'
>>>print('"Isn\'t,"shesaid.')
"Isn't,"shesaid.
>>>s='Firstline.\nSecondline.'#\nmeansnewline
>>>s#withoutprint(),\nisincludedintheoutput
'Firstline.\nSecondline.'
>>>print(s)#withprint(),\nproducesanewline
Firstline.
Secondline.
如果你前面带有 \ 的字符被当作特殊字符，你可以使用 原始字符串，方法是在第一个引号前面加上一个
r :
>>>print('C:\some\name')#here\nmeansnewline!
C:\some
ame
>>>print(r'C:\some\name')#notetherbeforethequote
C:\some\name
字符串文本能够分成多行。一种方法是使用三引号： """...""" 或者 '''...''' 。行尾换行符会被自动包含
到字符串中，但是可以在行尾加上 \ 来避免这个行为。下面的示例： 可以使用反斜杠为行结尾的连续字符
串，它表示下一行在逻辑上是本行的后续内容:
print("""\
Usage:thingy[OPTIONS]
‐hDisplaythisusagemessage
‐HhostnameHostnametoconnectto
""")
将生成以下输出（注意，没有开始的第一行）:
Usage:thingy[OPTIONS]
‐hDisplaythisusagemessage
‐HhostnameHostnametoconnectto
字符串可以由 + 操作符连接(粘到一起)，可以由 * 表示重复:
>>>#3times'un',followedby'ium'
>>>3*'un'+'ium'
'unununium'
相邻的两个字符串文本自动连接在一起。:
>>>'Py''thon'
'Python'
它只用于两个字符串文本，不能用于字符串表达式:
>>>prefix='Py'
>>>prefix'thon'#can'tconcatenateavariableandastringliteral
...
SyntaxError:invalidsyntax
>>>('un'*3)'ium'
...
SyntaxError:invalidsyntax
如果你想连接多个变量或者连接一个变量和一个字符串文本，使用 + :
>>>prefix+'thon'
'Python'
这个功能在你想切分很长的字符串的时候特别有用:
>>>text=('Putseveralstringswithinparentheses'
'tohavethemjoinedtogether.')
>>>text
'Putseveralstringswithinparenthesestohavethemjoinedtogether.'
字符串也可以被截取(检索)。类似于 C ，字符串的第一个字符索引为 0 。Python没有单独的字符类型；一
个字符就是一个简单的长度为1的字符串。:
>>>word='Python'
>>>word[0]#characterinposition0
'P'
>>>word[5]#characterinposition5
'n'
索引也可以是负数，这将导致从右边开始计算。例如:
>>>word[‐1]#lastcharacter
'n'
>>>word[‐2]#second‐lastcharacter
'o'
>>>word[‐6]
'P'
请注意 -0 实际上就是 0，所以它不会导致从右边开始计算。
除了索引，还支持 切片。索引用于获得单个字符，切片 让你获得一个子字符串:
>>>word[0:2]#charactersfromposition0(included)to2(excluded)
'Py'
>>>word[2:5]#charactersfromposition2(included)to5(excluded)
'tho'
注意，包含起始的字符，不包含末尾的字符。这使得 s[:i]+s[i:] 永远等于 s :
>>>word[:2]+word[2:]
'Python'
>>>word[:4]+word[4:]
'Python'
切片的索引有非常有用的默认值；省略的第一个索引默认为零，省略的第二个索引默认为切片的字符串的
大小。:
>>>word[:2]#characterfromthebeginningtoposition2(excluded)
'Py'
>>>word[4:]#charactersfromposition4(included)totheend
'on'
>>>word[‐2:]#charactersfromthesecond‐last(included)totheend
'on'
有个办法可以很容易地记住切片的工作方式：切片时的索引是在两个字符 之间 。左边第一个字符的索引为
0，而长度为 n 的字符串其最后一个字符的右界索引为 n。例如:
+‐‐‐+‐‐‐+‐‐‐+‐‐‐+‐‐‐+‐‐‐+
|P|y|t|h|o|n|
+‐‐‐+‐‐‐+‐‐‐+‐‐‐+‐‐‐+‐‐‐+
0123456
‐6‐5‐4‐3‐2‐1
文本中的第一行数字给出字符串中的索引点 0...6。第二行给出相应的负索引。切片是从 i 到 j 两个数值标示
的边界之间的所有字符。
对于非负索引，如果上下都在边界内，切片长度就是两个索引之差。例如， word[1:3] 是 2 。
试图使用太大的索引会导致错误:
>>>word[42]#thewordonlyhas6characters
Traceback(mostrecentcalllast):
File"<stdin>",line1,in<module>
IndexError:stringindexoutofrange
Python 能够优雅地处理那些没有意义的切片索引：一个过大的索引值(即下标值大于字符串实际长度)将被
字符串实际长度所代替，当上边界比下边界大时(即切片左值大于右值)就返回空字符串:
>>>word[4:42]
'on'
>>>word[42:]
''
Python字符串不可以被更改 — 它们是 不可变的 。因此，赋值给字符串索引的位置会导致错误:
>>>word[0]='J'
...
TypeError:'str'objectdoesnotsupportitemassignment
>>>word[2:]='py'
...
TypeError:'str'objectdoesnotsupportitemassignment
如果你需要一个不同的字符串，你应该创建一个新的:
>>>'J'+word[1:]
'Jython'
>>>word[:2]+'py'
'Pypy'
内置函数 len() 返回字符串长度:
>>>s='supercalifragilisticexpialidocious'
>>>len(s)
34
See also
Text Sequence Type — str
字符串是 序列类型 的例子，它们支持这种类型共同的操作。
String Methods
字符串和Unicode字符串都支持大量的方法用于基本的转换和查找。
String Formatting
这里描述了使用 str.format() 进行字符串格式化的信息。
String Formatting Operations
这里描述了旧式的字符串格式化操作，它们在字符串和Unicode字符串是 % 操作符的左操作数时调
用。
3.1.3. 列表
Python 有几个 复合 数据类型，用于表示其它的值。最通用的是 list (列表) ，它可以写作中括号之间的一列
逗号分隔的值。列表的元素不必是同一类型:
>>>squares=[1,4,9,16,25]
>>>squares
[1,4,9,16,25]
就像字符串(以及其它所有内建的 序列 类型)一样，列表可以被索引和切片:
>>>squares[0]#indexingreturnstheitem
1
>>>squares[‐1]
25
>>>squares[‐3:]#slicingreturnsanewlist
[9,16,25]
所有的切片操作都会返回一个包含请求的元素的新列表。这意味着下面的切片操作返回列表一个新的
（浅）拷贝副本:
>>>squares[:]
[1,4,9,16,25]
列表也支持连接这样的操作:
>>>squares+[36,49,64,81,100]
[1,4,9,16,25,36,49,64,81,100]
不像 不可变的 字符串，列表是 可变的，它允许修改元素:
>>>cubes=[1,8,27,65,125]#something'swronghere
>>>4**3#thecubeof4is64,not65!
64
>>>cubes[3]=64#replacethewrongvalue
>>>cubes
[1,8,27,64,125]
你还可以使用 append() 方法 （后面我们会看到更多关于列表的方法的内容）在列表的末尾添加新的元素:
>>>cubes.append(216)#addthecubeof6
>>>cubes.append(7**3)#andthecubeof7
>>>cubes
[1,8,27,64,125,216,343]
也可以对切片赋值，此操作可以改变列表的尺寸，或清空它:
>>>letters=['a','b','c','d','e','f','g']
>>>letters
['a','b','c','d','e','f','g']
>>>#replacesomevalues
>>>letters[2:5]=['C','D','E']
>>>letters
['a','b','C','D','E','f','g']
>>>#nowremovethem
>>>letters[2:5]=[]
>>>letters
['a','b','f','g']
>>>#clearthelistbyreplacingalltheelementswithanemptylist
>>>letters[:]=[]
>>>letters
[]
内置函数 len() 同样适用于列表:
>>>letters=['a','b','c','d']
>>>len(letters)
4
允许嵌套列表(创建一个包含其它列表的列表)，例如:
>>>a=['a','b','c']
>>>n=[1,2,3]
>>>x=[a,n]
>>>x
[['a','b','c'],[1,2,3]]
>>>x[0]
['a','b','c']
>>>x[0][1]
'b'
3.2. 编程的第一步
当然，我们可以使用 Python 完成比二加二更复杂的任务。例如，我们可以写一个生成 菲波那契 子序列的
程序，如下所示:
>>>#Fibonacciseries:
...#thesumoftwoelementsdefinesthenext
...a,b=0,1
>>>whileb<10:
...print(b)
...a,b=b,a+b
...
1
1
2
3
5
8
这个例子介绍了几个新功能。
第一行包括了一个 多重赋值：变量 a 和 b 同时获得了新的值 0 和 1 最后一行又使用了一次。
在这个演示中，变量赋值前，右边首先完成计算。右边的表达式从左到右计算。
条件（这里是 b<10 ）为 true 时， while 循环执行。在 Python 中，类似于 C，任何非零整数都是
true；0 是 false。条件也可以是字符串或列表，实际上可以是任何序列；
所有长度不为零的是 true，空序列是 false。示例中的测试是一个简单的比较。标准比较操作符与 C 相
同： < ， > ， == ， <= ， >= 和 != 。
循环 体 是 缩进 的：缩进是 Python 组织语句的方法。Python (还)不提供集成的行编辑功能，所以你要
为每一个缩进行输入 TAB 或空格。
实践中建议你找个文本编辑来录入复杂的 Python 程序，大多数文本编辑器提供自动缩进。交互式录入
复合语句时，必须在最后输入一个空行来标识结束（因为解释器没办法猜测你输入的哪一行是最后一
行），需要 注意的是同一个语句块中的每一行必须缩进同样数量的空白。
关键字 print() 语句输出给定表达式的值。它控制多个表达式和字符串输出为你想要字符串（就像我们在
前面计算器的例子中那样）。
字符串打印时不用引号包围，每两个子项之间插入空间，所以你可以把格式弄得很漂亮，像这样:
>>>i=256*256
>>>print('Thevalueofiis',i)
Thevalueofiis65536
用一个逗号结尾就可以禁止输出换行:
>>>a,b=0,1
>>>whileb<1000:
...print(b,end=',')
...a,b=b,a+b
...
1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,
Footnotes
[1] 因为 ** 的优先级高于 ‐ ，所以 ‐3**2 将解释为 ‐(3**2) 且结果为 ‐9 。为了避免这点并得到 9 ，你可以使用
(‐3)**2 。
[2] 与其它语言不同，特殊字符例如 \n 在单引号( '...' )和双引号( "..." )中具有相同的含义。两者唯一的区别是在
单引号中，你不需要转义 " （但你必须转义 \' )，反之亦然。
Previous
© Copyright 2013, D.D.
Built with Sphinx using a theme provided by Read the Docs.
Python tutorial
View page source
Next
Docs » 4. 深入 Python 流程控制
4. 深入 Python 流程控制
除了前面介绍的 while 语句，Python 还从其它语言借鉴了一些流程控制功能，并有
所改变。
4.1. if 语句
也许最有名的是 if 语句。例如:
>>>x=int(input("Pleaseenteraninteger:"))
Pleaseenteraninteger:42
>>>ifx<0:
...x=0
...print('Negativechangedtozero')
...elifx==0:
...print('Zero')
...elifx==1:
...print('Single')
...else:
...print('More')
...
More
可能会有零到多个 elif 部分，else 是可选的。关键字 ‘elif‘ 是 ’else if’ 的缩写，这个可
以有效地避免过深的缩进。if ... elif ... elif ... 序列用于替代其它语言中的 switch 或
case 语句。
4.2. for 语句
Python 中的 for 语句和 C 或 Pascal 中的略有不同。通常的循环可能会依据一个等
差数值步进过程（如 Pascal），或由用户来定义迭代步骤和中止条件（如 C ），
Python 的 for 语句依据任意序列（链表或字符串）中的子项，按它们在序列中的顺
序来进行迭代。例如（没有暗指）：
>>>#Measuresomestrings:
...words=['cat','window','defenestrate']
>>>forwinwords:
...print(w,len(w))
...
cat3
window6
defenestrate12
在迭代过程中修改迭代序列不安全（只有在使用链表这样的可变序列时才会有这样
的情况）。如果你想要修改你迭代的序列（例如，复制选择项），你可以迭代它的
复本。使用切割标识就可以很方便的做到这一点:
>>>forwinwords[:]:#Loopoveraslicecopyoftheentirelist.
...iflen(w)>6:
...words.insert(0,w)
...
>>>words
['defenestrate','cat','window','defenestrate']
4.3. range() 函数
如果你需要一个数值序列，内置函数 range() 会很方便，它生成一个等差级数链表:
>>>foriinrange(5):
...print(i)
...
0
1
2
3
4
range(10) 生成了一个包含 10 个值的链表，它用链表的索引值填充了这个长度为
10 的列表，所生成的链表中不包括范围中的结束值。也可以让 range() 操作从另一
个数值开始，或者可以指定一个不同的步进值（甚至是负数，有时这也被称为 “步
长”）:
range(5,10)
5through9
range(0,10,3)
0,3,6,9
range(‐10,‐100,‐30)
‐10,‐40,‐70
需要迭代链表索引的话，如下所示结合使 用 range() 和 len()
>>>a=['Mary','had','a','little','lamb']
>>>foriinrange(len(a)):
...print(i,a[i])
...
0Mary
1had
2a
3little
4lamb
不过，这种场合可以方便的使用 enumerate()，请参见 循环技巧。
如果你只是打印一个序列的话会发生奇怪的事情:
>>>print(range(10))
range(0,10)
在不同方面 range() 函数返回的对象表现为它是一个列表，但事实上它并不是。当
你迭代它时，它是一个能够像期望的序列返回连续项的对象；但为了节省空间，它
并不真正构造列表。
我们称此类对象是 可迭代的，即适合作为那些期望从某些东西中获得连续项直到结
束的函数或结构的一个目标（参数）。我们已经见过的 for 语句就是这样一个迭代
器。list() 函数是另外一个（ 迭代器 ），它从可迭代（对象）中创建列表:
>>>list(range(5))
[0,1,2,3,4]
稍后我们会看到更多返回可迭代（对象）和以可迭代（对象）作为参数的函数。
4.4. break 和 continue 语句, 以及循环中的 else 子句
break 语句和 C 中的类似，用于跳出最近的一级 for 或 while 循环。
循环可以有一个
else 子句；它在循环迭代完整个列表（对于 for ）或执行条件为
false （对于 while ）时执行，但循环被 break 中止的情况下不会执行。以下搜索素
数的示例程序演示了这个子句:
>>>forninrange(2,10):
...forxinrange(2,n):
...ifn%x==0:
...print(n,'equals',x,'*',n//x)
...break
...else:
...#loopfellthroughwithoutfindingafactor
...print(n,'isaprimenumber')
...
2isaprimenumber
3isaprimenumber
4equals2*2
5isaprimenumber
6equals2*3
7isaprimenumber
8equals2*4
9equals3*3
(Yes, 这是正确的代码。看仔细：
else 语句是属于 for 循环之中， 不是 if 语句。)
与循环一起使用时，
else 子句与 try 语句的
else 子句比与 if 语句的具有更多的共
同点：try 语句的
else 子句在未出现异常时运行，循环的
else 子句在未出现
break 时运行。更多关于 try 语句和异常的内容，请参见 异常处理。
continue 语句是从 C 中借鉴来的，它表示循环继续执行下一次迭代:
>>>fornuminrange(2,10):
...ifnum%2==0:
...print("Foundanevennumber",num)
...continue
...print("Foundanumber",num)
Foundanevennumber2
Foundanumber3
Foundanevennumber4
Foundanumber5
Foundanevennumber6
Foundanumber7
Foundanevennumber8
Foundanumber9
4.5. pass 语句
pass 语句什么也不做。它用于那些语法上必须要有什么语句，但程序什么也不做的
场合，例如:
>>>whileTrue:
...pass#Busy‐waitforkeyboardinterrupt(Ctrl+C)
...
这通常用于创建最小结构的类:
>>>classMyEmptyClass:
...pass
...
另一方面，pass 可以在创建新代码时用来做函数或控制体的占位符。可以让你在更
抽象的级别上思考。pass 可以默默的被忽视:
>>>definitlog(*args):
...pass#Remembertoimplementthis!
...
4.6. 定义函数
我们可以创建一个用来生成指定边界的斐波那契数列的函数:
>>>deffib(n):#writeFibonacciseriesupton
..."""PrintaFibonacciseriesupton."""
...a,b=0,1
...whilea<n:
...print(a,end='')
...a,b=b,a+b
...print()
...
>>>#Nowcallthefunctionwejustdefined:
...fib(2000)
011235813213455891442333776109871597
关键字 def 引入了一个函数 定义。在其后必须跟有函数名和包括形式参数的圆括
号。函数体语句从下一行开始，必须是缩进的。
函数体的第一行语句可以是可选的字符串文本，这个字符串是函数的文档字符串，
或者称为 docstring。（更多关于 docstrings 的信息请参考 文档字符串） 有些工具
通过 docstrings 自动生成在线的或可打印的文档，或者让用户通过代码交互浏览；
在你的代码中包含 docstrings 是一个好的实践，让它成为习惯吧。
函数 调用 会为函数局部变量生成一个新的符号表。确切的说，所有函数中的变量
赋值都是将值存储在局部符号表。变量引用首先在局部符号表中查找，然后是包含
函数的局部符号表，然后是全局符号表，最后是内置名字表。因此，全局变量不能
在函数中直接赋值（除非用 global 语句命名），尽管他们可以被引用。
函数引用的实际参数在函数调用时引入局部符号表，因此，实参总是 传值调用
（这里的 值 总是一个对象 引用 ，而不是该对象的值）。
[1]
一个函数被另一个函数
调用时，一个新的局部符号表在调用过程中被创建。
一个函数定义会在当前符号表内引入函数名。函数名指代的值（即函数体）有一个
被 Python 解释器认定为 用户自定义函数 的类型。 这个值可以赋予其他的名字（即
变量名），然后它也可以被当做函数使用。这可以作为通用的重命名机制:
>>>fib
<functionfibat10042ed0>
>>>f=fib
>>>f(100)
01123581321345589
如果你使用过其他语言，你可能会反对说：
fib 不是一个函数，而是一个方法，因
为它并不返回任何值。事实上，没有 return 语句的函数确实会返回一个值，虽然是
一个相当令人厌烦的值（指 None ）。这个值被称为
None （这是一个内建名
称）。如果
None 值是唯一被书写的值，那么在写的时候通常会被解释器忽略（即
不输出任何内容）。如果你确实想看到这个值的输出内容，请使用 print() 函数:
>>>fib(0)
>>>print(fib(0))
None
定义一个返回斐波那契数列数字列表的函数，而不是打印它，是很简单的:
>>>deffib2(n):#returnFibonacciseriesupton
..."""ReturnalistcontainingtheFibonacciseriesupton."""
...result=[]
...a,b=0,1
...whilea<n:
...result.append(a)#seebelow
...a,b=b,a+b
...returnresult
...
>>>f100=fib2(100)#callit
>>>f100#writetheresult
[0,1,1,2,3,5,8,13,21,34,55,89]
和以前一样，这个例子演示了一些新的 Python 功能：
return 语句从函数中返回一个值，不带表达式的 return 返回
None 。
过程结束后也会返回
None 。
语句
result.append(b) 称为链表对象
result 的一个 方法。方法是一个“属于”某
个对象的函数，它被命名为
obj.methodename ，这里的
obj 是某个对象（可能是
一个表达式），
methodename 是某个在该对象类型定义中的方法的命名。
不同的类型定义不同的方法。不同类型可能有同样名字的方法，但不会混淆。
（当你定义自己的对象类型和方法时，可能会出现这种情况，class 的定义方法
详见 类 ）。示例中演示的
append() 方法由链表对象定义，它向链表中加入一
个新元素。在示例中它等同于
result=result+[a] ，不过效率更高。
4.7. 深入 Python 函数定义
在 Python 中，你也可以定义包含若干参数的函数。这里有三种可用的形式，也可
以混合使用。
4.7.1. 默认参数值
最常用的一种形式是为一个或多个参数指定默认值。这会创建一个可以使用比定义
时允许的参数更少的参数调用的函数，例如:
defask_ok(prompt,retries=4,complaint='Yesorno,please!'):
whileTrue:
ok=input(prompt)
ifokin('y','ye','yes'):
returnTrue
ifokin('n','no','nop','nope'):
returnFalse
retries=retries‐1
ifretries<0:
raiseOSError('uncooperativeuser')
print(complaint)
这个函数可以通过几种不同的方式调用:
只给出必要的参数:
ask_ok('Doyoureallywanttoquit?')
给出一个可选的参数:
ask_ok('OKtooverwritethefile?',2)
或者给出所有的参数:
ask_ok('OKtooverwritethefile?',2,'Comeon,onlyyesorno!')
这个例子还介绍了 in 关键字。它测定序列中是否包含某个确定的值。
默认值在函数 定义 作用域被解析，如下所示:
i=5
deff(arg=i):
print(arg)
i=6
f()
将会输出
5 。
重要警告: 默认值只被赋值一次。这使得当默认值是可变对象时会有所不同，比如
列表、字典或者大多数类的实例。例如，下面的函数在后续调用过程中会累积（前
面）传给它的参数:
deff(a,L=[]):
L.append(a)
returnL
print(f(1))
print(f(2))
print(f(3))
这将输出:
[1]
[1,2]
[1,2,3]
如果你不想让默认值在后续调用中累积，你可以像下面一样定义函数:
deff(a,L=None):
ifLisNone:
L=[]
L.append(a)
returnL
4.7.2. 关键字参数
函数可以通过 关键字参数 的形式来调用，形如
keyword=value 。例如，以下的函
数:
defparrot(voltage,state='astiff',action='voom',type='NorwegianBlue'):
print("‐‐Thisparrotwouldn't",action,end='')
print("ifyouput",voltage,"voltsthroughit.")
print("‐‐Lovelyplumage,the",type)
print("‐‐It's",state,"!")
接受一个必选参数 (
voltage ) 以及三个可选参数 (
state ,
action , 和
type )。可以用
以下的任一方法调用:
parrot(1000)#1positionalargument
parrot(voltage=1000)#1keywordargument
parrot(voltage=1000000,action='VOOOOOM')#2keywordarguments
parrot(action='VOOOOOM',voltage=1000000)#2keywordarguments
parrot('amillion','bereftoflife','jump')#3positionalarguments
parrot('athousand',state='pushingupthedaisies')#1positional,1keyword
不过以下几种调用是无效的:
parrot()#requiredargumentmissing
parrot(voltage=5.0,'dead')#non‐keywordargumentafterakeywordargument
parrot(110,voltage=220)#duplicatevalueforthesameargument
parrot(actor='JohnCleese')#unknownkeywordargument
在函数调用中，关键字的参数必须跟随在位置参数的后面。传递的所有关键字参数
必须与函数接受的某个参数相匹配 （例如
actor 不是
parrot 函数的有效参数），
它们的顺序并不重要。这也包括非可选参数（例如
parrot(voltage=1000) 也是有效
的）。任何参数都不可以多次赋值。下面的示例由于这种限制将失败:
>>>deffunction(a):
...pass
...
>>>function(0,a=0)
Traceback(mostrecentcalllast):
File"<stdin>",line1,in?
TypeError:function()gotmultiplevaluesforkeywordargument'a'
引入一个形如
**name 的参数时，它接收一个字典（参见 Mapping Types — dict
），该字典包含了所有未出现在形式参数列表中的关键字参数。这里可能还会组合
使用一个形如
*name （下一小节详细介绍） 的形式参数，它接收一个元组（下一
节中会详细介绍），包含了所有没有出现在形式参数列表中的参数值（
*name 必须
在
**name 之前出现）。 例如，我们这样定义一个函数:
defcheeseshop(kind,*arguments,**keywords):
print("‐‐Doyouhaveany",kind,"?")
print("‐‐I'msorry,we'realloutof",kind)
forarginarguments:
print(arg)
print("‐"*40)
keys=sorted(keywords.keys())
forkwinkeys:
print(kw,":",keywords[kw])
它可以像这样调用:
cheeseshop("Limburger","It'sveryrunny,sir.",
"It'sreallyvery,VERYrunny,sir.",
shopkeeper="MichaelPalin",
client="JohnCleese",
sketch="CheeseShopSketch")
当然它会按如下内容打印:
‐‐DoyouhaveanyLimburger?
‐‐I'msorry,we'realloutofLimburger
It'sveryrunny,sir.
It'sreallyvery,VERYrunny,sir.
‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐
client:JohnCleese
shopkeeper:MichaelPalin
sketch:CheeseShopSketch
注意在打印关键字参数之前，通过对关键字字典
keys() 方法的结果进行排序，生
成了关键字参数名的列表；如果不这样做，打印出来的参数的顺序是未定义的。
4.7.3. 可变参数列表
最后，一个最不常用的选择是可以让函数调用可变个数的参数。这些参数被包装进
一个元组（参见 元组和序列 ）。在这些可变个数的参数之前，可以有零到多个普
通的参数:
defwrite_multiple_items(file,separator,*args):
file.write(separator.join(args))
通常，这些
可变 参数是参数列表中的最后一个，因为它们将把所有的剩余输入参
数传递给函数。任何出现在
*args 后的参数是关键字参数，这意味着，他们只能被
用作关键字，而不是位置参数:
>>>defconcat(*args,sep="/"):
...returnsep.join(args)
...
>>>concat("earth","mars","venus")
'earth/mars/venus'
>>>concat("earth","mars","venus",sep=".")
'earth.mars.venus'
4.7.4. 参数列表的分拆
另有一种相反的情况: 当你要传递的参数已经是一个列表，但要调用的函数却接受
分开一个个的参数值。这时候你要把已有的列表拆开来。例如内建函数 range() 需
要要独立的 start，stop 参数。你可以在调用函数时加一个
* 操作符来自动把参数
列表拆开:
>>>list(range(3,6))#normalcallwithseparatearguments
[3,4,5]
>>>args=[3,6]
>>>list(range(*args))#callwithargumentsunpackedfromalist
[3,4,5]
以同样的方式，可以使用
** 操作符分拆关键字参数为字典:
>>>defparrot(voltage,state='astiff',action='voom'):
...print("‐‐Thisparrotwouldn't",action,end='')
...print("ifyouput",voltage,"voltsthroughit.",end='')
...print("E's",state,"!")
...
>>>d={"voltage":"fourmillion","state":"bleedin'demised","action":"VOOM"}
>>>parrot(**d)
‐‐Thisparrotwouldn'tVOOMifyouputfourmillionvoltsthroughit.E'sbleedin'd
emised!
4.7.5. Lambda 形式
出于实际需要，有几种通常在函数式编程语言例如 Lisp 中出现的功能加入到了
Python。通过 lambda 关键字，可以创建短小的匿名函数。这里有一个函数返回它
的两个参数的和： lambdaa,b:a+b 。 Lambda 形式可以用于任何需要的函数对
象。出于语法限制，它们只能有一个单独的表达式。语义上讲，它们只是普通函数
定义中的一个语法技巧。类似于嵌套函数定义，lambda 形式可以从外部作用域引
用变量:
>>>defmake_incrementor(n):
...returnlambdax:x+n
...
>>>f=make_incrementor(42)
>>>f(0)
42
>>>f(1)
43
上面的示例使用 lambda 表达式返回一个函数。另一个用途是将一个小函数作为参
数传递:
>>>pairs=[(1,'one'),(2,'two'),(3,'three'),(4,'four')]
>>>pairs.sort(key=lambdapair:pair[1])
>>>pairs
[(4,'four'),(1,'one'),(3,'three'),(2,'two')]
4.7.6. 文档字符串
这里介绍的文档字符串的概念和格式。
第一行应该是关于对象用途的简介。简短起见，不用明确的陈述对象名或类型，因
为它们可以从别的途径了解到（除非这个名字碰巧就是描述这个函数操作的动
词）。这一行应该以大写字母开头，以句号结尾。
如果文档字符串有多行，第二行应该空出来，与接下来的详细描述明确分隔。接下
来的文档应该有一或多段描述对象的调用约定、边界效应等。
Python 的解释器不会从多行的文档字符串中去除缩进，所以必要的时候应当自己
清除缩进。这符合通常的习惯。第一行之后的第一个非空行决定了整个文档的缩进
格式。（我们不用第一行是因为它通常紧靠着起始的引号，缩进格式显示的不清
楚。）留白“相当于”是字符串的起始缩进。每一行都不应该有缩进，如果有缩进的
话，所有的留白都应该清除掉。留白的长度应当等于扩展制表符的宽度（通常是8
个空格）。
以下是一个多行文档字符串的示例:
>>>defmy_function():
..."""Donothing,butdocumentit.
...
...No,really,itdoesn'tdoanything.
..."""
...pass
...
>>>print(my_function.__doc__)
Donothing,butdocumentit.
No,really,itdoesn'tdoanything.
4.7.7. 函数注解
函数注解 是关于用户自定义的函数的完全可选的、随意的元数据信息。无论
Python 本身或者标准库中都没有使用函数注解；本节只是描述了语法。第三方的
项目是自由地为文档，类型检查，以及其它用途选择函数注解。
注解是以字典形式存储在函数的
__annotations__ 属性中，对函数的其它部分没有
任何影响。参数注解（Parameter annotations）是定义在参数名称的冒号后面，紧
随着一个用来表示注解的值得表达式。返回注释（Return annotations）是定义在
一个
‐> 后面，紧随着一个表达式，在冒号与
‐> 之间。下面的示例包含一个位置
参数，一个关键字参数，和没有意义的返回值注释:
>>>deff(ham:42,eggs:int='spam')‐>"Nothingtoseehere":
...print("Annotations:",f.__annotations__)
...print("Arguments:",ham,eggs)
...
>>>f('wonderful')
Annotations:{'eggs':<class'int'>,'return':'Nothingtoseehere','ham':42}
Arguments:wonderfulspam
4.8. 插曲：编码风格
此时你已经可以写一些更长更复杂的 Python 程序，是时候讨论一下 编码风格 了。
大多数语言可以写（或者更明白的说， 格式化 ）作几种不同的风格。有些比其它
的更好读。让你的代码对别人更易读是个好想法，养成良好的编码风格对此很有帮
助。
对于 Python，PEP 8 引入了大多数项目遵循的风格指导。它给出了一个高度可读，
视觉友好的编码风格。每个 Python 开发者都应该读一下，大多数要点都会对你有
帮助：
使用 4 空格缩进，而非 TAB
在小缩进（可以嵌套更深）和大缩进（更易读）之间，4空格是一个很好的折
中。TAB 引发了一些混乱，最好弃用
折行以确保其不会超过 79 个字符
这有助于小显示器用户阅读，也可以让大显示器能并排显示几个代码文件
使用空行分隔函数和类，以及函数中的大块代码
可能的话，注释独占一行
使用文档字符串
把空格放到操作符两边，以及逗号后面，但是括号里侧不加空
格：
a=f(1,2)+g(3,4)
统一函数和类命名
推荐类名用
驼峰命名 ， 函数和方法名用
小写_和_下划线 。总是用
self 作为方法
的第一个参数（关于类和方法的知识详见 初识类 ）
不要使用花哨的编码，如果你的代码的目的是要在国际化环境。Python 的默认
情况下，UTF-8，甚至普通的 ASCII 总是工作的最好
同样，也不要使用非 ASCII 字符的标识符，除非是不同语种的会阅读或者维护
代码。
Footnotes
[1] 实际上， 引用对象调用 描述的更为准确。如果传入一个可变对象，调用者会看到调用
操作带来的任何变化（如子项插入到列表中）。
Previous
© Copyright 2013, D.D.
Built with Sphinx using a theme provided by Read the Docs.
Python tutorial
Search docs
1. 开胃菜
2. 使用 Python 解释器
3. Python 简介
4. 深入 Python 流程控制
4.1. if 语句
4.2. for 语句
4.3. range() 函数
4.4. break 和 continue 语句, 以及循
环中的 else 子句
4.5. pass 语句
4.6. 定义函数
4.7. 深入 Python 函数定义
4.8. 插曲：编码风格
5. 数据结构
6. 模块
7. 输入和输出
8. 错误和异常
9. 类
10. Python 标准库概览
11. 标准库浏览 – Part II
12. 虚拟环境和包
13. 接下来？
14. 交互式输入行编辑历史回溯
15. 浮点数算法：争议和限制
16. 附录
