Python 是一种解释型、面向对象、动态数据类型的高级程序设计语言。Python 是跨平台的
开发工具，可以在多个操作系上进行程序设计，包括Windows 、Linux 和MacOSX 。Python 提
供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等内容。除了内置的库外，
Python 还有大量的第三方库，可以通过网络免费下载安装使用。

目前，通用的Python 有两个版本，分别是Python 2.x 和Python 3.x 。这两个版本并不兼容，
部分语句的语法有差别。不过Python 官方提供了可将Python 2.x 代码转换成为Python 3.x 的代
码工具，以便程序设计者使用。

Roban 机器人使用Python 3.5 。本章主要介绍Windows 平台下Python 3.x 的基本应用。

2.1 
Python 
语法
2.1.1 
Python 
运行方式
Python 的解释器python.exe 位于Python 的安装目录，运行Python 源程序需要使用解释器进
行解释。目前，常用的运行方式有三种，分别是通过命令管理器运行Python 脚本，通过Python 
自带的IDLE 运行Python 脚本，以及通过集成开发环境运行Python 脚本。

1. 
命令管理器
同时按下键盘上的Windows 键与R键，并在输入框中输入“cmd”，按Enter 键即可进入命
令管理器。在命令管理器中输入“Python”并按Enter 键即可运行Python 脚本。

在命令管理器中运行Python 脚本的方式有以下两种：

（1）在命令管理器中直接编辑Python 脚本
。
在当前Python 提示符“>>>”的右侧输入Python 脚本，例如
：
print("hello 
world 
!"
) 


16
按Enter 键，运行结果如图2.1 所示。


图2.1 
在命令管理器中直接编辑Python 脚本

（2）交互式运行Python 脚本。
交互式运行Python 脚本，即在命令管理器中直接打开Python 脚本。打开命令管理器后，输
入Python 完整文件名（包括路径）即可。例如输入“PythonD：
\ 
helloworld”，并按Enter 键，运
行结果如图2.2 所示。


图2.2 
交互式运行Python 脚本

2. 
Python 
自带的IDLE 
在安装Python 后，会自动安装一个IDLE。它是一个Python Shell ，可以与Python 进行交互。
在所有程序目录中，可以在“Python3.7”文件夹中找到“IDLE (Python 3.7 64-bit)”，单击即可打
开IDLE 窗口。通过IDLE 运行Python 脚本的方式有以下两种：

（1）在IDLE 中直接编辑Python 脚本。
打开IDLE 窗口后，在Python 提示符“>>>”的右侧直接输入Python 脚本，同在命令管理
器中直接编辑Python 脚本一样，如图2.3 所示。


图2.3 
在IDLE 中直接编辑Python 脚本

（2）在IDLE 中创建Python 脚本文件。
在IDLE 主窗口的菜单栏上选择FileNewFile ，将打开一个新窗口，在该窗口中，可以直
接编写Python 代码，如图2.4 所示。
→ 


17
图2.4 
在IDLE 中创建Python 脚本文件

3. 
集成开发环境
集成开发环境（IntegratedDevelopmentEnvironment，IDE）是用于提供程序开发环境的应用
程序，一般包括代码编辑器、编译器、调试器和图形用户界面等工具。Python 程序设计常用的
集成开发工具有MicrosoftVisualStudio 、PyCharm ，以及Eclipse+PyDev 。本书以PyCharm 为例，
进行简单介绍。

在PyCharm 中，选择File→ 
NewProject ，在创建新项目窗口中设置项目位置和解释器，如
图2.5 所示。


图2.5 
创建Python 项目

在项目管理器中选中项目，右击，在弹出的快捷菜单中选择New 
→ 
PythonFile 。在新建
PythonFile 窗口中的文件名称输入框中输入“hello.py”。单击OK 按钮，在代码窗口中输入代码
后，选择Run→ 
Run ，运行helloworld.py ，如图2.6 所示。

在编写Python 时，当使用中文输出或注释时运行脚本，会提示错误信息：SyntaxError：Non-
ASCII character ’ \x…。出错的原因是Python 的默认编码文件是ASCII 码，而Python 文件中使


18
用了中文等非英语字符，此时需要在Python 源文件的最开始一行加入一句：

#coding = 
UTF-
8 


图2.6 
在PyCharm 中运行Python 程序

2.1.2 
Python 
程序书写格式
Python 程序书写最具特色的就是代码缩进。Python 不同于其他程序语言（如C、Java 语言）
， 
采用大括号“{} ”分隔代码块，而是采用代码缩进和冒号“：”区分代码之间的层次关系。例如：
判断数字a 和b的大小关系。

Python 代码：

a=
6 

b=
9 

if 
a<b: 
print("a<b"
) 

else: 
print("a>b"
) 

C语言代码：

#include 
<stdio.h> 

int 
main( 
)
{ 
int 
a=6; 
int 
b=9; 


if(a<b)
{ 

print("a<b")
; } 
else{ 

print("a>b")
; } } 

此外，Python 与C、Java 等语言不同，Python 程序不需要从主函数执行，本例中，直接执
行程序第一条语句a=6。if 语句后面的冒号“：”表示下一行是子模块的开始，所有满足if 条件
而执行的语句（代码块）缩进相同。

注：Python 对代码缩进要求非常严格，同一个级别代码块的缩进量必须相同。如果不采用
代码缩进，将抛出SytaxError 异常。

2.1.3 
变量、数据类型、表达式
1. 
变量
对于程序语句x1=2020，x1 为变量，2020 为常数，= 为赋值操作符，语句将等号右边的值

赋给等号左边的变量。
变量相当于计算机中存在的一个位置，在程序运行过程中可以向该位置放入或取出数据。
语句x2=x1+1 执行时，就是把变量x1 中的数据取出来，加上1后，再放入变量x2 中。
标识变量需要为每个变量起一个名字，变量名遵从Python 标识符命名规则：

