Python3 基础语法

最新推荐文章于 2025-07-29 12:01:52 发布

hhq2lcl

最新推荐文章于 2025-07-29 12:01:52 发布

阅读量1.4k

点赞数

CC 4.0 BY-SA版权

文章标签： python

本文链接：https://blog.youkuaiyun.com/hhq2lcl/article/details/79925938

1.1.编码

默认情况下， Python 3 源码文件以 UTF-8 编码，所有字符串都是 unicode 字符串。当然你也可
以为源码文件指定不同的编码：

# -*- coding: cp-1252 -*-

1.2.标识符
第一个字符必须是字母表中字母或下划线 '_'。
标识符的其他的部分有字母、数字和下划线组成。
标识符对大小写敏感。

在 Python 3 中，非 -ASCII 标识符也是允许的了。

1.3.python 保留字
保留字即关键字，我们不能把它们用作任何标识符名称。 Python 的标准库提供了一个 keyword
module，可以输出当前版本的所有关键字：
>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'break', 'class', 'continue', 'def', 'del',
'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is',
'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with',

'yield']

1.4.注释
Python 中单行注释以 # 开头，实例如下：

#!/usr/bin/python3
# 第 一 个 注 释
print ("Hello, Python!") # 第 二 个 注 释

执行以上代码，输出结果为：

Hello, Python!

多行注释可以用多个 # 号：

#!/usr/bin/python3
# 第 一 个 注 释
# 第 二 个 注 释
print ("Hello, Python!")

执行以上代码，输出结果为：

Hello, Python!

1.5.行与缩进
python 最具特色的就是使用缩进来表示代码块，不需要使用大括号 ({})。
缩进的空格数是可变的，但是同一个代码块的语句必须包含相同的缩进空格数。实例如下

if True:
    print ("True")
else:
    print ("False")

以下代码最后一行语句缩进数的空格数不一致，会导致运行错误：

if True:
    print ("Answer")
    print ("True")
else:
    print ("Answer")

 print ("False") # 缩 进 不 一 致 ， 会 导 致 运 行 错 误

以上程序由于缩进不一致，执行后会出现类似以下错误：

File "test.py", line 6

print("False")    #缩进不一致，会导致运行错误。


IndentationError: unindent does not match any outer indentation level

1.6.多行语句
Python 通常是一行写完一条语句，但如果语句很长，我们可以使用反斜杠 (\)来实现多行语句，例
如：

total = item_one + \
item_two + \
item_three

在 [], {}, 或 () 中的多行语句，不需要使用反斜杠 (\)，例如：

total = ['item_one', 'item_two', 'item_three',

'item_four', 'item_five']

1.7.数据类型
python 中数有四种类型：整数、长整数、浮点数和复数。
整数，如 1
长整数是比较大的整数
浮点数如 1.23、 3E-2

复数如 1 + 2j、 1.1 + 2.2j

