20220609 高阶函数学习总结

20220609 学习总结

一、匿名函数
1.匿名函数 - 没有名字的函数
lambda 形参列表：返回值
相当于：
def (形参列表)：
return 返回值

函数名 = lambda 形参列表：返回值

相当于：
def 函数名(形参列表)：
return 返回值
注意：匿名函数的本质还是函数，输了定义的语法结构和普通函数不一样，其他的都一样

eg：
求任何两个数的和

def sum(num1 , num2):
	return num1 + num2
print(sum1(1))
sum1 = lambda num1 = 1, num2 = 2: num1 + num2

2.匿名函数的应用

给实参高阶函数传参的时候，函数对应的参数优先考虑使用匿名函数
实参高阶函数 - 如果一个函数有一个参数是函数，那么这个函数就是实参高阶函数
函数对应的参数的传参方式：1、传普通函数的函数名 2、传匿名函数

eg：写一个匿名函数，可以获取任意一个整数的十位数

n_10 = lambda num1:int(str(num1)[-2])
print(n_10(10554113))

如果一个函数的参数是函数(实参高阶函数)，这个参数怎么传参：1.传普通函数的函数名 2.传匿名函数
def temp():
print(‘临时函数’)

二、常用实参高阶函数
1.max, min, sorted(sort)

max(序列) - 求序列中最大的元素（直接比较每个元素本身的大校求最大值）

max（序列, key = 函数） - 按照函数指定的规则比较序列中的元素求出最大值
函数的要求：
a、有且只有一个参数；这个参数指向序列中的每个元素
b、需要一个返回值；返回值就是比较对象（将参数看出序列中的元素，在返回值这个位置来描述比较的值和元素之间的关系）
eg：
案例：求nums中个位数最大的元素: 19
nums = [19, 67, 28, 100, 23]

nums = [19, 67, 28, 100, 23]
print(max(nums,key = lambda item: item % 10))#19

eg:
求nums中各个位数之和最大的元素: 67
nums = [19, 67, 28, 100, 23]

nums = [19, 67, 28, 100, 23]

def s_num(list1):
    s = 0
    for x in str(list1):
        s += int(x)
    return s

result = max(nums, key=s_num)
print(result)

result = max(nums, key = lambda item:sum(int(x) for x in str(item)))
print(result)

eg:
求students中分数最高的学生： {‘name’: ‘stu1’, ‘age’: 18, ‘score’: 98, ‘sex’: ‘男’},
students = [
{‘name’: ‘stu1’, ‘age’: 18, ‘score’: 90, ‘sex’: ‘男’},
{‘name’: ‘stu2’, ‘age’: 28, ‘score’: 72, ‘sex’: ‘女’},
{‘name’: ‘stu3’, ‘age’: 24, ‘score’: 57, ‘sex’: ‘女’},
{‘name’: ‘stu4’, ‘age’: 17, ‘score’: 97, ‘sex’: ‘男’},
{‘name’: ‘stu5’, ‘age’: 20, ‘score’: 64, ‘sex’: ‘女’},
]

students = [
    {'name': 'stu1', 'age': 18, 'score': 90, 'sex': '男'},
    {'name': 'stu2', 'age': 28, 'score': 72, 'sex': '女'},
    {'name': 'stu3', 'age': 24, 'score': 57, 'sex': '女'},
    {'name': 'stu4', 'age': 17, 'score': 97, 'sex': '男'},
    {'name': 'stu5', 'age': 20, 'score': 64, 'sex': '女'},
]
result = max(students, key = lambda stu:stu['score'])
print(result)#{'name': 'stu4', 'age': 17, 'score': 97, 'sex': '男'}

eg:
求nums中绝对值最小的元素
nums = [-23, 100, 89, -56, -234, 123]

nums = [-23, 100, 89, -56, -234, 123]
result = min(nums,key = lambda item:item ** 2)
print(result)#-23

eg:
将students中所有的元素按照年龄的大小从小到大排序
students = [
{‘name’: ‘stu1’, ‘age’: 18, ‘score’: 90, ‘sex’: ‘男’},
{‘name’: ‘stu2’, ‘age’: 28, ‘score’: 72, ‘sex’: ‘女’},
{‘name’: ‘stu3’, ‘age’: 24, ‘score’: 57, ‘sex’: ‘女’},
{‘name’: ‘stu4’, ‘age’: 17, ‘score’: 97, ‘sex’: ‘男’},
{‘name’: ‘stu5’, ‘age’: 20, ‘score’: 64, ‘sex’: ‘女’},
]

result = sorted(students, key = lambda item: item['age'])
print(result)
#[{'name': 'stu4', 'age': 17, 'score': 97, 'sex': '男'}, {'name': 'stu1', 'age': 18, 'score': 90, 'sex': '男'}, {'name': 'stu5', 'age': 20, 'score': 64, 'sex': '女'}, {'name': 'stu3', 'age': 24, 'score': 57, 'sex': '女'}, {'name': 'stu2', 'age': 28, 'score': 72, 'sex': '女'}]

2.map - 基于原序列中的元素，通过指定的规则创建一个新的序列

1）map(函数，序列)
函数的要求：a.有且仅有一个参数，参数就指向后面这个序列中元素
b.有一个返回值；返回值就是新序列中的元素
2）map(函数，序列1，序列2)
函数的要求：a.有且仅有两个参数；分别指向后面两个序列中的元素
b.有一个返回值；返回值就是新序列中的元素
3）map(函数，序列1，序列2，序列3)
函数的要求：a.有且只有三个参数；分别只想后面三个序列中的元素
b.有一个返回值；返回值就是新序列中的元素
eg:
已经两个列表A和B，创建一个字典，A中的元素是key，B中的元素是value
A = [‘name’, ‘age’, ‘sex’]
B = [‘张三’, 18, ‘女’]

