本书共分两部分，**部分包括计算思维与Python简介、算法、数据与计算、流程控制、函数、模块、数据文件、面向对象编程、异常处理、图形界面设计和绘制曲线，为方便教学，每章*后均附有简答题和编程题；第二部分给出了7个实验，即数据与计算、流程控制、函数、数据文件、面向对象编程、图形界面设计和绘制曲线。
本书按课程教学模式来组织内容，既适合教师授课，也适合学生自学；同时，本书面向应用需求，教学内容先进，尽力帮助学生理解并掌握计算思维和编程技术。
本书内容丰富、图文并茂，讲解简明易懂、循序渐进、深入浅出，可作为高等学校非计算机专业学生学习“Python程序设计”课程的教材，也可作为初学者、Python爱好者的辅助学习资料。

第5章函数
在程序设计过程中，程序员常会遇到这样的情况，有些操作经常重复出现，有时是在一个程序中多次重复出现，有时是在不同程序中多次重复出现,这些重复运算的程序段是相同的，只不过是每次都以不同的参数进行重复。如果在一个程序中，相同的程序段多次重复编写，势必会使程序行数过多，一方面会占用大量的存储空间，另一方面又浪费宝贵的编程时间。对于许多都要使用的计算函数和求解问题的程序，情况也是如此。如果每个需要这些程序的人都自行单独设计，将浪费大量的时间与**，大大地降低程序员的工作效率。解决这一问题的有效办法就是将上述各种情况下共同使用的程序设计成可供其他程序使用的独立程序段。
在Python中，这样的程序段被称为函数，其实质就是计算思维中的模块设计概念。对于数值���算、数据库管理、界面布局、多线程、游戏设计等领域的问题，也可以使用函数这一技术。例如，已知正整数m和n，要求计算组合值m!/n!/（m－n）!。在这个应用程序中，要使用计算阶乘的程序3次，每次就只对不同的数据进行计算，而程序结构则是一样的。
在Python中，函数分为内置函数、标准库函数、第三方库函数和自定义函数四大类。本章主要介绍自定义函数及其调用，内容包括嵌套调用、返回列表、形式参数与实在参数、全局变量与局部变量、lambda函数、递归函数等。
5.1函数定义与调用
在Python编程规范中，程序书写的顺序通常是，首先进行函数定义，然后才是通过主程序实现函数调用。
5.1.1函数定义与调用
Python除了提供大量丰富的内置函数和模块方法，还允许自定义函数，这为编写程序提供了一种有效扩展功能的方法。
1. 函数定义
用户在定义函数时需要使用def语句，在def语句内部一方面是定义函数的功能，另一方面是将函数值返回给主调函数（即主程序）。
def语句的一般引用格式如下： def <函数名>(<形参表>):
<函数体>
return <返回值>说明：
（1） 定义函数由保留字def开头，且与其后的<函数名>之间要用空格分隔；
（2） <函数名>必须是合法的Python标识符，且其后必须跟圆括号以标识函数；
（3） 圆括号后必须跟冒号，从而让系统自行识别并处理后续的<函数体>；
（4） <形参表>位于括号内，表示函数涉及的参数，由逗号分隔不同的形参；
（5） <函数体>用于实现函数的具体执行功能；
（6） <函数体>由语句块组成，必须缩进固定空格数，且*好沿用IDLE交互环境中的隐含设置；
（7） 若是有参函数，则要有<返回值>选项，可由return语句实现。
2. 函数调用及其返回
（1） 函数调用。调用函数的一般格式如下： <函数名>(<实参表>)说明： <实参表>表示函数调用时所需的全部参数。由于实参中的值将传递给形参，所以实参应该是常数、有值的变量、表达式、另一个函数调用等。
（2） 返回语句。return语句的功能是从被调函数返回到主调函数继续执行，返回时可以附带一个返回值，由return语句后面的参数指定。其一般引用格式如下： return<表达式>说明：
① <表达式>用于表示函数的返回值。
② 定义函数必须以return（<表达式>）语句结尾，除非没有返回值。
③ 若有可选项<表达式>，则函数将返回该表达式的值；若无可选项<表达式>），则系统自动返回常量None。图51函数调用过程