1.8.字符串
python 中单引号和双引号使用完全相同。
使用三引号 ('''或 """)可以指定一个多行字符串。
转义符 '\'
自然字符串，通过在字符串前加 r 或 R。如 r"this is a line with \n" 则 \n 会显示，并不是
换行。 python 允许处理 unicode 字符串，加前缀 u 或 U，如 u"this is an unicode string"。字
符串是不可变的。按字面意义级联字符串，如 "this " "is " "string" 会被自动转换为 this is
string。
word = '字符串 '
sentence = "这是一个句子。 "
paragraph = """这是一个段落，

可以由多行组成 """

1.9.空行
函数之间或类的方法之间用空行分隔，表示一段新的代码的开始。类和函数入口之间也用一行空行分隔，以突出函数入口的开始。
空行与代码缩进不同，空行并不是 Python 语法的一部分。书写时不插入空行， Python 解释器运行也不会出错。但是空行的作用在于分隔两段不同功能或含义的代码，便于日后代码的维护或重构。

记住：空行也是程序代码的一部分。

1.10. 等待用户输入
执行下面的程序在按回车键后就会等待用户输入：

#!/usr/bin/python3
input("\n\n 按 下 enter 键 后 退 出 。 ")

以上代码中， "\n\n"在结果输出前会输出两个新的空行。一旦用户按下键时，程序将退出。

1.11. 同一行显示多条语句
Python 可以在同一行中使用多条语句，语句之间使用分号 (;)分割，以下是一个简单的实例：

#!/usr/bin/python3
import sys; x = 'runoob'; sys.stdout.write(x + '\n')

执行以上代码，输入结果为：

$ python3 test.py
runoob

1.12. 多个语句构成代码组
缩进相同的一组语句构成一个代码块，我们称之代码组。
像 if、 while、 def 和 class 这样的复合语句，首行以关键字开始，以冒号 ( : )结束，该行之后的
一行或多行代码构成代码组。
我们将首行及后面的代码组称为一个子句 (clause)。
如下实例：

if expression :
    suite
elif expression :
    suite
else :
    suite

1.13. 命令行参数
很多程序可以执行一些操作来查看一些基本信， Python 可以使用 -h 参数查看各参数帮助信息：
$ python -h
usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...
Options and arguments (and corresponding environment variables):
-c cmd : program passed in as string (terminates option list)
-d : debug output from parser (also PYTHONDEBUG=x)
-E : ignore environment variables (such as PYTHONPATH)
-h : print this help message and exit
我们在使用脚本形式执行 Python 时，可以接收命令行输入的参数，具体使用可以参照 Python 3 命
令行参数。

2. Python3 基本数据类型
Python 中的变量不需要声明。每个变量在使用前都必须赋值，变量赋值以后该变量才会被创建。在
Python 中，变量就是变量，它没有类型，我们所说的 "类型 "是变量所指的内存中对象的类型。
等号（=）用来给变量赋值。等号（=）运算符左边是一个变量名 ,等号（=）运算符右边是存储在变
量中的值。例如：

counter	=100	#	整 型 变 量
miles=1000.0	#	浮 点 型 变 量
name="runoob"	#	字 符 串
print(counter)
print(miles)
print(name)

执行以上程序会输出如下结果：

100
1000.0
runoob

2.1.多个变量赋值
Python 允许你同时为多个变量赋值。例如：
a = b = c = 1
以上实例，创建一个整型对象，值为 1，三个变量被分配到相同的内存空间上。
您也可以为多个对象指定多个变量。例如：
a, b, c = 1, 2, "runoob"

以上实例，两个整型对象 1 和 2 的分配给变量 a 和 b，字符串对象 "runoob" 分配给变量 c。

2.2.标准数据类型
Python3 中有六个标准的数据类型：
Number（数字） String（字符串） List（列表）
Tuple（元组） Sets（集合） Dictionary（字典）
2.2.1.Number（数字）

Python3 支持 int、 float、 bool、 complex（复数）。

在 Python 3 里，只有一种整数类型 int，表示为长整型，没有 python2 中的 Long。
像大多数语言一样，数值类型的赋值和计算都是很直观的。
第 6 页共 117 页
内置的 type()函数可以用来查询变量所指的对象类型。

>>> a, b, c, d = 20, 5.5, True, 4+3j
>>> print(type(a), type(b), type(c), type(d))
<class 'int'> <class 'float'> <class 'bool'> <class 'complex'>

注意：在 Python2 中是没有布尔型的，它用数字 0 表示 False，用 1 表示 True。到 Python3 中，把
True 和 False 定义成关键字了，但它们的值还是 1 和 0，它们可以和数字相加。
当你指定一个值时， Number 对象就会被创建：

var1 = 1
var2 = 10

您也可以使用 del 语句删除一些对象引用。
del 语句的语法是：

del var1[,var2[,var3[....,varN]]]]

您可以通过使用 del 语句删除单个或多个对象。例如：

del var
del var_a, var_b

数值运算

>>> 5 + 4 # 加 法
9 >
>> 4.3 - 2 # 减 法
2.3
>>> 3 * 7 # 乘 法
21
>>> 2 / 4 # 除 法 ， 得 到 一 个 浮 点 数
0.5
>>> 2 // 4 # 除 法 ， 得 到 一 个 整 数
0 >
>> 17 % 3 # 取 余
2 >
>> 2 ** 5 # 乘 方
32

注意：
1、 Python 可以同时为多个变量赋值，如 a, b = 1, 2。
2、一个变量可以通过赋值指向不同类型的对象。
3、数值的除法（/）总是返回一个浮点数，要获取整数使用 //操作符。

4、在混合计算时， Python 会把整型转换成为浮点数。

数值类型实例
Python 还支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b)表示，复

数的实部 a 和虚部 b 都是浮点型

2.2.2.String（字符串）
Python 中的字符串用单引号 (')或双引号 (")括起来，同时使用反斜杠 (\)转义特殊字符。字符串的
截取的语法格式如下：

  变 量 [头 下 标 :尾 下 标 ]

索引值以 0 为开始值， -1 为从末尾的开始位置。
加号 (+) 是字符串的连接符，星号 (*) 表示复制当前字符串，紧跟的数字为复制的次数。实例
如下：

#!/usr/bin/python3
str = 'Runoob'
print(str)	#输 出 字 符 串
print(str[0:-1])#输 出 第 一 个 个 到 倒 数 第 二 个 的 所 有 字 符
print(str[0])	#输 出 字 符 串 第 一 个 字 符
print(str[2:5])	#输 出 从 第 三 个 开 始 到 第 五 个 的 字 符
print(str[2:])	#输 出 从 第 三 个 开 始 的 后 的 所 有 字 符
print(str*2)    #输 出 字 符 串 两 次
print(str+"TEST")#连 接 字 符 串

执行以上程序会输出如下结果：

Runoob
Runoo
R n
oo
noob
RunoobRunoob
RunoobTEST

Python 使用反斜杠 (\)转义特殊字符，如果你不想让反斜杠发生转义，可以在字符串前面添加一个

r，表示原始字符串：

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

另外，反斜杠 (\) 可以作为续行符，表示下一行是上一行的延续。也可以使用 """...""" 或者
'''...''' 跨越多行。

注意， Python 没有单独的字符类型，一个字符就是长度为 1 的字符串。

>>> print('Ru\noob')
Ru
oob
>>> print(r'Ru\noob')
Ru\noob
>>>

与 C 字符串不同的是， Python 字符串不能被改变。向一个索引位置赋值，比如 word[0] = 'm'会

导致错误。

注意：
1、反斜杠可以用来转义，使用 r 可以让反斜杠不发生转义。
2、字符串可以用 +运算符连接在一起，用 *运算符重复。
3、 Python 中的字符串有两种索引方式，从左往右以 0 开始，从右往左以 -1 开始。

4、 Python 中的字符串不能改变。

2.2.3.List（列表）

List（列表）是 Python 中使用最频繁的数据类型。
列表可以完成大多数集合类的数据结构实现。列表中元素的类型可以不相同，它支持数字，字符串，甚至可以包含列表（所谓嵌套）。列表是写在方括号 ([])之间、用逗号分隔开的元素列表。和字符串一样，列表同样可以被索引和截取，列表被截取后返回一个包含所需元素的新列表。

列表截取的语法格式如下：

变 量 [头 下 标 :尾 下 标 ]

索引值以 0 为开始值， -1 为从末尾的开始位置。
加号（+）是列表连接运算符，星号（*）是重复操作。如下实例：

#!/usr/bin/python3
list = [ 'abcd', 786 , 2.23, 'runoob', 70.2 ]
tinylist=[123,'runoob']
print(list)	#输 出 完 整 列 表
print(list[0])	#输 出 列 表 第 一 个 元 素
print(list[1:3])#从 第 二 个 开 始 输 出 到 第 三 个 元 素
print(list[2:])	#输 出 从 第 三 个 元 素 开 始 的 所 有 元 素
print(tinylist*2)#输 出 两 次 列 表
print(list+tinylist)#连 接 列 表

以上实例输出结果：

['abcd', 786, 2.23, 'runoob', 70.2]
abcd
[786, 2.23]
[2.23, 'runoob', 70.2]
[123, 'runoob', 123, 'runoob']
['abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob']

与 Python 字符串不一样的是，列表中的元素是可以改变的：

>>> a = [1, 2, 3, 4, 5, 6]
>>> a[0] = 9
>>> a[2:5] = [13, 14, 15]
>>> a
[9, 2, 13, 14, 15, 6]
>>> a[2:5] = [] # 删 除
>>> a
[9, 2, 6]

List 内置了有很多方法，例如 append()、 pop()等等，这在后面会讲到。

注意：
1、 List 写在方括号之间，元素用逗号隔开。
2、和字符串一样， list 可以被索引和切片。
3、 List 可以使用 +操作符进行拼接。

4、 List 中的元素是可以改变的。

2.2.4.Tuple（元组）

元组（tuple）与列表类似，不同之处在于元组的元素不能修改。元组写在小括号 (())里，元素之间
用逗号隔开。
第 10 页共 117 页
元组中的元素类型也可以不相同：

#!/usr/bin/python3
tuple = ( 'abcd', 786 , 2.23, 'runoob', 70.2 )
tinytuple = (123, 'runoob')
print(tuple)	#输 出 完 整 元 组
print(tuple[0])	#输 出 元 组 的 第 一 个 元 素
print(tuple[1:3])#输 出 从 第 二 个 元 素 开 始 到 第 三 个 元 素
print(tuple[2:])#输 出 从 第 三 个 元 素 开 始 的 所 有 元 素
print(tinytuple*2)#输 出 两 次 元 组
print(tuple+tinytuple)#连 接 元 组

以上实例输出结果：

('abcd', 786, 2.23, 'runoob', 70.2)
abcd
(786, 2.23)
(2.23, 'runoob', 70.2)
(123, 'runoob', 123, 'runoob')
('abcd', 786, 2.23, 'runoob', 70.2, 123, 'runoob')

元组与字符串类似，可以被索引且下标索引从 0 开始， -1 为从末尾开始的位置。也可以进行截取（看上面，这里不再赘述）。
其实，可以把字符串看作一种特殊的元组。

>>> tup = (1, 2, 3, 4, 5, 6)
>>> print(tup[0])
1 
>>> print(tup[1:5])
(2, 3, 4, 5)
>>> tup[0] = 11 # 修 改 元 组 元 素 的 操 作 是 非 法 的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>># 修 改 元 组 元 素 的 操 作 是 非 法 的
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

虽然 tuple 的元素不可改变，但它可以包含可变的对象，比如 list 列表。
构造包含 0 个或 1 个元素的元组比较特殊，所以有一些额外的语法规则：

tup1 = () # 空 元 组
tup2 = (20,) # 一 个 元 素 ， 需 要 在 元 素 后 添 加 逗 号# 空 元 组
tup2 = (20,) # 一 个 元 素 ， 需 要 在 元 素 后 添 加 逗 号

string、 list 和 tuple 都属于 sequence（序列）。

注意：
1、与字符串一样，元组的元素不能修改。
2、元组也可以被索引和切片，方法一样。
3、注意构造包含 0 或 1 个元素的元组的特殊语法规则。

4、元组也可以使用 +操作符进行拼接。

2.2.5.Set（集合）

集合（set）是一个 无序不重复 元素的序列。
基本功能是进行成员关系测试和删除重复元素。
可以使用大括号 ({})或者 set()函数创建集合，注意：创建一个空集合必须用 set() 而不是 { }，

因为 { } 是用来创建一个空字典。

#!/usr/bin/python3
student = ({'Tom', 'Jim', 'Mary', 'Tom', 'Jack', 'Rose'}) 
print(student) # 输 出 集 合 ， 重 复 的 元 素 被 自 动 去 掉
# 成 员 测 试
if('Rose' in student) :
    print('Rose 在 集 合 中 ')
else :
    print('Rose 不 在 集 合 中 ')
# set 可 以 进 行 集 合 运 算
a = set('abracadabra')
b = set('alacazam')
print(a)
print(a	-b)	#a 和 b 的 差 集
print(a	|b)	#a 和 b 的 并 集
print(a	&b)	#a 和 b 的 交 集
print(a	^b)	#a 和 b 中 不 同 时 存 在 的 元 素

以上实例输出结果：

{'Mary', 'Jim', 'Rose', 'Jack', 'Tom'}
Rose 在 集 合 中
{'b', 'a', 'c', 'r', 'd'}
{'b', 'd', 'r'}
{'l', 'r', 'a', 'c', 'z', 'm', 'b', 'd'}
{'a', 'c'}
{'l', 'r', 'z', 'm', 'b', 'd'}

2.2.6.Dictionary（字典）

字典（dictionary）是 Python 中另一个非常有用的内置数据类型。
列表是 有序 的对象结合，字典是 无序 的对象集合。两者之间的区别在于：字典当中的元素是通过键来存取的，而不是通过偏移存取。
字典是一种映射类型，字典用 "{ }"标识，它是一个无序的键 (key) : 值 (value)对集合。
键 (key)必须使用不可变类型。
在同一个字典中，键 (key)必须是唯一的。

#!/usr/bin/python3
dict = {}
dict['one']="1-菜 鸟 教 程 "
dict[2]	="2-菜 鸟 工 具 "
tinydict={'name':'runoob','code':1,'site':'www.runoob.com'}
print(dict['one'])	#输出键为'one'的值
print(dict[2])         #输出键为2的值
print(tinydict)         #输出完整的字典
print(tinydict.keys()) #输出所有键
print(tinydict.values()) #输出所有值

以上实例输出结果：

1 - 菜 鸟 教 程
2 - 菜 鸟 工 具
{'name': 'runoob', 'site': 'www.runoob.com', 'code': 1}
dict_keys(['name', 'site', 'code'])
dict_values(['runoob', 'www.runoob.com', 1])

构造函数 dict() 可以直接从键值对序列中构建字典如下：

>>> dict([('Runoob', 1), ('Google', 2), ('Taobao', 3)])
{'Taobao': 3, 'Runoob': 1, 'Google': 2}
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
>>> dict(Runoob=1, Google=2, Taobao=3)
{'Taobao': 3, 'Runoob': 1, 'Google': 2}

另外，字典类型也有一些内置的函数，例如 clear()、 keys()、 values()等。
注意：
1、字典是一种映射类型，它的元素是键值对。
2、字典的关键字必须为不可变类型，且不能重复。

3、创建空字典使用 { }。

2.3.Python 数据类型转换

有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名
即可。

以下几个内置的函数可以执行数据类型之间的转换。这些函数返回一个新的对象，表示转换的值。

      函数                  描述

int(x [,base])         将 x 转换为一个整数
float(x)               将 x 转换到一个浮点数
complex(real [,imag])  创建一个复数
str(x)                 将对象 x 转换为字符串
repr(x)                将对象 x 转换为表达式字符串
eval(str)              用来计算在字符串中的有效 Python 表达式,并返回一个对象
tuple(s)               将序列 s 转换为一个元组
list(s)                将序列 s 转换为一个列表
set(s)                 转换为可变集合
dict(d)                创建一个字典。d必须是一个序列 (key,value)元组。
frozenset(s)           转换为不可变集合
chr(x)                 将一个整数转换为一个字符
unichr(x)              将一个整数转换为 Unicode 字符
ord(x)                 将一个字符转换为它的整数值
hex(x)                 将一个整数转换为一个十六进制字符串
oct(x)                 将一个整数转换为一个八进制字符串

3. Python3 解释器

Linux/Unix 的系统上，一般默认的 python 版本为 2.x ，我们可以将 python3.x 安装在
/usr/local/python3 目录中。
安装完成后，我们可以将路径 /usr/local/python3/bin 添加到您的 Linux/Unix 操作系统的环境
变量中，这样您就可以通过 shell 终端输入下面的命令来启动 Python3 。
$ PATH=$PATH:/usr/local/python3/bin/python3 # 设置环境变量
$ python3 --version
Python 3.4.0
在 Window 系统下你可以通过以下命令来设置 Python 的环境变量，假设你的 Python 安装在
C:\Python34 下 :

set path=%path%;C:\python34

3.1.交互式编程

我们可以在命令提示符中输入 "Python"命令来启动 Python 解释器：

$ python3

执行以上命令后，出现如下窗口信息：

$ python3
Python 3.4.0 (default, Apr 11 2014, 13:05:11)
[GCC 4.8.2] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

在 python 提示符中输入以下语句，然后按回车键查看运行效果：

print ("Hello, Python!");

以上命令执行结果如下：

Hello, Python!

当键入一个多行结构时，续行是必须的。我们可以看下如下 if 语句：

>>> flag=True
>>> if flag:
... print("flag条 件 为	True!")
...
flag条件为True!

3.2.脚本式编程

将如下代码拷贝至 hello.py 文件中：
print ("Hello, Python!");
通过以下命令执行该脚本：
python3 hello.py
输出结果为：
Hello, Python!
在 Linux/Unix 系统中，你可以在脚本顶部添加以下命令让 Python 脚本可以像 SHELL 脚本一样可直
接执行：
#! /usr/bin/env python3
然后修改脚本权限，使其有执行权限，命令如下：
$ chmod +x hello.py
执行以下命令：
./hello.py
输出结果为：
Hello, Python!4. Python3 注释
确保对模块 , 函数 , 方法和行内注释使用正确的风格
Python 中的注释有单行注释和多行注释：
Python 中单行注释以 #开头，例如：：
# 这是一个注释
print("Hello, World!")
多行注释用三个单引号（'''）或者三个双引号（"""）将注释括起来，例如 :
1、单引号（'''）
#!/usr/bin/python3
'''
这是多行注释，用三个单引号
这是多行注释，用三个单引号
'''
print("Hello, World!")
2、双引号（"""）
第 16 页共 117 页
#!/usr/bin/python3
"""
这是多行注释，用三个单引号
这是多行注释，用三个单引号
"""
print("Hello, World!")
5. Python3 运算符
5.1.什么是运算符？
本章节主要说明 Python 的运算符。举个简单的例子 4 +5 = 9 。例子中， 4 和 5 被称为操作数，
"+" 称为运算符。
Python 语言支持以下类型的运算符 :
算术运算符比较（关系）运算符赋值运算符逻辑运算符
位运算符成员运算符身份运算符运算符优先级
接下来让我们一个个来学习 Python 的运算符。
5.2.Python 算术运算符
以下假设变量 a 为 10，变量 b 为 21：

运算符	描述	实例
+	加 - 两个对象相加	a + b 输出结果 31
-	减 - 得到负数或是一个数减去另一个数	a - b 输出结果 -11
*	乘 - 两个数相乘或是返回一个被重复若干次的字符串	a * b 输出结果 210
/	除 - x 除以 y	b / a 输出结果 2.1
%	取模 - 返回除法的余数	b % a 输出结果 1
**	幂 - 返回 x 的 y 次幂	a**b 为 10 的 21 次方
//	取整除 - 返回商的整数部分	9//2 输出结果 4 , 9.0//2.0 输出结果 4.0

以下实例演示了 Python 所有算术运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
c = a + b
第 17 页共 117 页
print ("1 - c 的值为： ", c)
c = a - b
print ("2 - c 的值为： ", c)
c = a * b
print ("3 - c 的值为： ", c)
c = a / b
print ("4 - c 的值为： ", c)
c = a % b
print ("5 - c 的值为： ", c)
# 修改变量 a 、 b 、 c
a = 2
b = 3
c = a**b
print ("6 - c 的值为： ", c)
a = 10
b = 5
c = a//b
print ("7 - c 的值为： ", c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 11
3 - c 的值为： 210
4 - c 的值为： 2.1
5 - c 的值为： 1
6 - c 的值为： 8
7 - c 的值为： 2
Python 比较运算符
以下假设变量 a 为 10，变量 b 为 20：

运算符	描述	实例
==	等于 - 比较对象是否相等	(a == b) 返回 False。
!=	不等于 - 比较两个对象是否不相等	(a != b) 返回 true.

第 18 页共 117 页

>	大于 - 返回 x 是否大于 y	(a > b) 返回 False。
<	小于 - 返回 x 是否小于 y。所有比较运算符返回 1 表示真，返回 0 表示假。这分别与特殊的变量 True 和 False 等价。注意，这些变量名的大写。	(a < b) 返回 true。
>=	大于等于 - 返回 x 是否大于等于 y。	(a >= b) 返回 False。
<=	小于等于 - 返回 x 是否小于等于 y。	(a <= b) 返回 true。

以下实例演示了 Python 所有比较运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
if ( a == b ):
print ("1 - a 等于 b")
else:
print ("1 - a 不等于 b")
if ( a != b ):
print ("2 - a 不等于 b")
else:
print ("2 - a 等于 b")
if ( a < b ):
print ("3 - a 小于 b")
else:
print ("3 - a 大于等于 b")
if ( a > b ):
print ("4 - a 大于 b")
else:
print ("4 - a 小于等于 b")
# 修改变量 a 和 b 的值
a = 5;
b = 20;
if ( a <= b ):
第 19 页共 117 页
print ("5 - a 小于等于 b")
else:
print ("5 - a 大于 b")
if ( b >= a ):
print ("6 - b 大于等于 a")
else:
print ("6 - b 小于 a")
以上实例输出结果：
1 - a 不等于 b
2 - a 不等于 b
3 - a 大于等于 b
4 - a 大于 b
5 - a 小于等于 b
6 - b 大于等于 a
5.3.Python 赋值运算符
以下假设变量 a 为 10，变量 b 为 20：

运算符	描述	实例
=	简单的赋值运算符	c = a + b 将 a + b 的运算结果赋值为 c
+=	加法赋值运算符	c += a 等效于 c = c + a
-=	减法赋值运算符	c -= a 等效于 c = c - a
*=	乘法赋值运算符	c = a 等效于 c = c a
/=	除法赋值运算符	c /= a 等效于 c = c / a
%=	取模赋值运算符	c %= a 等效于 c = c % a
**=	幂赋值运算符	c = a 等效于 c = c a
//=	取整除赋值运算符	c //= a 等效于 c = c // a

以下实例演示了 Python 所有赋值运算符的操作：
#!/usr/bin/python3
a = 21
b = 10
c = 0
第 20 页共 117 页
c = a + b
print ("1 - c 的值为： ", c)
c += a
print ("2 - c 的值为： ", c)
c *= a
print ("3 - c 的值为： ", c)
c /= a
print ("4 - c 的值为： ", c)
c = 2
c %= a
print ("5 - c 的值为： ", c)
c **= a
print ("6 - c 的值为： ", c)
c //= a
print ("7 - c 的值为： ", c)
以上实例输出结果：
1 - c 的值为： 31
2 - c 的值为： 52
3 - c 的值为： 1092
4 - c 的值为： 52.0
5 - c 的值为： 2
6 - c 的值为： 2097152
7 - c 的值为： 99864
5.4.Python 位运算符
按位运算符是把数字看作二进制来进行计算的。 Python 中的按位运算法则如下：
下表中变量 a 为 60， b 为 13 二进制格式如下：
a = 0011 1100
b = 0000 1101
-----------------
a&b = 0000 1100
a|b = 0011 1101
a^b = 0011 0001
第 21 页共 117 页
~a = 1100 0011

运算符	描述	实例
&	按位与运算符：参与运算的两个值,如果两个相应位都为 1,则该位的结果为 1,否则为 0	(a & b) 输出结果 12 ，二进制解释： 0000 1100
\|	按位或运算符：只要对应的二个二进位有一个为 1 时，结果位就为 1。	(a \| b) 输出结果 61 ，二进制解释： 0011 1101
^	按位异或运算符：当两对应的二进位相异时，结果为 1	(a ^ b) 输出结果 49 ，二进制解释： 0011 0001
~	按位取反运算符：对数据的每个二进制位取反,即把 1 变为 0,把 0 变为 1	(~a ) 输出结果 -61 ，二进制解释： 1100 0011，在一个有符号二进制数的补码形式。
<<	左移动运算符：运算数的各二进位全部左移若干位，由"<<" 右边的数指定移动的位数，高位丢弃，低位补 0。	a << 2 输出结果 240 ，二进制解释： 1111 0000
>>	右移动运算符：把">>"左边的运算数的各二进位全部右移若干位， ">>"右边的数指定移动的位数	a >> 2 输出结果 15 ，二进制解释： 0000 1111

以下实例演示了 Python 所有位运算符的操作：
#!/usr/bin/python3
a = 60 # 60 = 0011 1100
b = 13 # 13 = 0000 1101
c = 0
c = a & b; # 12 = 0000 1100
print ("1 - c 的值为： ", c)
c = a | b; # 61 = 0011 1101
print ("2 - c 的值为： ", c)
c = a ^ b; # 49 = 0011 0001
print ("3 - c 的值为： ", c)
c = ~a; # -61 = 1100 0011
print ("4 - c 的值为： ", c)
c = a << 2; # 240 = 1111 0000
print ("5 - c 的值为： ", c)
c = a >> 2; # 15 = 0000 1111
print ("6 - c 的值为： ", c)
以上实例输出结果：
第 22 页共 117 页
1 - c 的值为： 12
2 - c 的值为： 61
3 - c 的值为： 49
4 - c 的值为： -61
5 - c 的值为： 240
6 - c 的值为： 15
5.5.Python 逻辑运算符
Python 语言支持逻辑运算符，以下假设变量 a 为 10, b 为 20:

运算符	逻辑表达式	描述	实例
and	x and y	布尔"与" - 如果 x 为 False，x and y 返回 False，否则它返回 y 的计算值。	(a and b) 返回 20。
or	x or y	布尔"或" - 如果 x 是 True，它返回 True，否则它返回 y 的计算值	(a or b) 返回 10。
not	not x	布尔"非" - 如果 x 为 True，返回 False 。如果 x 为 False，它返回 True。	not(a and b) 返回 False

。
以上实例输出结果：
#!/usr/bin/python3
a = 10
b = 20
if ( a and b ):
print ("1 - 变量 a 和 b 都为 true")
else:
print ("1 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("2 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("2 - 变量 a 和 b 都不为 true")
# 修改变量 a 的值
a = 0
第 23 页共 117 页
if ( a and b ):
print ("3 - 变量 a 和 b 都为 true")
else:
print ("3 - 变量 a 和 b 有一个不为 true")
if ( a or b ):
print ("4 - 变量 a 和 b 都为 true，或其中一个变量为 true")
else:
print ("4 - 变量 a 和 b 都不为 true")
if not( a and b ):
print ("5 - 变量 a 和 b 都为 false，或其中一个变量为 false")
else:
print ("5 - 变量 a 和 b 都为 true")
以上实例输出结果：
1 - 变量 a 和 b 都为 true
2 - 变量 a 和 b 都为 true，或其中一个变量为 true
3 - 变量 a 和 b 有一个不为 true
4 - 变量 a 和 b 都为 true，或其中一个变量为 true
5 - 变量 a 和 b 都为 false，或其中一个变量为 false
5.6.Python 成员运算符
除了以上的一些运算符之外， Python 还支持成员运算符，测试实例中包含了一系列的成员，包括字
符串，列表或元组。

运算符	描述	实例
in	如果在指定的序列中找到值返回 True，否则返回 False。	x 在 y 序列中 , 如果 x 在 y 序列中返回 True。
not in	如果在指定的序列中没有找到值返回 True，否则返回 False。	x 不在 y 序列中 , 如果 x 不在 y 序列中返回 True。

以下实例演示了 Python 所有成员运算符的操作：
#!/usr/bin/python3
a = 10
b = 20
list = [1, 2, 3, 4, 5 ];
第 24 页共 117 页
if ( a in list ):
print ("1 - 变量 a 在给定的列表中 list 中 ")
else:
print ("1 - 变量 a 不在给定的列表中 list 中 ")
if ( b not in list ):
print ("2 - 变量 b 不在给定的列表中 list 中 ")
else:
print ("2 - 变量 b 在给定的列表中 list 中 ")
# 修改变量 a 的值
a = 2
if ( a in list ):
print ("3 - 变量 a 在给定的列表中 list 中 ")
else:
print ("3 - 变量 a 不在给定的列表中 list 中 ")
以上实例输出结果：
1 - 变量 a 不在给定的列表中 list 中
2 - 变量 b 不在给定的列表中 list 中
3 - 变量 a 在给定的列表中 list 中
5.7.Python 身份运算符
身份运算符用于比较两个对象的存储单元

运算符	描述	实例
is	is 是判断两个标识符是不是引用自一个对象	x is y, 如果 id(x) 等于 id(y) , is 返回结果 1
is not	is not 是判断两个标识符是不是引用自不同对象	x is not y, 如果 id(x) 不等于 id(y). is not 返回结果 1

以下实例演示了 Python 所有身份运算符的操作：
#!/usr/bin/python3
a = 20
b = 20
if ( a is b ):
print ("1 - a 和 b 有相同的标识 ")
else:
第 25 页共 117 页
print ("1 - a 和 b 没有相同的标识 ")
if ( id(a) == id(b) ):
print ("2 - a 和 b 有相同的标识 ")
else:
print ("2 - a 和 b 没有相同的标识 ")
# 修改变量 b 的值
b = 30
if ( a is b ):
print ("3 - a 和 b 有相同的标识 ")
else:
print ("3 - a 和 b 没有相同的标识 ")
if ( a is not b ):
print ("4 - a 和 b 没有相同的标识 ")
else:
print ("4 - a 和 b 有相同的标识 ")
以上实例输出结果：
1 - a 和 b 有相同的标识
2 - a 和 b 有相同的标识
3 - a 和 b 没有相同的标识
4 - a 和 b 没有相同的标识
5.8.Python 运算符优先级
以下表格列出了从最高到最低优先级的所有运算符：

运算符	描述
**	指数 (最高优先级)
~ + -	按位翻转, 一元加号和减号 (最后两个的方法名为 +@ 和 -@)
* / % //	乘，除，取模和取整除
+ -	加法减法
>> <<	右移，左移运算符
&	位 'AND'
^ \|	位运算符

第 26 页共 117 页

<= < > >=	比较运算符
<> == !=	等于运算符
= %= /= //= -= += = *=	赋值运算符
is is not	身份运算符
in not in	成员运算符
not or and	逻辑运算符

以下实例演示了 Python 所有运算符优先级的操作：
#!/usr/bin/python3
a = 20
b = 10
c = 15
d = 5
e = 0
e = (a + b) * c / d #( 30 * 15 ) / 5
print ("(a + b) * c / d 运算结果为： ", e)
e = ((a + b) * c) / d # (30 * 15 ) / 5
print ("((a + b) * c) / d 运算结果为： ", e)
e = (a + b) * (c / d); # (30) * (15/5)
print ("(a + b) * (c / d) 运算结果为： ", e)
e = a + (b * c) / d; # 20 + (150/5)
print ("a + (b * c) / d 运算结果为： ", e)
以上实例输出结果：
(a + b) * c / d 运算结果为： 90.0
((a + b) * c) / d 运算结果为： 90.0
(a + b) * (c / d) 运算结果为： 90.0
a + (b * c) / d 运算结果为： 50.0
6. Python3 数字(Number)
Python 数字数据类型用于存储数值。
数据类型是不允许改变的 ,这就意味着如果改变数字数据类型得值，将重新分配内存空间。以下实例
在变量赋值时 Number 对象将被创建：
第 27 页共 117 页
var1 = 1
var2 = 10
您也可以使用 del 语句删除一些数字对象的引用。
del 语句的语法是：
del var1[,var2[,var3[....,varN]]]]
您可以通过使用 del 语句删除单个或多个对象的引用，例如：
del var
del var_a, var_b
Python 支持三种不同的数值类型：
整型 (Int) - 通常被称为是整型或整数，是正或负整数，不带小数点。 Python3 整型是没有限制大
小的，可以当作 Long 类型使用，所以 Python3 没有 Python2 的 Long 类型。
浮点型 (float) - 浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.5e2 =
2.5 x 102 = 250）
复数 ( (complex)) - 复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b)表示，复
数的实部 a 和虚部 b 都是浮点型。
我们可以使用十六进制和八进制来代表整数：
>>> number = 0xA0F # 十六进制
>>> number
2575
>>> number=0o37 # 八进制
>>> number
31

int	float	complex
10	0	3.14j
100	15.2	45.j
-786	-21.9	9.322e-36j
80	32.3+e18	.876j
-490	-90	-.6545+0J
-0x260	-3.25E+101	3e+26J
0x69	70.2-E12	4.53e-7j

Python 支持复数，复数由实数部分和虚数部分构成，可以用 a + bj,或者 complex(a,b)表示，复
第 28 页共 117 页
数的实部 a 和虚部 b 都是浮点型。
6.1.Python 数字类型转换
有时候，我们需要对数据内置的类型进行转换，数据类型的转换，你只需要将数据类型作为函数名
即可。
int(x) 将 x 转换为一个整数。
float(x) 将 x 转换到一个浮点数。
complex(x) 将 x 转换到一个复数，实数部分为 x，虚数部分为 0。
complex(x, y) 将 x 和 y 转换到一个复数，实数部分为 x，虚数部分为 y。 x 和 y 是数字表达
式。
以下实例将浮点数变量 a 转换为整数：
>>> a = 1.0
>>> int(a)
1 6
.2.Python 数字运算
Python 解释器可以作为一个简单的计算器，您可以在解释器里输入一个表达式，它将输出表达式的
值。
表达式的语法很直白： +, -, * 和 / 和其它语言（如 Pascal 或 C）里一样。例如：
>>> 2 + 2
4 >
>> 50 - 5*6
20
>>> (50 - 5*6) / 4
5.0
>>> 8 / 5 # 总是返回一个浮点数
1.6
注意：在不同的机器上浮点运算的结果可能会不一样。
在整数除法中，除法（/）总是返回一个浮点数，如果只想得到整数的结果，丢弃可能的分数部分，
可以使用运算符 // ：
>>> 17 / 3 # 整数除法返回浮点型
5.666666666666667
>>>
第 29 页共 117 页
>>> 17 // 3 # 整数除法返回向下取整后的结果
5 >
>> 17 % 3 # ％操作符返回除法的余数
2 >
>> 5 * 3 + 2
17
等号（=）用于给变量赋值。赋值之后，除了下一个提示符，解释器不会显示任何结果。
>>> width = 20
>>> height = 5*9
>>> width * height
900
Python 可以使用 ** 操作来进行幂运算：
>>> 5 ** 2 # 5 的平方
25
>>> 2 ** 7 # 2 的 7 次方
128
变量在使用前必须先 "定义 "（即赋予变量一个值），否则会出现错误：
>>> n # 尝试访问一个未定义的变量
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
不同类型的数混合运算时会将整数转换为浮点数：
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
在交互模式中，最后被输出的表达式结果被赋值给变量 _ 。例如：
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
第 30 页共 117 页
113.0625
>>> round(_, 2)
113.06
此处， _ 变量应被用户视为只读变量。
6.3.数学函数

函数	返回值 ( 描述 )
abs(x)	返回数字的绝对值，如 abs(-10) 返回 10
ceil(x)	返回数字的上入整数，如 math.ceil(4.1) 返回 5
cmp(x, y)	如果 x < y 返回 -1, 如果 x == y 返回 0, 如果 x > y 返回 1。 Python 3 已废弃。使用使用 (x>y)-(x<y) 替换。
exp(x)	返回 e 的 x 次幂(ex),如 math.exp(1) 返回 2.718281828459045
fabs(x)	返回数字的绝对值，如 math.fabs(-10) 返回 10.0
floor(x)	返回数字的下舍整数，如 math.floor(4.9)返回 4
log(x)	如 math.log(math.e)返回 1.0,math.log(100,10)返回 2.0
log10(x)	返回以 10 为基数的 x 的对数，如 math.log10(100)返回 2.0
max(x1, x2,...)	返回给定参数的最大值，参数可以为序列。
min(x1, x2,...)	返回给定参数的最小值，参数可以为序列。
modf(x)	返回 x 的整数部分与小数部分，两部分的数值符号与 x 相同，整数部分以浮点型表示。
pow(x, y)	x**y 运算后的值。
round(x [,n])	返回浮点数 x 的四舍五入值，如给出 n 值，则代表舍入到小数点后的位数。
sqrt(x)	返回数字 x 的平方根，数字可以为负数，返回类型为实数，如 math.sqrt(4) 返回 2+0j

6.4.随机数函数
随机数可以用于数学，游戏，安全等领域中，还经常被嵌入到算法中，用以提高算法效率，并提高
程序的安全性。
Python 包含以下常用随机数函数：

函数	描述
choice(seq)	从序列的元素中随机挑选一个元素，比如 random.choice(range(10))，从 0

第 31 页共 117 页

到 9 中随机挑选一个整数。
randrange ([start,] stop [,step])	从指定范围内，按指定基数递增的集合中获取一个随机数，基数缺省值为 1
random()	随机生成下一个实数，它在[0,1)范围内。
seed([x])	改变随机数生成器的种子 seed。如果你不了解其原理，你不必特别去设定 seed， Python 会帮你选择 seed。
shuffle(lst)	将序列的所有元素随机排序
uniform(x, y)	随机生成下一个实数，它在[x,y]范围内。

6.5.三角函数
Python 包括以下三角函数：
6.6.数学常量

常量	描述
pi	数学常量 pi（圆周率，一般以π来表示）
e	数学常量 e， e 即自然常数（自然常数）。

7. Python3 字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号 ('或 ")来创建字符串。

函数	描述
acos(x)	返回 x 的反余弦弧度值。
asin(x)	返回 x 的反正弦弧度值。
atan(x)	返回 x 的反正切弧度值。
atan2(y, x)	返回给定的 X 及 Y 坐标值的反正切值。
cos(x)	返回 x 的弧度的余弦值。
hypot(x, y)	返回欧几里德范数 sqrt(xx + yy)。
sin(x)	返回的 x 弧度的正弦值。
tan(x)	返回 x 弧度的正切值。
degrees(x)	将弧度转换为角度,如 degrees(math.pi/2) ，返回 90.0
radians(x)	将角度转换为弧度

第 32 页共 117 页
创建字符串很简单，只要为变量分配一个值即可。例如：
var1 = 'Hello World!'
var2 = "Runoob"
Python 访问字符串中的值
Python 不支持单字符类型，单字符也在 Python 也是作为一个字符串使用。
Python 访问子字符串，可以使用方括号来截取字符串，如下实例：
#!/usr/bin/python3
var1 = 'Hello World!'
var2 = "Runoob"
print ("var1[0]: ", var1[0])
print ("var2[1:5]: ", var2[1:5])
以上实例执行结果：
var1[0]: H
var2[1:5]: unoo
Python 字符串更新
你可以对已存在的字符串进行修改，并赋值给另一个变量，如下实例：
#!/usr/bin/python3
var1 = 'Hello World!'
print ("已更新字符串 : ", var1[:6] + 'Runoob!')
以上实例执行结果
已更新字符串 : Hello Runoob!
7.1.Python 转义字符
在需要在字符中使用特殊字符时， python 用反斜杠 (\)转义字符。如下表：

转义字符	描述
\(在行尾时)	续行符
\\	反斜杠符号
\'	单引号
\"	双引号
\a	响铃
\b	退格(Backspace)

第 33 页共 117 页

\e	转义
\000	空
\n	换行
\v	纵向制表符
\t	横向制表符
\r	回车
\f	换页
\oyy	八进制数， yy 代表的字符，例如： \o12 代表换行
\xyy	十六进制数， yy 代表的字符，例如： \x0a 代表换行
\other	其它的字符以普通格式输出

7.2.Python 字符串运算符
下表实例变量 a 值为字符串 "Hello"， b 变量值为 "Python"：

操作符	描述	实例
+	字符串连接	a + b 输出结果： HelloPython
*	重复输出字符串	a*2 输出结果： HelloHello
[]	通过索引获取字符串中字符	a[1] 输出结果 e
[ : ]	截取字符串中的一部分	a[1:4] 输出结果 ell
in	成员运算符 - 如果字符串中包含给定的字符返回 True	H in a 输出结果 1
not in	成员运算符 - 如果字符串中不包含给定的字符返回 True	M not in a 输出结果 1
r/R	原始字符串 - 原始字符串：所有的字符串都是直接按照字面的意思来使用，没有转义特殊或不能打印的字符。原始字符串除在字符串的第一个引号前加上字母"r（" 可以大小写）以外，与普通字符串有着几乎完全相同的语法。	print r'\n' prints \n 和 print R'\n' prints \n
%	格式字符串	请看下一节内容。

实例
#!/usr/bin/python3
a = "Hello"
b = "Python"
第 34 页共 117 页
print("a + b 输出结果： ", a + b)
print("a * 2 输出结果： ", a * 2)
print("a[1] 输出结果： ", a[1])
print("a[1:4] 输出结果： ", a[1:4])
if( "H" in a) :
print("H 在变量 a 中 ")
else :
print("H 不在变量 a 中 ")
if( "M" not in a) :
print("M 不在变量 a 中 ")
else :
print("M 在变量 a 中 ")
print (r'\n')
print (R'\n')
以上实例输出结果为：
a + b 输出结果： HelloPython
a * 2 输出结果： HelloHello
a[1] 输出结果： e
a[1:4] 输出结果： ell
H 在变量 a 中
M 不在变量 a 中
\n
\n
7.3.Python 字符串格式化
Python 支持格式化字符串的输出。尽管这样可能会用到非常复杂的表达式，但最基本的用法是将
一个值插入到一个有字符串格式符 %s 的字符串中。
在 Python 中，字符串格式化使用与 C 中 sprintf 函数一样的语法。
如下实例：
#!/usr/bin/python3
print ("我叫 %s 今年 %d 岁 !" % ('小明 ', 10))
以上实例输出结果：
我叫小明今年 10 岁 !
第 35 页共 117 页
python 字符串格式化符号 :

符号	描述
%c	格式化字符及其 ASCII 码
%s	格式化字符串
%d	格式化整数
%u	格式化无符号整型
%o	格式化无符号八进制数
%x	格式化无符号十六进制数
%X	格式化无符号十六进制数（大写）
%f	格式化浮点数字，可指定小数点后的精度
%e	用科学计数法格式化浮点数
%E	作用同%e，用科学计数法格式化浮点数
%g	%f 和%e 的简写
%G	%f 和 %E 的简写
%p	用十六进制数格式化变量的地址

格式化操作符辅助指令 :

符号	功能
*	定义宽度或者小数点精度
-	用做左对齐
+	在正数前面显示加号( + )
<sp>	在正数前面显示空格
#	在八进制数前面显示零('0')，在十六进制前面显示'0x'或者'0X'(取决于用的是'x'还是'X')
0	显示的数字前面填充'0'而不是默认的空格
%	'%%'输出一个单一的'%'
(var)	映射变量(字典参数)
m.n.	m 是显示的最小总宽度,n 是小数点后的位数(如果可用的话)

7.4.Python 三引号
python 三引号允许一个字符串跨多行，字符串中可以包含换行符、制表符以及其他特殊字符。实例
第 36 页共 117 页
如下
#!/usr/bin/python3
para_str = """这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( \t )。
也可以使用换行符 [ \n ]。
"""
print (para_str)
以上实例执行结果为：
这是一个多行字符串的实例
多行字符串可以使用制表符
TAB ( )。
也可以使用换行符 [
]。
三引号让程序员从引号和特殊字符串的泥潭里面解脱出来，自始至终保持一小块字符串的格式是所
谓的 WYSIWYG（所见即所得）格式的。
一个典型的用例是，当你需要一块 HTML 或者 SQL 时，这时用字符串组合，特殊字符串转义将会非常
的繁琐。
errHTML = '''
<HTML><HEAD><TITLE>
Friends CGI Demo</TITLE></HEAD>
<BODY><H3>ERROR</H3>
<B>%s</B><P>
<FORM><INPUT TYPE=button VALUE=Back
ONCLICK="window.history.back()"></FORM>
</BODY></HTML>
'''
cursor.execute('''
CREATE TABLE users (
login VARCHAR(8),
uid INTEGER,
prid INTEGER)
第 37 页共 117 页
''')
7.5.Unicode 字符串
在 Python2 中，普通字符串是以 8 位 ASCII 码进行存储的，而 Unicode 字符串则存储为 16 位 unicode
字符串，这样能够表示更多的字符集。使用的语法是在字符串前面加上前缀 u。
在 Python3 中，所有的字符串都是 Unicode 字符串。
7.6.Python 的字符串内建函数
Python 的字符串常用内建函数如下：

序号	方法及描述
1	capitalize() 将字符串的第一个字符转换为大写
2	center(width, fillchar) 返回一个指定的宽度 width 居中的字符串， fillchar 为填充的字符，默认为空格。
3	count(str, beg= 0,end=len(string)) 返回 str 在 string 里面出现的次数，如果 beg 或者 end 指定则返回指定范围内 str 出现的次数
4	bytes.decode(encoding="utf-8", errors="strict") Python3 中没有 decode 方法，但我们可以使用 bytes 对象的 decode() 方法来解码给定的 bytes 对象，这个 bytes 对象可以由 str.encode() 来编码返回。
5	encode(encoding='UTF-8',errors='strict') 以 encoding 指定的编码格式编码字符串，如果出错默认报一个 ValueError 的异常，除非 errors 指定的是'ignore'或者'replace'
6	endswith(suffix, beg=0, end=len(string)) 检查字符串是否以 obj 结束，如果 beg 或者 end 指定则检查指定的范围内是否以 obj 结束，如果是，返回 True,否则返回 False.
7	expandtabs(tabsize=8) 把字符串 string 中的 tab 符号转为空格， tab 符号默认的空格数是 8 。
8	find(str, beg=0 end=len(string)) 检测 str 是否包含在字符串中中，如果 beg 和 end 指定范围，则检查是否包含在指定范围内，如果是返回开始的索引值，否则返回-1
9	index(str, beg=0, end=len(string))

第 38 页共 117 页

跟 find()方法一样，只不过如果 str 不在字符串中会报一个异常.
10	isalnum() 如果字符串至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False
11	isalpha() 如果字符串至少有一个字符并且所有字符都是字母则返回 True, 否则返回 False
12	isdigit() 如果字符串只包含数字则返回 True 否则返回 False..
13	islower() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是小写，则返回 True，否则返回 False
14	isnumeric() 如果字符串中只包含数字字符，则返回 True，否则返回 False
15	isspace() 如果字符串中只包含空格，则返回 True，否则返回 False.
16	istitle() 如果字符串是标题化的(见 title())则返回 True，否则返回 False
17	isupper() 如果字符串中包含至少一个区分大小写的字符，并且所有这些(区分大小写的)字符都是大写，则返回 True，否则返回 False
18	join(seq) 以指定字符串作为分隔符，将 seq 中所有的元素(的字符串表示)合并为一个新的字符串
19	len(string) 返回字符串长度
20	ljust(width[, fillchar]) 返回一个原字符串左对齐,并使用 fillchar 填充至长度 width 的新字符串， fillchar 默认为空格。
21	lower() 转换字符串中所有大写字符为小写.
22	lstrip()

第 39 页共 117 页

截掉字符串左边的空格
23	maketrans() 创建字符映射的转换表，对于接受两个参数的最简单的调用方式，第一个参数是字符串，表示需要转换的字符，第二个参数也是字符串表示转换的目标。
24	max(str) 返回字符串 str 中最大的字母。
25	min(str) 返回字符串 str 中最小的字母。
26	replace(old, new [, max]) 把将字符串中的 str1 替换成 str2,如果 max 指定，则替换不超过 max 次。
27	rfind(str, beg=0,end=len(string)) 类似于 find()函数，不过是从右边开始查找.
28	rindex( str, beg=0, end=len(string)) 类似于 index()，不过是从右边开始.
29	rjust(width,[, fillchar]) 返回一个原字符串右对齐,并使用 fillchar(默认空格）填充至长度 width 的新字符串
30	rstrip() 删除字符串字符串末尾的空格.
31	split(str="", num=string.count(str)) num=string.count(str)) 以 str 为分隔符截取字符串，如果 num 有指定值，则仅截取 num 个子字符串
32	splitlines([keepends]) 按照行('\r', '\r\n', \n')分隔，返回一个包含各行作为元素的列表，如果参数 keepends 为 False，不包含换行符，如果为 True，则保留换行符。
33	startswith(str, beg=0,end=len(string)) 检查字符串是否是以 obj 开头，是则返回 True，否则返回 False。如果 beg 和 end 指定值，则在指定范围内检查。
34	strip([chars]) 在字符串上执行 lstrip()和 rstrip()

第 40 页共 117 页

35	swapcase() 将字符串中大写转换为小写，小写转换为大写
36	title() 返回"标题化"的字符串,就是说所有单词都是以大写开始，其余字母均为小写(见 istitle())
37	translate(table, deletechars="") 根据 str 给出的表(包含 256 个字符)转换 string 的字符, 要过滤掉的字符放到 deletechars 参数中
38	upper() 转换字符串中的小写字母为大写
39	zfill (width) 返回长度为 width 的字符串，原字符串右对齐，前面填充 0
40	isdecimal() 检查字符串是否只包含十进制字符，如果是返回 true，否则返回 false。

8. Python3 列表
序列是 Python 中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第
一个索引是 0，第二个索引是 1，依此类推。
Python 有 6 个序列的内置类型，但最常见的是列表和元组。
序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外， Python 已经内置确定序列的长度以及确定最大和最小的元素的方法。
列表是最常用的 Python 数据类型，它可以作为一个方括号内的逗号分隔值出现。
列表的数据项不需要具有相同的类型
创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：
list1 = ['Google', 'Runoob', 1997, 2000];
list2 = [1, 2, 3, 4, 5 ];
list3 = ["a", "b", "c", "d"];
与字符串的索引一样，列表索引从 0 开始。列表可以进行截取、组合等。
8.1.访问列表中的值
使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
#!/usr/bin/python3
list1 = ['Google', 'Runoob', 1997, 2000];
第 41 页共 117 页
list2 = [1, 2, 3, 4, 5, 6, 7 ];
print ("list1[0]: ", list1[0])
print ("list2[1:5]: ", list2[1:5])
运行实例 » 下载
以上实例输出结果：
list1[0]: Google
list2[1:5]: [2, 3, 4, 5]
8.2.更新列表
你可以对列表的数据项进行修改或更新，你也可以使用 append()方法来添加列表项，如下所示：
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print ("第三个元素为 : ", list[2])
list[2] = 2001
print ("更新后的第三个元素为 : ", list[2])
注意：我们会在接下来的章节讨论 append()方法的使用
以上实例输出结果：
第三个元素为 : 1997
更新后的第三个元素为 : 2001
8.3.删除列表元素
可以使用 del 语句来删除列表的的元素，如下实例：
#!/usr/bin/python3
list = ['Google', 'Runoob', 1997, 2000]
print (list)
del list[2]
print ("删除第三个元素 : ", list)
以上实例输出结果：
删除第三个元素 : ['Google', 'Runoob', 2000]
注意：我们会在接下来的章节讨论 remove()方法的使用
8.4.Python 列表脚本操作符
列表对 + 和 * 的操作符与字符串相似。 + 号用于组合列表， * 号用于重复列表。
如下所示：
第 42 页共 117 页

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	TRUE	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

8.5.Python 列表截取与拼接
Python 的列表截取与字符串操作类型，如下所示：
L=['Google', 'Runoob', 'Taobao']
操作：

Python 表达式	结果	描述
L[2]	'Taobao'	读取第三个元素
L[-2]	'Runoob'	从右侧开始读取倒数第二个元素: count from the right
L[1:]	['Runoob', 'Taobao']	输出从第二个元素开始后的所有元素

>>> L=['Google', 'Runoob', 'Taobao']
>>> L[2]
'Taobao'
>>> L[-2]
'Runoob'
>>> L[1:]
['Runoob', 'Taobao']
>>>
列表还支持拼接操作：
>>> squares = [1, 4, 9, 16, 25]
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
8.6.嵌套列表
使用嵌套列表即在列表里创建其它列表，例如：
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
第 43 页共 117 页
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'
8.7.Python 列表函数&方法
Python 包含以下函数 :

序号	函数
1	len(list) 列表元素个数
2	max(list) 返回列表元素最大值
3	min(list) 返回列表元素最小值
4	list(seq) 将元组转换为列表

Python 包含以下方法 :

序号	方法
1	list.append(obj) 在列表末尾添加新的对象
2	list.count(obj) 统计某个元素在列表中出现的次数
3	list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
4	list.index(obj) 从列表中找出某个值第一个匹配项的索引位置
5	list.insert(index, obj)

第 44 页共 117 页

将对象插入列表
6	list.pop(obj=list[-1]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
7	list.remove(obj) 移除列表中某个值的第一个匹配项
8	list.reverse() 反向列表中元素
9	list.sort([func]) 对原列表进行排序
10	list.clear() 清空列表
11	list.copy() 复制列表

9. Python3 元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。
元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
如下实例：
tup1 = ('Google', 'Runoob', 1997, 2000);
tup2 = (1, 2, 3, 4, 5 );
tup3 = "a", "b", "c", "d";
9.1.创建空元组
tup1 = ();
元组中只包含一个元素时，需要在元素后面添加逗号
tup1 = (50,);
元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。
9.2.访问元组
元组可以使用下标索引来访问元组中的值，如下实例 :
#!/usr/bin/python3
第 45 页共 117 页
tup1 = ('Google', 'Runoob', 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])
以上实例输出结果：
tup1[0]: Google
tup2[1:5]: (2, 3, 4, 5)
9.3.修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例 :
#!/usr/bin/python3
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
# 以下修改元组元素操作是非法的。
# tup1[0] = 100
# 创建一个新的元组
tup3 = tup1 + tup2;
print (tup3)
以上实例输出结果：
(12, 34.56, 'abc', 'xyz')
9.4.删除元组
元组中的元素值是不允许删除的，但我们可以使用 del 语句来删除整个元组，如下实例 :
#!/usr/bin/python3
tup = ('Google', 'Runoob', 1997, 2000)
print (tup)
del tup;
print ("删除后的元组 tup : ")
print (tup)
以上实例元组被删除后，输出变量会有异常信息，输出如下所示：
删除后的元组 tup :
Traceback (most recent call last):
File "test.py", line 8, in <module>
第 46 页共 117 页
print (tup)
NameError: name 'tup' is not defined
9.5.元组运算符
与字符串一样，元组之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算
后会生成一个新的元组。

Python 表达式	结果	描述
len((1, 2, 3))	3	计算元素个数
(1, 2, 3) + (4, 5, 6)	(1, 2, 3, 4, 5, 6)	连接
('Hi!',) * 4	('Hi!', 'Hi!', 'Hi!', 'Hi!')	复制
3 in (1, 2, 3)	TRUE	元素是否存在
for x in (1, 2, 3): print x,	1 2 3	迭代

9.6.元组索引，截取
因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元
素，如下所示：
元组：
L = ('Google', 'Taobao', 'Runoob')

Python 表达式	结果	描述
L[2]	'Runoob!'	读取第三个元素
L[-2]	'Taobao'	反向读取；读取倒数第二个元素
L[1:]	('Taobao', 'Runoob!')	截取元素，从第二个开始后的所有元素。

运行实例如下：
>>> L = ('Google', 'Taobao', 'Runoob')
>>> L[2]
'Runoob'
>>> L[-2]
'Taobao'
>>> L[1:]
('Taobao', 'Runoob')
9.7.元组内置函数
Python 元组包含了以下内置函数
第 47 页共 117 页

序号	方法及描述	实例
1	len(tuple) 计算元组元素个数。	>>> tuple1 = ('Google', 'Runoob', 'Taobao') >>> len(tuple1) 3 > >>
2	max(tuple) 返回元组中元素最大值。	>>> tuple2 = ('5', '4', '8') >>> max(tuple2) '8' >>>
3	min(tuple) 返回元组中元素最小值。	>>> tuple2 = ('5', '4', '8') >>> min(tuple2) '4' >>>
4	tuple(seq) 将列表转换为元组。	>>> list1= ['Google', 'Taobao', 'Runoob', 'Baidu'] >>> tuple1=tuple(list1) >>> tuple1 ('Google', 'Taobao', 'Runoob', 'Baidu')

10. Python3 字典
字典是另一种可变容器模型，且可存储任意类型对象。
字典的每个键值 (key=>value)对用冒号 (:)分割，每个对之间用逗号 (,)分割，整个字典包括在花括
号 ({})中 ,格式如下所示：
d = {key1 : value1, key2 : value2 }
键必须是唯一的，但值则不必。
值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。
一个简单的字典实例：
dict = {'Alice': '2341', 'Beth': '9102', 'Cecil': '3258'}
也可如此创建字典：
dict1 = { 'abc': 456 };
dict2 = { 'abc': 123, 98.6: 37 };
第 48 页共 117 页
10.1. 访问字典里的值
把相应的键放入熟悉的方括弧，如下实例 :
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
print ("dict['Name']: ", dict['Name'])
print ("dict['Age']: ", dict['Age'])
以上实例输出结果：
dict['Name']: Runoob
dict['Age']: 7
如果用字典里没有的键访问数据，会输出错误如下：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'};
print ("dict['Alice']: ", dict['Alice'])
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 5, in <module>
print ("dict['Alice']: ", dict['Alice'])
KeyError: 'Alice'
10.2. 修改字典
向字典添加新内容的方法是增加新的键 /值对，修改或删除已有键 /值对如下实例 :
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
dict['Age'] = 8; # 更新 Age
dict['School'] = "菜鸟教程 " # 添加信息
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School']) 以上实例输出结果：
dict['Age']: 8
dict['School']: 菜鸟教程
第 49 页共 117 页
10.3. 删除字典元素
能删单一的元素也能清空字典，清空只需一项操作。
显示删除一个字典用 del 命令，如下实例：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'}
del dict['Name'] # 删除键 'Name'
dict.clear() # 删除字典
del dict # 删除字典
print ("dict['Age']: ", dict['Age'])
print ("dict['School']: ", dict['School'])
但这会引发一个异常，因为用执行 del 操作后字典不再存在：
Traceback (most recent call last):
File "test.py", line 9, in <module>
print ("dict['Age']: ", dict['Age'])
TypeError: 'type' object is not subscriptable
注： del() 方法后面也会讨论。
10.4. 字典键的特性
字典值可以没有限制地取任何 python 对象，既可以是标准的对象，也可以是用户定义的，但键不行。
两个重要的点需要记住：
1）不允许同一个键出现两次。创建时如果同一个键被赋值两次，后一个值会被记住，如下实例：
#!/usr/bin/python3
dict = {'Name': 'Runoob', 'Age': 7, 'Name': '小菜鸟 '}
print ("dict['Name']: ", dict['Name'])
以上实例输出结果：
dict['Name']: 小菜鸟
2）键必须不可变，所以可以用数字，字符串或元组充当，而用列表就不行，如下实例：
#!/usr/bin/python3
dict = {['Name']: 'Runoob', 'Age': 7}
print ("dict['Name']: ", dict['Name'])
以上实例输出结果：
Traceback (most recent call last):
第 50 页共 117 页
File "test.py", line 3, in <module>
dict = {['Name']: 'Runoob', 'Age': 7}
TypeError: unhashable type: 'list'
10.5. 字典内置函数&方法
Python 字典包含了以下内置函数：

序号	函数及描述	实例
1	len(dict) 计算字典元素个数，即键的总数。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> len(dict) 3
2	str(dict) 输出字典，以可打印的字符串表示。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> str(dict) "{'Name': 'Runoob', 'Class': 'First', 'Age': 7}"
3	type(variable) 返回输入的变量类型，如果变量是字典就返回字典类型。	>>> dict = {'Name': 'Runoob', 'Age': 7, 'Class': 'First'} >>> type(dict) <class 'dict'>

Python 字典包含了以下内置方法：

序号	函数及描述
1	radiansdict.clear() 删除字典内所有元素
2	radiansdict.copy() 返回一个字典的浅复制
3	radiansdict.fromkeys() 创建一个新字典，以序列 seq 中元素做字典的键， val 为字典所有键对应的初始值
4	radiansdict.get(key, default=None) 返回指定键的值，如果值不在字典中返回 default 值
5	key in dict 如果键在字典 dict 里返回 true，否则返回 false
6	radiansdict.items()

第 51 页共 117 页

以列表返回可遍历的(键, 值) 元组数组
7	radiansdict.keys() 以列表返回一个字典所有的键
8	radiansdict.setdefault(key, default=None) 和 get()类似, 但如果键不存在于字典中，将会添加键并将值设为 default
9	radiansdict.update(dict2) 把字典 dict2 的键/值对更新到 dict 里
10	radiansdict.values() 以列表返回字典中的所有值

11. Python3 编程第一步
在前面的教程中我们已经学习了一些 Python3 的基本语法知识，下面我们尝试来写一个斐波纳契
数列。
实例如下：
#!/usr/bin/python3
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 10:
print(b)
a, b = b, a+b
执行以上程序，输出结果为：
1 1 2 3 5 8 这
个例子介绍了几个新特征。
第一行包含了一个复合赋值：变量 a 和 b 同时得到新值 0 和 1。最后一行再次使用了同样的方
第 52 页共 117 页
法，可以看到，右边的表达式会在赋值变动之前执行。右边表达式的执行顺序是从左往右的。
>>> i = 256*256
>>> print('i 的值为： ', i)
i 的值为： 65536
11.1. end 关键字
关键字 end 可以用于将结果输出到同一行，或者在输出的末尾添加不同的字符，实例如下：
#!/usr/bin/python3
# Fibonacci series: 斐波纳契数列
# 两个元素的总和确定了下一个数
a, b = 0, 1
while b < 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,
12. Python3 条件控制
Python 条件语句是通过一条或多条语句的执行结果（True 或者 False）来决定执行的代码块。
可以通过下图来简单了解条件语句的执行过程 :
if 语句
第 53 页共 117 页
Python 中 if 语句的一般形式如下所示：
if condition_1:
statement_block_1
elif condition_2:
statement_block_2
else:
statement_block_3
如果 "condition_1" 为 True 将执行 "statement_block_1" 块语句
如果 "condition_1" 为 False，将判断 "condition_2"
如果"condition_2" 为 True 将执行 "statement_block_2" 块语句
如果 "condition_2" 为 False，将执行"statement_block_3"块语句
Python 中用 elif 代替了 else if，所以 if 语句的关键字为： if – elif – else。
注意：
1、每个条件后面要使用冒号（:），表示接下来是满足条件后要执行的语句块。
2、使用缩进来划分语句块，相同缩进数的语句在一起组成一个语句块。
3、在 Python 中没有 switch – case 语句。
实例
以下是一个简单的 if 实例：
#!/usr/bin/python3
var1 = 100
if var1:
print ("1 - if 表达式条件为 true")
print (var1)
var2 = 0
if var2:
print ("2 - if 表达式条件为 true")
print (var2)
print ("Good bye!")
执行以上代码，输出结果为：
1 - if 表达式条件为 true
第 54 页共 117 页
100
Good bye!
从结果可以看到由于变量 var2 为 0，所以对应的 if 内的语句没有执行。
以下实例演示了狗的年龄计算判断：
#!/usr/bin/python3
age = int(input("请输入你家狗狗的年龄: "))
print("")
if age < 0:
print("你是在逗我吧!")
elif age == 1:
print("相当于 14 岁的人。 ")
elif age == 2:
print("相当于 22 岁的人。 ")
elif age > 2:
human = 22 + (age -2)*5
print("对应人类年龄: ", human)
### 退出提示
input("点击 enter 键退出")
将以上脚本保存在 dog.py 文件中，并执行该脚本：
$ python3 dog.py
请输入你家狗狗的年龄: 1
相当于 14 岁的人。
点击 enter 键退出
以下为 if 中常用的操作运算符:

操作符	描述
<	小于
<=	小于或等于
>	大于
>=	大于或等于

第 55 页共 117 页

==	等于，比较对象是否相等
!=	不等于

实例
#!/usr/bin/python3
# 程序演示了 == 操作符
# 使用数字
print(5 == 6)
# 使用变量
x = 5
y = 8
print(x == y)
以上实例输出结果：
False
False
high_low.py 文件演示了数字的比较运算：
#!/usr/bin/python3
# 该实例演示了数字猜谜游戏
number = 7
guess = -1
print("数字猜谜游戏!")
while guess != number:
guess = int(input("请输入你猜的数字： "))
if guess == number:
print("恭喜，你猜对了！ ")
elif guess < number:
print("猜的数字小了...")
elif guess > number:
print("猜的数字大了...")
执行以上脚本，实例输出结果如下：
第 56 页共 117 页
$ python3 high_low.py
数字猜谜游戏!
请输入你猜的数字： 1
猜的数字小了...
请输入你猜的数字： 9
猜的数字大了...
请输入你猜的数字： 7
恭喜，你猜对了！
12.1. if 嵌套
在嵌套 if 语句中，可以把 if...elif...else 结构放在另外一个 if...elif...else 结构中。
if 表达式 1:
语句
if 表达式 2:
语句
elif 表达式 3:
语句
else
语句
elif 表达式 4:
语句
else:
语句
实例
# !/usr/bin/python3
num=int(input("输入一个数字： "))
if num%2==0:
if num%3==0:
print ("你输入的数字可以整除 2 和 3")
else:
print ("你输入的数字可以整除 2，但不能整除 3")
else:
第 57 页共 117 页
if num%3==0:
print ("你输入的数字可以整除 3，但不能整除 2")
else:
print ("你输入的数字不能整除 2 和 3")
将以上程序保存到 test_if.py 文件中，执行后输出结果为：
$ python3 test.py
输入一个数字： 6
你输入的数字可以整除 2 和 3
13. Python3 循环语句
本章节将为大家介绍 Python 循环语句的使用。
Python 中的循环语句有 for 和 while。
Python 循环语句的控制结构图如下所示：
13.1. while 循环
Python 中 while 语句的一般形式：
while 判断条件：
语句
同样需要注意冒号和缩进。另外，在 Python 中没有 do..while 循环。
以下实例使用了 while 来计算 1 到 100 的总和：
#!/usr/bin/env python3
n = 100
sum = 0
counter = 1
第 58 页共 117 页
while counter <= n:
sum = sum + counter
counter += 1
print("1 到 %d 之和为: %d" % (n,sum))
执行结果如下：
1 到 100 之和为: 5050
13.2. 无限循环
我们可以通过设置条件表达式永远不为 false 来实现无限循环，实例如下：
#!/usr/bin/python3
var = 1
while var == 1 : # 表达式永远为 true
num = int(input("输入一个数字 :"))
print ("你输入的数字是: ", num)
print ("Good bye!")
执行以上脚本，输出结果如下：
输入一个数字 :5
你输入的数字是: 5
输入一个数字 :
你可以使用 CTRL+C 来退出当前的无限循环。
无限循环在服务器上客户端的实时请求非常有用。
13.3. while 循环使用 else 语句
在 while … else 在条件语句为 false 时执行 else 的语句块：
#!/usr/bin/python3
count = 0
while count < 5:
print (count, " 小于 5")
count = count + 1
第 59 页共 117 页
else:
print (count, " 大于或等于 5")
执行以上脚本，输出结果如下：
0 小于 5
1 小于 5
2 小于 5
3 小于 5
4 小于 5
5 大于或等于 5
13.4. 简单语句组
类似 if 语句的语法，如果你的 while 循环体中只有一条语句，你可以将该语句与 while 写在同一行中，如下所示：
#!/usr/bin/python
flag = 1
while (flag): print ('欢迎访问菜鸟教程!')
print ("Good bye!")
注意：以上的无限循环你可以使用 CTRL+C 来中断循环。
执行以上脚本，输出结果如下：
13.5. for 语句
Python for 循环可以遍历任何序列的项目，如一个列表或者一个字符串。
for 循环的一般格式如下：
for <variable> in <sequence>:
<statements>
else:
<statements>
Python loop 循环实例：
>>> languages = ["C", "C++", "Perl", "Python"]
>>> for x in languages:
... print (x)
第 60 页共 117 页
...
C C
++
Perl
Python
>>>
以下 for 实例中使用了 break 语句， break 语句用于跳出当前循环体：
#!/usr/bin/python3
sites = ["Baidu", "Google","Runoob","Taobao"]
for site in sites:
if site == "Runoob":
print("菜鸟教程!")
break
print("循环数据 " + site)
else:
print("没有循环数据!")
print("完成循环!")
执行脚本后，在循环到 "Runoob"时会跳出循环体：
循环数据 Baidu
循环数据 Google
菜鸟教程!
完成循环!
13.6. range()函数
如果你需要遍历数字序列，可以使用内置 range()函数。它会生成数列，例如:
>>> for i in range(5):
... print(i)
...
0 1 2 3
第 61 页共 117 页
4 你
也可以使用 range 指定区间的值：
>>> for i in range(5,9) :
print(i)
5 6 7 8 >
>>
也可以使 range 以指定数字开始并指定不同的增量(甚至可以是负数，有时这也叫做'步长'):
>>> for i in range(0, 10, 3) :
print(i)
0 3 6 9 >
>>
负数：
>>> for i in range(-10, -100, -30) :
print(i)
-10
-40
-70
>>>
您可以结合 range()和 len()函数以遍历一个序列的索引,如下所示:
>>> a = ['Google', 'Baidu', 'Runoob', 'Taobao', 'QQ']
第 62 页共 117 页
>>> for i in range(len(a)):
... print(i, a[i])
...
0 Google
1 Baidu
2 Runoob
3 Taobao
4 QQ
>>>
还可以使用 range()函数来创建一个列表：
>>> list(range(5))
[0, 1, 2, 3, 4]
>>>
13.7. break 和 continue 语句及循环中的 else 子句
break 语句可以跳出 for 和 while 的循环体。如果你从 for 或 while 循环中终止，任何对应的循环 else 块将不执行。
实例如下：
#!/usr/bin/python3
for letter in 'Runoob': # 第一个实例
if letter == 'b':
break
print ('当前字母为 :', letter)

var = 10	# 第二个实例
while var > 0:
print ('当期变量值为 :', var)
var = var -1
if var == 5:
break
print ("Good bye!")
执行以上脚本输出结果为：

第 63 页共	117 页	continue print ('当前变量值 :', var) print ("Good bye!") 执行以上脚本输出结果为：当前字母 : R 当前字母 : u 当前字母 : n 当前字母 : b 当前变量值 : 9
#!/usr/bin/python3 for letter in 'Runoob':	# 第一个实例
if letter == 'o':	# 字母为 o 时跳过输出
continue print ('当前字母 :', letter) var = 10	# 第二个实例
while var > 0: var = var -1 if var == 5:	# 变量为 5 时跳过输出

当前字母为 : R
当前字母为 : u
当前字母为 : n
当前字母为 : o
当前字母为 : o
当期变量值为 : 10
当期变量值为 : 9
当期变量值为 : 8
当期变量值为 : 7
当期变量值为 : 6
Good bye!
continue 语句被用来告诉 Python 跳过当前循环块中的剩余语句，然后继续进行下一轮循环。

第 64 页共 117 页
当前变量值 : 8
当前变量值 : 7
当前变量值 : 6
当前变量值 : 4
当前变量值 : 3
当前变量值 : 2
当前变量值 : 1
当前变量值 : 0
Good bye!
循环语句可以有 else 子句，它在穷尽列表(以 for 循环)或条件变为 false (以 while 循环)导致循环终止时被执行,但循环
被 break 终止时不执行。
如下实例用于查询质数的循环例子:
#!/usr/bin/python3
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, '等于', x, '*', n//x)
break
else:
# 循环中没有找到元素
print(n, ' 是质数')
执行以上脚本输出结果为：
2 是质数
3 是质数
4 等于 2 * 2
5 是质数
6 等于 2 * 3
7 是质数
8 等于 2 * 4
9 等于 3 * 3
第 65 页共 117 页
13.8. pass 语句
Python pass 是空语句，是为了保持程序结构的完整性。
pass 不做任何事情，一般用做占位语句，如下实例
>>> while True:
... pass # 等待键盘中断 (Ctrl+C)
最小的类:
>>> class MyEmptyClass:
... pass
以下实例在字母为 o 时执行 pass 语句块:
#!/usr/bin/python3
for letter in 'Runoob':
if letter == 'o':
pass
print ('执行 pass 块')
print ('当前字母 :', letter)
print ("Good bye!")
执行以上脚本输出结果为：
当前字母 : R
当前字母 : u
当前字母 : n
执行 pass 块
当前字母 : o
执行 pass 块
当前字母 : o
当前字母 : b
Good bye!
14. Python3 迭代器与生成器
14.1. 迭代器
迭代是 Python 最强大的功能之一，是访问集合元素的一种方式。。

第 66 页共	117 页	while True: try: print (next(it)) except StopIteration:
import sys	# 引入 sys 模块
list=[1,2,3,4] it = iter(list)	# 创建迭代器对象

迭代器是一个可以记住遍历的位置的对象。
迭代器对象从集合的第一个元素开始访问，直到所有的元素被访问完结束。迭代器只能往前不会后退。
迭代器有两个基本的方法： iter() 和 next()。
字符串，列表或元组对象都可用于创建迭代器：
>>> list=[1,2,3,4]
>>> it = iter(list) # 创建迭代器对象
>>> print (next(it)) # 输出迭代器的下一个元素
1 >
>> print (next(it))
2 >
>>
迭代器对象可以使用常规 for 语句进行遍历：
#!/usr/bin/python3
list=[1,2,3,4]
it = iter(list) # 创建迭代器对象
for x in it:
print (x, end=" ")
执行以上程序，输出结果如下：
1 2 3 4
也可以使用 next() 函数：
#!/usr/bin/python3

第 67 页共 117 页
sys.exit()
执行以上程序，输出结果如下：
1 2 3 4 1
4.2. 生成器
在 Python 中，使用了 yield 的函数被称为生成器（generator）。
跟普通函数不同的是，生成器是一个返回迭代器的函数，只能用于迭代操作，更简单点理解生成器就是一个迭代器。
在调用生成器运行的过程中，每次遇到 yield 时函数会暂停并保存当前所有的运行信息，返回 yield 的值。并在下一次
执行 next()方法时从当前位置继续运行。
以下实例使用 yield 实现斐波那契数列：
#!/usr/bin/python3
import sys
def fibonacci(n): # 生成器函数 - 斐波那契
a, b, counter = 0, 1, 0
while True:
if (counter > n):
return
yield a
a, b = b, a + b
counter += 1
f = fibonacci(10) # f 是一个迭代器，由生成器返回生成
while True:
try:
print (next(f), end=" ")
except StopIteration:
sys.exit()
执行以上程序，输出结果如下：
第 68 页共 117 页
0 1 1 2 3 5 8 13 21 34 55
15. Python3 函数
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。
函数能提高应用的模块性，和代码的重复利用率。你已经知道 Python 提供了许多内建函数，比如 print()。但你也可以
自己创建函数，这被叫做用户自定义函数。
15.1. 定义一个函数
你可以定义一个由自己想要功能的函数，以下是简单的规则：
函数代码块以 def 关键词开头，后接函数标识符名称和圆括号 ()。
任何传入参数和自变量必须放在圆括号中间，圆括号之间可以用于定义参数。
函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。
函数内容以冒号起始，并且缩进。
return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的 return 相当于返回 None。
语法
Python 定义函数使用 def 关键字，一般格式如下：
def 函数名（参数列表） :
函数体
默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
实例
让我们使用函数来输出"Hello World！ "：
>>> def hello() :
print("Hello World!")
>>> hello()
Hello World!
>>>
更复杂点的应用，函数中带上参数变量:
#!/usr/bin/python3
# 计算面积函数
def area(width, height):
第 69 页共 117 页
return width * height
def print_welcome(name):
print("Welcome", name)
print_welcome("Runoob")
w = 4
h = 5
print("width =", w, " height =", h, " area =", area(w, h))
以上实例输出结果：
Welcome Runoob
width = 4 height = 5 area = 20
15.2. 函数调用
定义一个函数：给了函数一个名称，指定了函数里包含的参数，和代码块结构。
这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从 Python 命令提示符执行。
如下实例调用了 printme() 函数：
#!/usr/bin/python3
# 定义函数
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
# 调用函数
printme("我要调用用户自定义函数!");
printme("再次调用同一函数");
以上实例输出结果：
我要调用用户自定义函数!
再次调用同一函数
第 70 页共 117 页
15.3. 按值传递参数和按引用传递参数
在 Python 中，所有参数（变量）都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原
始的参数也被改变了。例如：
#!/usr/bin/python3
# 可写函数说明
def changeme( mylist ):
"修改传入的列表"
mylist.append([1,2,3,4]);
print ("函数内取值: ", mylist)
return
# 调用 changeme 函数
mylist = [10,20,30];
changeme( mylist );
print ("函数外取值: ", mylist)
传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
函数内取值: [10, 20, 30, [1, 2, 3, 4]]
函数外取值: [10, 20, 30, [1, 2, 3, 4]]
15.4. 参数
以下是调用函数时可使用的正式参数类型：
必需参数
关键字参数
默认参数
不定长参数
必需参数
必需参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。
调用 printme()函数，你必须传入一个参数，不然会出现语法错误：
#!/usr/bin/python3
#可写函数说明
第 71 页共 117 页
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
#调用 printme 函数
printme();
以上实例输出结果：
Traceback (most recent call last):
File "test.py", line 10, in <module>
printme();
TypeError: printme() missing 1 required positional argument: 'str'
关键字参数
关键字参数和函数调用关系紧密，函数调用使用关键字参数来确定传入的参数值。
使用关键字参数允许函数调用时参数的顺序与声明时不一致，因为 Python 解释器能够用参数名匹配参数值。
以下实例在函数 printme() 调用时使用参数名：
#!/usr/bin/python3
#可写函数说明
def printme( str ):
"打印任何传入的字符串"
print (str);
return;
#调用 printme 函数
printme( str = "菜鸟教程");
以上实例输出结果：
菜鸟教程
以下实例中演示了函数参数的使用不需要使用指定顺序：
#!/usr/bin/python3
#可写函数说明
第 72 页共 117 页
def printinfo( name, age ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用 printinfo 函数
printinfo( age=50, name="runoob" );
以上实例输出结果：
名字: runoob
年龄: 50
默认参数
调用函数时，如果没有传递参数，则会使用默认参数。以下实例中如果没有传入 age 参数，则使用默认值：
#!/usr/bin/python3
#可写函数说明
def printinfo( name, age = 35 ):
"打印任何传入的字符串"
print ("名字: ", name);
print ("年龄: ", age);
return;
#调用 printinfo 函数
printinfo( age=50, name="runoob" );
print ("------------------------")
printinfo( name="runoob" );
以上实例输出结果：
名字: runoob
年龄: 50
------------------------
名字: runoob
年龄: 35
第 73 页共 117 页
不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述 2 种参数不同，声明时不会
命名。基本语法如下：
def functionname([formal_args,] *var_args_tuple ):
"函数_文档字符串"
function_suite
return [expression]
加了星号（*）的变量名会存放所有未命名的变量参数。如果在函数调用时没有指定参数，它就是一个空元组。我们也
可以不向函数传递未命名的变量。如下实例：
#!/usr/bin/python3
# 可写函数说明
def printinfo( arg1, *vartuple ):
"打印任何传入的参数"
print ("输出: ")
print (arg1)
for var in vartuple:
print (var)
return;
# 调用 printinfo 函数
printinfo( 10 );
printinfo( 70, 60, 50 );
以上实例输出结果：
输出:
10
输出:
70
60
50
匿名函数
python 使用 lambda 来创建匿名函数。
第 74 页共 117 页
所谓匿名，意即不再使用 def 语句这样标准的形式定义一个函数。
lambda 只是一个表达式，函数体比 def 简单很多。
lambda 的主体是一个表达式，而不是一个代码块。仅仅能在 lambda 表达式中封装有限的逻辑进去。
lambda 函数拥有自己的命名空间，且不能访问自有参数列表之外或全局命名空间里的参数。
虽然 lambda 函数看起来只能写一行，却不等同于 C 或 C++的内联函数，后者的目的是调用小函数时不占用栈内存从而
增加运行效率。
语法
lambda 函数的语法只包含一个语句，如下：
lambda [arg1 [,arg2,.....argn]]:expression
如下实例：
#!/usr/bin/python3
# 可写函数说明
sum = lambda arg1, arg2: arg1 + arg2;
# 调用 sum 函数
print ("相加后的值为 : ", sum( 10, 20 ))
print ("相加后的值为 : ", sum( 20, 20 ))
以上实例输出结果：
相加后的值为 : 30
相加后的值为 : 40
15.5. return 语句
return [表达式] 语句用于退出函数，选择性地向调用方返回一个表达式。不带参数值的 return 语句返回 None。之前的
例子都没有示范如何返回数值，以下实例演示了 return 语句的用法：
#!/usr/bin/python3
# 可写函数说明
def sum( arg1, arg2 ):
# 返回 2 个参数的和."
total = arg1 + arg2
print ("函数内 : ", total)
return total;
第 75 页共 117 页
# 调用 sum 函数
total = sum( 10, 20 );
print ("函数外 : ", total)
以上实例输出结果：
函数内 : 30
函数外 : 30
15.6. 变量作用域
Pyhton 中，程序的变量并不是在哪个位置都可以访问的，访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序可以访问哪个特定的变量名称。两种最基本的变量作用域如下：
全局变量
局部变量
15.7. 全局变量和局部变量
定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明
的变量名称都将被加入到作用域中。如下实例：
#!/usr/bin/python3
total = 0; # 这是一个全局变量
# 可写函数说明
def sum( arg1, arg2 ):
#返回 2 个参数的和."
total = arg1 + arg2; # total 在这里是局部变量.
print ("函数内是局部变量 : ", total)
return total;
#调用 sum 函数
sum( 10, 20 );
print ("函数外是全局变量 : ", total)
以上实例输出结果：
函数内是局部变量 : 30
第 76 页共 117 页
函数外是全局变量 : 0
16. Python3 数据结构
本章节我们主要结合前面所学的知识点来介绍 Python 数据结构。
16.1. 列表
Python 中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元
组不能。
以下是 Python 中列表的方法：

方法	描述
list.append(x)	把一个元素添加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过添加指定列表的所有元素来扩充列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定位置插入一个元素。第一个参数是准备插入到其前面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x) 。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个错误。
list.pop([i])	从列表的指定位置删除元素，并将其返回。如果没有指定索引， a.pop()返回最后一个元素。元素随即从列表中被删除。（方法中 i 两边的方括号表示这个参数是可选的，而不是要求你输入一对方括号，你会经常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于 del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个错误。
list.count(x)	返回 x 在列表中出现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于 a[:]。

下面示例演示了列表的大部分方法：
>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
第 77 页共 117 页
>>> a.index(333)
1 >
>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]
注意：类似 insert, remove 或 sort 等修改列表的方法没有返回值。
16.2. 将列表当做堆栈使用
列表方法使得列表可以很方便的作为一个堆栈来使用，堆栈作为特定的数据结构，最先进入的元素最后一个被释放（后
进先出）。用 append() 方法可以把一个元素添加到堆栈顶。用不指定索引的 pop() 方法可以把一个元素从堆栈顶释放
出来。例如：
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7 >
>> stack
[3, 4, 5, 6]
>>> stack.pop()
6 >
>> stack.pop()
5 >
>> stack
[3, 4]
第 78 页共 117 页
16.3. 将列表当作队列使用
也可以把列表当做队列用，只是在队列里第一加入的元素，第一个取出来；但是拿列表用作这样的目的效率不高。在
列表的最后添加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其他的元素都得一个
一个地移动）。
>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry") # Terry arrives
>>> queue.append("Graham") # Graham arrives
>>> queue.popleft() # The first to arrive now leaves
'Eric'

>>> queue.popleft()	# The second to arrive now leaves
'John' >>> queue	# Remaining queue in order of arrival

deque(['Michael', 'Terry', 'Graham'])
16.4. 列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结
果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for
和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
这里我们将列表中每个数值乘三，获得一个新的列表：
>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]
现在我们玩一点小花样：
>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]
这里我们对序列里每一个元素逐个调用某方法：
>>> freshfruit = [' banana', ' loganberry ', 'passion fruit ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']
我们可以用 if 子句作为过滤器：
第 79 页共 117 页
>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]
以下是一些关于循环和其它技巧的演示：
>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]
列表推导式可以使用复杂表达式或嵌套函数：
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']
16.5. 嵌套列表解析
Python 的列表还可以嵌套。
以下实例展示了 3X4 的矩阵列表：
>>> matrix = [
... [1, 2, 3, 4],
... [5, 6, 7, 8],
... [9, 10, 11, 12],
... ]
以下实例将 3X4 的矩阵列表转换为 4X3 列表：
>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
以下实例也可以使用以下方法来实现：
>>> transposed = []
>>> for i in range(4):
... transposed.append([row[i] for row in matrix])
...
第 80 页共 117 页
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
另外一种实现方法：
>>> transposed = []
>>> for i in range(4):
... # the following 3 lines implement the nested listcomp
... transposed_row = []
... for row in matrix:
... transposed_row.append(row[i])
... transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]
16.6. del 语句
使用 del 语句可以从一个列表中依索引而不是值来删除一个元素。这与使用 pop() 返回一个值不同。可以用 del 语句
从列表中删除一个切割，或清空整个列表（我们以前介绍的方法是给该切割赋一个空列表）。例如：
>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]
也可以用 del 删除实体变量：
>>> del a
16.7. 元组和序列
元组由若干逗号分隔的值组成，例如：
>>> t = 12345, 54321, 'hello!'
第 81 页共 117 页
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))
如你所见，元组在输出时总是有括号的，以便于正确表达嵌套结构。在输入时可能有或没有括号，不过括号通常是必
须的（如果元组是更大的表达式的一部分）。
16.8. 集合
集合是一个无序不重复元素的集。基本功能包括关系测试和消除重复元素。
可以用大括号({})创建集合。注意：如果要创建一个空集合，你必须用 set() 而不是 {} ；后者创建一个空的字典，下
一节我们会介绍这个数据结构。
以下是一个简单的演示：
>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket) # 删除重复的
{'orange', 'banana', 'pear', 'apple'}

