资源简介

(共67张PPT)
单元5
函数应用与模块化程序设计
Python程序设计
知识入门
知识要点
1．随机数函数 2．使用pip 命令下载与安装第三方模块 3．在PyCharm 中自动导入相关模块
1．随机数函数
随机数函数可以用于数学运算、游戏、安全等领域中，还经常被嵌入算法中，用以提高算法效率，并增强程序的安全性。Python 中常用的随机数函数及说明如表所示。
序号 函数 说明
1 choice(seq) 从序列的元素中随机挑选一个元素，例如：
random.choice(range(10))，从0到9中随机挑选一个整数
2 randrange([start,]stop[,step]) 从指定递增基数的集合中获取一个随机数，基数默认值为1
3 random() 在[0,1)范围内随机生成一个实数
4 seed([x]) 改变随机数生成器的种子seed
5 shuffle(lst) 将序列的所有元素随机排序
6 uniform(x,y) 在[x,y]范围内随机生成一个实数
2．使用pip 命令下载与安装第三方模块
下载和安装第三方模块可以使用Python 提供的pip 命令。pip 命令的基本语法格式如下。
pip [modulename]
其中，command 用于指定要执行的命令，常用命令有install（用于安装第三方模块）、uninstall（用于卸载已经安装的第三方模块）、list（用于显示已经安装的第三方模块）等。modulename 为可选参数，用于指定要安装或者卸载的模块名称，有时还可以包括版本号，当command 为install 或者uninstall 时此参数不能省略。
例如，安装第三方模块numpy 时，可以在命令提示符窗口中输入以下代码。
pip install numpy
执行上面的代码，将开始在线安装numpy 模块。
【说明】必须通过设置环境参数配置好可执行文件“pip.exe”的路径，否则在命令提示
符窗口中无法识别pip 命令。
3．在PyCharm 中自动导入相关模块
在PyCharm 中，如果导入模块的代码中，import 后面的模块名称“matplotlib”“numpy”下面出现红色的波浪线，就表示相应模块还未安装。
01
OPTION
将鼠标指针移到出现红色波浪线的模块名称“matplotlib”上，弹出提示信息框。
02
OPTION
按【Alt+Enter】组合键，出现一个快捷菜单，选择【Install package matplotlib】命令，然后按【Enter】键或者单击执行该命令。
03
OPTION
模块matplotlib 成功安装后，会出现图所示的提示信息。
04
OPTION
以同样的方法安装模块numpy，模块numpy 成功安装后，会出现图 所示的提示信息。
05
OPTION
模块matplotlib 和numpy 成功安装后，import 后面的模块名称“matplotlib”“numpy”下面红色的波浪线消失了，表示相应模块已成功导入。
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
5.1.1 Python 数学常量
Python 数学常量主要包括：
pi
e
圆周率，数学中一般以π 来表示
自然常数
5.1.2 Python 常用数学运算函数
序号 基本语法格式 功能描述与返回值
1 abs(x) 返回数值的绝对值，例如abs(-10)返回10
2 ceil(x) 返回数值的上入整数，例如math.ceil(4.1)返回5
3 cmp(x,y) 如果xy返回1
4 exp(x) 返回e的x次幂(ex)，例如math.exp(1)返回2.718281828459045
5 fabs(x) 返回数值的绝对值，例如math.fabs(-10)返回10.0
6 floor(x) 返回数值的下舍整数，例如math.floor(4.9)返回4
7 log(x) 如math.log(math.e)返回1.0，math.log(100,10)返回2.0
8 log10(x) 返回以10为基数的x的对数，例如math.log10(100)返回2.0
9 max(x1,x2,…) 返回给定参数的最大值，参数可以为序列
10 min(x1,x2,…) 返回给定参数的最小值，参数可以为序列
11 modf(x) 返回x的整数部分与小数部分，两部分的数值符号与x相同，整数部分以浮点型表示
12 pow(x,y) x**y运算后的值，即返回x的y次幂
13 round(x[,n]) 返回浮点数x的四舍五入值，例如给出n值，则代表舍入到小数点后的位数
14 sqrt(x) 返回数值x的平方根
15 acos(x) 返回x的反余弦弧度值
16 asin(x) 返回x的反正弦弧度值
17 atan(x) 返回x的反正切弧度值
18 atan2(y,x) 返回给定的x及y坐标值的反正切值
19 cos(x) 返回x的弧度的余弦值
20 hypot(x,y) 返回欧几里德范数sqrt(x*x+y*y)
21 sin(x) 返回的x弧度的正弦值
22 tan(x) 返回x弧度的正切值
23 degrees(x) 将弧度转换为角度，例如degrees(math.pi/2)，返回90.0
24 radians(x) 将角度转换为弧度
编写程序绘制爱心
【任务5-1】
【任务描述】
（1）在PyCharm 中创建项目“Unit05”。
（2）在项目“Unit05”中创建Python 程序文件“t5-1.py”。
（3）编写程序，绘制爱心。
【任务5-1】
01
【任务实施】
02
创建PyCharm 项目“Unit05”
创建Python 程序文件“t5-1.py”
03
编写Python 代码
04
运行Python 程序
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
5.2.1 定义函数
Python 中使用def 关键字自定义函数，定义函数的基本语法格式如下。
def 函数名称([0 个或多个参数组成的参数列表]):
''< 注释内容>''
< 函数体>
return [ 表达式]
函数定义说明如下。
函数定义部分以def 关键字开头，后接函数名称、小括号“()”和冒号“:”，函数名称在调用函数时使用，小括号用于定义参数，任何传入参数和自变量必须放在小括号内，如果有多个参数，各参数之间使用半角逗号“,”分隔；如果不指定参数，则表示函数没有参数，调用函数时，也不指定参数值。函数可以有参数也可以没有，但必须保留一对小括号“()”，否则会出现异常。默认情况下，参数值和参数名称是按函数定义中的顺序匹配的。
函数体是由多条语句组成的代码块，即函数被调用时，要执行的功能代码。函数体
的代码相对于def 关键字必须保持合理的缩进。
5.2.1 定义函数
如果函数有返回值，使用return 语句返回。return [ 表达式] 用于退出函数，有选择性地向调用方返回一个值。也可以让函数返回空值，不带表达式的return 语句返回None。函数的返回值可以是Python 支持的任意类型，并且无论return 语句出现在函数的什么位置，只要该语句得以执行，就会直接结束函数的执行。如果函数中没有return 语句，或者省略了return 语句的表达式，将返回None，即返回空值。
在函数体的前一行可以选择性地进行注释，注释的内容包括函数功能、传递参数的作用等，注释可以为用户提供友好的提示和帮助信息，但并非函数定义的必需内容，也可以没有注释。如果有注释，这些注释相对于def 关键字也必须保持合理的缩进。
创建一个函数时，如果暂时不需要编写代码实现其功能，就可以使用pass 语句作为占位符填充函数体，表示“以后会编写代码”，示例如下。
def func():
pass # 占位符
5.2.1 定义函数
【实例5-1】演示计算矩形面积函数的定义
运行以上代码，不会显示任何内容，也不会抛出异常，因为函数area() 还没有调用。
def area(width, height):
''' 计算矩形面积函数'''
area=width * height
return area
实例5-1 的代码如下所示。
5.2.2 调用函数
函数定义完成后，可以调用函数，实现其功能。可以将函数作为一个值赋给指定变量。
调用函数的基本语法格式如下。
函数名称([0 个或多个参数组成的参数列表])
要调用的函数必须是已经定义的。如果已定义的函数有参数，则调用时也要指定各个参数值；如果需要传递多个参数值，则各参数之间使用半角逗号“,”分隔；如果函数没有参数，则直接写一对小括号“()”即可。
调用函数时，如果函数只返回一个值，该返回值可以赋给一个变量；如果返回多个值，则返回值可以赋给多个变量或一个元组。
5.2.2 调用函数
【实例5-2】定义一个函数factorial()，计算n 的阶乘，即n!
实例5-2 中前5 行代码为函数定义代码，最后一行中的factorial(n) 为函数调用代码，调用函数时要给出实际参数n 的值，以替换定义中的参数m，函数调用后得到返回值s，并返回给调用方。
def factorial(m):
s=1
for i in range(1,m+1):
s*=i
return s
n=5
print("{0}!={1}".format(n,factorial(n)))
实例5-2 的代码如下所示。
实例5-2 代码的运行结果如下。
5!=120
定义函数计算总金额、优惠金额和实付金额等数据
【任务5-2】
【任务描述】
（1）在项目“Unit05”中创建Python 程序文件“t5-2.py”。
（2）定义函数计算总金额、优惠金额和实付金额等。
【任务5-2】
01
【任务实施】
创建Python 程序文件“t5-2.py”，编写代码。
02
运行程序文件“5-7.py” 。
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
5.3.1 Python 函数的参数传递
1．形式参数和实际参数
（1）形式参数
（2）实际参数
定义函数时，函数名称后面小括号中的参数称为“形式参数”，简称形参。
调用函数时，函数名称后面小括号中的参数称为“实际参数”，简称实参。
根据实参的类型，可以将实参的值或实参的引用传递给形参。当实参为不可变对象时，传递实参的值；当实参为可变对象时，传递实参的引用。值传递和引用传递的基本区别是：对于值传递，改变形参的值，实参的值不会改变；对于引用传递，改变形参的值，实参的值也一同改变。
5.3.1 Python 函数的参数传递
2．可变对象与不可变对象的参数传递
（1）可变对象的参数传递
对于代码x=[1,2,3]，[1,2,3] 是列表类型。
先使变量x=[1,2,3,4]，然后再使x[2]=5，则是将列表的第3 个元素值进行更改，x 还是那个列表，只是其内部的一部分值被修改了。
参数传递的如果是可变对象，就类似C++ 的引用传递，包括列表、字典等对象。例如函数fun(x)，则是将x 真正地传过去，在函数fun(x) 内部修改x 的值，函数fun(x) 外部的x也会受影响。
若可变对象作为函数参数，在函数里修改了参数的值，那么在调用这个函数时的原始参数也会被改变。
5.3.1 Python 函数的参数传递
【实例5-3】演示可变对象的参数传递
# 可变对象参数传递实例
def mutable(mylist):
# 修改传入的列表
mylist.append([40,50])
print(" 函数内取值：", mylist)
return
# 调用mutable() 函数
mylist = [10, 20, 30]
mutable(mylist)
print(" 函数外取值：", mylist)
实例5-3 的代码如下所示。
函数内取值: [10, 20, 30, [40, 50]]
函数外取值: [10, 20, 30, [40, 50]]
运行结果
5.3.1 Python 函数的参数传递
2．可变对象与不可变对象的参数传递
（2）不可变对象的参数传递
在Python 中，类型属于对象，变量是没有类型的。对于代码y=5，数值5 是int 类型，而变量y 没有类型，它仅仅是一个对象的引用，可以指向list 类型对象，也可以指向int 类型对象。
先使变量y=5，然后再使y=10，实际上是新生成一个int 对象10，再让y 指向它，而5被丢弃，这不是改变y 的值，而是新生成了y。
参数传递的如果是不可变对象，就类似C++ 的值传递，包括整数、元组和字符串等对象。例如fun(x) 传递的只是x 的值，没有影响x 对象本身。在fun(x) 内部修改x 的值，只是修改另一个复制的对象，不会影响x 本身。
5.3.1 Python 函数的参数传递
【实例5-4】演示不可变对象的参数传递
# 不可变对象的参数传递实例
def immutable(y):
y= 5
print(" 变量y 值为：", y) # 结果是5
return y
x = 2
print(" 函数返回值为：",immutable(x))
print(" 变量x 值为：",x ) # 结果是2
实例5-4 的代码如下所示。
变量y 值为： 5
函数返回值为： 5
变量x 值为： 2
运行结果
5.3.2 Python 函数的参数类型
1．位置参数
位置参数也称为必需参数，调用函数时，函数的位置参数必须以正确的顺序传入函数，参数数量必须和函数定义时一样，即调用函数的位置和数量必须和定义时是一样的。调用函数时，如果指定的实参数量与形参数量不一致会出现TypeError 异常，并提示缺少必要的位置参数。如果指定的实参位置与形参位置不一致，有时会出现TypeError 异常，有时不会抛出异常，但得到的结果与预期不符，即产生Bug。
5.3.2 Python 函数的参数类型
【实例5-5】演示位置参数必须按指定顺序传递的情形
def printInfo(name, age,gender):
# 输出对应传入的字符串
print(" 姓名：", name)
print(" 年龄：", age)
print(" 性别：", gender)
return
# 调用printInfo() 函数
printInfo("LiMing",21," 男")
实例5-5 的代码如下所示。
姓名： LiMing
年龄： 21
性别： 男
运行结果
5.3.2 Python 函数的参数类型
2．关键字参数
关键字参数使用形参的名称来确定传递的参数值，函数调用时可以使用“key=value”的关键字参数形式。关键字参数用来确定传入的参数值。
使用关键字参数允许调用函数时参数的顺序与定义时不一致，只要参数名称正确即可，因为Python 解释器能够用参数名匹配参数值。这样可以避免需要牢记参数位置的麻烦，使得函数调用和参数传递更加灵活方便。
5.3.2 Python 函数的参数类型
【实例5-6】演示关键字参数不需要按指定顺序传递的情形
def printInfo(name, age,gender):
# 输出传入的字符串
print(" 姓名：", name,end=" ")
print(" 年龄：", age,end=" ")
print(" 性别：", gender)
return
# 调用printInfo() 函数
printInfo(name="LiMing",age=21,gender=" 男")
printInfo(age=21,name="LiMing",gender=" 男")
printInfo(gender=" 男",age=21,name="LiMing")
实例5-6 的代码如下所示。
姓名： LiMing 年龄： 21 性别： 男
姓名： LiMing 年龄： 21 性别： 男
姓名： LiMing 年龄： 21 性别： 男
运行结果
5.3.2 Python 函数的参数类型
3．默认值参数
定义函数时可以为某些参数定义默认值，构成可选参数。在调用参数设置了默认值的函数时，如果没有传递参数值，则会直接使用函数定义时设置的默认参数值。
定义带有默认值参数的函数的基本语法格式如下。
def 函数名称(… , [ 参数名称= 参数的默认值 ]):
< 函数体>
return [ 表达式]
定义函数时，指定默认值的形参必须位于其他所有参数后，否则将会出现语法错误。并且默认值参数必须指向不可变对象，如果使用可变对象作为函数参数的默认值，多次调用函数时可能会出现结果不一致的情况。
5.3.2 Python 函数的参数类型
【实例5-7】演示调用函数时没有传入参数值使用默认值的情形
def printInfo(name, age, nation=" 汉族"):
# 输出任何传入的字符串
print(" 姓名：", name,end=" ")
print(" 年龄：", age,end=" ")
print(" 民族：", nation)
return
# 调用printInfo() 函数
printInfo(name="LiMing",age=21,nation=" 壮族")
printInfo(name="LiMing",age=20)
实例5-7 的代码如下所示。
姓名： LiMing 年龄： 21 民族： 壮族
姓名： LiMing 年龄： 20 民族： 汉族
运行结果
5.3.2 Python 函数的参数类型
4．不定长参数
（1）以元组形式给不定长参数传递多个参数值
以元组形式给不定长参数传递多个参数值时，不定长参数前面带一个星号“*”，定义这种形式的函数的基本语法格式如下。
def functionName([formal_args,] *var_args_tuple ):
< 函数体>
return [expression]
加了一个星号“*”的参数会存放到一个元组中，然后以元组的形式导入，该元组存放所有未命名的0 个或多个参数值。
5.3.2 Python 函数的参数类型
【实例5-8】演示以元组形式给不定长参数传递多个参数值
def printInfo(arg1, *args):
# 输出任何传入的参数
print(" 输出：", end="")
print(arg1,end="")
print(args)
# 调用printInfo() 函数
printInfo("weight",10, 20, 30)
printInfo("cherry","apple", "pear", "peach","cherry")
实例5-8 的代码如下所示。
输出：weight(10, 20, 30)
输出：cherry('apple', 'pear', 'peach', 'cherry')
运行结果
如果想使用一个已经存在的列表作为不定长参数，可以在列表的名称前加一个星号“*”，示例如下。
fruits=["apple", "pear", "peach","cherry"]
printInfo("cherry",*fruits)
5.3.2 Python 函数的参数类型
【实例5-9】演示给不定长参数传递参数值的多种情形
def printInfo(arg1, *args):
# 输出任何传入的参数
print(" 输出：", end="")
print(arg1, end=" ")
for item in args:
print(item, end=" ")
print("")
return
# 调用printInfo() 函数
printInfo("weight",10, 20, 30)
printInfo("cherry")
实例5-9 的代码如下所示。
运行结果
输出：weight 10 20 30
输出：cherry
5.3.2 Python 函数的参数类型
4．不定长参数
（2）以字典形式给不定长参数传递多个参数值
以字典形式给不定长参数传递多个参数值时，不定长参数前带两个星号“**”，定义这种形式的函数的基本语法格式如下。
def functionName([formal_args,] **var_args_dict ):
< 函数体>
return [expression]
加了两个星号“**”的参数会存放在一个字典中，然后以字典的形式导入，该字典存放所有未命名的0 个或多个参数值。
5.3.2 Python 函数的参数类型
【实例5-10】演示以字典形式给不定长参数传递多个参数值
def printInfo(arg1, **dict):
# 输出任何传入的参数
print(" 输出：", end="")
print(arg1, end=" ")
print(dict)
for key,value in dict.items():
print(key,":", value, end=" ")
return
# 调用printInfo() 函数
printInfo("student", name="LiMing", age=21, nation=" 壮族")
实例5-10 的代码如下所示。
输出：student {'name': 'LiMing', 'age': 21, 'nation': ' 壮族'}
name : LiMing age : 21 nation : 壮族
运行结果
如果想使用一个已经存在的字典作为不定长参数，可以在字典的名称前加两个星号“**”，
示例如下。
fruits={"name":"LiMing","age":21,"nation":" 壮族"}
printInfo("student",**fruits)
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
1．局部变量
局部变量是指在函数内部定义并使用的变量。它只在函数内部有效，即定义在函数内部的变量拥有一个局部作用域，局部变量的名称只在函数运行时才会创建，在函数运行之前或运行完毕之后，所有的局部变量的名称都不存在。如果在函数外部使用函数内部定义的变量，就会出现NameError 异常。
2．全局变量
（1）在函数外定义的变量拥有全局作用域
如果一个变量在函数外部定义，那么该变量不仅可以在函数外访问，也可以在函数内部访问。
【实例5-11】演示Python 中全局变量与局部变量的使用方法
def printAge1():
age = 50 # 局部变量
print(" 函数printAge1() 中输出局部变量：age=", age)
def printAge2():
print(" 函数printAge2() 中输出全局变量：age=", age)
printAge1()
printAge2()
print(" 函数外部输出全局变量：age=", age )
实例 5-11 的代码如下所示。
函数printAge1() 中输出局部变量：age= 50
函数printAge2() 中输出全局变量：age= 20
函数外部输出全局变量：age= 20
运行结果
2．全局变量
（2）对于在函数内部定义的变量，如果使用global 关键字定义，该变量也是全局变量，在函数外部也可以访问该变量，并且在该函数内部可以对其进行修改，但是在其他函数内部不能访问。
【实例5-12】演示全局变量的两种使用形式
实例5-12 的代码如下所示。
运行结果
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
5.5.1 创建模块
通过创建模块可以将相关的变量定义和函数定义编写在一个独立的Python 文件中，并且将该文件命名为“模块名称.py”，也就是说，创建模块，实际就是创建一个.py 文件。创建模块时，设置的模块名称尽量不要与Python 自带的标准模块重名。模块创建完成后，就可以在其他程序中导入并使用该模块了。
在“D:\PycharmProject\Unit05”文件夹中创建一个自定义模块“fibonacci.py”，代码如右图所示。
自定义模块完成后，可以通过“modname.itemname”这样的表示法来访问模块内的函数。
示例如下。
>>>fibonacci.fib1
5.5.2 导入模块
1．使用import 语句导入模块
想要使用Python 的模块中的变量或函数，需要在另一个文件里执行import 语句加载模块中的代码，其基本语法格式如下。
import module1[, module2[,…moduleN] [as alias]
其中，module1、module2……moduleN 表示要导入模块的名称；as alias 为模块的别名，通过别名也可以使用模块。
import 语句允许一次导入多个模块，在导入多个模块时，模块名称之间使用半角逗号“,”分隔，但这种做法不推荐，因为这会减弱代码的可读性。
当解释器遇到import 语句时，如果模块位于当前的搜索路径中就会被导入，搜索路径是解释器会先进行搜索的所有文件夹的列表。
5.5.2 导入模块
1．使用import 语句导入模块
一个模块只会被导入一次，不管执行多少次import 语句，这样可以防止模块被一遍又一遍地导入。
打开Windows 的命令提示符窗口，在命令提示符“>”后面输入命令“D:”，按【Enter】键，将当前盘更换为D 盘。然后输入命令“cd D:\PycharmProject\Unit05”，按【Enter】键，将当前文件夹更换为“Unit05”。
01
OPTION
接着在当前的命令提示符后面输入“python”，按【Enter】键，出现提示信息，同时进
入交互式Python 解释器中，命令提示符变为“>>>”，等待用户输入Python 命令。
02
OPTION
在命令提示符“>>>”后面输入以下命令导入前面创建的自定义模块fibonacci。
>>>import fibonacci
03
OPTION
5.5.2 导入模块
1．使用import 语句导入模块
这种导入的方法并没有把直接定义在“fibonacci.py”文件中的函数名称导入当前的字符表中，只是把模块fibonacci 的名称准备在那里了。调用模块中的变量、函数时，需要在变量名称、函数名称前添加“模块名称.”作为前缀，例如fibonacci.fib1()、fibonacci.fib2()。
>>>fibonacci.fib1(100)
示例1
运行结果
1 1 2 3 5 8 13 21 34 55 89
>>>fibonacci.fib2(100)
示例2
运行结果
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89]
>>>fibonacci.__name__
示例3
运行结果
'fibonacci'
5.5.2 导入模块
1．使用import 语句导入模块
调用模块fibonacci 中自定义函数fib1()、fib2() 的结果如图所示。
如果模块名称比较长不容易记住，可以在导入模块时，使用as 关键字为模块设置一个别名，然后就通过别名来调用模块中的变量、函数等对象。
5.5.2 导入模块
1．使用import 语句导入模块
例如，使用turtle 模块绘图，代码如下。
import turtle as t
t.penup() # 抬笔
t.goto(x, y) # 画笔起始位置
t.pencolor(rectcolor) # 画笔颜色
t.pendown() # 落笔
t.fillcolor(rectcolor) # 设置填充颜色
t.fillcolor(rectcolor) # 设置填充颜色
如果经常使用一个函数，也可以将该函数名称赋给一个本地的变量，然后通过本地的变量调用模块中的自定义函数，示例如下。
>>>fib= fibonacci.fib1
>>>fib(100)
1 1 2 3 5 8 13 21 34 55 89
运行结果
5.5.2 导入模块
2．使用from…import 语句导入模块
Python 的from 语句的功能是从模块中导入一个指定的函数或变量的名称到当前模块中，基本语法格式如下。
from modename import name1[, name2[,…nameN]]
其中，modename 表示导入的模块名称，区分字母大小写，需要和定义模块时设置的模块名称的大小写完全一致；name1、name2……nameN 表示要导入的变量、函数名称。可以同时导入多个变量和函数，各个对象之间使用半角逗号“,”分隔。
例如，要导入模块fibonacci 的fib1() 和fib2() 函数，使用如下语句。
>>>from fibonacci import fib1, fib2
>>>fib1(100)
1 1 2 3 5 8 13 21 34 55 89
运行结果
5.5.2 导入模块
3．使用from…import * 语句导入模块中的所有对象
还有一种方法，可以一次性把一个模块中的所有函数、变量名称全部都导入当前模块的字符表中，基本语法格式如下。
from modname import *
这会导入几乎所有的函数、变量名称，但是那些以单一下划线（_）开头的变量名称（局部变量）不在此列。通常并不主张使用这种方法来导入模块，因为这种方法经常会导致代码的可读性降低，有可能使导入的其他模块的名称覆盖本模块中已定义的。
5.5.2 导入模块
4．Python 模块的搜索路径
搜索路径是由一系列文件夹名称组成的，Python 解释器依次从这些文件夹中寻找导入的模块。这看起来很像环境变量，事实上，也可以通过定义环境变量的方式来确定搜索路径。搜索路径是在Python 编译或安装的时候确定的，安装新的模块时也会自动修改。
默认情况下，会按照以下顺序进行查找。
在当前文件夹（即当前正在执行的Python 文件所在的文件夹）中查找。
到环境变量中指定的每个文件夹中查找。
到Python 的默认安装文件夹中查找。
5.5.2 导入模块
4．Python 模块的搜索路径
搜索路径被存储在sys 模块中的path 变量中，可以通过以下代码输出搜索路径的文件夹。
>>>import sys
>>>print(sys.path)
运行结果如下。
['','D:\\Python\\Python3.10.2\\python38.zip','D:\\Python\\Python3.10.2\\DLLs',
'D:\\Python\\Python3.10.2\\lib','D:\\Python\\Python3.10.2',
'C:\\Users\\Administrator\\AppData\\Roaming\\Python\\Python38\\site-packages',
'D:\\Python\\Python3.10.2\\lib\\site-packages']
5.5.3 导入与使用Python 的标准模块
1．sys 模块
sys 模块是与Python 解释器及其环境操作相关的标准库。导入与使用sys 模块的代码如下。
>>>import sys
>>>for item in sys.argv:
print (item)
>>>print('python 路径：',sys.path)
导入sys 模块的argv、path 成员的代码如下。
>>>from sys import argv,path # 导入特定的成员
>>>print('path:',path) # 因为已经单独导入path 成员，所以此处引用时不需要加“sys.”
sys 还有stdin、stdout 和stderr 属性，在stdout 被重定向时，stdeer 也可以用于显示警告和错误信息。
5.5.3 导入与使用Python 的标准模块
1．sys 模块
Warning, log file not found starting a new one
47
>>>sys.stderr.write('Warning, log file not found starting a new one\n')
示例如下
运行结果如下
大多数脚本的定向终止都使用sys.exit() 语句。
5.5.3 导入与使用Python 的标准模块
2．os 模块
'D:\\PycharmProject\\Unit05'
>>>os.chdir('D:\PycharmProject') # 修改当前的工作目录
>>>os.system('mkdir Test05') # 执行系统命令mkdir
0
>>>import os
>>>os.getcwd() # 返回当前的工作目录
运行结果如下
os 模块提供了不少与操作系统相关的函数。导入与使用os 模块的代码如下。
运行结果如下
5.5.3 导入与使用Python 的标准模块
2．os 模块
>>>import os
>>>help(os)# 返回函数或模块功能的详细说明
>>>dir(os)# 返回模块os 中所有对象的列表
建议使用import os 语句导入os 模块而非from os import * 语句，这样可以保证随操作系统变化而有所变化的os.open() 语句不会覆盖内置函数open()。在使用os 这样的大型模块时，内置的dir() 和help() 函数非常有用。
示例如下
5.5.4 使用内置函数dir()
>>>import fibonacci
>>>dir(fibonacci)
示例如下
运行结果如下。
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'fib1', 'fib2']
dir() 函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果其参数包含方法__dir__()，该方法将被调用；如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
5.5.4 使用内置函数dir()
>>>a = [1, 2, 3, 4, 5]
>>>import fibonacci
>>>fib = fibonacci.fib1
>>>dir() # 得到一个当前模块中定义的属性列表
其中，'fib1', 'fib2' 就是导入的自定义函数名称。
运行结果如下。
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'fib', 'fibonacci']
如果没有给定参数，那么dir() 函数会返回当前定义的所有名称。
5.5.5 __name__ 属性
一个模块被一个程序第一次导入时，其主程序将运行。如果想在模块被导入时，使模块中的某一代码块不执行，可以用__name__ 属性。无论是隐式的还是显式的相对导入，都是从当前模块开始的。主模块的名字永远是“__main__”，一个Python 应用程序的主模块，应当总是使用绝对路径引用。
>>>if __name__ == '__main__':
print(' 程序自身在运行')
else:
print(' 我来自另一模块')
示例如下。
程序自身在运行
运行结果
循序渐进
知识要点
5.1 Python数学函数的应用 5.1.1 Python数学常量 5.1.2 Python常用数学运算函数 【任务5-1】编写程序绘制爱心 5.2 Python函数的定义与调用 5.2.1 定义函数 5.2.2 调用函数 【任务5-2】定义函数计算总金额、优惠金额和实付金额等数据 5.3 Python函数的参数 5.3.1 Python函数的参数传递 5.3.2 Python函数的参数类型
5.4 函数变量的作用域
5.5 Python模块的创建与导入
5.5.1 创建模块
5.5.2 导入模块
5.5.3 导入与使用Python的标准模块
5.5.4 使用内置函数dir
5.5.5 __name__属性
5.6 Python中创建与使用包
5.6.1 创建包
5.6.2 使用包
5.6.1 创建包
01
OPTION
在PyCharm 窗口中右击已创建好的PyCharm 项目，例如“PycharmProject”，在弹出的快捷菜单中选择【新建】-【Python 软件包】命令。
02
OPTION
在打开的【新建Python 软件包】对话框中输入包名称“package01”，然后按【Enter】键即可完成Python 包的创建。
以同样的方法再创建另一个包“package02”，PyCharm 项目“PycharmProject”中两个包的结构如图所示。
5.6.1 创建包
03
OPTION
在包中创建模块。
包“package01”创建完成后，就可以在该包中创建所需的模块了，这里创建模块“myModule01.py”。在PyCharm 窗口中右击已创建好的PyCharm 包“package01”，在弹出的快捷菜单中选择【新建】-【Python 文件】命令，在打开的【新建Python 文件】对话框中输入Python 模块名称“myModule01.py”，然后双击【Python 文件】选项，完成Python 模块的新建。
同样，包“package02”创建完成后，就可以在该包中创建所需的模块了，这里创建模块“myModule02.py”
04
OPTION
编写包中模块“myModule01.py”的代码。
5.6.1 创建包
05
OPTION
编写包中模块“myModule02.py”的代码。
5.6.2 使用包
1．通过“import+ 完整包名称+ 模块名称”形式加载指定模块
导入包“package01”中的模块“myModule01”的代码如下。
import package01.myModule01
通过这种方式导入模块“myModule01”后，使用模块“myModule01”中的变量和函数时，需要使用完整的名称，在变量名称和函数名称前加“package01.myModule01.”前缀。
5.6.2 使用包
【实例5-13】演示通过“import+ 完整包名称+ 模块名称”形式加载指定模块的变量和
函数的情形
import package01.myModule01
print(" 输出模块"myModule01" 中的全局变量",package01.myModule01.globalAttribute)
package01.myModule01.printStar()
输出模块"myModule01" 中的全局变量global ：全局变量
☆☆☆☆☆☆☆☆☆☆☆☆
运行结果
实例5-13 的代码
5.6.2 使用包
2．通过“from+ 完整包名称+import+ 模块名称”形式加载指定模块
导入包“package01”中的模块“myModule01”的代码如下。
from package01 import myModule01
通过这种方式导入模块“myModule01”，在使用“myModule01”中的变量和函数时，不需要带包名前缀“package01.”，但需要带模块名前缀“myModule01.”，示例代码如下。
myModule01.resolution()
5.6.2 使用包
3．通过“from+ 完整包名称+ 模块名称+import+ 变量名称或函数名称”形式加载指定变量或函数
导入包“package02”中的模块“myModule02”中定义的变量和函数的代码如下。
from package02.myModule02 import strInfo,resolution
通过这种方式导入模块的函数、变量后，可以直接使用函数、变量名称。
通过“from+ 完整包名称+import+ 模块名称”形式加载指定模块时，可以使用星号“*”代替多个变量或函数名称，表示加载该模块中的全部对象，示例如下。
from package02.myModule02 import *
5.6.2 使用包
【实例5-14】演示通过“from+ 完整包名称+ 模块名称+import+ 变量名称或函数名称” 形式加载指定变量或函数和通过“from+ 完整包名称+import+ 模块名称”形式加载指定模块两种情形
from package01 import myModule01
from package02.myModule02 import strInfo,resolution
if __name__=="__main__":
print(" 调用包1 的模块1 中的函数");
myModule01.resolution()
print(" 调用包2 的模块2 中的函数");
print(resolution(strInfo,3000,2000))
调用包1 的模块1 中的函数
物理分辨率： 2560 × 1600 像素
调用包2 的模块2 中的函数
物理分辨率： 3000 × 2000 像素
运行结果
实例5-14 的代码
THANKS

展开更多......

收起↑