（1）由字母、数字、下画线组成。所有标识符可以包括英文、数字以及下画线“_”，但不能
以数字开头。
（2）区分大小写。
（3）不能使用Python 中的保留字。
（4）以单下画线或双下画线开头的标识符有特殊意义。例如，__init__() 代表类的构造函数。
在Python 中，变量使用时不需要像C语言那样必须先声明，而是可以直接使用。此外，Python 
是一种动态类型的语言，其变量的类型也可以随时变化。

2. 
数据类型
在数学中，可以将数字分为整数、实数等类型。在Python 中，数据也是有类型的，因此，存
放数据的变量也是有类型的。

（1）数值型。包括整数类型和浮点类型。在Python 3.0 之后的版本中，整数没有大小限制。
1是整数，为整数类型。1.0 是实数，为浮点类型。赋值语句x=1 执行后，变量x的类型为整数

类型。

（2）布尔类型。在逻辑学中，对于一个问题可以用“真”或“假”描述，在Python 中，用
True 表示真，用False 表示假。例如：100>101 的结果为“假”，赋值语句b=100>101 执行后，变
量b的值为False 。
（3）字符串类型。字符串是字符的序列。在Python 中有多种方式表示字符串，通常使用单引
号、双引号将字符序列括起来。这两种形式本质上没有任何差别，只是在形式上略有差异。print 
"helloworld" 中，采用了双引号来表示字符串类型，同样，'helloworld' 
也可以表示字符串类型。
如果字符串中出现单引号或双引号自身，需要用转义字符“\”将单引号或双引号进行转

义。例如：在执行print('Roban’s functions')语句时，Python 无法判定book 后面的单引号

是字符串的结尾，还是字符串中的符号，在执行时会报错。此时，需要对该单引号进行转义：

print('Roban\’s functions')。双引号表示的字符串中出现的单引号不需要转义，例如：print 

(''Roban\’sfunctions'')。

此外，Python 中还可以通过三引号将字符序列括起来，表示多行字符串。

3. 
表达式
表达式是对相同类型的数据（如常数、变量等），用运算符号按一定的规则连接起来的有意
义的式子。

（1）算术运算符。算术运算符是处理四则混合运算的符号，常用于数字的处理。常见的算
术运算符如表2.1 所示。
表2.1 
算术运算符

运算符说明实例结果
+ 加12+8 20 
. 
减12.8 4 
* 乘12*8 96 
/ 除12/8 1.5 
// 取整除，即返回商的整数部分12//8 1 
% 求余，即返回除法的余数12%8 4 
. 
取负数，即返回其负数.8 .8 

（2）比较运算符。比较运算符也称关系运算符，用于对变量或者表达式的结果进行大小、真
假等比较，常用于条件语句中作为判断的依据。Python 中使用的比较运算符包括<、>、<=、>=、
==、!=，分别为小于、大于、小于或等于、大于或等于、等于和不等于6种比较运算符，如表
2.2 所示。比较运算符的运算结果为布尔型数据。如果比较结果为真，则返回True ；如果为假，
则返回False 。

21
表2.2 
算术运算符

运算符说明实例结果
> 大于'a'>'b' 
False 
< 小于156<225 True 
== 等于'c'=='c' 
True 
!= 不等于'a'!='b' 
True 
>= 大于或等于129>=156 False 
<= 小于或等于108<=155 True 

（3）逻辑运算符。逻辑运算符是对真和假两种布尔值进行运算，运算结果仍是布尔值。Python 
中的逻辑运算符主要包括and（逻辑与）、or（逻辑或）和not（逻辑非），如表2.3 所示。
表2.3 
逻辑运算符

运算符说明用法运算方向
and 逻辑与Aand B 从左到右
or 逻辑或Aor B 从左到右
not 逻辑非not A 从右到左

运用逻辑运算符进行逻辑运算时，需遵循的具体规则如表2.4 所示。

表2.4 
运用逻辑运算符进行逻辑运算的规则

表达式
1 
表达式
2 
表达式
1 
and 
表达式
2 
表达式
1 
or 
表达式
2 
not 
表达式
True True True True False 
True False False True False 
False False False False True 
False True False True True 

（4）运算符运算优先级。在表达式中包括多种运算符时，运算优先级规则为：算术运算符高
于比较运算符，比较运算符高于逻辑运算符。
在同类运算符中：加和减的运算优先级最低，“非”高于“与”高于“或”。
例：Python 中的各种运算。

a=
4 
b=
3 
c=
4 
d=
8 


print( a 
=
= c ) 
print( a > b ) 
print( d % 
c) 
print( d 
/
/ b ) 
print( a 
-
b ) 
print( 
a*
b + 
c*
d ) 
print( 
a>
d 
and 
a<b) 
print( 
a==
c 
or 
a<
b ) 

运行结果：

True 
True 0 2 1 
44 
False 
True 

2.1.4 
条件语句
条件语句，也称选择语句，即根据条件判断的结果，执行不同的程序段。在Python 中，选
择语句主要有三种形式，分别为if 语句、if…else 语句和if…elif…else 多分支语句。

1. 
if 
语句
Python 实现分支结构的语句主要是if 语句，简单的语法格式如下：
if 表达式：
语句块
其中，表达式可以是一个单纯的布尔值或变量，也可以是比较表达式或逻辑表达式。如果
表达式为真，则执行“语句块”；如果表达式为假，则跳过“语句块”继续执行后面的语句。

2. 
if…esle 
语句
if…else 语句又称双分支语句，其语法格式为
：
if 表达式
：
语句块
1
else：
语句块
2



当if…else 语句中表达式为真时，执行if 后面的语句块（即“语句块1”）；否则，执行else 
后面的语句块（即“语句块2”）。

Python 以缩进区分语句块，if 和else 能够组成一个有特定逻辑的控制结构，有相同的缩进。
每个语句块中的语句也要遵循这一原则。