>>> 'orange' in basket	# 检测成员
True
>>> 'crabgrass' in basket
False

>>> # 以下演示了两个集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b # 在 a 或 b 中的字母
第 82 页共 117 页

{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} >>> a & b	# 在 a 和 b 中都有的字母
{'a', 'c'} >>> a ^ b	# 在 a 或 b 中的字母，但不同时在 a 和 b 中

{'r', 'd', 'b', 'm', 'z', 'l'}
集合也支持推导式：
>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}
16.9. 字典
另一个非常有用的 Python 内建数据类型是字典。
序列是以连续的整数为索引，与此不同的是，字典以关键字为索引，关键字可以是任意不可变类型，通常用字符串或
数值。
理解字典的最佳方式是把它看做无序的键=>值对集合。在同一个字典之内，关键字必须是互不相同。
一对大括号创建一个空的字典： {}。
这是一个字典运用的简单例子：
>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
第 83 页共 117 页
>>> 'jack' not in tel
False
构造函数 dict() 直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
此外，字典推导可以用来创建任意键和值的表达式词典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}
16.10. 遍历技巧
在字典中遍历时，关键字和对应的值可以使用 items() 方法同时解读出来：
>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
... print(k, v)
...
gallahad the pure
robin the brave
在序列中遍历时，索引位置和对应值可以使用 enumerate() 函数同时得到：
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
... print(i, v)
...
0 tic
1 tac
2 toe
同时遍历两个或更多的序列，可以使用 zip() 组合：
>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
... print('What is your {0}? It is {1}.'.format(q, a))
...
第 84 页共 117 页
What is your name? It is lancelot.
What is your quest? It is the holy grail.
What is your favorite color? It is blue.
要反向遍历一个序列，首先指定这个序列，然后调用 reversesd() 函数：
>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9 7 5 3 1 要
按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值：
>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
Pear
17. Python3 模块
在前面的几个章节中我们脚本上是用 python 解释器来编程，如果你从 Python 解释器退出再进入，那么你定义的所有
的方法和变量就都消失了。
为此 Python 提供了一个办法，把这些定义存放在文件中，为一些脚本或者交互式的解释器实例使用，这个文件被称
为模块。
模块是一个包含所有你定义的函数和变量的文件，其后缀名是.py。模块可以被别的程序引入，以使用该模块中的函数
等功能。这也是使用 python 标准库的方法。
下面是一个使用 python 标准库中模块的例子。
#!/usr/bin/python3
# 文件名: using_sys.py
第 85 页共 117 页
import sys
print('命令行参数如下:')
for i in sys.argv:
print(i)
print('\n\nPython 路径为： ', sys.path, '\n')
执行结果如下所示：
$ python using_sys.py 参数 1 参数 2
命令行参数如下:
using_sys.py
参数 1
参数 2
Python 路径为： ['/root', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload',
'/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
1、 import sys 引入 python 标准库中的 sys.py 模块；这是引入某一模块的方法。
2、 sys.argv 是一个包含命令行参数的列表。
3、 sys.path 包含了一个 Python 解释器自动查找所需模块的路径的列表。
17.1. import 语句
想使用 Python 源文件，只需在另一个源文件里执行 import 语句，语法如下：
import module1[, module2[,... moduleN]
当解释器遇到 import 语句，如果模块在当前的搜索路径就会被导入。
搜索路径是一个解释器会先进行搜索的所有目录的列表。如想要导入模块 support，需要把命令放在脚本的顶端：
support.py 文件代码为：
#!/usr/bin/python3
# Filename: support.py
def print_func( par ):
print ("Hello : ", par)
return
第 86 页共 117 页
test.py 引入 support 模块：
#!/usr/bin/python3
# Filename: test.py
# 导入模块
import support
# 现在可以调用模块里包含的函数了
support.print_func("Runoob")
以上实例输出结果：
$ python3 test.py
Hello : Runoob
一个模块只会被导入一次，不管你执行了多少次 import。这样可以防止导入模块被一遍又一遍地执行。
当我们使用 import 语句的时候， Python 解释器是怎样找到对应的文件的呢？
这就涉及到 Python 的搜索路径，搜索路径是由一系列目录名组成的， Python 解释器就依次从这些目录中去寻找所引入
的模块。
这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。
搜索路径是在 Python 编译或安装的时候确定的，安装新的库应该也会修改。搜索路径被存储在 sys 模块中的 path 变量，
做一个简单的实验，在交互式解释器中，输入以下代码：
>>> import sys
>>> sys.path
['', '/usr/lib/python3.4', '/usr/lib/python3.4/plat-x86_64-linux-gnu', '/usr/lib/python3.4/lib-dynload',
'/usr/local/lib/python3.4/dist-packages', '/usr/lib/python3/dist-packages']
>>>
sys.path 输出是一个列表，其中第一项是空串''，代表当前目录（若是从一个脚本中打印出来的话，可以更清楚地看出
是哪个目录），亦即我们执行 python 解释器的目录（对于脚本的话就是运行的脚本所在的目录）。
因此若像我一样在当前目录下存在与要引入模块同名的文件，就会把要引入的模块屏蔽掉。
了解了搜索路径的概念，就可以在脚本中修改 sys.path 来引入一些不在搜索路径中的模块。
现在，在解释器的当前目录或者 sys.path 中的一个目录里面来创建一个 fibo.py 的文件，代码如下：
# 斐波那契(fibonacci)数列模块
def fib(n): # 定义到 n 的斐波那契数列
第 87 页共 117 页
a, b = 0, 1
while b < n:
print(b, end=' ')
a, b = b, a+b
print()
def fib2(n): # 返回到 n 的斐波那契数列
result = []
a, b = 0, 1
while b < n:
result.append(b)
a, b = b, a+b
return result
然后进入 Python 解释器，使用下面的命令导入这个模块：
>>> import fibo
这样做并没有把直接定义在 fibo 中的函数名称写入到当前符号表里，只是把模块 fibo 的名字写到了那里。
可以使用模块名称来访问函数：
>>> fibo.fib(1000)
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
>>> fibo.fib2(100)
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>> fibo.__name__
'fibo'
如果你打算经常使用一个函数，你可以把它赋给一个本地的名称：
>>> fib = fibo.fib
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
17.2. from…import 语句
Python 的 from 语句让你从模块中导入一个指定的部分到当前命名空间中，语法如下：
from modname import name1[, name2[, ... nameN]]
例如，要导入模块 fibo 的 fib 函数，使用如下语句：
>>> from fibo import fib, fib2
第 88 页共 117 页
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这个声明不会把整个 fibo 模块导入到当前的命名空间中，它只会将 fibo 里的 fib 函数引入进来。
17.3. From…import* 语句
把一个模块的所有内容全都导入到当前的命名空间也是可行的，只需使用如下声明：
from modname import *
这提供了一个简单的方法来导入一个模块中的所有项目。然而这种声明不该被过多地使用。
深入模块
模块除了方法定义，还可以包括可执行的代码。这些代码一般用来初始化这个模块。这些代码只有在第一次被导入时
才会被执行。
每个模块有各自独立的符号表，在模块内部为所有的函数当作全局符号表来使用。
所以，模块的作者可以放心大胆的在模块内部使用这些全局变量，而不用担心把其他用户的全局变量搞花。
从另一个方面，当你确实知道你在做什么的话，你也可以通过 modname.itemname 这样的表示法来访问模块内的函数。
模块是可以导入其他模块的。在一个模块（或者脚本，或者其他地方）的最前面使用 import 来导入一个模块，当然这
只是一个惯例，而不是强制的。被导入的模块的名称将被放入当前操作的模块的符号表中。
还有一种导入的方法，可以使用 import 直接把模块内（函数，变量的）名称导入到当前操作模块。比如:
>>> from fibo import fib, fib2
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这种导入的方法不会把被导入的模块的名称放在当前的字符表中（所以在这个例子里面， fibo 这个名称是没有定义的）。
这还有一种方法，可以一次性的把模块中的所有（函数，变量）名称都导入到当前模块的字符表:
>>> from fibo import *
>>> fib(500)
1 1 2 3 5 8 13 21 34 55 89 144 233 377
这将把所有的名字都导入进来，但是那些由单一下划线（_）开头的名字不在此例。大多数情况， Python 程序员不使
用这种方法，因为引入的其它来源的命名，很可能覆盖了已有的定义。
17.4. __name__属性
一个模块被另一个程序第一次引入时，其主程序将运行。如果我们想在模块被引入时，模块中的某一程序块不执行，
我们可以用__name__属性来使该程序块仅在该模块自身运行时执行。
#!/usr/bin/python3
第 89 页共 117 页
# Filename: using_name.py
if __name__ == '__main__':
print('程序自身在运行')
else:
print('我来自另一模块')
运行输出如下：
$ python using_name.py
程序自身在运行
$ python
>>> import using_name
我来自另一模块
>>>
说明：每个模块都有一个__name__属性，当其值是'__main__'时，表明该模块自身在运行，否则是被引入。
17.5. dir() 函数
内置的函数 dir() 可以找到模块内定义的所有名称。以一个字符串列表的形式返回:
</p>
<pre>
>>> import fibo, sys
>>> dir(fibo)
['__name__', 'fib', 'fib2']
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__loader__', '__name__',
'__package__', '__stderr__', '__stdin__', '__stdout__',
'_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe',
'_home', '_mercurial', '_xoptions', 'abiflags', 'api_version', 'argv',
'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder',
'call_tracing', 'callstats', 'copyright', 'displayhook',
'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix',
'executable', 'exit', 'flags', 'float_info', 'float_repr_style',
'getcheckinterval', 'getdefaultencoding', 'getdlopenflags',
'getfilesystemencoding', 'getobjects', 'getprofile', 'getrecursionlimit',
第 90 页共 117 页
'getrefcount', 'getsizeof', 'getswitchinterval', 'gettotalrefcount',
'gettrace', 'hash_info', 'hexversion', 'implementation', 'int_info',
'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path',
'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1',
'setcheckinterval', 'setdlopenflags', 'setprofile', 'setrecursionlimit',
'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout',
'thread_info', 'version', 'version_info', 'warnoptions']
如果没有给定参数，那么 dir() 函数会罗列出当前定义的所有名称:
>>> a = [1, 2, 3, 4, 5]
>>> import fibo
>>> fib = fibo.fib
>>> dir() # 得到一个当前模块中定义的属性列表
['__builtins__', '__name__', 'a', 'fib', 'fibo', 'sys']
>>> a = 5 # 建立一个新的变量 'a'
>>> dir()
['__builtins__', '__doc__', '__name__', 'a', 'sys']
>>>
>>> del a # 删除变量名 a
>>>
>>> dir()
['__builtins__', '__doc__', '__name__', 'sys']
>>>
17.6. 标准模块
Python 本身带着一些标准的模块库，在 Python 库参考文档中将会介绍到（就是后面的"库参考文档"）。
有些模块直接被构建在解析器里，这些虽然不是一些语言内置的功能，但是他却能很高效的使用，甚至是系统级调用
也没问题。
这些组件会根据不同的操作系统进行不同形式的配置，比如 winreg 这个模块就只会提供给 Windows 系统。
应该注意到这有一个特别的模块 sys ，它内置在每一个 Python 解析器中。变量 sys.ps1 和 sys.ps2 定义了主提示符
和副提示符所对应的字符串:
>>> import sys
>>> sys.ps1
'>>> '
第 91 页共 117 页
>>> sys.ps2
'... '
>>> sys.ps1 = 'C> '
C> print('Yuck!')
Yuck!
C>
17.7. 包
包是一种管理 Python 模块命名空间的形式，采用"点模块名称"。
比如一个模块的名称是 A.B，那么他表示一个包 A 中的子模块 B 。
就好像使用模块的时候，你不用担心不同模块之间的全局变量相互影响一样，采用点模块名称这种形式也不用担心不
同库之间的模块重名的情况。
这样不同的作者都可以提供 NumPy 模块，或者是 Python 图形库。
不妨假设你想设计一套统一处理声音文件和数据的模块（或者称之为一个"包"）。
现存很多种不同的音频文件格式（基本上都是通过后缀名区分的，例如： .wav， :file:.aiff， :file:.au，），所以你需要
有一组不断增加的模块，用来在不同的格式之间转换。
并且针对这些音频数据，还有很多不同的操作（比如混音，添加回声，增加均衡器功能，创建人造立体声效果），所
你还需要一组怎么也写不完的模块来处理这些操作。
这里给出了一种可能的包结构（在分层的文件系统中） :
sound/ 顶层包

__init__.py	初始化 sound 包
formats/	文件格式转换子包

__init__.py
wavread.py
wavwrite.py
aiffread.py
aiffwrite.py
auread.py
auwrite.py
...

effects/	声音效果子包
__init__.py
echo.py

第 92 页共 117 页
surround.py
reverse.py
...

filters/	filters 子包
__init__.py
equalizer.py
vocoder.py
karaoke.py
...
在导入一个包的时候， Python 会根据 sys.path 中的目录来寻找这个包中包含的子目录。
目录只有包含一个叫做 __init__.py 的文件才会被认作是一个包，主要是为了避免一些滥俗的名字（比如叫做 string）
不小心的影响搜索路径中的有效模块。
最简单的情况，放一个空的 :file:__init__.py 就可以了。当然这个文件中也可以包含一些初始化代码或者为（将在后面
介绍的） __all__变量赋值。
用户可以每次只导入一个包里面的特定模块，比如:
import sound.effects.echo
这将会导入子模块:sound.effects.echo。他必须使用全名去访问:
sound.effects.echo.echofilter(input, output, delay=0.7, atten=4)
还有一种导入子模块的方法是:
from sound.effects import echo
这同样会导入子模块: echo，并且他不需要那些冗长的前缀，所以他可以这样使用:
echo.echofilter(input, output, delay=0.7, atten=4)
还有一种变化就是直接导入一个函数或者变量:
from sound.effects.echo import echofilter
同样的，这种方法会导入子模块: echo，并且可以直接使用他的 echofilter() 函数:
echofilter(input, output, delay=0.7, atten=4)
注意当使用 from package import item 这种形式的时候，对应的 item 既可以是包里面的子模块（子包），或者包里面定
义的其他名称，比如函数，类或者变量。
import 语法会首先把 item 当作一个包定义的名称，如果没找到，再试图按照一个模块去导入。如果还没找到，恭喜，
一个:exc:ImportError 异常被抛出了。
反之，如果使用形如 import item.subitem.subsubitem 这种导入形式，除了最后一项，都必须是包，而最后一项则可以是
模块或者是包，但是不可以是类，函数或者变量的名字。

第 93 页共 117 页
17.8. 从一个包中导入*
设想一下，如果我们使用 from sound.effects import *会发生什么？
Python 会进入文件系统，找到这个包里面所有的子模块，一个一个的把它们都导入进来。
但是很不幸，这个方法在 Windows 平台上工作的就不是非常好，因为 Windows 是一个大小写不区分的系统。
在这类平台上，没有人敢担保一个叫做 ECHO.py 的文件导入为模块 echo 还是 Echo 甚至 ECHO。
（例如， Windows 95 就很讨厌的把每一个文件的首字母大写显示）而且 DOS 的 8+3 命名规则对长模块名称的处理
会把问题搞得更纠结。
为了解决这个问题，只能烦劳包作者提供一个精确的包的索引了。
导入语句遵循如下规则：如果包定义文件 __init__.py 存在一个叫做 __all__ 的列表变量，那么在使用 from package
import * 的时候就把这个列表中的所有名字作为包内容导入。
作为包的作者，可别忘了在更新包之后保证 __all__ 也更新了啊。你说我就不这么做，我就不使用导入*这种用法，好
吧，没问题，谁让你是老板呢。这里有一个例子，在:file:sounds/effects/__init__.py 中包含如下代码:
__all__ = ["echo", "surround", "reverse"]
这表示当你使用 from sound.effects import *这种用法时，你只会导入包里面这三个子模块。
如果 __all__ 真的没有定义，那么使用 from sound.effects import *这种语法的时候，就不会导入包 sound.effects 里的任
何子模块。他只是把包 sound.effects 和它里面定义的所有内容导入进来（可能运行__init__.py 里定义的初始化代码）。
这会把 __init__.py 里面定义的所有名字导入进来。并且他不会破坏掉我们在这句话之前导入的所有明确指定的模块。
看下这部分代码:
import sound.effects.echo
import sound.effects.surround
from sound.effects import *
这个例子中，在执行 from...import 前，包 sound.effects 中的 echo 和 surround 模块都被导入到当前的命名空间中了。（当
然如果定义了__all__就更没问题了）
通常我们并不主张使用*这种方法来导入模块，因为这种方法经常会导致代码的可读性降低。不过这样倒的确是可以省
去不少敲键的功夫，而且一些模块都设计成了只能通过特定的方法导入。
记住，使用 from Package import specific_submodule 这种方法永远不会有错。事实上，这也是推荐的方法。除非是你要
导入的子模块有可能和其他包的子模块重名。
如果在结构中包是一个子包（比如这个例子中对于包 sound 来说），而你又想导入兄弟包（同级别的包）你就得使用
导入绝对的路径来导入。比如，如果模块 sound.filters.vocoder 要使用包 sound.effects 中的模块 echo，你就要写成 from
sound.effects import echo。
from . import echo
from .. import formats
第 94 页共 117 页
from ..filters import equalizer
无论是隐式的还是显式的相对导入都是从当前模块开始的。主模块的名字永远是"__main__"，一个 Python 应用程序的
主模块，应当总是使用绝对路径引用。
包还提供一个额外的属性__path__。这是一个目录列表，里面每一个包含的目录都有为这个包服务的__init__.py，你得
在其他__init__.py 被执行前定义哦。可以修改这个变量，用来影响包含在包里面的模块和子包。
这个功能并不常用，一般用来扩展包里面的模块。
18. Python3 输入和输出
在前面几个章节中，我们其实已经接触了 Python 的输入输出的功能。本章节我们将具体介绍 Python 的输入输出。
18.1. 输出格式美化
Python 两种输出值的方式: 表达式语句和 print() 函数。
第三种方式是使用文件对象的 write() 方法，标准输出文件可以用 sys.stdout 引用。
如果你希望输出的形式更加多样，可以使用 str.format() 函数来格式化输出值。
如果你希望将输出的值转成字符串，可以使用 repr() 或 str() 函数来实现。
str()：函数返回一个用户易读的表达形式。
repr()：产生一个解释器易读的表达形式。
例如
>>> s = 'Hello, Runoob'
>>> str(s)
'Hello, Runoob'
>>> repr(s)
"'Hello, Runoob'"
>>> str(1/7)
'0.14285714285714285'
>>> x = 10 * 3.25
>>> y = 200 * 200
>>> s = 'x 的值为： ' + repr(x) + ', y 的值为： ' + repr(y) + '...'
>>> print(s)
x 的值为： 32.5, y 的值为： 40000...
>>> # repr() 函数可以转义字符串中的特殊字符
... hello = 'hello, runoob\n'
>>> hellos = repr(hello)
第 95 页共 117 页
>>> print(hellos)
'hello, runoob\n'
>>> # repr() 的参数可以是 Python 的任何对象
... repr((x, y, ('Google', 'Runoob')))
"(32.5, 40000, ('Google', 'Runoob'))"
这里有两种方式输出一个平方与立方的表:
>>> for x in range(1, 11):
... print(repr(x).rjust(2), repr(x*x).rjust(3), end=' ')
... # 注意前一行 'end' 的使用
... print(repr(x*x*x).rjust(4))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
8 64 512
9 81 729
10 100 1000
>>> for x in range(1, 11):
... print('{0:2d} {1:3d} {2:4d}'.format(x, x*x, x*x*x))
...
1 1 1
2 4 8
3 9 27
4 16 64
5 25 125
6 36 216
7 49 343
第 96 页共 117 页
8 64 512
9 81 729
10 100 1000
注意：在第一个例子中, 每列间的空格由 print() 添加。
这个例子展示了字符串对象的 rjust() 方法, 它可以将字符串靠右, 并在左边填充空格。
还有类似的方法, 如 ljust() 和 center()。这些方法并不会写任何东西, 它们仅仅返回新的字符串。
另一个方法 zfill(), 它会在数字的左边填充 0，如下所示：
>>> '12'.zfill(5)
'00012'
>>> '-3.14'.zfill(7)
'-003.14'
>>> '3.14159265359'.zfill(5)
'3.14159265359'
str.format() 的基本使用如下:
>>> print('{}网址： "{}!"'.format('菜鸟教程', 'www.runoob.com'))
菜鸟教程网址： "www.runoob.com!"
括号及其里面的字符 (称作格式化字段) 将会被 format() 中的参数替换。
在括号中的数字用于指向传入对象在 format() 中的位置，如下所示：
>>> print('{0} 和 {1}'.format('Google', 'Runoob'))
Google 和 Runoob
>>> print('{1} 和 {0}'.format('Google', 'Runoob'))
Runoob 和 Google
如果在 format() 中使用了关键字参数, 那么它们的值会指向使用该名字的参数。
>>> print('{name}网址： {site}'.format(name='菜鸟教程', site='www.runoob.com'))
菜鸟教程网址： www.runoob.com
位置及关键字参数可以任意的结合:
>>> print('站点列表 {0}, {1}, 和 {other}。 '.format('Google', 'Runoob',
other='Taobao'))
站点列表 Google, Runoob, 和 Taobao。 '!a' (使用 ascii()), '!s' (使用 str()) 和 '!r' (使用 repr()) 可以用于在格式化某个值
之前对其进行转化:
>>> import math
>>> print('常量 PI 的值近似为： {}。 '.format(math.pi))
第 97 页共 117 页
常量 PI 的值近似为： 3.141592653589793。
>>> print('常量 PI 的值近似为： {!r}。 '.format(math.pi))
常量 PI 的值近似为： 3.141592653589793。
可选项 ':' 和格式标识符可以跟着字段名。这就允许对值进行更好的格式化。下面的例子将 Pi 保留到小数点后三位：
>>> import math
>>> print('常量 PI 的值近似为 {0:.3f}。 '.format(math.pi))
常量 PI 的值近似为 3.142。
在 ':' 后传入一个整数, 可以保证该域至少有这么多的宽度。用于美化表格时很有用。
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> for name, number in table.items():
... print('{0:10} ==> {1:10d}'.format(name, number))
...
Runoob ==> 2
Taobao ==> 3
Google ==> 1
如果你有一个很长的格式化字符串, 而你不想将它们分开, 那么在格式化时通过变量名而非位置会是很好的事情。
最简单的就是传入一个字典, 然后使用方括号 '[]' 来访问键值 :
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {0[Runoob]:d}; Google: {0[Google]:d}; '
'Taobao: {0[Taobao]:d}'.format(table))
Runoob: 2; Google: 1; Taobao: 3
也可以通过在 table 变量前使用 '**' 来实现相同的功能：
>>> table = {'Google': 1, 'Runoob': 2, 'Taobao': 3}
>>> print('Runoob: {Runoob:d}; Google: {Google:d}; Taobao: {Taobao:d}'.format(**table))
Runoob: 2; Google: 1; Taobao: 3
18.2. 旧式字符串格式化
% 操作符也可以实现字符串格式化。它将左边的参数作为类似 sprintf() 式的格式化字符串, 而将右边的代入, 然后返
回格式化后的字符串. 例如:
>>> import math
>>> print('常量 PI 的值近似为： %5.3f。 ' % math.pi)
常量 PI 的值近似为： 3.142。
因为 str.format() 比较新的函数，大多数的 Python 代码仍然使用 % 操作符。但是因为这种旧式的格式化最终会从该
第 98 页共 117 页
语言中移除, 应该更多的使用 str.format().
18.3. 读取键盘输入
Python 提供了 input() 置函数从标准输入读入一行文本，默认的标准输入是键盘。
input 可以接收一个 Python 表达式作为输入，并将运算结果返回。
#!/usr/bin/python3
str = input("请输入： ");
print ("你输入的内容是: ", str)
这会产生如下的对应着输入的结果：
请输入：菜鸟教程
你输入的内容是: 菜鸟教程
18.4. 读和写文件
open() 将会返回一个 file 对象，基本语法格式如下:
open(filename, mode)
filename： filename 变量是一个包含了你要访问的文件名称的字符串值。
mode： mode 决定了打开文件的模式：只读，写入，追加等。所有可取值见如下的完全列表。这个参数是非强制的，默
认文件访问模式为只读(r)。
不同模式打开文件的完全列表：

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件
w+	打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则将其覆盖。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新