一个函数可以通过return语句返回一个特定类型的值，也可以不使用return语句，而是只执行函数主体中的代码，这种情况下，函数将向调用者返回一个未定义的值。实际上，创建函数的方法与编写其他应用程序是完全相同的，其差别仅仅是在一个函数中至少要有一条return语句，除非没有返回值。
（3） 函数调用过程。当函数调用出现在主程序中时，将执行所指定的a()函数。在a()函数执行到return语句时，将流程转移主程序，同时将返回值传递给主程序，然后继续执行函数调用后面的语句。函数调用的过程如图51所示。
3. 无参函数及其调用

无参函数在没有参数的情况下，使函数没有通用性，即运行结果是固定的。一般用于显示指定信息，若涉及数据也只是转换，而不是计算，所以没有返回值。
【例51】显示3行提示信息。
源程序如下： #定义两个无参函数
def printstar():
print("")
def print_message():
print(" Computation Thinking! ")
#主程序并3次调用无参函数
printstar()
print_message()
printstar()本例中定义两个无参函数，主程序将三次调用无参函数。
运行结果如图52所示。
图52例51的运行结果
【例52】显示一个平行四边形图案。
源程序如下： #定义无参函数
def printstar():
s=""
for i in range(0,7,1):
#显示左侧空格
for k in range(0,i+3,1):
print(" ",end="")
print(s)#显示星号串
#主程序并调用无参函数
printstar()本例中定义无参函数只是显示图案，所以主程序直接调用，并没有参数传递和变量引用。
运行结果如图53所示。
图53例52的运行结果
4. 有参函数及其调用
【例53】找出两个数中的较大数。
源程序如下： #定义有参函数
def larger(x,y):
if x>y:
return x
else:
return y
#主程序及函数调用
a=int(input("输入第1个数: "))
b=int(input("输入第2个数: "))
c=larger(a,b)
print("较大数: \t",c)本例中的有参函数larger()在获得由实参a和b传递的数据后，使函数能够找出指定两数中的较大数，从而使函数具有通用性，即运行结果不是固定的。
运行结果如图54所示。
图54例53的运行结果
5.1.2嵌套调用
在执行主程序时可以调用**个函数，在执行**个函数时还可以调用第二个函数，这样可以一个又一个地调用下去，这种调用称之为嵌套调用。下面用一个例子加以说明。
【例54】计算1＋（1＋2）＋…＋（1＋2＋3＋4＋5＋6＋7＋8＋9＋10）。
求解方法： 由于这里的和式由20项阶加组成，但每一项又是一个需若干数据阶加的式子。所以要定义两个函数，并进行嵌套调用。
源程序如下： #定义函数sum1()对一项阶加
def sum1(n):
sum=0
for i in range(1,n+1,1) : sum=sum+i
return sum
#定义函数sum2()对若干数据累加
def sum2(n):
sum=0
for i in range(1,n+1,1):
#第二次调用函数
sum=sum+sum1(i)
return sum
#主程序并嵌套调用函数
n=int(input("输入数据: "))
#**次调用函数
s=sum2(n)
print("累加和值: ",s)本例中的嵌套调用过程是，主程序调用sum2()函数，sum2()函数再调用sum1()函数，从而构成两重嵌套的调用函数过程。
运行结果如图55所示。
图55例54的运行结果
5.1.3返回值类型与函数类型
由于Python使用解释方式实现语义分析，进而导致变量的数据类型可以动态变化。所以，实参类型、返回值类型和函数类型均可以动态变化。
【例55】实参类型动态变化示例。
源程序如下： #定义函数
def larger(x,y):
if x>y:
return x
else:
return y
#主程序及其4次调用函数
a=3.5
b=4.5
c=larger(a,b)
print(a,b,"中的较大数: ",c)
m=6
n=2
d=larger(m,n)
print(m,n,"中的较大数: ",d)
s1="This"
s2="That"
e=larger(s1,s2)
print(s1,s2,"中的较大数: ",e)
c1=3+4J
c2=4-5J
f=larger(c1,c2)
print(c1,c2,"中的较大数: ",f)本例中进行4次函数调用，第1次是2个实数作为实参，第2次是2个整数作为实参，第3次是2个字符串作为实参，第4次是2个复数作为实参。运行结果表明，前3次调用都得到正确结果，但是复数不能进行大于比较，因此系统将显示错误代码。
运行结果如图56所示。
图56例55的运行结果
5.1.4返回列表
让函数返回一个列表，并由列表中的多个元素来描述函数的多值计算，能够解决函数式程序设计中只能实现单值返回的问题。
【例56】编程生成由6个随机数构成的列表。
源程序如下： #导入random模块
import random
#定义函数生成由n个随机数构成的列表
def my_random(n):
a=[]
for k in range(n):
#将一个随机数附加到列表中
a.append(random.random())
return a
#主程序及其调用函数
n=int(input("输入数据: "))
m=my_random(n)
print("列表元素: ")
#输出列表中的所有元素
for k in m: print(k)运行结果如图57所示。
图57例56的运行结果
5.2形式参数与实在参数
Python的函数与其他**语言一样，主程序把一些参数传递给函数，在函数对这些参数进行运算和处理后，再把结果传递给主程序。参数传递是通过主程序中的实在参数和被调用函数中的形式参数相结合来完成的，换句话说，在主程序中要列出实在参数，而在函数中要设置一些形式参数。当进行函数调用时，使形式参数和实在参数相结合，从而实现参数的传递。形式参数（简称形参）和实在参数（简称实参）相结合的具体情况如下：
（1） 实参和形参在数量上*好相等；
（2） 对应位置上的实参和形参*好数据类型一致或兼容；
（3） 实参可以是常量、变量、表达式或另一个函数，而形参只能是变量；
（4） 如果实参为常量，则将常量赋值给形参；
（5） 如果实参为表达式，则将表达式的值赋值给形参；
（6） 如果实参为另一个函数，则一定要能够获得返回值；
（7） 如果实参为已赋值变量，则将其值赋给形参。
5.2.1简单变量作为实参
【例57】设定两个正整数m和n，计算组合值m!/n!/(m－n)!。
求解方法： 本例将定义计算阶乘的函数，其中实参是有值的简单变量，其值由系统自行赋给形参，主程序通过3次调用计算阶乘的函数来获得组合值。
源程序如下： #定义有参函数comp()
def comp(k):
fact=1
for i in range(1,k+1,1) : fact=facti
return fact
#主程序
m=int(input("m="))
n=int(input("n="))
#三次调用函数comp()
c=comp(m)/comp(n)/comp(m-n)
print("6!/2!/4!=",c)运行结果如图58所示。
图58例57的运行结果
【例58】利用穷举算法找出两个正整数中的*大公约数。
求解方法： 获取两数中的较小数并由变量least表示，使用for循环穷举可能的因数，即变量k的取值范围（必须降序）为least～1。若x、y同时能够整除k，则表示k是*大公约数，将其值返回给主程序。由于k的取值过程是从大到小的，所以**条件成立时就是*大公约数。
源程序如下： #定义函数gcd(x, y)找出两数中的*大公约数
def gcd(x,y):
#获取两数中的较小数
if x>y:
least=y
else:
least=x
for k in range(least,0,-1):
#若x, y同时整除k, 则k是*大公约数
if(x % k==0 and y % k==0):
gcd=k
return gcd
#主程序
a=int(input("a="))
b=int(input("b="))
#调用函数并显示结果
print(a,"和",b,"的*大公约数为",gcd(a,b))运行结果如图59所示。
图59例58的运行结果
【例59】利用欧几里得算法找出两个正整数中的*大公约数。
求解方法： 欧几里得算法又称辗转相除法。设定两个正整数为x和y，若x%y的值大于0，则重复进行如下3个操作： r=x%y，x=y，y=r，直到x%y为0时，这时的y就是*大公约数。
源程序如下： #定义函数gcd(x, y)找出两数中的*大公约数
def gcd(x,y):
r=x%y
while r>0:
x=y
y=r
r=x%y
return y
#主程序及其调用函数
a=int(input("a="))
b=int(input("b="))
print(a,"和",b,"的*大公约数为",gcd(a,b))【例510】验证哥德巴赫猜想。猜想的大意是，任意大于等于6的偶数都可以写成两个质数之和，例如： 6=3+3，8=3+5，10=3+7。编程验证100以内的所有偶数。
求解方法： 定义p（m）函数，功能是若m为质数，则函数返回值为1，否则返回值为0。主程序使用for 循环穷举所有偶数，并两次调用p（m）函数进行是否质数的判断。另外，使用变量count控制每行显示5个偶数。由于至今人类并没有发现反例，所以验证过程能够正常进行。
源程序如下： #定义函数p(m), 若取值为1则是质数, 否则取值为0表示不是质数
def p(m):
k=2
flag=0
while kif m%k==0:#不是质数
flag=1
break
k=k+1
if flag==0:
return 1
else:
return 0
#主程序及其两次调用函数
count=0#控制换行
for n in range(6,100,2):#穷举全部偶数
for k in range(3,n,1):#穷举可能的质数
if p(k)==1 and p(n-k)==1:
count=count+1
print(n,"=",k,"+",n-k,end="\t")
if count%4==0 : print()
break运行结果如图510所示。
图510例510的运行结果
【例511】找出100以内两两相邻的全部质数，例如3和5，5和7，11和13，等等。
源程序如下： #定义函数
def p(m):
k=2
flag=0
while kif m%k==0:
flag=1
break
k=k+1
if flag==0:
return 1
else:
return 0
#主程序及其两次调用函数
count=0
for n in range(3,100,2):#穷举全部奇数
if p(n)==1 and p(n+2)==1:#是否是相邻质数
count=count+1
print("第",count,"对相邻质数: ",n,":",n+2)主程序使用for 循环穷举所有奇数，并两次调用p（n）和p（n+2）函数进行是否质数的判断。
运行结果如图511所示。
图511例511的运行结果
【例512】找出500以内的全部亲密数对。
如果整数A的全部因数（包括1，不包括A本身）之和等于B，且整数B的全部因数（包括1，不包括B本身）之和等于A，则将整数A和B称为亲密数对。例如220和284就是一对亲密数，计算过程如下：
（1） 220 =1+ 2+ 4+ 5+ 10+ 11+ 20+ 22+ 44+ 55+ 110= 284
（2） 284 =1+ 2+ 4+ 71+ 142= 220
源程序如下： #定义函数p()求n的因数和
def p(n):
s=0
for k in range(1,n,1):
if n%k==0 : s=s+k
return s
#定义函数display()显示n的因数阶加式
def display(n):
print(n,"=1",end="")
for k in range(2,n,1):
if n%k==0 : print("+",k,end="")
#主程序及其两次调用函数
for a in range(1,500,1):
for b in range(a+1,500,1):
if p(a)==b and p(b)==a:#测试是否亲密数对
display(a)
print("=",b)
display(b)
print("=",a)
print("亲密数: ",a,b)
break

