Python函数与模块

---

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】！

---

一、函数

• 函数是一段可以重复使用的代码，通过传递的参数返回不同的结果，前面章节已经使用了Python定义的函数如range()、len()、input()，本章讲解用户自定义的函数。
• 对于重复使用的代码，可以编写为自定义函数以便于重复使用代码，同时提高开发人员的开发效率。函数可以分为无参函数和带参函数。

1.1无参函数

• Python的自定义无参函数并不复杂。以关键字def开始，后面跟函数名、小括号、冒号，最后使用retrun退出函数。用表达式可以传递函数的返回值，如果没有返回值，则返回None。
• 函数起名规范：函数是以字母、数据和下划线组成的字符串，但是不能以数字开发。

# 示例1：使用无参函数实现两个数相加并输出二则之和   
# 该程序首先定义了无参函数 add()，它输出 10 + 20的结果值，return没有返回值，直接使用函数名add()进行了调用。   
def add():       
op1=10       
op2=20       
rt=op1+op2       
print(op1,"+",op2,"=",rt)       
return         
add()  # 调用函数   
      
# 程序输出：   
10 + 20 = 30            
# 更改后的函数：让用户自定义输入两个数字进行相加   
def add():       
x=int(input("请输入x的值:  "))       
y=int(input("请输入y的值:  "))       
rt=x+y       
print(x,"+",y,"=",rt)       
return      
add()  # 调用函数      

# 把上面的代码进行修改，用 return 返回结果值   
# 函数add()使用return语句可以返回两数相加的结果值，
# 变量 i 接收函数add()返回的值。Python在处理返回结果值时，如果没有return语句，会默认返回None，程序并不会报错。   
def add():       
op1=10       
op2=20       
rt=op1+op2          
return rt   
i = add()   
print(i)         
# 更改后的函数，让用户自定义输入两个数字，程序最终只输出和   
def add():       
x=int(input("请输入x的值:  " ))       
y=int(input("请输入y的值:  "))       
rt=x+y         
return rt   
i = add()   
print(i)

# 示例2：输出九九乘法表示例代码如下：   
def nine():       
op1 = (1,2,3,4,5,6,7,8,9)       
op2 = (1,2,3,4,5,6,7,8,9)       
for i in op1:           
for j in op2:               
print(i,"*",j,"=",i * j)       
return      
nine()   

使用函数时经常会出现一些错误，总结如下：

• 函数的定义要先于函数的调用，否则会出错。
• 函数体的代码是一个整体，否则会出错。
• 定义函数时要使用冒号，但调用时不可以使用冒号。

1.2带参函数

• Python带参函数的语法格式如下：

def 函数名称(形式参数列表):    
代码块    
return [表达式]   

• 列表，简称形式列表
• 注意：形式参数实际上只是占位符，用于体现参数的个数，每个参数都没有提供具体的数值。
• 调用带参函数时，需要为每个参数传递对应的实际数值，又称实参列表。

# 示例4：定义并调用带参数完成两数相加的运算   
def add(x,y):       
return  x+y   
print(add(1,2))          
# 执行结果   
3         
# 当调用函数时，根据传递的实际参数值出现位置与函数定义的形式参数列表进行匹配   

# 示例5：使用位置参数方式或关键字参数方式调用带参函数   
def aa(x,y):       
print(x,y)   
aa(10,6)   
aa(6,10)      # 执行结果   
10 6
6 10         
# 当程序代码比较繁琐时，参数的顺序很难记住，可以使用关键字参数。关键字参数是在调用函数时，明确指定参数赋值给指定的形参   
def aa(x,y):       
print(x,y)          
aa(x=10,y=6)   
aa(x=6,y=10)      # 执行结果   
10 6   
6 10         
# 代码中，aa(x=10,y=6)和aa(x=6,y=10)语句在调用函数aa(x,y)的同时，指定了参数的名称和对应值(x=10,y=6)和(y=6,x=10)。
# 这两个语句明确指定了实参和形参的对应关系，与参数所在的位置无关。   
# 调用带参函数时，传入函数的参数个数必须和名声的参数个数一致。
# 当函数包含多个参数时，一旦实参个数与行惨个数不符，就可能出错。
# 为了避免这样的错误发生，Python在函数定义时允许为形惨指定默认值，从而在调用参数时可以少写参数，省略的参数默认值为其赋值。   
# 下面是使用参数默认值的代码示例：   
def aa(x,y):       
print(x,y)          
aa(10)  # 报错，缺少y   
aa(x=10)  # 报错，缺少y   
aa(y=10,x=6)  # 正确传入的参数个数与形惨一致   