。

第 99 页共 117 页

的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

以下实例将字符串写入到文件 foo.txt 中：
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
f.write( "Python 是一个非常好的语言。 \n 是的，的确非常好!!\n" )
# 关闭打开的文件
f.close()
第一个参数为要打开的文件名。
第二个参数描述文件如何使用的字符。 mode 可以是 'r' 如果文件只读, 'w' 只用于写 (如果存在同名文件则将被删除),
和 'a' 用于追加文件内容; 所写的任何数据都会被自动增加到末尾. 'r+' 同时用于读写。 mode 参数是可选的; 'r' 将是默
认值。
此时打开文件 foo.txt,显示如下：
$ cat /tmp/foo.txt
Python 是一个非常好的语言。
是的，的确非常好!!
18.5. 文件对象的方法
本节中剩下的例子假设已经创建了一个称为 f 的文件对象。
f.
read()
为了读取一个文件的内容，调用 f.read(size), 这将读取一定数目的数据, 然后作为字符串或字节对象返回。
size 是一个可选的数字类型的参数。当 size 被忽略了或者为负, 那么该文件的所有内容都将被读取并且返回。
以下实例假定文件 foo.txt 已存在（上面实例中已创建）：
#!/usr/bin/python3
第 100 页共 117 页
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.read()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。
是的，的确非常好!!
f.
readline()
f.readline() 会从文件中读取单独的一行。换行符为 '\n'。 f.readline() 如果返回一个空字符串, 说明已经已经读取到最后
一行。
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
str = f.readline()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。
f.
readlines()
f.readlines() 将返回该文件中包含的所有行。
如果设置可选参数 sizehint, 则读取指定长度的字节, 并且将这些字节按行分割。
#!/usr/bin/python3
# 打开一个文件
第 101 页共 117 页
f = open("/tmp/foo.txt", "r")
str = f.readlines()
print(str)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
['Python 是一个非常好的语言。 \n', '是的，的确非常好!!\n']
另一种方式是迭代一个文件对象然后读取每行:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "r")
for line in f:
print(line, end='')
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
Python 是一个非常好的语言。
是的，的确非常好!!
这个方法很简单, 但是并没有提供一个很好的控制。因为两者的处理机制不同, 最好不要混用。
f.
write()
f.write(string) 将 string 写入到文件中, 然后返回写入的字符数。
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo.txt", "w")
num = f.write( "Python 是一个非常好的语言。 \n 是的，的确非常好!!\n" )
第 102 页共 117 页
print(num)
# 关闭打开的文件
f.close()
执行以上程序，输出结果为：
29
如果要写入一些不是字符串的东西, 那么将需要先进行转换:
#!/usr/bin/python3
# 打开一个文件
f = open("/tmp/foo1.txt", "w")
value = ('www.runoob.com', 14)
s = str(value)
f.write(s)
# 关闭打开的文件
f.close()
执行以上程序，打开 foo1.txt 文件：
$ cat /tmp/foo1.txt
('www.runoob.com', 14)
f.
tell()
f.tell() 返回文件对象当前所处的位置, 它是从文件开头开始算起的字节数。
f.
seek()
如果要改变文件当前的位置, 可以使用 f.seek(offset, from_what) 函数。
from_what 的值, 如果是 0 表示开头, 如果是 1 表示当前位置, 2 表示文件的结尾，例如：
seek(x,0) ：从起始位置即文件首行首字符开始移动 x 个字符
seek(x,1) ：表示从当前位置往后移动 x 个字符
seek(-x,2)：表示从文件的结尾往前移动 x 个字符
from_what 值为默认为 0，即文件开头。下面给出一个完整的例子：
>>> f = open('/tmp/foo.txt', 'rb+')
>>> f.write(b'0123456789abcdef')
16
第 103 页共 117 页
>>> f.seek(5) # 移动到文件的第六个字节
5 >
>> f.read(1)
b'5'
>>> f.seek(-3, 2) # 移动到文件的倒数第三字节
13
>>> f.read(1)
b'd'
f.close()
在文本文件中 (那些打开文件的模式下没有 b 的), 只会相对于文件起始位置进行定位。
当你处理完一个文件后, 调用 f.close() 来关闭文件并释放系统的资源，如果尝试再调用该文件，则会抛出异常。
>>> f.close()
>>> f.read()
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ValueError: I/O operation on closed file
<pre>
<p>
当处理一个文件对象时, 使用 with 关键字是非常好的方式。在结束后, 它会帮你正确的关闭文件。而且写起来也比
try - finally 语句块要简短:</p>
<pre>
>>> with open('/tmp/foo.txt', 'r') as f:
... read_data = f.read()
>>> f.closed
True
文件对象还有其他方法, 如 isatty() 和 trucate(), 但这些通常比较少用。
18.6. pickle 模块
python 的 pickle 模块实现了基本的数据序列和反序列化。
通过 pickle 模块的序列化操作我们能够将程序中运行的对象信息保存到文件中去，永久存储。
通过 pickle 模块的反序列化操作，我们能够从文件中创建上一次程序保存的对象。
基本接口：
pickle.dump(obj, file, [,protocol])
第 104 页共 117 页
有了 pickle 这个对象, 就能对 file 以读取的形式打开:
x = pickle.load(file)
注解：从 file 中读取一个字符串，并将它重构为原来的 python 对象。
file: 类文件对象，有 read()和 readline()接口。
实例 1：
#!/usr/bin/python3
import pickle
# 使用 pickle 模块将数据对象保存到文件
data1 = {'a': [1, 2.0, 3, 4+6j],
'b': ('string', u'Unicode string'),
'c': None}
selfref_list = [1, 2, 3]
selfref_list.append(selfref_list)
output = open('data.pkl', 'wb')
# Pickle dictionary using protocol 0.
pickle.dump(data1, output)
# Pickle the list using the highest protocol available.
pickle.dump(selfref_list, output, -1)
output.close()
实例 2：
#!/usr/bin/python3
import pprint, pickle
#使用 pickle 模块从文件中重构 python 对象
pkl_file = open('data.pkl', 'rb')
第 105 页共 117 页
data1 = pickle.load(pkl_file)
pprint.pprint(data1)
data2 = pickle.load(pkl_file)
pprint.pprint(data2)
pkl_file.close()
19. Python3 File(文件) 方法
file 对象使用 open 函数来创建，下表列出了 file 对象常用的函数：