例：用if 语句判断学生是否已经满足入学年龄。

age = 7 
if 
age 
>
= 
6: 

print 
(
" 
满足"
) 
else: 

print 
(
" 
不满足"
) 

利用if 语句判断年龄是否为6以上，如果“是”，则输出“满足”；否则，输出“不满足”。
Python 中指定任何非0和非空值为True，0或者空值（如空的列表）为False 。上面代码中，
如果条件age>=6 变成了age ，程序在执行时也不会出错，而是执行条件为真的部分。

3. 
if…elif…else 
多分支语句
if 语句可以实现嵌套，即在if 语句中包含if 语句
。
例：if 语句判断学生的入学情况
。


age = 
10 
if 
age>=12: 
print("初中及以上"
) 
else: 
if 
age>=6: 
print("小学"
) 
else: 
print("未入学"
) 

上面这段代码中，年龄小于13 岁的都属于第一个else 的语句块，第二个if 和else 的缩进与

第一条print 语句相同。
Python 中if 语句也可以实现多分支的选择，语法格式为：
if 条件1： 

语句块
1
elif 条件2：
语句块
2
…



24
elif 条件n： 
语句块n 
else： 
语句块n+1 
例：if 语句判断小学生的年级（分为7个等级）。

age = 
10 
if 
age>=11: 
print 
(
" 
已毕业"
) 
elif 
age>=10: 
print 
(
" 
五年级"
) 
elif 
age>=9: 
print 
(
" 
四年级"
) 
elif 
age>=8: 
print 
(
" 
三年级"
) 
elif 
age>=7: 
print 
(
" 
二年级"
) 
elif 
age>6: 
print 
(
" 
一年级"
) 
else: 
print 
(
" 
未入学"
) 

程序运行时，首先判断age>=11 是否为真，若为真，则输出“已毕业”，结束if 语句；否则，
继续判断其他表达式的真假，如果最终进入else 的语句块，那么表明age<7 ，输出“一年级”并
退出。也就是说，if 语句实现了6个分支，根据学生的年龄，准确判断其所处的年级。

2.1.5 
while 
循环语句
Python 中有两个主要的循环结构，即while 循环和for 循环，用于在满足条件时重复执行某
段代码块（循环体），以处理需要重复处理的相同任务。

1. 
while 
循环语句
while 循环是通过一个条件表达式来控制是否继续反复执行循环体中的语句。循环体指一组
被重复执行的语句。while 循环语句的语法格式为：
while 表达式：
循环体
Python 先判断条件表达式的值为真或假，如果为真，则执行循环体中的语句。执行完毕，会
再次判断条件的值为真或假，再决定是否执行循环体中的语句，直到条件表达式的值为假，退


出循环。
例：while 循环求1+2+…+100。

sum=
0 

i=
1 

while 
i<=100: 
sum=sum+
i 
i=i+
1 

print 
sum 

程序利用sum 变量保存求和结果，每次加的数保存在变量i中，第一个数为1，在变量i小
于或等于100 时，while 语句条件为真，执行循环体，将变量i值加到sum，为了再次执行循环
体时加下一个数，需要将变量i加1，循环体语句执行结束后，再次判断条件是否为真，如果为
真再次执行循环体。当条件不满足，即i=101 时，循环结束，输出sum 的值为5050。

对于有限循环次数的while 循环程序，为确保循环能够正常结束，不陷入死循环（即在执行
若干次循环体后，while 条件变为假，循环结束），循环体中一定要包含使用循环条件变为假的
语句，如上面代码中的i=i+1。

2. 
for 
循环
for 循环是一个依次重复执行的循环。通常适用于枚举或遍历序列，以及迭代对象中的元素。
for 循环语法格式为：
for 变量in 遍历对象：
循环体
执行for 循环时，遍历对象中的每个元素都会赋值给变量，然后为每个元素执行一遍循环
体。变量的作用范围是for 所在的循环结构。
例：for 循环求1+2+…+100。

sum = 0 
for i 
in 
range(101)
: 
sum 
+
= i 
print(sum) 

程序利用sum 变量保存求和结果，通过for 循环遍历range(101) 中的数字，即1～100 中的
所有整数，并将每次遍历的结果加到sum 变量，range(101) 中所有数字的遍历结束后，循环结
束，输出sum 的值为5050。

上述代码中，使用了range() 函数，该函数是Python 内置的函数，用于生成一系列连续的整
数，多用于for 循环中。其语法格式为：


range( 起始数值，终止数值[，步长]) 

range() 函数生成从起始数值到终止数值（不含终止数值）间的数字序列。步长参数为可选
项，默认值为1。例如：range(1,5) 得到的数字序列为1,2,3,4；range(2,11,2) 得到的数字序列为
2,4,6,8,10。

2.1.6 
continue 
与break 
语句
1. 
continue 
语句
continue 语句在循环结构中执行时，将会立即结束本次循环，开始下一轮循环，即跳过循环
体中在continue 语句之后的所有语句，继续下一轮循环。
例：while 循环输出2*i，i不是3的倍数。

for i 
in 
range(10)
: 
if i % 3 
=
= 
0: i 
+
= i 
continue 
else: 
print 
(2*i) i 
+
= i 

输出结果：248101416 

2. 
break 
语句
break 语句在循环结构中执行时，将会跳出循环结构，转而执行循环结构后的语句，即不管
循环条件是否为假，遇到break 语句都将提前结束循环。

例：用for 循环找出20 以内被3除余2的数。

for i 
in 
range(20)
: 
if 
i%
3 
=
= 2 : 
print(i) 

输出结果：258111417 
例：用for 循环找出20 以内第一个被3除余2的数。

for i 
in 
range(20)
: 
if 
i%
3 
=
= 2 : 
print(i) 
break 

输出结果：2 


2.1.7 
列表
列表由一系列按特定顺序排列的元素组成。元素可以是任何类型的变量。与其他语言中的