# 定义参数默认值时，要注意：位置参数必须出现在有默认值参数之前   
def aa(x,y=1):       
print(x,y)      
aa(10,20)  # 如果定义了默认值以后，依旧传递了参数，那么将会使用传递的参数   
10 20            
def aa(x,y=1):  # 如果没有给默认值默认形惨传递值，那么将使用定义的默认值进行打印       
print(x,y)      
aa(10)  # 也就是这个结果   

# 示例6：编写实现计算器功能：要求：用户输入两个数字和运算符，程序根据用户指定的运算符执行加、减、乘、除运算。
# 为了使程序结果清晰，需要编写2个函数，一个是用来处理加减乘除运算，一个是用来处理字符串和数值转换   
def add(x,y):       
return x + y      
def subtract(x,y):      
return x - y      
def multiply(x,y):       
return x * y      
def divide (x,y):       
return x * y      # 用户输入   
print("选择运算:  ")   
print("1、相加")   
print("2、相减")   
print("3、相乘")   
print("4、相处")   # 人机交互用户输入   
choice = int(input("请输入你的选择(1/2/3/4):  "))      
# 用户输入需要进行运算的两个数   
num1 = int(input("输入第一个数字:  "))   
num2 = int(input("输入第二个数字:  "))      
if choice == 1:       
print(num1,"+",num2,"=",add(num1,num2))   
elif choice == 2:       
print(num1,"-",num2,"=",subtract(num1,num2))   
elif choice == 3:       
print(num1,"*",num2,"=",multiply(num1,num2))   
elif choice == 4:       
print(num1,"/",num2,"=",divide(num1,num2))   
else:       
print("Error:非法输入")                 
# 运行结果如下   
选择运算:     
1、相加   
2、相减   
3、相乘   
4、相处   
请输入你的选择(1/2/3/4):  
2   
输入第一个数字:  
50   
输入第二个数字:  
50   
50 - 50 = 0   

1.3函数中变量的作用域

• 作用域是指变量在程序中的应用范围，而变量声明的位置决定它的作用域。Python按作用域分有局部变量和全局变量。
• 全局变量是指在一个模块中最高级别的变量有全局作用域，除非被删除否则存活到程序运行结束，所有函数都能访问全局变量。
• 局部变量是指定义在函数内的变量有局部作用域。依赖于定义变量的函数现阶段是否处于活动状态。调用函数时，局部变量产生，暂时存在。一旦函数执行完，局部变量将会被释放。
• 局部变量的作用域仅限于定义它的函数
• 全局变量的作用域在整个模块内都是可见的
• 在同一个函数中，不允许有同名的局部变量
• 在不同的函数中，可以有同名局部变量
• 在同一个程序中，全局变量和局部变量同名时，局部变量具有更高的 优先级

局部变量和全局变量的使用规则：

# 使用函数实现年龄的输出   
name = "Tim"  # 全局变量      
def f1():       
age = 18  # 局部变量       
print(age,name)      
def f2():       
age = 19 # 局部变量       
print(age,name)      
f1()   
f2()         # 输出结果   
18 Tim   
19 Tim   

• 在Python中尽量不适用全局变量，因为程序的任意代码都可以自由地访问和修改全局变量的值，非常容易出现数据被意外修改的错误，而这种错误很难被发现。
• global的作用是声明变量为全局变量，即使变量定义在函数内部，加上global后，也可以在全局范围访问。

def f1():       
global name  # 全局变量，global要写在需要声明为全局变量名称的前面中间加一个空格即可       
name="Tim"   # 定义变量的值，卸载后面，注意前后顺序       
age = 18  # 局部变量       
print(age,name)      
def f2():       
age = 19   # 局部变量       
print(age,name)          
f1()   
f2()         # 执行结果   
18 Tim   
19 Tim   

1.4lambda函数

• lambda函数的作用是创建匿名函数，是一种声明函数的特俗方式。其中params相当于函数接收的参数列表，expr是函数返回值的表达式