序号	方法及描述
1	file.close() 关闭文件。关闭后文件不能再进行读写操作。
2	file.flush() 刷新文件内部缓冲，直接把内部缓冲区的数据立刻写入文件, 而不是被动的等待输出缓冲区写入。
3	file.fileno() 返回一个整型的文件描述符(file descriptor FD 整型), 可以用在如 os 模块的 read 方法等一些底层操作上。
4	file.isatty() 如果文件连接到一个终端设备返回 True，否则返回 False。
5	file.next() 返回文件下一行。
6	file.read([size]) 从文件读取指定的字节数，如果未给定或为负则读取所有。
7	file.readline([size]) 读取整行，包括 "\n" 字符。
8	file.readlines([sizehint]) 读取所有行并返回列表，若给定 sizeint>0，返回总和大约为 sizeint 字节的行, 实际读取值可能比 sizhint 较大, 因为需要填充缓冲区。
9	file.seek(offset[, whence]) 设置文件当前位置

第 106 页共 117 页

10	file.tell() 返回文件当前位置。
11	file.truncate([size]) 截取文件，截取的字节通过 size 指定，默认为当前文件位置。
12	file.write(str) 将字符串写入文件，没有返回值。
13	file.writelines(sequence) 向文件写入一个序列字符串列表，如果需要换行则要自己加入每行的换行符。