数组不同，列表元素之间可以没有任何关系，可以是不同数据类型。
列表包含多个元素。通常给列表指定一个表示复数的名称，如letters、digits 或names。
在Python 中用方括号“[] ”来表示列表，并用逗号来分隔其中的元素。
例：列表定义，元素可以是任何类型。

numbers = 
[1,2,3,4,5]
letters = 
["a","b","c","d","e"
]
anything 
=[1,"Python",True]
print(numbers)
print(letters)
print(anything)


输出结果为：

[1, 
2, 
3, 
4, 
5] 
['a'
, 
'b'
, 
'c'
, 
'd'
, 
e'
] 
[1, 
'Python'
, 
True] 

1. 
访问列表元素
通过下标（索引）访问列表元素，格式如下
：
列表名称[索引
]
例：计算某同学5门功课的平均成绩
。


grades=[89,78,72,92,101]
sum=
0
i=
0
while 
i<len(grades)
:


sum=sum+grades[i] 
i=i+
1 
print 
("average 
grade:",sum/len(grades)
) 

本例中，利用函数len() 求出列表长度，即列表元素个数，在while 循环中，通过索引（i变
量，初值为0）访问列表元素，将列表元素的内容累加求和，最后输出平均值。索引0访问的是
列表的第一个元素，索引可以为负数，.
1 
访问的是列表的最后一个元素。

与C语言中的数组一样，列表元素可以直接赋值修改。


28
2. 
操作列表常用方法
常用操作列表的方法如表2.5 所示。
表2.5 中示例的初始列表为：
numbers=[one,two, three,four,five] 

表2.5 
常用操作列表的方法

方法说明示例
append() 向列表尾部添加元素
xs.append("six") 结果为：
xs=["one","two","three", 
"four","five","six"] 
insert(index, value) 在列表中插入元素
xs.insert(2,"six") 结果为：
xs=["one","two","six", 
"three","four","five"] 
pop() 
删除列表末尾的元素, 
带返回值，
实现出栈操作
x2=xs.pop() 结果为：
xs=["one","two", 
"three","four"], 
x2="five" 
del() 从列表中删除元素
x2=xs.del(2), 
删除第2个元素
pop(i) 删除列表i位置的元素
x2=xs.pop(2), 
删除第2个元素并返回
x2="three" 
remove(value) 
根据值删除元素
（多个满足条件时
只删除第一个指定的值）
xs.insert(2,"five") 
xs.remove("five") 结果为：
xs 与初始值相同
sort([reverse=True]) 
列表进行永久性排序, 
默认为升序
xs.sort() 结果为：
xs=["five", "four", "one", 
"three", "two"] 
sorted() 函数对列表进行临时排序
ys=sorted(xs) 结果为：
xs 不变，ys 为xs 排序结果
reverse() 反转列表元素的排列顺序
xs.reverse() 结果：
xs=['five', 'four','three', 
'two', 'one'] 
len() 函数获取列表的长度len(xs) 


3. 
列表分片
取列表的一部分元素，称为分片。Python 对列表提供了强大的分片操作，运算符仍然为下
标运算符。创建列表分片，需要指定所取元素的起始索引和终止索引，中间用冒号分隔。分片
将包含从起始索引到终止索引（不含终止索引）对应的所有元素。

例如，要输出列表中的前3个元素，需要指定索引0～3，这将输出分别为0、1和2的元素。

numbers = 
[1,2,3,4,5,6,7,8,9,0] 
print 
(numbers[0:3]
) 

输出结果为：

[1, 
2, 
3] 

不指定起始索引，Python 将自动从列表头开始；不指定终止索引，Python 将提取到列表末
尾；终止索引小于或等于起始索引时，分片结果为空；两个索引都不指定时，将复制整个列表。
例：复制列表。

fruits=['apple','banana','watermelon','grape','lemon'
]
copyfruits=fruits[:
]
copyfruits.append('mango'
)
print 
(fruits)
print 
(copyfruits)


输出结果为：

['apple'
, 
'banana'
, 
'watermelon'
, 
'grape'
, 
'lemon'
] 
['apple'
, 
'banana'
, 
'watermelon'
, 
'grape'
, 
'lemon'
, 
'mango'
] 

4. 
列表的加和乘运算
对于两个列表，加法表示连接操作，即将两个列表合并成一个列表。例如：
letters=['a','b','c','d','e''f']，numbers=[1,2,3,4,5,6,7,8,9,10]，L=letters+numbers 
则

L=['a','b','c','d','e''f',1,2,3,4,5,6,7,8,9,10] 
列表的乘法表示将原来的列表重复多次。例如L=[0]*100 会产生一个含有100 个0的列表。
乘法操作通常用于对一个具有足够长度的列表初始化。


2.1.8 
元组与字典
1. 
元组
列表适用于存储在程序运行期间可能变化的数据集，列表元素是可以修改的。在需要创建
一系列不可修改的元素时，可以使用元组。Python 将不能修改的、不可变的列表称为元组。

元组看起来犹如列表，但使用圆括号而不是方括号来标识。定义元组后，就可以使用索引
来访问其元素，就像访问列表元素一样。

例：元组的使用。

letters=('a','b','c','d','e','f'
) 
L=len(letters) 
for i 
in 
range(0,L)
: 

print(letters[i]
)
for a 
in 
letters:
print(a)


2. 
字典
字典是一系列“键：值”对。每个键都与一个值相关联，键和值之间用冒号分隔。Python 使
用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。
在Python 中，字典用放在花括号中的一系列“键：值”对表示，各个“键：值”对之间用

逗号分隔。例如：
person_0="name"："LiMing","age"：24 
字典变量person_0 定义了name 和age 两个键，分别取值为" LiMing " 和24。
访问字典元素与访问列表元素类似，由于每个值对应一个键，访问该值时需要用键作为索