目录
**部分基 础 知 识
第1章计算思维与Python语言3
1.1程序设计3
1.1.1程序与计算机程序3
1.1.2程序设计步骤5
1.1.3程序设计语言6
1.1.4**语言分类7
1.2计算思维8
1.2.1计算思维概念9
1.2.2计算思维特征11
1.3Python简介12
1.3.1Python优点12
1.3.2Python缺点14
1.3.3Python主要应用15
1.4Python运行环境16
1.4.1Python下载与安装16
1.4.2Python帮助信息19
1.4.3Python文件夹结构21
1.4.4Python运行模式21
习题127第2章算法29
2.1程序设计方法29
2.1.1结构化程序设计方法29
2.1.2面向对象程序设计方法30
2.2算法32
2.2.1求解���题方式32
2.2.2算法概念32
2.2.3算法特征32
2.3算法表示33
2.3.1使用自然语言描述算法33
2.3.2使用传统流程图描述算法34
2.3.3使用NS图描述算法36
2.3.4使用伪代码描述算法37
2.4常用算法介绍37
2.4.1简单算法37
2.4.2阶乘算法38
2.4.3求斐波那契数算法38
2.4.4求*大公约数算法39
2.4.5判断素数算法40
2.5综合算法介绍40
2.5.1数值计算40
2.5.2穷举算法41
2.5.3查找算法43
2.5.4排序算法44
2.6迭代、递推和递归46
2.6.1迭代46
2.6.2递推47
2.6.3递归48
习题248第3章数据与计算50
3.1输入输出50
3.1.1输入数据50
3.1.2输出数据51
3.2编码风格与简单程序53
3.2.1编码风格53
3.2.2简单程序53
3.3组合符号54
3.3.1标识符54
3.3.2关键字55
3.3.3预定义标识符56
3.3.4命名规则57
3.4数据类型57
3.4.1数据类型及其分类57
3.4.2常量和变量58
3.5数字数据58
3.5.1整型数据58
3.5.2实型数据61
3.5.3分数型数据62
3.5.4复数型数据62
3.6字符串型数据63
3.6.1字符串常量63
3.6.2转义字符63
3.6.3字符串测试函数64
3.6.4字符串运算符65
3.6.5字符串内置函数66
3.7布尔型数据68
3.7.1关系运算68
3.7.2布尔常量69
3.7.3布尔运算69
3.8序列数据70
3.8.1列表70
3.8.2元组74
3.8.3字典74
3.8.4集合76
习题377第4章流程控制80
4.1简单程序与流程控制80
4.1.1简单程序80
4.1.2流程控制语句81
4.1.3测试条件81
4.2分支选择81
4.2.1单分支选择82
4.2.2双分支选择83
4.2.3多分支选择84
4.3循环控制86
4.3.1while语句86
4.3.2range（）函数89
4.3.3for语句89
4.3.4循环嵌套94
4.3.5continue、break和pass语句98
4.4列表处理101
4.4.1一维列表102
4.4.2二维列表107
4.5查找与排序114
4.5.1折半查找114
4.5.2排序115
4.6字符串处理118
4.6.1单个字符串118
4.6.2多个字符串122
习题4123第5章函数125
5.1函数定义与调用125
5.1.1函数定义与调用125
5.1.2嵌套调用128
5.1.3返回值类型与函数类型129
5.1.4返回列表130
5.2形式参数与实在参数130
5.2.1简单变量作为实参131
5.2.2一维列表作为实参137
5.2.3二维列表作为实参139
5.2.4可变参数139
5.3变量的作用域140
5.3.1全局变量与局部变量140
5.3.2global语句141
5.3.3变量同名143
5.4匿名函数144
5.4.1lambda函数144
5.4.2程序示例144
5.5递归函数145
5.5.1递归函数及其调用145
5.5.2程序示例145
习题5151第6章模块152
6.1模块152
6.1.1导入模块152
6.1.2导入模块成员153
6.1.3模块搜索路径154
6.2数值类模块155
6.2.1math模块155
6.2.2cmath模块157
6.2.3decimal模块157
6.2.4fractions模块159
6.3random模块161
6.3.1常用函数161
6.3.2程序示例163
6.4时间类模块165
6.4.1time模块167
6.4.2datetime模块171
6.4.3calendar模块172
6.5os模块174
6.5.1常用函数174
6.5.2程序示例176
6.6sys模块178
6.6.1常用函数178
6.6.2命令行参数179
6.7自定义模块180
6.7.1主模块181
6.7.2自定义模块示例182
6.7.3Python编译文件183
6.8自定义包183
6.8.1包与模块的组织结构183
6.8.2包与模块的导入184
6.8.3自定义包示例185
习题6187第7章数据文件189
7.1文件概述189
7.1.1引言189
7.1.2文件分类189
7.2打开文件与关闭文件191
7.2.1打开文件191
7.2.2关闭文件193
7.3读写文本文件193
7.3.1读取文件函数193
7.3.2读取文本文件194
7.3.3写入文本文件198
7.4读写二进制文件200
7.4.1将字符串转换为字节数据201
7.4.2将字节数据转换为字符串201
7.4.3读写二进制文件202
7.5struct模块202
7.5.1pack()、unpack()和calcsize()函数203
7.5.2程序示例204
7.6fileinput模块206
7.6.1fileinput模块206
7.6.2程序示例206
7.7codecs模块208
7.7.1读取文本文件209
7.7.2写入文本文件209
习题7210第8章面向对象编程212
8.1面向对象编程基础212
8.1.1对象与类212
8.1.2对象特征213
8.1.3继承213
8.1.4多态性与重载214
8.2类的定义和引用215
8.2.1类的构成215
8.2.2类的定义与引用215
8.2.3构造函数和析构函数217
8.2.4实例变量219
8.2.5私有成员与公有成员220
8.2.6公有方法与私有方法221
8.3继承222
8.3.1单继承222
8.3.2多继承223
8.3.3方法重写224
8.4多态与运算符重载224
8.4.1多态224
8.4.2运算符重载225
习题8226第9章异常处理229
9.1程序错误及其处理229
9.1.1程序错误类型229
9.1.2程序运行错误处理方法232
9.2标准异常233
9.2.1标准异常233
9.2.2标准异常示例234
9.3抛出异常和捕捉异常235
9.3.1抛出异常235
9.3.2捕捉异常237
9.4断言240
9.4.1断言概念240
9.4.2assert语句240
9.5自定义异常类242
9.5.1引言242
9.5.2程序示例242
习题9243第10章图形界面设计245
10.1Python图形界面设计245
10.1.1Python图形开发库245
10.1.2Tkinter的常用组件与标准属性246
10.1.3创建窗口246
10.2布局管理247
10.2.1pack布局的管理247
10.2.2grid布局的管理249
10.2.3place布局的管理251
10.3Tkinter的常用组件252
10.3.1Label组件252
10.3.2Button组件253
10.3.3Entry和Text组件255
10.3.4Listbox组件257
10.3.5Radiobutton和Checkbutton组件259
10.3.6Frame与LabelFrame组件261
10.3.7Scrollbar组件262
10.3.8Menu组件264
10.3.9对话框266
10.4事件处理271
10.4.1事件类型271
10.4.2事件绑定273
10.4.3键盘事件275
习题10276第11章绘制曲线278
11.1Canvas组件278
11.1.1Canvas对象及其通用属性278
11.1.2屏幕坐标279
11.2绘制图形279
11.2.1绘制直线、矩形和多边形279
11.2.2绘制圆弧和椭圆282
11.3显示位图、图像与文本285
11.3.1显示位图285
11.3.2显示图像286
11.3.3显示文本287
11.4控制图形288
11.4.1删除图形288
11.4.2移动图形289
11.4.3位置坐标289
11.4.4缩放图形290
11.4.5绘制函数图形292
11.5体验内置的turtle演示程序293
11.5.1利用IDLE内置程序293
11.5.2利用安装文件夹中的演示程序294
11.6turtle绘图296
11.6.1turtle模块296
11.6.2应用案例297
11.7分形图形301
11.7.1Koch曲线301
11.7.2Hilbert曲线302
11.7.3分形树304
11.8显示字体306
11.8.1通过元组显示字体306
11.8.2通过Font对象显示字体307
习题11308
第二部分实验
实验Ⅰ数据与计算313实验Ⅱ流程控制316实验Ⅲ函数319实验Ⅳ数据文件323实验Ⅴ面向对象编程325实验Ⅵ图形界面设计329实验Ⅶ绘制曲线333参考文献336