本文介绍了Python函数的高级特性，包括位置参数与关键字参数的使用，函数的返回值，全局变量与局部变量的区别，如何使用`global`和`nonlocal`关键字，以及匿名函数lambda的语法。此外，还详细讲解了递归函数的概念、作用以及使用递归解决问题的步骤。
day10-函数进阶
1.位置参数和关键字参数
- 实参按照传递方式的不同分为位置参数和关键字参数两种
1）位置参数
调用函数的时候让实参和形参一一对应(第一个实参给第一个形参赋值，第二个实参给第二个形参赋
值…)
格式：数据1, 数据2, 数据3, …
2）关键字参数
让实参和形参通过关键字(形参名)对应
格式：形参名1=数据1,形参名2=数据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
关键字参数
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) # 抱错！位置参数必须在关键字参数的前面
print(10, end='a')
print(10, 20, 30, sep=',')
def print(*data, end='\n', sep=' '):
pass
sorted([1, 23, 8], reverse=True)
- 参数默认值
定义函数的时候可以给以 ‘形参名=数据’ 的形式给参数赋默认值，调用函数的时候有默认值的参数可以不赋值
注意: 有默认值的参数必须在没有默认值参数的后面
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()
func2(y=200)
func2(z=300)
def func3(x, y, z=100):
print(f'x:{x}, y:{y}, z:{z}')
- 参数类型说明
定义函数的时候，可以对参数类型进行说明
-
赋默认值，默认值是什么类型，参数类型说明就是什么类型
-
形参名:数据类型
def func4(x=''):
pass
def func5(x: list) -> None:
x.append('100')
func5([])
- 不定长参数
在形参前加*或者加**, 就可以让这个参数变成不定长参数。不定长参数的形参可以同时接受多个实
参
1）带*的不定长参数
带*的参数会变成一个元组，元组中的元素就是对应的实参
注意：a. 一个函数可以同时存在带和不带的参数，如果不带的在带的后面，不带*的参数必须使
用关键字参数
b.带*的参数必须使用位置参数
2）带**的不定长参数
带**的不定长参数会变成一个字典;调用的时候用关键字参数传参，每个关键字就是字典的key，关
键字后面的数据就是字典的value
注意：a.定义的时候定长参数必须放在不定长参数的前面
b.带和带**的不定长参数可以同时存在，但是必须在**前面。（如果同时存在可以让函数
在调用的时候更加灵活）
def func6(*x):
print(f'x:{x}')
func6()
func6(10)
func6(10, 20)
func6(1, 2, 3, 4, 5)
# 练习：定义一个函数，可以求多个数的和
# sum1(10, 20) sum1(10, 20, 30)
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}')
func7(10) # x:10, y:()
func7(10, 20, 30, 40, 50) # x:10, y:(20, 30, 40, 50)
def func8(*x, y):
print(f'x:{x}, y:{y}')
func8(1, 2, 3, y=10)
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 func10(x, **y):
print(f'x:{x}, y:{y}')
2.函数的返回值
- 返回值
1）什么是返回值
返回值就是从函数内部传递到函数外部的数据。（如果实现函数的功能，产生了新的数据一般都需
要将这个新的数据通过返回值返回）
2）怎么确定函数返回值
在函数体中通过return关键字来返回返回值： return 数据
注意：同一个函数中，只有一个return有效。（因为执行函数体的时候只要遇到return函数直接结
束）
如果要在一个函数中返回多个数据，用能够保持多个数据的容器。常用元组: return 数据1, 数据2,
数据3,…
3）怎么在函数外部获取函数返回值
获取函数调用表达式的值就是获取函数的返回值。(返回值对应的数据能做的，函数调用表达式都可
以做)
def sum1(num1, num2):
s = num2 + num1
return s, s/2
def func1():
print('111111')
return # 相当于 return None
print('222222')
func1()
def func2():
return 100
def func3(x):
print(x)
print(100)
print(func2())
a = 100
b = func2()
print(a, b)
print(100 + 200)
print(func2() + 200)
list1 = [100, func2()]
print(list1)
func3(100)
func3(func2())
def func4():
return [1, 2, 3]
print(func4())
print(func4()[0])
for x in func4():
print(f'x: {x}')
if func4():
print('你好！')
def func5(x):
if x & 1:
return '奇数'
else:
return '偶数'
print(func5(11))
def func6():
print('abc')
print(func6())
# 练习：删除指定列表中所有指定元素
# [1, 23, 4, 5, 1, 34, 2, 1] 删除元素 1 -> [23, 4, 5, 34, 2]
# 方法一：
def del_item(list1: list, item):
for x in list1[:]:
if x == item:
list1.remove(x)
nums = [1, 23, 4, 5, 1, 34, 2, 1]
del_item(nums, 1)
print(nums)
# 方法二：
def del_item2(list1: list, item):
new_list = [x for x in list1 if x != item]
return new_list
nums = [1, 23, 4, 5, 1, 34, 2, 1]
new_l = del_item2(nums, 1)
new_l.append('end')
print(new_l)
3.全局变量和局部变量
根据变量的作用域不同将变量分为全局变量和局部变量两种
- 全局变量
定义在函数和类外面的变量都是全局变量
全局变量的作用域：从定义开始到程序结束的任何地方都可以用
# 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的作用：在函数中定义或者修改全局变量
用法：
global 变量名
变量名 = 值
2)*nonlocal
作用：在局部的局部中修改一个局部变量的值
nonlocal 变量名
变量名 = 值
# 1)使用global在函数中定义全局变量
def func4():
global z
z = 100
# 2)修改全局变量的值(如果直接在函数内容给全局变量赋值，不会修改值，而是产生一个新的局部变量)
name = '张三'
def func5():
global name
name = '李四'
print(f'函数内部name: {name}')
func5()
print(f'函数外部name: {name}')
def func6():
age = 18
def func7():
nonlocal age
age = 20
print(f'局部的局部age: {age}')
func7()
print(f'局部age:{age}')
func6()
4.匿名函数
- 什么是匿名函数
匿名函数的本质还是函数；但是匿名函数只能通过一条语句来实现函数的功能。
1)语法:
函数名 = lambda 形参列表：返回值
相当于：
def 函数名(形参列表)：
return 返回值
# 求两个数的和
# def sum1(num1, num2):
# return num1 + num2
sum1 = lambda num1, num2: num1+num2
print(sum1(10, 20)) # 30
print(sum1(num2=30, num1=70)) # 100
func2 = lambda num1: num1**2
# 练习：写一个匿名函数，判断指定的年是否是闰年
is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0)
print(is_leap_year(2020))
is_leap_year2 = lambda year: '闰年' if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0) else '平年'
print(is_leap_year2(2021))
递归
- 什么是递归函数
在函数中调用函数本身的函数就是递归函数
作用：循环能做的，递归都可以做。(指导思想：能用循环解决的问题就不要递归)
递归控制次数：控制递归函数在指定次数后结束
- 使用递归解决问题的步骤
“”"
第一步：像普通函数一样来定义函数
第二步：找临界值(找函数结束的条件)
第三步：找关系(找f(n)和f(n-1) - 找上次循环和本次循环之间的关系)
第四步：假设函数的功能已经实现，通过关系用f(n-1)实现f(n)的功能
“”"
# 用递归：1+2+3+4+5...+n
# f(n) = 1+2+3+...+n-1+n
# f(n-1) = 1+2+3+...+n-1
# 关系：f(n) = f(n-1)+n
def sum1(n):
# 1.找临界值
if n == 1:
return 1
# 2.找关系
# sum1(n) = sum(n-1)+n
return sum1(n-1)+n
print(sum1(100))
# def print_star(n):
# for x in range(1, n+1):
# print('*'*x)
# print_star(4)
def print_star(n):
# 1.找临界值
if n == 1:
print('*')
return
# 2.关系: 先实现f(n-1)然后再打印n个*
print_star(n-1)
print('*'*n)
print_star(4)
扫一扫
616
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