A = ['name', 'age', 'sex']
B = ['张三', 18, '女']
result = map(lambda l1,l2:(l1,l2),A,B)
print(list(result))#[('name', '张三'), ('age', 18), ('sex', '女')]

eg:
计算nums中所有元素各个位数的和，得到一个新列表： [10, 13, 10, 1, 5]
nums = [19, 67, 28, 100, 23]

result = map(lambda item:sum(int(x) for x in str(item)),nums)

eg:
案例3：获取students中所有学生的名字，得到一个新的列表: [‘stu1’, ‘stu2’, ‘stu3’, ‘stu4’, ‘stu5’]
students = [
{‘name’: ‘stu1’, ‘age’: 18, ‘score’: 90, ‘sex’: ‘男’},
{‘name’: ‘stu2’, ‘age’: 28, ‘score’: 72, ‘sex’: ‘女’},
{‘name’: ‘stu3’, ‘age’: 24, ‘score’: 57, ‘sex’: ‘女’},
{‘name’: ‘stu4’, ‘age’: 17, ‘score’: 97, ‘sex’: ‘男’},
{‘name’: ‘stu5’, ‘age’: 20, ‘score’: 64, ‘sex’: ‘女’},
]

students = [
    {'name': 'stu1', 'age': 18, 'score': 90, 'sex': '男'},
    {'name': 'stu2', 'age': 28, 'score': 72, 'sex': '女'},
    {'name': 'stu3', 'age': 24, 'score': 57, 'sex': '女'},
    {'name': 'stu4', 'age': 17, 'score': 97, 'sex': '男'},
    {'name': 'stu5', 'age': 20, 'score': 64, 'sex': '女'},
]
result = map(lambda stu:stu['name'],students)
print(list(result))

3.reduce - 将序列中的元素，通过指定的规则合并成一个数据

reduce(函数，序列，初始值)
初始值 - 根据合并方式，初始值一般是0（数值求和）、1（数值求乘积）或者空串（字符串拼接）
函数：
a、有且只有两个参数；第一个参数指向初始值，第二个参数指向序列中每个元素
b、有一个返回值；用来描述合并方式
eg：
案例1：求nums中所有元素的和
nums = [19, 67, 28, 100, 23]

from functools import reduce
nums = [19, 67, 28, 100, 23]
result = reduce(lambda x, y:x +y,nums,0)
print(result)#237

eg：
将nums中所有的元素的乘积
nums = [19, 67, 28, 100, 23]

nums = [19, 67, 28, 100, 23]	
result = reduce(lambda x,y: x*y,nums,1)
print(result)#81981200

eg:
将nums中所有的数十位数合并成一个字符串
nums = [19, 67, 28, 100, 23]

nums = [19, 67, 28, 100, 23]
result = reduce(lambda x, y: x + str(y // 10 % 10), nums, '')
print(result) #16202

将nums中所有的数合并成一个字符串
nums = [19, 67, 28, 100, 23]

result = reduce(lambda x,item:x + str(item),nums,'')
print(result)#19672810023

三、迭代器
1.什么是迭代器（iter）
迭代器是容器；
特点：
打印看不到元素；
无法统计元素的个数
获取元素的时候职能从上往下（从前往后）按顺序一个一个的取，取一个少一个

2.创建迭代器
1）通过类型转换，将其他容器转换成迭代器
2）创建一个生成器

i1 = iter('abc')
print(i1)#<str_iterator object at 0x000001D5D4815AC0>
i2 = iter([1, 2, 3, 4, 5])
print(i2)#<list_iterator object at 0x000002B27EBD3640>
# 打印迭代器看不到元素
# 无法统计元素的个数
# print(len(i1))    #报错

3.获取元素

1）获取单个元素：next（迭代器）

i1 = iter('abc')
i2 = iter([1, 2, 3, 4, 5])
print(next(i1)) #a
print(next(i1)) #b
print(next(i1)) #c
# print(next(i1)) #报错！
#无论以任何方式得到了迭代器中的元素，被得到的元素一定会从迭代器中消失。
i3 = iter('hello!')
result = list(i3)
print(result)   #['h', 'e', 'l', 'l', 'o', '!']
# print(next(result)) #报错！

2）遍历：

i2 = iter([10, 20, 30, 50, 60])
for x in i2:
    pass
# print(next(i2))#报错！


i2 = iter([10, 20, 30, 50, 60])
next(i2)
next(i2)
for x in i2:
    print("x",x)

四、生成器
1.生成器
生成器是容器；
生成器作为容器，保存不是多个数据，而是产生多个数据的算法

2.怎么创建生成器
调用带有yield关键字的函数

def func1():
    print('hello sister!')
    yield
    return 100

result = func1()
print('resulet:',result)

3.怎么控制生成器中元素的个数和值
生成器能创建多少个数据以及能创建哪些数据，就看执行生成器对应的函数的函数体的时候，
就会遇到多少次yield，每次遇到yield的时候对应的值是多少

def func2():
    yield 100
    yield 200
    yield 300
    for x in range(3):
        yield x * 100
gen2 = func2()

print(next(gen2))#100
print(next(gen2))#200

4.怎么获取生成器中的元素

和迭代器中获取元素的方式意义