# 示例8：编写一个普通函数和一个lambda函数   
def sum1(x,y):       
return x + y   
sum2=lambda x,y:x+y   # 这就是一个匿名函数   
print(sum1(3,4))   
print(sum2(3,4))         
# 实现的是相同的功能，但lambda函数更加简洁，只需一条语句实现，所以lambda也称为lambda表达式。
# 使用lambda只能是表达式，不能包含if、for等条件循环语句。对于不需要复用、简单的匿名函数，使用lambda能起到很好的效果。   

二、内建函数

• Python除了本身的语法结构，还提供了常用的内建函数。内建函数是程序员经常用到的方法，可以提高程序的编写效率。
• 如float()就是内建的函数。内建函数是自动加载的，Python的解释器可以识别。它不需要导入模块，不必做任何的操作。不需要引用就可以调用。下面开始介绍常用的内建函数。

2.1abs()函数

• abs()函数能够返回一个数字的绝对值，即正数
• 语法格式：abs (x) 参数x可以是正数，也可以是负数

>>> abs(10)   10     
>>> abs(-10)   10      
>>> bb = -3   
>>> abs(bb)   3         # 参数10和-10返回的绝对值，都是10   

2.2bool()函数

• bool()函数返回值是True或False，它是Boolean(布尔值)的简写，
• 将参数 x 转换为Boolean类型，当参数是数字时，0返回Flase，其他任何值都返回True。参数是字符串时，None或空字符串返回Flase。参数是空的列表、元组或字典返回False；否则返回True。

>>> bool()  # 无参返回Flase   False      
>>> bool(0)   False      
>>> bool(-3)   True     
>>> bool(None)  # 注意None，首字母要大写   
>False      
>>> bool("")   
>False     
>>> bool("xyz") 
>True     
>>> bool([11,22])   
>True         # 字符串和数字都可以转换为float类型。如果不能转换，就会抛出异常   

2.3float()函数

• float()函数用于转换数据为float类型“浮点型”
• 参数 x 可以是字符串或数字

>>> float("25")   
>25.0    
>>> float(3)  
>3.0      
>>> float(999.2342342) 
> 999.2342342     
>>> float("123123123.1412312315123131")  
>123123123.14123124         # 字符串和数字都可以转换为float类型。如果不能转换，就会抛出异常   

2.4int()

• int()函数可以将数据转换为整数

>>> int(199.99)   # 浮点类转换为整型   
>199      
>>> int("100")  # 字符出啊u你换砖为整型   
>100      
>>> int("99.9")  # 字符串   
>Traceback (most recent call last):     
>File "", line 1, in <module>   
>ValueError: invalid literal 
>for int() with base 10: '99.9'         
># 注意：当参数是字符串时，字符串只能是整数格式。如果是浮点格式将会异常产生   

2.5range()

• range()函数可以生成一个迭代对象
• 第一个参数 start 表示起始值，是可选参数，默认值是0
• 第二个参数 stop 表示终止值
• 第三个参数表示步长，是可选参数，可以是正数或负数，默认值是1
• 从给定的第一个参数开始，到比第二个参数值小的数字结束，常与for循环一起使用，循环执行指定数字的次数

>>> range(0,5)   
>range(0, 5)      
>>> list(range(0,5))   [0, 1, 2, 3, 4]     
>>> range(0,30,3)  # 0开始，30结束，3表示步进   
>range(0, 30, 3)      
>>> list(range(30,3,-3))   
>[30, 27, 24, 21, 18, 15, 12, 9, 6]         
>for i in range(0,5):       
>print(i)   
>0   
>1   
>2   
>3   
>4   

2.6sum()函数

• sum()函数可以对列表中元素求和

>>> num=list(range(1,101))   
>>> num   
>[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
> 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
>  41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
>   61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 
81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100]   
>>> print(sum(num))   
>5050         # 使用range()生成了一个列表，然后使用sum()对列表中的数值进行累加求和   

2.7max()函数

• max()函数可以返回列表、元素或字符串中最大的元素，如果元素是英文字母，那么字母是“大于”数字的，而小写字母“大于“大写字母

>>> num = [6,2,12,7,65]   
>>> max(num)   
>65      
>>> staring = "d,u,a,n,g,D,U,A,N,G"   
>>> max(staring)   'u'      
>>> max(1000,650,98,1578,9)   
>1578   

2.8min()函数

