Python随堂笔记 函数
哈喽！大家好，我是【张时贰】，一位热爱学习的博主！
【张时贰】的写作风格：喜欢用【言简意赅】的方式由【理论】到【实践】去讲解每一个知识点，而不喜欢用【晦涩难懂】的官方陈述
【张时贰】博客的主要是自己学习过程中的笔记与心得
欢迎点赞 收藏 ⭐留言 如有错误敬请指正！
感谢月薪百万的你支持我！
2022.04.15 下午
文章目录
- 前言
- 5 函数
-
- 5.1 函数定义和调用
- 5.2 函数参数
-
- 5.2.1 参数传递
- 5.2.2 参数类型
- 5.2.3 参数传递的序列解包
- 5.3 特殊函数
-
- 5.3.1 匿名函数
- 5.3.2 递归函数
- 5.3.3 嵌套函数
- 5.4 装饰器
-
- 5.4.1 装饰器的定义和调用
- 5.4.2 带参数的装饰器
- 5.5 变量作用域
-
- 5.5.1 全局变量和局部变量
- 5.5.2 global和nonlocal
前言
本文章是 【Python语言基础】 专栏的文章，主要是上课的随堂笔记与练习
Python专栏 传送门
提示：本文的环境配置是Python3的开发环境。目录顺序以当堂内容(教材)为准，所以并非“1、2、3”
本节主要内容：学习Python函数的使用
5 函数
5.1 函数定义和调用
函数定义
函数是组织好的、可重复使用的、用来实现单一或相关联功能的代码段
函数的使用能提高应用的模块性、代码的重用率和可读性Python提供了许多内建函数，如
input()、print()等函数，可以直接在程序中使用，当Python提供的内建函数不能满足要求时，需要用户自定义函数用户自定义函数的一般格式为：
def 函数名([参数1,参数2,…])：
"""函数说明"""
函数体
def myHello():
return "Hello, everyone!"
#myHello()函数的返回结果为"Hello, everyone!"
函数调用
函数定义完成后，就可以在程序中调用了，函数调用时需要指出函数名称，并传入相应的参数
函数调用时传入的参数称为实际参数，简称实参
在默认情况下，函数调用时传入的实参个数、顺序等必须和函数定义时形参的个数、顺序一致
函数调用时的执行顺序如下：
- 执行函数调用前的语句
- 执行函数调用，运行被调用函数内的语句，并返回相应结果
- 执行函数调用后的语句
定义一个求梯形面积函数并调用
#定义函数.
def echelonArea(top,bottom,height): #3个形参:top上底,bottom下底,height高
area = 1 / 2 * (top + bottom) * height #计算梯形面积
return area
if __name__ == "__main__":
t = 3.6; b = 6.2; h = 4.5
area1 = echelonArea(t,b,h)
print("area1 ＝",area1)
area2 = echelonArea
print("area2 ＝",area2(t,b,h))
'''
area1 ＝ 22.05
area2 ＝ 22.05
'''
5.2 函数参数
5.2.1 参数传递
定义一个函数Swap(x,y)，实参为数字类型。在函数Swap(x,y)中交换2个形参的值，观察函数外面的实参变化情况
#定义函数
def Swap(x,y): #2个形参:x、y
print("交换前：x = %d, y = %d"%(x,y))
x,y = y,x #交换2个形参(x、y)的值
print("交换后：x = %d, y = %d"%(x,y))
a = 5; b = 6 #定义变量a、b
print("调用前：a = %d, b = %d."%(a,b))
Swap(a,b) #调用函数Swap()
print("调用后：a = %d, b =%d."%(a,b))
'''
调用前：a = 5, b = 6
交换前：x = 5, y = 6
交换后：x = 6, y = 5
调用后：a = 5, b = 6
'''
由此可见，和C++、JAVA同理，形参的改变不会影响实参
定义一个函数
changeList(myList)，实参为列表。在函数调用中给列表myList添加了一个新元素，观察函数外面的实参变化情况
#定义函数
def changeList(myList):
myList.append(4)
list1 = [1,2,3]
print("调用前list1:",list1)
changeList(list1)
print("调用后list1:",list1)
'''
调用前list1: [1, 2, 3]
调用后list1: [1, 2, 3, 4]
'''
不可变类型： 类似 C++ 的值传递，如整数、字符串、元组。如
fun(a)，传递的只是 a 的值，没有影响 a 对象本身。如果在 fun(a) 内部修改 a 的值，则是新生成一个 a 的对象可变类型： 类似 C++ 的引用传递，如 列表，字典。如
fun(list)，则是将 list 真正的传过去，修改后 fun 外部的 list 也会受影响
5.2.2 参数类型
必需参数
定义一个加法函数
myAdd()，使用必需参数传递参数
#定义函数.
def myAdd(x,y,z):
return x + y + z
a = 3; b = 4; c = 5 #定义变量a、b、c
print("调用结果:",myAdd(a,b,c)) #调用函数，使用必需参数
'''
调用结果: 12
'''
关键字参数
定义一个函数
stuInfo()，使用关键字参数传递参数
#定义函数.
def stuInfo(sno,sname):
return "学号：" + sno + "\n" + "姓名：" + sname
print(stuInfo(sname = "Rose",sno = "x1001"))
'''
学号：x1001
姓名：Rose
'''
默认参数
定义一个函数
stuInfo()，使用默认参数传递参数
#定义函数.
def stuInfo(sno,sname,age = 18):
return "学号：" + sno + "," + "姓名：" + sname + "," + "年龄：" + str(age)
print(stuInfo(sname = "Rose",sno = "x1001")) #age使用默认参数值18
print(stuInfo(sname = "Mike",sno = "x1002",age = 20)) #age使用传入参数值20
'''
学号：x1001, 姓名：Rose, 年龄：18
学号：x1002, 姓名：Mike, 年龄：20
'''
不定长参数
在实际应用中，有可能需要一个函数能处理比当初声明时更多的参数，这种参数称为不定长参数
不定长参数有如下两种形式:
*args：将接收的多个参数放在一个元组中**args：将显式赋值的多个参数放入字典中
定义一个求和函数
addFunc()，使用不定长参数传递参数
def addFunc(x,y,*args):
res = x + y
for k in args:
res += k
return res
print("调用结果:",addFunc(1,2,3,4,5)) #调用结果: 15
def func(**args):
for key,value in args.items():
print("%s:%s"%(key,value))
func(新发明1="高铁",新发明2="扫码支付",新发明3="共享单车",新发明4="网购")
'''
新发明1:高铁
新发明2:扫码支付
新发明3:共享单车
新发明4:网购
'''
5.2.3 参数传递的序列解包
def func(x,y,z):
return x * 100 + y * 10 + z
#元组，一一对应
func(*[1,2,3]) #123
#字典，有序
func(**{'x':1,'y':2,'z':3}) #123
func(**{'z':1,'y':2,'x':3}) #321
5.3 特殊函数
5.3.1 匿名函数
匿名函数是指没有函数名的简单函数，只可以包含一个表达式，不允许包含其他复杂的语句，表达式的结果就是函数的返回值。在Python中，使用关键字lambda创建匿名函数
创建匿名函数的一般格式为：
lambda [arg1[,arg2,…,argn]]: expression
arg1,arg2,…,argn：形参，可以没有，也可以有一个或多个expression：表达式
sum = lambda x,y: x + y
sum(3,4) #7
func = lambda a,b=3,c=2: b ** 2-4 * a * c
func(1) #1 (1传递给a,bc使用默认参数)
func(1,4) #8 (a=1,b=4,c使用默认参数)
list1 = [1,2,3]
list2 = [4,5,6]
sum = lambda x,y: x + y
sum(list1,list2) #[1, 2, 3, 4, 5, 6]
list(map(lambda x,y: x + y,list1,list2)) #[5, 7, 9]
5.3.2 递归函数
如果一个函数在函数体中直接或者间接调用自身，那么这个函数就称为递归函数
递归函数在执行过程中可能会返回以再次调用该函数
如果函数a中调用函数a自身，则称为直接递归
如果在函数a中调用函数b，在函数b中又调用函数a，则称为间接递归
求1+2+…+n的和来分析递归函数的原理和使用方法
如果用
fac(n)表示1+2+…+n的和，则
fac(n)= 1+2+…+n，fac(n-1)= 1+2+…+(n-1)…fac(2)= 1 + 2，fac(1)= 1
根据
fac(n)的公式，可以定义如下的求和函数fac(n)：
def fac(n):
if n == 1:
return 1
else:
return fac(n-1)+n
典中点再来一个爬楼梯问题，使用递归函数求斐波那契数列前20项之和
#定义求斐波那契数列第n项的函数
def fib(n):
if n == 1 or n == 2:
return 1
else:
return fib(n - 1) + fib(n - 2)
#求斐波那契数列前20项目之和
sum = 0
for i in range(1,21):
sum = sum + fib(i)
print("前20项之和为:",sum)
'''
前20项之和为: 17710
'''
5.3.3 嵌套函数
- 嵌套函数指在一个函数(称为外函数)中定义了另外一个函数(称为内函数)
- 嵌套函数中的内函数只能在外函数中调用，不能在外函数外面直接调用
#定义外函数
def outerFunc():
#定义内函数
def innerFunc():
print('innerFunc') #内函数中的语句
print('outerFunc') #外函数中的语句
innerFunc() #调用内函数
outerFunc() #调用外函数
innerFunc() #报错
'''
innerFunc
outerFunc
'''
#定义外函数
def outerFunc(x):
#定义内函数
def innerFunc(y):
return x * y
return innerFunc #调用内函数
print("方法一调用结果:",outerFunc(3)(4)) #在调用时传递外函数参数和内函数参数
a = outerFunc(3) #调用外函数
print("方法二调用结果:",a(4)) #间接调用内函数
'''
运行结果：
方法一调用结果: 12
方法二调用结果: 12
'''
5.4 装饰器
5.4.1 装饰器的定义和调用
装饰器(Decorator)是Python函数中一个比较特殊的功能，用来包装函数的函数。可以使程序代码更简洁。
装饰器常用于下列情况：
- 将多个函数中的重复代码拿出来整理成一个装饰器
- 对多个函数的共同功能进行处理
定义装饰器的一般格式
def decorator(func):
pass
@decorator
def func():
pass
装饰器的定义和调用
#定义装饰器
def deco(func):
print("I am in deco.")
func()
return "deco return value."
#使用装饰器修饰函数
@deco
def func():
print("I am in func.")
print(func)
'''
I am in deco.
I am in func.
deco return value.
'''
使用装饰器修改网页文本格式
#定义装饰器
def deco(func):
#定义内函数
def modify_text(str):
return "" + func(str) + ""
return modify_text
#使用装饰器修饰函数
@deco
def textFunc(str):
return str
print(textFunc("text"))
'''
text
'''
5.4.2 带参数的装饰器
使用带参数的装饰器检查函数参数合法性
#定义带参数的装饰器
def DECO(args):
#定义内部装饰器
def deco(func):
#定义内函数
def call_func(x,y):
print("%d %s %d = "%(x,args,y),end='')
return func(x,y)
return call_func
return deco
#传递装饰器参数
@DECO('&')
def andFunc(x,y): #按位'与'运算
return x & y
#传递装饰器参数.
@DECO('|')
def orFunc(x,y): #按位'或'运算
return x | y
if __name__ == "__main__":
print(andFunc(5,6))
print(orFunc(5,6))
'''
5 & 6 = 4
5 | 6 = 7
'''
5.5 变量作用域
Python中，不同位置定义的变量决定了这个变量的访问权限和作用范围。Python中的变量可分为如下4种
- 局部变量和局部作用域
L(Local)：包含在def关键字定义的语句块中- 全局变量和全局作用域
G(Global)：在模块的函数外定义的变量- 闭包变量和闭包作用域
E(Enclosing)：定义在嵌套函数的外函数内、内函数外的变量- 内建变量和内建作用域
B(Built-in)：系统内固定模块里定义的变量
5.5.1 全局变量和局部变量
全局变量和局部变量的使用
x = 100 #定义全局变量x
def f(x):
print("x =",x) #形参x的值来自实参
y = 200 #创建局部变量y=200
print("y =",y)
f(x) #调用函数.实参为全局变量x=100
'''
x = 100
y = 200
'''
5.5.2 global和nonlocal
使用关键字
global修改变量作用域
x = 100 #定义全局变量
def myFunc():
global x #使用关键字global修改x为全局变量
print("全局变量: x =",x)
x = 200 #修改全局变量
print("修改后的全局变量: x =",x)
myFunc() #调用函数
'''
全局变量: x = 100
修改后的全局变量: x = 200
'''
使用关键字
nonlocal修改变量作用域
def outerFunc():
x = 100 #定义闭包变量x
def innerFunc():
nonlocal x #使用关键字nonlocal修改x为闭包变量
print("闭包变量: x =",x)
x = 200 #修改闭包变量的值
print("修改后的闭包变量: x =",x)
innerFunc()
outerFunc() #调用外函数
'''
闭包变量: x = 100
修改后的闭包变量: x = 200
'''