20. Python3 OS 文件/目录方法
os 模块提供了非常丰富的方法用来处理文件和目录。常用的方法如下表所示：

序号	方法及描述
1	os.access(path, mode) 检验权限模式
2	os.chdir(path) 改变当前工作目录
3	os.chflags(path, flags) 设置路径的标记为数字标记。
4	os.chmod(path, mode) 更改权限
5	os.chown(path, uid, gid) 更改文件所有者
6	os.chroot(path) 改变当前进程的根目录
7	os.close(fd) 关闭文件描述符 fd
8	os.closerange(fd_low, fd_high) 关闭所有文件描述符，从 fd_low (包含) 到 fd_high (不包含), 错误会忽略
9	os.dup(fd)

第 107 页共 117 页

复制文件描述符 fd
10	os.dup2(fd, fd2) 将一个文件描述符 fd 复制到另一个 fd2
11	os.fchdir(fd) 通过文件描述符改变当前工作目录
12	os.fchmod(fd, mode) 改变一个文件的访问权限，该文件由参数 fd 指定，参数 mode 是 Unix 下的文件访问权限。
13	os.fchown(fd, uid, gid) 修改一个文件的所有权，这个函数修改一个文件的用户 ID 和用户组 ID，该文件由文件描述符 fd 指定。
14	os.fdatasync(fd) 强制将文件写入磁盘，该文件由文件描述符 fd 指定，但是不强制更新文件的状态信息。
15	os.fdopen(fd[, mode[, bufsize]]) 通过文件描述符 fd 创建一个文件对象，并返回这个文件对象
16	os.fpathconf(fd, name) 返回一个打开的文件的系统配置信息。 name 为检索的系统配置的值，它也许是一个定义系统值的字符串，这些名字在很多标准中指定（POSIX.1, Unix 95, Unix 98, 和其它）。
17	os.fstat(fd) 返回文件描述符 fd 的状态，像 stat()。
18	os.fstatvfs(fd) 返回包含文件描述符 fd 的文件的文件系统的信息，像 statvfs()
19	os.fsync(fd) 强制将文件描述符为 fd 的文件写入硬盘。
20	os.ftruncate(fd, length) 裁剪文件描述符 fd 对应的文件, 所以它最大不能超过文件大小。
21	os.getcwd() 返回当前工作目录
22	os.getcwdu() 返回一个当前工作目录的 Unicode 对象