• min()函数返回列表、元组、或字符串中最小的元素，与max()的使用方式相反，它取得是最小值

>>> min([6,2,12,7,65])   
>2   

三、模块与包

• 如果编写的程序中类和函数较多时，就需要对它们进行有效得组织分类，在Python中模块和包都是组织的方式
• 。复杂度较低可以使用模块管理，复杂度则还要使用包进行管理。

3.1模块

• 模块是Python中一个重要的概念，实际上就是包含Python函数或者类的程序。
• 模块就是一个包含Python定义和语句的文件，把一组相关的函数或代码组织到一个文件中，一个文件即是一个模块。
• 模块的文件名=模块名+后缀.py。模块之间代码共享，可以相互调用，实现代码重用，并且模块中函数名称必须唯一。

3.1.1模块定义

• 下面代码演示模块的定义，保存的文件名是myModule.py

[root@localhost ~]# cat myModule.py    
def add(a,b):       
print(a+b)   
def mul(a,b):       
print(a*b)          
# 在模块myModule中，定义了2个函数，一个加法函数和一个乘法函数。它们处理的问题是同类的，作为一个模块定义   

3.1.2模块导入

• 使用模块的函数时，要先导入模块才能使用，导入有2种方式。在一行导入一个模块
• 语法格式：import 模块名
• 还可以在一行导入多个模块
• 语法格式：import 模块名1,模块名2,…
• 模块和变量一样也有作用于的区别。如果在模块的顶层导入，则作用域是全局的。
• 如果在函数中导入，则作用域是局部的，其作用域只是所在的函数中。一个模块只能被加载一次，无论它被导入多少次，可以阻止多重导入时代码被多次执行。在实际编码时，推荐直接在顶层导入。
• 导入的模块也分几种，有Python的标准库模块、第三方模块和应用程序自定义的模块。加载执行时在搜索路径中找到指定的模块，如果是第一次导入，模块将被加载并执行，之后再调用就不需要再次加载了。

# 示例1：导入标准模块sys   
>>> import sys   
>>> print(sys.platform)   
>linux2         
># Python的标准模块sys包含了Python环境相关的函数，sys.platform返回当前平台的系统名称   

# 示例2：导入并调用自定义模块 myModule   
>>> import myModule    
>>> myModule.add(2,3)  # 调用add函数   
>5       
>>> myModule.mul(2,3)  # 调用mul函数   
>6   

• 模块名就是定义的文件名。在调用模块中函数的语句格式是模块名.函数名。每个模块都有name属性，表示模块的名称。
• 如果不适用模块名，而直接用函数进行调用，就需要在导入时指定需要使用的模块的属性，一行导入一个模块属性的语法如下

语法格式：from 模块名 import 属性名

• 一行导入模块的多个属性语法如下
• 语法格式：from 模块名 import 属性名1,属性名2,…

# 示例3：导入模块属性代码   
>>> from myModule import add,mul   
>>>> add(1,3)   4   
>>>> mul(1,3)   3            

• 示例3的代码是先导入模块myModule的add()、mul()函数，可以不适用模块名，直接使用函数名调用。另外，还可以使用as关键字为模块属性重新命名。

或

• from 模块名 import 属性名 as 属性新名称
• 语法格式：import 模块名 as 模块新名称

# 示例4：使用as关键字为模块重新命名   
>>> from myModule 
>import add as add1,mul as mul1   
>>> add1(2,3)   5   
>>> mul1(2,3)   6        
> # 示例4的代码，先将函数add()重命名为add1，mul重命名为mul1，程序种可以用新的名称调用函数   

总结

• 最后希望你编程学习上不急不躁,按照计划有条不紊推进,把任何一件事做到极致,都是不容易的,加油,努力！相信自己！

文末福利

• 最后这里免费分享给大家一份Python全套学习资料，希望能帮到那些不满现状，想提升自己却又没有方向的朋友，也可以和我一起来学习交流呀。

包含编程资料、学习路线图、源代码、软件安装包等！【[点击这里]】领取！

• ① Python所有方向的学习路线图，清楚各个方向要学什么东西
• ② 100多节Python课程视频，涵盖必备基础、爬虫和数据分析
• ③ 100多个Python实战案例，学习不再是只会理论
• ④ 华为出品独家Python漫画教程，手机也能学习

可以扫描下方二维码领取【保证100%免费】