引。例如，person_0["age"] 可以得到"age" 键对应的值24。
字典元素的修改、添加与删除说明如下：

（1）修改：对已有的键直接赋值。
（2）添加：增加新的“键：值”对，对新增加的键赋值。
（3）删除：用del 命令删除一个字典键
。
例：字典元素的修改、添加与删除
。
person={"name":"LiMing","age":24}
print(person)
print 
(person["name"]
)
person["weight"]=120
print(person)



person["name"]="LiuPing" 
print(person) 
del 
person["name"
] 

print(person) 程序运行结果为：

{'name'
: 
'LiMing'
, 
'age'
: 
24}
LiMing
{'name'
: 
'LiMing'
, 
'age'
: 
24, 
'weight'
: 
120}
{'name'
: 
'LiuPing'
, 
'age'
: 
24, 
'weight'
: 
120}
{'age'
: 
24, 
'weight'
: 
120}


字典对象提供了items()、keys() 和values() 方法，分别用于获取“键：值”对的集合、键的
集合和值的集合。

例：字典的遍历。

person={"name":"LiMing","age":24} 

for k 
in 
person.keys()
: 
print(k) 

for v 
in 
person.values()
: 
print(v) 

for 
key,value 
in 
person.items()
: 
print(key,value) 

items() 方法取得字典中“键：值”对的集合，在循环中分别赋值给key 变量和value 变量。
程序运行结果为：

name 
age 
LiMing 
24 
name 
LiMing 
age 
24 

2.2 
Python 
函数
函数，最早由中国清朝数学家李善兰function 翻译而来，出于其著作《代数学》。之所以这
么翻译，他给出的原因是“凡此变数中函彼变数者，则此为彼之函数”，也即函数指一个量随着
另一个量的变化而变化，或者说一个量中包含另一个量。


在数学中，计算角度值通常会用到arctanx、arcsinx 
以及arccosx 
等函数，根据参数
x 
的值，

即可求解角度值。求解得到的角度值，可以作为返回值，用于其他运算。如：求解arctanx+
y 
时，

可以定义一个一元函数，即只有一个参数的函数f(x)=arctanx，计算arctanx 
后得到一个值，作

为函数的返回值，赋值给f(x)。通过f(x)
+ y 
即可表示上述运算，对于f(x) 
运算，将会调用

f(x)=arctanx。上述运算中运用到函数的参数、函数的返回值、函数的定义及调用。

Python 函数与数学函数的概念是相似的，除了具备参数、返回值外，也可以重复调用已定
义的函数。

2.2.1 
函数定义
函数定义即创建函数，可以理解为创建一个具有某种用途的工具。函数定义的语法格式：

def 函数名([参数1，参数2，…])
：
函数
体


如果函数有返回值，函数体中使用return 作返回。return 关键字后面可以是数值或其他类

型的数据，也可以是变量或表达式。在执行到return 语句时函数结束。一个函数可能会有多个

return 语句。

例：定义可以实现
x × y 
的函数f(x,y)，并计算
3 × 
4+
8 
的结果。

def 
f(x,y)
: 
return 
x*
y 
print(f(3,4)+8) 

函数代码块以def 关键词开头，后接函数标识符名称和圆括号“()”，括号里面是函数的参
数，冒号后面对应缩进的代码块是函数体。函数如果需要有返回的结果，利用return 关键字作
返回。在print 语句调用函数f(x,y) 时，参数3传给x，4传给y，计算出结果12 后，将12 作为
函数返回值与8相加。程序运行结果是输出20。

上例中函数定义时并不会执行，程序第一条执行的语句是print 语句，函数定义中的语句只
有在被调用时才会执行。

例：定义对列表中元素求和的函数，并计算range(10) 中的所有元素之和。

def 
total(list)
: 

sum = 0 

for i 
in 
list: 

sum 
+
= i 

return 
sum 

array = 
range(10) 

s = 
total(array) 


print(s) 

2.2.2 
函数参数
1. 
Python 
变量
在C语言中，系统会为每个变量分配内存空间，当改变变量的值时，改变的是内存空间中
的值，变量的地址是不改变的。Python 采用的是基于值的管理方式。
当给变量赋值时，系统会为这个值分配内存空间，然后让这个变量指向这个值；当改变变
量的值时，系统会为这个新的值分配另一个内存空间，然后还是让这个变量指向这个新值。
如果没有任何变量指向内存空间的某个值，这个值称为垃圾数据，系统会自动将其删除，回

收它占用的内存空间。
在Python 中，可以使用id() 函数获取变量或值的地址。
例：Python 变量与地址。

Num = 
number = 
2048
print("address 
of 
Num 
is 
:",id(Num)
)
print("address 
of 
number 
is 
:",id(number)
)


程序运行结果为：

address 
of 
Num 
is : 
2427449135056 
address 
of 
number 
is 
:2427449135056 

数值、字符串、元组等常量对象的存储位置用地址来描述，数值、字符串变量指向的是数
值或字符串对象的地址。Num 变量与number 变量的取值都为2048，两个变量都指向数值对象
2048 所在的地址，因此id(Num) 与id(number) 相等。而列表、字典变量指向的存储地址，在修
改部分元素时并不会发生变化，只有在重新定义列表时，地址才会发生变化。

从变量指向地址内容是否可以变化的角度看，数值、字符串、元组是不可变类型，而列表
和字典则是可变类型。

2. 
Python 
函数的参数传递
在数值、字符串、元组变量作为函数参数时，如fun(a)，传递的只是a的值，不会影响a变
量本身。如果在函数中修改a 的值，只是修改另一个复制的对象，不会影响a 本身。

在列表、字典变量作为函数参数时，则是将列表地址传过去，如果在函数中修改列表内容，
函数外部的列表值也会发生变化。

例：参数传递。


def 
swap(x,y)
: 
t=
x 
x=
y 
y=
t 