第 108 页共 117 页

23	os.isatty(fd) 如果文件描述符 fd 是打开的，同时与 tty(-like)设备相连，则返回 true, 否则 False。
24	os.lchflags(path, flags) 设置路径的标记为数字标记，类似 chflags()，但是没有软链接
25	os.lchmod(path, mode) 修改连接文件权限
26	os.lchown(path, uid, gid) 更改文件所有者，类似 chown，但是不追踪链接。
27	os.link(src, dst) 创建硬链接，名为参数 dst，指向参数 src
28	os.listdir(path) 返回 path 指定的文件夹包含的文件或文件夹的名字的列表。
29	os.lseek(fd, pos, how) 设置文件描述符 fd 当前位置为 pos, how 方式修改: SEEK_SET 或者 0 设置从文件开始的计算的 pos; SEEK_CUR 或者 1 则从当前位置计算; os.SEEK_END 或者 2 则从文件尾部开始. 在 unix， Windows 中有效
30	os.lstat(path) 像 stat(),但是没有软链接
31	os.major(device) 从原始的设备号中提取设备 major 号码 (使用 stat 中的 st_dev 或者 st_rdev field)。
32	os.makedev(major, minor) 以 major 和 minor 设备号组成一个原始设备号
33	os.makedirs(path[, mode]) 递归文件夹创建函数。像 mkdir(), 但创建的所有 intermediate-level 文件夹需要包含子文件夹。
34	os.minor(device) 从原始的设备号中提取设备 minor 号码 (使用 stat 中的 st_dev 或者 st_rdev field )。
35	os.mkdir(path[, mode]) 以数字 mode 的 mode 创建一个名为 path 的文件夹.默认的 mode 是 0777 (八进制)。

