函数进阶
---------------------函数的参数
---------------------函数的返回值
---------------------匿名函数
---------------------实参高阶函数
一、函数的参数
# 1.位置参数和关键字参数
'''
根据调用参数的时候实参的传递方式不同,可以将实参分为位置参数和关键字参数两种:
1)位置参数:直接多个数据用逗号隔开,让实参和形参从位置上一一对应。
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(20, 10, 30) # x:20, y:10, z:30
# 关键字参数(交换位置不会交换对应关系)
func1(x=10, y=20, z=30) # x:10, y:20, z:30
func1(y=20, z=30, x=10) # x:10, y:20, z:30
# 混用
func1(10, y=20, z=30) # x:10, y:20, z:30
func1(10, z=30, y=20) # x:10, y:20, z:30
func1(10, 20, z=30) # x:10, y:20, z:30
# func1(10, y=20, 30) # 报错 ,位置参数不可在关键字参数的后面
# 2.参数默认值
'''
定义函数的时候,可以一'形参名=数据'的方式给参数赋默认值;有默认值的参数在调用的时候可以不用传参。
定义函数的时候可以有的参数有默认值有的参数没有默认值,但是没有默认值的参数必须在有默认值参数的前面,否则程序会报错。
'''
def func2(x=10, y=20, z=30):
print(f'x:{x}, y:{y}, z:{z}')
func2() # x:10, y:20, z:30
func2(100) # x:100, y:20, z:30
func2(100, 200) # x:100, y:200, z:30
func2(100, 200, 300) # x:100, y:200, z:300
func2(z=300) # x:10, y:20, z:300
def func3(x, y, z=30):
print(f'x:{x}, y:{y}, z:{z}')
#def func4(x=10, y, z): # 会报错
# 3.参数类型说明
'''
定义函数的时候如果对参数进行类型说明,可以让函数体在使用参数的时候有对应类型的代码提示。
类型说明的方式有两种:
1)没有默认值的参数的类型说明:形参名:类型名
2)给参数赋默认值,默认值的类型就是对应的形参的类型
'''
def func4(x: str , y = 'abc') -> int: # -> int 返回值类型说明
print(x.split('a'))
print(y.join('100'))
pass
func4('manfa') # ['m', 'nf', ''] 1abc0abc0
# 4.不定长参数
'''
1)带*的不定长参数
在形参前面加*就可以让这个形参变成一个不定长参数,可以同时接收多个实参;
带*的不定长参数会变成一个元组,接收到的实参会变成元组中的元素。
注意: a.带*的不定长参数只能用位置参数传参
b.同一个函数中既有定长参数也有带*的不定长参数,那么*前面的定长参数必须用位置参数传参,*后面的定长参数必须用关键字传参。
'''
def func5(*x):
print(x)
func5() # ()
func5(10) # (10,) # 若元组中只有一个元素,元素后面要加逗号','
func5(10, 20, 30, 40, 50) # (10, 20, 30, 40, 50)
# 补充:只有一个元素的元组,唯一的元素后面必须加逗号
# 定义一个函数求多个数的和
def sum1(*nums):
s = 0
for x in nums:
s += x
print(s)
sum1(1, 2, 3) # 6
sum1(2, 20, 34, 5, 2) # 63
def func6(x, *y, z):
print(f'x:{x}, y:{y}, z:{z}')
func6(100, 10, 20, 30, z=200) # x:100, y:(10, 20, 30), z:200
# 参数中独立存在的*的作用:让*前面的参数用位置参数传参,*后面的参数用关键字参数传参
def func7(x, *, y): # 用来约束前后的传参方式,本身不是参数
print(x, y)
'''
2)带**的不定长参数(了解)
定义函数的时候在某个参数前加**,让这个参数变成不定长参数,可以同时接收多个关键字参数对应的实参。(关键字可以随便写)
'''
def func8(**x):
print(x)
func8() # {}
func8(a=10) # {'a': 10}
func8(a1=10, a2=20, a3=30) # {'a1': 10, 'a2': 20, 'a3': 30}
# 定义函数获取学生信息
def get_student_info(name, age, **score):
print(name, age, score)
get_student_info('小明', 18, English=89, math=70, c=55) # 小明 18 {'English': 89, 'math': 70, 'c': 55}
get_student_info('张三', 23, python=87) # 张三 23 {'python': 87}
# 问题:函数中'*args, **kwargs'是什么意思?
# 答:让这个函数调用的时候既可以传多个位置参数,又可以传多个关键字参数,还可以位置参数和关键字参数一起使用,但是要注意位置参数必须要在关键字参数前面。
def func9(*args, **kwargs):
pass
func9()
func9(10, 20, 30)
func9(a=2, b=11, c=22)
func9(10, 20, 30, a=10, b=20)
二、函数的返回值
# 1.什么是返回值
'''
返回值就是从函数内部传递到函数外部的数据。python中的函数有且只有一个返回值,默认情况下函数的返回值是None。
'''
# 2.怎么确定函数返回值
'''
语法:return 返回值
执行函数体的时候,如果遇到了return,return后面的值就是函数的返回值
初学者添加函数返回值的原则:看实现函数的功能有没有产生新的数据,如果有,就将产生的新数据作为函数返回值返回。
'''
# 定义函数求两个数的和
def sum2(num1, num2):
return num1 + num2
print(sum2(12, 10))
# 案例:定义函数提取字符串中所有的字母
def get_letter(str1:str):
new_str = ''
for x in str1:
if x.islower() or x.isupper():
new_str += x
return new_str
print(get_letter('123abc4F2K')) # abcFK
result = get_letter('123abc4F2K')
print(result, len(result), '+'.join(result)) # abcFK 5 a+b+c+F+K
# 案例:定义函数删除数字列表中所有小于0的数
def del_minus(nums:list):
#方法1:
# return [x for x in nums if x >= 0]
#方法2:不需要返回值
for x in nums.copy():
if x < 0:
nums.remove(x)
# 没有返回值的函数,调用函数后直接使用赋有实参的变量
list1 = [10, 20, -4, -5, 22, -10]
del_minus(list1)
print(list1) # [10, 20, 22]
list2 = [1, 3, 89, -2, -1, -49, 22, -4]
del_minus(list2)
print(list2) # [1, 3, 89, 22]
# 3.怎么获取函数返回值
'''
函数调用表达式的值就是函数的返回值(返回值能做的事情,函数调用表达式都可以做)。
如果需要在函数外部使用函数的返回值,直接获取函数调用表达式的值。
函数调用表达式 - 调用函数的语句
补充:函数调用过程
第一步:回到函数定义的位置
第二步:传参(用实参给形参赋值)
第三步:执行函数体
第四步:执行完函数体,确定函数的返回值(如果遇到了return,return后面的值就是函数的返回值,否则函数的返回值为None。
第五步:回到函数调用的位置(这个时候函数调用表达式的结果就是函数的返回值)
'''
print(sum2(10, 20)) # 30
x = sum2(100, 200)
print(x) # 300
list1 = [10, 20, sum2(1, 2)]
print(list1) # [10, 20, 3]
# 4.return的作用
# 1)返回数据(将数据作为函数返回值返回)
# 2)提前结束函数(执行函数体的时候,什么时候遇到return,函数什么时候结束)
def func1():
for x in range(5):
print('===')
return
print('+++')
print('---')
func1() # ===
def func1():
for x in range(5):
return '&'
print(func1()) # &
三、匿名函数
# 1.匿名函数
'''
语法:
函数名 = lambda 形参列表:返回值
(使用实参高阶函数时更多的会使用匿名函数)
相当于:
def 函数名(形参列表):
return 返回值
注意:a.匿名函数的调用和普通函数没有区别
b.匿名函数至少需要一个形参
'''
# 案例:写一个匿名函数求两个数的和
sum2 = lambda num1,num2:num1 + num2
print(sum2(10, 20)) # 30
print(sum2(num1=100, num2=200)) # 300
# 练习:定义一个匿名函数,判断指定的年是否是闰年
is_leap_year = lambda year: (year % 4 == 0 and year % 100 != 0) or year % 400 == 0
print(is_leap_year(1000))
四、实参高阶函数
# 1.什么是实参高阶函数 - 如果一个函数有一个参数也是函数,那么这个函数就是实参高阶函数.
'''
调用实参高阶函数,给函数类型的参数传参的时候有两个选择:a.传符合条件的普通函数名;b.传一个匿名函数
'''
def func1(x): # func1是实参高阶函数
print(x(10, 20) + 10)
def t(x, y):
return 100
func1(t) #t(10, 20) # 110
func1(lambda a, b:12) # 22
# 2.python中常用实参高阶函数
# 1)max、min、sorted
'''
max(序列) - 直接比较序列中元素的大小,求最大值
max(序列, key=函数) - 按照函数制定的比较规则比较序列中元素的大小求最大值
函数要求:a.有且只有一个参数(这个参数代表序列中的元素)
b.有一个返回值(返回值就是比较对象)
c.函数可以是普通函数名或者匿名函数
'''
# 普通用法
print(max([10, 23, 45, 7, 12]))
# 案例1:求nums中个位数最大的元素
nums = [90, 19, 34, 67, 88]
result = max(nums, key=lambda item: item % 10)
print(result) # 19
# 案例2:求nums中数值最大的元素
nums = ['19', '901', '99', '78', '65']
result = max(nums, key=lambda item: int(item))
print(result) # '901'
# 练习1:求nums中十位数最大的元素
nums = [89, 102, 543, 92, 8]
result = max(nums, key=lambda item: item % 100 // 10)
print(result)
# 练习2:求students中分数最低的学生信息
students = [
{'name': '小明', 'age': 30, 'score': 87},
{'name': '张三', 'age': 19, 'score': 67},
{'name': '小花', 'age': 22, 'score': 90},
{'name': '李四', 'age': 25, 'score': 83}
]
result = min(students, key=lambda items: items['score'])
print(result)
# 练习3:将students中字典按照年龄值从小到大排序
students = [
{'name': '小明', 'age': 30, 'score': 87},
{'name': '张三', 'age': 19, 'score': 67},
{'name': '小花', 'age': 22, 'score': 90},
{'name': '李四', 'age': 25, 'score': 83}
]
result = sorted(students, key=lambda item: item['age'])
print(result)
students.sort(key=lambda item: item['age'])
print(students)
# 案例:求nums各个位数之和最大的元素
nums = [102, 89, 341, 90, 77]
def t(item):
s = 0
for x in str(item):
s += int(x)
return s
result = max(nums, key=t)
print(result)
# 2)map
'''
map(函数, 序列) - 基于序列中的元素按照函数制定的规则创建一个新的序列
函数的要求:a.有且只有一个参数(参数代表序列中的元素)
b.有一个返回值(返回值就是新序列中的元素)
map(函数, 序列1, 序列2)
函数的要求:a.有且只有两个参数(参数代表两个序列中的元素)
b.有一个返回值(返回值就是新序列中的元素)
map(函数, 序列1, 序列2, 序列3, ...)
'''
# 案例1:将nums中所有的元素都乘以2,创建一个新的序列
nums = [10, 23, 4, 8, 11]
result = list(map(lambda item: item * 2, nums))
print(result) # [20, 46, 8, 16, 22]
# 案例2:已知两个列表分别保存的是学生的语文成绩和数学成绩,创建一个列表保存每个学生的总成绩
chinese = [89, 78, 90, 56, 70]
math1 = [99, 82, 56, 77, 69]
result = list(map(lambda item1, item2: item1 + item2, chinese, math1))
print(result) # [188, 160, 146, 133, 139]
# 3)reduce
'''
reduce(函数, 序列, 初始值) - 将序列中的元素按照函数制定规则合并成一个数据
a.初始值 - 累积求和初始值为0;累积求乘积初始值为1;字符串拼接初始值为空值。
b.函数的要求:有且只有两个参数(第一个参数代表初始值;第二个参数代表序列中的每个元素。
有一个返回值(代表合并方式)
'''
# 注意:reduce使用之前需要先导入
from functools import reduce
# 案例1:求nums中所有元素的和
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + i2, nums, 0)
print(result) # 112
# 案例2:求nums中所有元素的乘积
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 * i2, nums, 1)
print(result)
# 案例3:将nums中所有元素的个位数拼接成一个数字
# 注意:reduce使用之前需要先导入
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + str(i2)[-1], nums, '')
print(result) # '06862'
# 练习:求nums所有个位数的和
nums = [20, 46, 8, 16, 22]
result = reduce(lambda i1, i2: i1 + i2 % 10, nums, 0)
print(result)