def 
swaplist(x)
: t = 
x[0] 
x[0] = 
x[1] 
x[1] = t 

n=
2
m=
3
array = 
[2,3]
swap(n,m)
swaplist(array)
print("n=",n,
" 
m=",m)
print(array)


程序运行结果为：

a=
2 
b=
3 
[3, 
2] 

3. 
缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。
例：缺省参数。

def 
Student(name,grade = 
3)
: 

print("name:",name,"grade:",grade) 
Student(grade = 
5,name = 
"LiMing"
) 
Student(name = 
"LiMing"
) 
Student("LiMing"
) 

程序运行结果为：

name: 
LiMing 
grade: 5 
name: 
LiMing 
grade: 3 
name: 
LiMing 
grade: 3 


2.2.3 
Python 
模块
在Python 中，可以将一组相关的函数、数据放在一个以.py 作为文件扩展名的Python 文件
中，这种文件称为模块。Python 模块为函数和数据创建了一个以模块名称命名的作用域。利用
模块可以定义函数、类和变量，模块里也可以包含可执行的代码。Python 的模块机制应用于系
统模块、自定义模块和第三方模块。

模块定义好后，可以使用如下两种方式引入模块。

（1）使用import 语句引入模块。语法如下：
importmodule1[，module2[，…moduleN] 
解释器遇到import 语句，如果模块位于当前的搜索路径，该模块就会被自动导入。
调用模块中函数时，格式为：
模块名. 函数名
在调用模块中的函数时，之所以要加上模块名，是因为在多个模块中可能存在名称相同的
函数，如果只通过函数名来调用，解释器无法知道到底要调用哪个函数。
例：引入系统math 模块，求解一元二次方程。

import 
math
print("please 
input 
a,b,c"
)
a=int(input("a=")
)
b=int(input("b=")
)
c=int(input("c=")
)
deta=b**2-4*a*
c
if 
deta>=0:


print("x1=",(-b+math.sqrt(deta))/2/a) 
print("x2=",(-b-math.sqrt(deta))/2/a) 
else: 
print("no 
result"
) 

input() 函数用于键盘输入，返回值类型为字符串，由于一元二次方程系数为整数，需要利
用int() 函数将输入的字符串转换为整数。开平方函数sqrt 不属于Python 系统基本函数，位于
math 模块中，在调用该函数前需要导入math 模块。

例：course 模块（文件名：course.py）。

def 
information(
) : 

title= 
input( 
"input 
title 
of 
course 
:
" ) 

time= 
float(input 
("input 
time 
of 
course: " 
)
) 


print("title="
, 
title) 
print("time= 
"
, 
time) 

course 模块定义了一个名为information 的函数，并在函数中声明了title、time 两个变量分
别用于存储课程名称与对应的课时，并通过input() 函数与print() 函数输入和输出课程信息。
例：主程序（文件名：coursemain.py）。

import 
course 
def 
main()
: 
course.information(
) 
main(
) 

运行程序coursemain.py ，结果为：

input 
title 
of 
course 
:python 
input 
time 
of 
course: 
72 
title= 
python 
time= 
72.0 

（2）使用from 语句导入指定函数。
有时只需要用到模块中的某个函数，from 语句可从模块中导入指定的部分。格式如下：
from 模块名import 函数1[，函数2[，…函数n]] 
例如：
from math importsqrt 

如果想把一个模块的所有内容全都导入，格式为
：
from 模块名import 
*


2.3 
Python 
对象与类
Python 中的任何数据都是对象。例如，整型、字符串、列表等都是对象。

每个对象由标识、类型和值3部分组成。对象的标识（变量名）代表该对象在内存中的存
储位置。对象的类型表明它可以拥有的数据和值的类型。在Python 中，可变类型的值是可以更
改的，不可变类型的值是不能修改的。

对象不仅有值，还有相关联的方法。例如，一个字符串不仅包含文本，也有关联的方法，如
将整个字符串变成小写或者大写的lower() 方法和upper() 方法。

例：对象的类型与方法。


fruit="apple" 
number=23 
print(type(fruit)
) 
print(type(number)
) 
print(fruit.lower()
) 
print(fruit.upper()
) 

type() 函数的作用是获取变量的类型。
程序运行结果为：

<type 
'str'
>
<type 
'int'
>
apple
APPLE


任何一个字符串对象都有lower() 方法和upper() 方法，而整型对象则没有这两种方法。所
有的字符串对象都是由同一个模板产生的，这种模板用于描述字符串对象的共同特征，称为类。
对象是根据类创建的，一个类可以创建多个对象。

类是数据（描述事物的特征，在类中称为属性）和函数（描述事物的行为，在类中称为方
法）的集合。

2.3.1 
类的定义与使用
使用类可以描述任何事物。下面通过创建一个简单的学生类说明在Python 中类的定义与使
用方法。
例：Animal 类（文件名：animal.py）。

class 
Animal()
: 

def 
__init__(self,kind,number)
:
self.kind=kind
self.number=number


def 
printAnimal(self)
:
print("kind=",self.kind,"number=",self.number)
a=Animal("bird",53)



a.printAnimal(
)
a.number=38
print("kind="a.kind,"number=",a.number)


Animal 类说明：

（1）在Python 中，使用class 关键字来声明一个类。根据约定，首字母大写的名称指的是类。
类定义中的括号指定的父类是object，表示从普通的Python 对象类创建Animal 类。
（2）_ _init__() 方法。这是一个特殊的方法，称为构造方法。开头和末尾各有两个下画线，
是一种约定，旨在避免Python 默认方法与普通方法发生名称冲突。
方法中包含3个形式参数：self、kind 和number。其中，形式参数self 必不可少，还必须位
于其他形式参数的前面。Python 调用_ _init__() 方法创建Student 实例时，将自动传入实际参数
self。每个与类相关联的方法调用都自动传递实际参数self，它是一个指向实例本身的引用，让
实例能够访问类中的属性和方法。

（3）属性。_ _init__() 方法中定义的两个变量都有前缀self。以self 为前缀的变量都可供类
中的所有方法使用，可以通过类的任何实例来访问这些变量。self.kind=kind 获取存储在形式参
数kind 中的值，并将其存储到变量kind 中，然后该变量被关联到当前创建的实例。self.number= 
number 的作用与此类似。像这样可通过实例访问的变量称为属性。
（4）在创建Animal 实例a时，Python 将调用Animal 类的方法_ _init__() 。由于self 自动传
递，因此不需要在参数中包括self，只需给最后两个形式参数（kind 和number）提供值。通过
将实际参数bird 和53 分别传递给形式参数kind 和number，为kind 属性和number 属性赋值。
（5）类中定义了另外一个方法：printAnimal() 。由于方法不需要额外的信息，因此只有一个
形式参数self。
（6）使用点号“·”操作符访问对象的属性和方法。
（7）可以通过对对象属性直接赋值的方式修改属性或增加属性
。
Animal 类实例的输出结果
：
kind= 
bird 
number= 
53 
kind= 
bird 
number= 
38 

2.3.2 
类的继承
编写的类以另一个已有的类为基础，可使用继承。一个类继承另一个类时，它将自动获得
另一个类的所有属性和方法；原有的类称为父类，而新类称为子类。子类继承了父类的所有属
性和方法，同时还可以定义自己的属性和方法。

例：Pigeon 类（文件名：animal.py）。


class 
Animal(object)
: 

def 
__init__(self,kind,number)
:
self.kind=kind
self.number=number


def 
printAnimal(self)
: 
print("kind=",self.kind,"number=",self.number) 
class 
Pigeon 
(Animal)
: 

def 
__init__(self,kind,number,weight,color)
:
super(Pigeon,self).__init__(kind,number)
self.weight=weight
self.color=color


def 
printCharacter(self)
: 

print("weight=",self.weight,"color=",self.color) 
a= 
Pigeon 
("Pigeon",23,1.2, 
"write"
) 
a.printAnimal(
) 
a.printCharacter(
) 

Pigeon 类说明：

（1）创建子类。定义子类时，必须在括号内指定父类的名称。
（2）super() 是一个特殊函数，帮助Python 将父类和子类关联起来。这行代码让Python 调用
Pigeon 父类（Animal）的方法_ _init__() ，让Pigeon 实例包含父类的所有属性。父类也称为超
类（superclass），名称super 因此而得名。方法_ _init__() 定义中包含5个形式参数：self、kind、
number、weight 和color。其中，形式参数self 必不可少。由于Animal 类在构造函数中创建了
kind 和number 属性，Pigeon 类将继承父类这两个属性。父类中不包含的属性由子类在构造函数
中创建。

（3）子类继承了父类方法printAnimal() ，可以直接调用
。
程序运行结果为
：
kind=Pigeon 
number=23 
weight=1.2 
color=write 

2.4 
文件和异常
文件的主要作用是存储数据。文件存储在磁盘或其他辅助存储设备上，是可读可写的。磁
盘存储数据的基本单位是字节（8位二进制数），因此读写文件的基本单位是字节。文件中存储
的内容是ASCII 字符或文字，这类文件称为文本文件。文件中存储的数据是整型（包括其他表


示成无符号整数的数据类型，如图像、音频或视频）、浮点型或其他数据结构，这类文件称为二

进制文件。应用程序在处理文件时，可以根据文件存储的内容决定读写方式
。
读写文件主要有两种方式
：


（1）顺序读写：每个数据（字符、整数或其他类型数据）必须按顺序从头到尾一个接一个地
进行读写。进行顺序读写时，Python 会设置一个变量，用于存储当前要读写数据的位置，每次
读写完成后，变量会自动增加，指向下一个数据位置。
（2）随机读写：读写文件中任意位置的数据时，可以直接定位到该位置进行读写。
2.4.1 
文本文件读写
在Python 中，操作文件需要先创建或者打开指定文件并创建文件对象，可以通过open() 函

数实现。open() 函数包含两个参数，分别为文件名和文件打开模式，其中文件打开模式为可选

参数。

注意：如果不指定路径，Python 将在当前执行的文件所在的目录中查找文件。函数open() 
返回一个表示文件的对象。

1. 
读文本文件
在读取文本文件之前，首先在D盘创建一个名为“poem.txt”的文本文件。在Python 中，常
用的读取文本文件的方式主要有以下两种。

（1）读取整个文本文件。读取文件的全部内容，调用read() 方法即可实现。
例：读取整个文本文件。
with 
open("D:\poem.txt"
) 
as 
f:
content=f.read(
)
print(content)


上述例子中，with 表示在不需要访问文件时将其关闭。在with 结构中，只调用了open() 打
开文件，并没有调用close()，Python 会在合适的时候自动将文件关闭。

（2）逐行读取。在使用read() 方法读取文件时，如果文件过大，一次性读取全部内容到内
存，容易造成内存不足，所以通常会采用逐行读取。文件对象提供了readline() 方法用于每次读
取一行数据。
例：逐行读取文件。

with 
open("D:\poem.txt"
) 
as 
f: 
for 
line 
in 
f: 
print(line) 


for 语句对文件对象执行循环，遍历文件中的每行。在循环过程中，line 取值为文本文件一
行的内容（包括换行符）。

程序输出结果与上例相比，各行间多出一个空白行。因为在文本文件中，每行的末尾都有
一个看不见的换行符，而print 语句也会加上一个换行符，因此每行末尾都有两个换行符：一个
来自文件，另一个来自print 语句。要消除这些多余的空白行，可以使用字符串对象的rstrip() 方
法将line 右端的空白符去掉，如：print(line.rstrip()) 。

此外，文件对象中还提供了readlines() 方法用于逐行读取文件内容。

例：逐行读取文件内容。

with 
open("D:\poem.txt"
) 
as 
f: 
lines = 
f.readlines(
) 
print(lines) 

2. 
写文本文件
Python 的文件对象提供了write() 方法可以向文件中写入内容，常用的写入方式分别为以写
入模式写文本文件和以附加模式写文本文件。

（1）以写入模式写文本文件。要将文本写入文件，在调用open() 时需要提供另一个实际参
数，操作文件的模式告诉Python 要写入打开的文件。
例：以写入模式写文本文件。

with 
open("D:\poem.txt","w"
) 
as 
f: 
f.write(
" 
相见欢"
) 
f.write("无言独上西楼，月如钩。"
) 
f.write("寂寞梧桐深院锁清秋。"
) 
f.write("剪不断，理还乱，是离愁，"
) 
f.write("别是一般滋味在心头。"
) 

上述代码中，调用open() 时提供了两个实际参数，第一个实际参数也是要打开文件的名称，
第二个实际参数"w" 表示以写入模式打开这个文件。打开文件时，可指定读取模式"r"、写入模
式"w"、附加模式"a" ，或读取和写入的模式"r+""w+"。如果省略了模式实际参数，Python 将以默
认的只读模式打开文件。

如果写入的文件不存在，函数open() 将自动创建文件。如果指定的文件已经存在，Python 
将在返回文件对象前清空该文件。

文件对象的方法write() 将一个字符串写入文件。由于是顺序读写模式，连续的3个写方
法将3个字符串写到文本文件中。在写文件的过程中，并没有写入换行符，因此文件的内容在


文本编辑器中只显示一行。如果想要分行写文件，可以加入换行符“\n”，如：f.write(" 相见欢
\n")。

（2）以附加模式写文本文件。附加模式是指打开一个文件用于追加。如果该文件已存在，新
的内容将会被写入已有内容之后。如果该文件不存在，创建新文件进行写入
。
例：以附加模式写入文本文件
。


with 
open("D:\poem.txt","w"
) 
as 
f: 

f.write(
" 
浣溪沙\n"
) 
f.write("一曲新酒就一杯，去年天气旧亭台\n"
) 
f.write("夕阳西下几时回？\n"
) 
with 
open("D:\poem.txt","a"
) 
as 
f: 
f.write("无可奈何花落去，似曾相识燕归来。\n"
) 
f.write("小园香径独徘徊。\n"
) 

2.4.2 
二进制文件读写
与文本文件的读写一样，在读写二进制格式的文件时也需要先打开文件，再进行文件读写。
打开二进制文件时，可指定读取模式"rb"、写入模式"wb"、附加模式"ab"，或读取和写入的模
式"rb+""wb+"。

由于Python 中的整数、浮点数等类型的数据都是对象，并不是真正写入文件的内容，因此
在写入二进制文件之前，需要先利用struct 模块的pack() 方法对整数等类型数据作格式转换，转
换方法为：

struct.pack(fmt,values) 

pack() 方法中fmt 参数定义如表2.6 所示。

表2.6 
fmt 
参数定义


例如：写二进制文件。


import 
struct
numbers = 
[0,1,2,3,4,5,6,7,8,9]
filename="D:\list_number.dat"
with 
open(filename,"wb"
) 
as 
f:


for 
number 
in 
numbers: 
d=struct.pack("i",number) 
f.write(d) 

d=struct.pack("i",number) 

语句struct.pack("i",number) 将整数转换成C语言的整型格式：占4字节，低位在前，列表
numbers 的整数都按这种格式写入文件。

Python 读二进制文件时，从文件中读到一组字节序列，需要使用struct.unpack() 方法将其转
换成Python 的数据类型。

例：读二进制文件。

import 
struct 

filename="D:\list_number.dat" 

sum=
0 

with 
open(filename,"rb"
) 
as 
fr: 
for i 
in 
range(0,10)
: 
b=fr.read(4) 
d=struct.unpack("i",b) 
sum=sum + 
d[0] 

print('sum=',sum) 

程序读取的二进制文件为上例生成文件。文件对象的read() 方法不指定参数时，读取的是
文件的全部内容；指定数值时，读取指定数量的字节。由于文件中用4字节存储一个整数，因
此read 方法指定的参数为4。unpack() 方法将长度为4的字符（节）转换成列表，列表的第1个
元素即为读取的整数。

2.4.3 
异常
Python 程序执行期间发生错误时，程序将停止，并显示一个traceback ，其中包含有关异常
的报告。Python 使用“异常”对象来管理程序执行期间发生的错误。在产生错误时，Python 会
创建一个异常对象。如果编写了处理该异常的代码，程序将继续运行。

异常是使用try-except 代码块处理的。try-except 代码块让Python 执行指定的操作，同时告
诉Python 发生异常时怎样处理。使用了try-except 代码块时，即使出现异常，程序也将继续运行。


在编写程序的过程中，经常会使用各种运算符，特别在进行除法运算时，除数不能为0，这

时就需要进行异常处理。

例：除数为0的异常处理。

try : a = 
int(input("除数：")
) b = 
int(input("被除数：")
) 
print(a/b) 

except: 
print("You 
can't 
divide 
by 
zero 
!"
) 

except 代码块在出错时会执行。Python 细分了多种不同类型的错误，如IOError 、ZeroDivisionError 等。如果进一步限定出错情况，在except 关键字后面可以使用具体的错误类型。如上
例中使用except ZeroDivisionError 更确切。

此外，对文件进行操作时，常会遇到找不到文件的问题，如要查找的文件可能在其他地方、
文件名可能不正确或者这个文件根本就不存在。对于所有这些情形，都可使用try-except 代码块
以直观的方式进行处理。

filename = 
"animal.txt"
try:


with 
open(filename) 
as 
f:
content=f.read(
)
print(content)


except 
IOError:
print("the 
file 
"+filename 
+
" 
does 
not 
exist."
)