day10-函数进阶
函数的参数
位置参数和关键字参数
实参按照传递的方式不同分为位置参数和关键字参数两种
位置参数
调用函数的时候让实参和形参一一对应(第一个实参给第一个形参赋值,第二个实参给第二个形参赋值。。。)
格式:数据1,数据2,数据3,。。。
def func1(x, y, z):
print(f'x:{x}, y:{y}, z:{z}')
# 位置参数
func1(10, 20, 30) # x:10, y:20, z:30
func1(10, 30, 20) # x:10, y:30, z:20
关键字参数
让实参和形参通过关键字(形参名)对应
格式:形参名1=数据1,形参名2=数据2,。。。
# 关键字参数
func1(x=100, y=200, z=300) # x:100, y:200, z:300
func1(z=30, x=10, y=20) # x:10, y:20, z:30
# func1(x=100, y=200, y=300) # 报错!
关键字参数和位置参数混用
混用的时候位置参数必须在关键字参数前面
# 混用
func1(10, z=30, y=20) # x:10, y:20, z:30
# func1(x=20, 40, z=60) # 抱错!位置参数必须在关键字参数的前面
参数默认值
定义函数的时候可以给以’形参名=数据’的形式给参数赋默认值,调用函数的时候有默认值的参数可以不赋值
注意:有默认值的参数必须在没有默认值参数的后面
def func2(x=1, y=10, z=100):
print(f'x:{x}, y:{y}, z:{z}')
func2(1, 2, 3) # x:1, y:2, z:3
func2(10, 20) # x:10, y:20, z:100
func2(10)
func2()
参数类型说明
定义函数的时候,可以对参数类型进行说明
赋默认值,默认值是什么类型,参数类型说明就是什么类型
形参名:数据类型
def func4(x=''):
pass
def func5(x: list) -> None:
x.append('100')
func5([])
不定长参数
在形参前加*或者加**,就可以让这个参数变成不定长参数。不定长参数的形参可以同时接受多个实参
1)带*的不定长参数
带*的参数会变成一个元组,元组中的元素就是对应的实参
注意:一个函数可以同时存在带喝不带的参数,如果不带*的在带 *的后面,不带 * 的参数必须使用关键字参数
带*的参数必须使用位置参数
def sum1(*num):
s = 0
for x in num:
s += x
print(s)
sum1(10, 20) # 30
sum1(10, 20, 30) # 60
def func7(x, *y):
print(f'x:{x}, y:{y}')
2)带**的不定长参数
带**的不定长参数会变成一个字典;调用的时候关键字参数传参,每个关键字就是字典的key,关键字后面的数据就是字典的value
注意:定义的时候顶层参数必须放在**不定长参数的前面
带*和带 ** 的不定长参数可以同时存在,但是 *必须在**的前面(如果同时存在可以让函数在调用的时候更加灵活)
def func9(**num):
print(num)
func9() # {}
func9(a=10, b=20) # {'a': 10, 'b': 20}
func9(x=100, y=200, z=300, m=0) # {'x': 100, 'y': 200, 'z': 300, 'm': 0}
def func12(*x, **y):
print(f'x:{x}, y:{y}')
func12(1, 2, 3)
func12(a=10, b=20)
func12(1, 2, a=3, b=4)
函数的返回值
返回值就是从函数内部传递到函数外部的数据。(如果实现函数的功能,产生了新的数据一般都需要将这个新的数据通过返回值返回)
在函数体中通过return关键字来返回返回值:return 数据
注意:同一个函数中,只有一个return有效。(因为执行函数体的时候只有遇到return函数直接结束)
如果要在一个函数中返回多个数据,用能够保持多个数据的容器。常用元组:return 数据1,数据2,数据3,。。。
获取函数调用表达式的值就是获取函数的返回值(返回值对应的数据能做到,函数表达式都可以做)
def func1():
print('111111')
return # 相当于 return None
print('222222')
func1()
def func4():
return [1, 2, 3]
print(func4())
print(func4()[0])
for x in func4():
print(f'x: {x}')
全局变量和局部变量
根据变量的作用域不同将变量分为全局变量和局部变量两种
全局变量
定义在函数和类外面的变量都是全局变量
全局变量的作用域:从定义开始到程序结束的任何地方都可以用
# a是全局变量
a = 10
# b、c是全局变量
for b in range(4):
c = 100
pass
for _ in range(3):
print(f'循环里面a: {a}')
print(f'循环里面b: {b}')
print(f'循环里面c: {c}')
def func1():
print(f'函数里面a:{a}')
print(f'函数里面b:{b}')
print(f'函数里面c:{c}')
func1()
print(f'外部a:{a}')
print(f'外部b:{b}')
print(f'外部c:{c}')
局部变量
定义在函数里面的变量是局部变量
作用域:从定义开始到函数结束
局部变量产生的原因:每次调用函数的时候,系统会自动被调用的这个函数在栈区间开辟一块独立的内存空间,专门用来保存在这个函数中定义的变量。当函数调用结束的时候这块内存空间会自动销毁
# m和x是局部变量
def func3(m=10):
x = 'abc'
print(f'函数内部x:{x}')
print(f'函数内部m:{m}')
for _ in range(2):
print(f'函数内部x2:{x}')
func3()
# print(f'函数外部x:{x}') # NameError: name 'x' is not defined
# print(f'函数外部m:{m}') # NameError: name 'm' is not defined
global和nonlocal
global和nonlocal是函数体中的关键字,只能在函数体中使用
1)global的作用:在函数中定义或者修改全局变量
用法:
global 变量名
变量名 = 值
2)*nonlocal
作用:在局部的举报中修改一个局部变量的值
nonlocal 变量名
变量名 = 值
# 1)使用global在函数中定义全局变量
def func4():
global z
z = 100
func4()
print(f'外部z:{z}')
修改全局变量的值(如果直接在函数内容给全局变量赋值,不会修改值,而是产生一个新的局部变量)
name = '张三'
def func5():
global name
name = '李四'
print(f'函数内部name: {name}')
func5()
print(f'函数外部name: {name}')
匿名函数
匿名函数的本质还是函数:但是匿名函数只能通过一条语句来实现函数的功能
语法:
函数名:lambda 形参列表:返回值
相当于:
def 函数名(形参列表):
return 返回值
# 求两个数的和
# def sum1(num1, num2):
# return num1 + num2
sum1 = lambda num1, num2=3: num1+num2
print(sum1(10, 20))
print(sum1(num2=100, num1=200))
print(sum1(2))
# 写一个匿名函数func2, 功能是打印一个数的平方
func2 = lambda num: print(num**2)
# print(func2(3))
func2(3)
递归
在函数中调用函数本身的函数就是递归函数
作用:循环能做的,递归都可以做。(能用循环解决的问题就不要用递归)
递归控制次数:控制递归函数在指定次数后结束
count = 5
def func1():
global count
count -= 1
print('======')
if count == 0:
return
func1()
func1()
使用递归解决问题的步骤
第一步:像定义普通函数一样来定义函数
第二步:找临界值(找函数结束的条件)
第三步:找关系(找f(n)和f(n-1) - 找上次循环和本次循环之间的关系)
第四步:假设函数的功能已经实现,通过关系用f(n-1)实现f(n)的功能