第 109 页共 117 页

36	os.mkfifo(path[, mode]) 创建命名管道， mode 为数字，默认为 0666 (八进制)
37	os.mknod(filename[, mode=0600, device]) 创建一个名为 filename 文件系统节点（文件，设备特别文件或者命名 pipe）。
38	os.open(file, flags[, mode]) 打开一个文件，并且设置需要的打开选项， mode 参数是可选的
39	os.openpty() 打开一个新的伪终端对。返回 pty 和 tty 的文件描述符。
40	os.pathconf(path, name) 返回相关文件的系统配置信息。
41	os.pipe() 创建一个管道. 返回一对文件描述符(r, w) 分别为读和写
42	os.popen(command[, mode[, bufsize]]) 从一个 command 打开一个管道
43	os.read(fd, n) 从文件描述符 fd 中读取最多 n 个字节，返回包含读取字节的字符串，文件描述符 fd 对应文件已达到结尾, 返回一个空字符串。
44	os.readlink(path) 返回软链接所指向的文件
45	os.remove(path) 删除路径为 path的文件。如果 path 是一个文件夹，将抛出 OSError; 查看下面的 rmdir()删除一个 directory
46	os.removedirs(path) 递归删除目录。
47	os.rename(src, dst) 重命名文件或目录，从 src 到 dst
48	os.renames(old, new) 递归地对目录进行更名，也可以对文件进行更名。
49	os.rmdir(path)

。

第 110 页共 117 页

删除 path 指定的空目录，如果目录非空，则抛出一个 OSError 异常。
50	os.stat(path) 获取 path 指定的路径的信息，功能等同于 C API 中的 stat()系统调用。
51	os.stat_float_times([newvalue]) 决定 stat_result 是否以 float 对象显示时间戳
52	os.statvfs(path) 获取指定路径的文件系统统计信息
53	os.symlink(src, dst) 创建一个软链接
54	os.tcgetpgrp(fd) 返回与终端 fd（一个由 os.open()返回的打开的文件描述符）关联的进程组
55	os.tcsetpgrp(fd, pg) 设置与终端 fd（一个由 os.open()返回的打开的文件描述符）关联的进程组为 pg。
56	os.tempnam([dir[, prefix]]) 返回唯一的路径名用于创建临时文件。
57	os.tmpfile() 返回一个打开的模式为(w+b)的文件对象 .这文件对象没有文件夹入口，没有文件描述符，将会自动删除。
58	os.tmpnam() 为创建一个临时文件返回一个唯一的路径
59	os.ttyname(fd) 返回一个字符串，它表示与文件描述符 fd 关联的终端设备。如果 fd 没有与终端设备关联，则引发一个异常。
60	os.unlink(path) 删除文件路径
61	os.utime(path, times) 返回指定的 path 文件的访问和修改的时间。
62	os.walk(top[, topdown=True[, οnerrοr=None[, followlinks=False]]]) 输出在文件夹中的文件名通过在树中游走，向上或者向下。

第 111 页共 117 页

63	os.write(fd, str) 写入字符串到文件描述符 fd 中. 返回实际写入的字符串长度

21. Python3 错误和异常
作为 Python 初学者，在刚学习 Python 编程时，经常会看到一些报错信息，在前面我们没有提及，这章节我们会专门介
绍。
Python 有两种错误很容易辨认：语法错误和异常。
21.1. 语法错误
Python 的语法错误或者称之为解析错，是初学者经常碰到的，如下实例
>>> while True print('Hello world')
File "<stdin>", line 1, in ?
while True print('Hello world')
^
SyntaxError: invalid syntax
这个例子中，函数 print() 被检查到有错误，是它前面缺少了一个冒号（:）。
语法分析器指出了出错的一行，并且在最先找到的错误的位置标记了一个小小的箭头。
21.2. 异常
即便 Python 程序的语法是正确的，在运行它的时候，也有可能发生错误。运行期检测到的错误被称为异常。
大多数的异常都不会被程序处理，都以错误信息的形式展现在这里:
>>> 10 * (1/0)
Traceback (most recent call last):
File "<stdin>", line 1, in ?
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
File "<stdin>", line 1, in ?
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
File "<stdin>", line 1, in ?
TypeError: Can't convert 'int' object to str implicitly
异常以不同的类型出现，这些类型都作为信息的一部分打印出来: 例子中的类型有 ZeroDivisionError， NameError 和
第 112 页共 117 页
TypeError。
错误信息的前面部分显示了异常发生的上下文，并以调用栈的形式显示具体信息。
21.3. 异常处理
以下例子中，让用户输入一个合法的整数，但是允许用户中断这个程序（使用 Control-C 或者操作系统提供的方法）。
用户中断的信息会引发一个 KeyboardInterrupt 异常。
>>> while True:
try:
x = int(input("Please enter a number: "))
break
except ValueError:
print("Oops! That was no valid number. Try again ")
try 语句按照如下方式工作；
首先，执行 try 子句（在关键字 try 和关键字 except 之间的语句）
如果没有异常发生，忽略 except 子句， try 子句执行后结束。
如果在执行 try 子句的过程中发生了异常，那么 try 子句余下的部分将被忽略。如果异常的类型和 except 之后的名称
相符，那么对应的 except 子句将被执行。最后执行 try 语句之后的代码。
如果一个异常没有与任何的 except 匹配，那么这个异常将会传递给上层的 try 中。
一个 try 语句可能包含多个 except 子句，分别来处理不同的特定的异常。最多只有一个分支会被执行。
处理程序将只针对对应的 try 子句中的异常进行处理，而不是其他的 try 的处理程序中的异常。
一个 except 子句可以同时处理多个异常，这些异常将被放在一个括号里成为一个元组，例如:
except (RuntimeError, TypeError, NameError):
pass
最后一个 except 子句可以忽略异常的名称，它将被当作通配符使用。你可以使用这种方法打印一个错误信息，然后再
次把异常抛出。
import sys
try:
f = open('myfile.txt')
s = f.readline()
i = int(s.strip())
except OSError as err:
第 113 页共 117 页
print("OS error: {0}".format(err))
except ValueError:
print("Could not convert data to an integer.")
except:
print("Unexpected error:", sys.exc_info()[0])
raise
try except 语句还有一个可选的 else 子句，如果使用这个子句，那么必须放在所有的 except 子句之后。这个子句将在 try
子句没有发生任何异常的时候执行。例如:
for arg in sys.argv[1:]:
try:
f = open(arg, 'r')
except IOError:
print('cannot open', arg)
else:
print(arg, 'has', len(f.readlines()), 'lines')
f.close()
使用 else 子句比把所有的语句都放在 try 子句里面要好，这样可以避免一些意想不到的、而 except 又没有捕获的异常。
异常处理并不仅仅处理那些直接发生在 try 子句中的异常，而且还能处理子句中调用的函数（甚至间接调用的函数）里
抛出的异常。例如:
>>> def this_fails():
x = 1/0
>>> try:
this_fails()
except ZeroDivisionError as err:
print('Handling run-time error:', err)
Handling run-time error: int division or modulo by zero
21.4. 抛出异常
Python 使用 raise 语句抛出一个指定的异常。例如:
>>> raise NameError('HiThere')
Traceback (most recent call last):
第 114 页共 117 页
File "<stdin>", line 1, in ?
NameError: HiThere
raise 唯一的一个参数指定了要被抛出的异常。它必须是一个异常的实例或者是异常的类（也就是 Exception 的子类）。
如果你只想知道这是否抛出了一个异常，并不想去处理它，那么一个简单的 raise 语句就可以再次把它抛出。
>>> try:
raise NameError('HiThere')
except NameError:
print('An exception flew by!')
raise
An exception flew by!
Traceback (most recent call last):
File "<stdin>", line 2, in ?
NameError: HiThere
21.5. 用户自定义异常
你可以通过创建一个新的 exception 类来拥有自己的异常。异常应该继承自 Exception 类，或者直接继承，或者间接继
承，例如:
>>> class MyError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
>>> try:
raise MyError(2*2)
except MyError as e:
print('My exception occurred, value:', e.value)
My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
File "<stdin>", line 1, in ?
第 115 页共 117 页
__main__.MyError: 'oops!'
在这个例子中，类 Exception 默认的 __init__() 被覆盖。
当创建一个模块有可能抛出多种不同的异常时，一种通常的做法是为这个包建立一个基础异常类，然后基于这个基础
类为不同的错误情况创建不同的子类:
class Error(Exception):
"""Base class for exceptions in this module."""
pass
class InputError(Error):
"""Exception raised for errors in the input.
Attributes:
expression -- input expression in which the error occurred
message -- explanation of the error
"""
def __init__(self, expression, message):
self.expression = expression
self.message = message
class TransitionError(Error):
"""Raised when an operation attempts a state transition that's not
allowed.
Attributes:
previous -- state at beginning of transition
next -- attempted new state
message -- explanation of why the specific transition is not allowed
"""
def __init__(self, previous, next, message):
self.previous = previous
第 116 页共 117 页
self.next = next
self.message = message
大多数的异常的名字都以"Error"结尾，就跟标准的异常命名一样。
21.6. 定义清理行为
try 语句还有另外一个可选的子句，它定义了无论在任何情况下都会执行的清理行为。例如:
>>> try:
raise KeyboardInterrupt
finally:
print('Goodbye, world!')
Goodbye, world!
KeyboardInterrupt
以上例子不管 try 子句里面有没有发生异常， finally 子句都会执行。
如果一个异常在 try 子句里（或者在 except 和 else 子句里）被抛出，而又没有任何的 except 把它截住，那么这个
异常会在 finally 子句执行后再次被抛出。
下面是一个更加复杂的例子（在同一个 try 语句里包含 except 和 finally 子句） :
>>> def divide(x, y):
try:
result = x / y
except ZeroDivisionError:
print("division by zero!")
else:
print("result is", result)
finally:
print("executing finally clause")
>>> divide(2, 1)
result is 2.0
executing finally clause
>>> divide(2, 0)
division by zero!
executing finally clause
第 117 页共 117 页
>>> divide("2", "1")
executing finally clause
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 3, in divide
TypeError: unsupported operand type(s) for /: 'str' and 'str'
21.7. 预定义的清理行为
一些对象定义了标准的清理行为，无论系统是否成功的使用了它，一旦不需要它了，那么这个标准的清理行为就会执
行。
这面这个例子展示了尝试打开一个文件，然后把内容打印到屏幕上:
for line in open("myfile.txt"):
print(line, end="")
以上这段代码的问题是，当执行完毕后，文件会保持打开状态，并没有被关闭。
关键词 with 语句就可以保证诸如文件之类的对象在使用完之后一定会正确的执行他的清理方法:
with open("myfile.txt") as f:
for line in f:
print(line, end="")
以上这段代码执行完毕后，就算在处理过程中出问题了，文件 f 总是会关闭。