匿名函数、高阶函数、迭代器、生成器

一、匿名函数

1.匿名函数

本质还是函数(除了定义函数的语法以外的函数相关内容都是适用于匿名函数)

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

相当于：
def 函数名(形参列表):
    return 返回值

案例：写一个匿名函数求任意两个数的和

sum2 = lambda num1, num2: num1 + num2
print(sum2(10, 20))

案例：写一个匿名函数求任意三个整数的个位数的和

sum3 = lambda num1, num2, num3: num1 % 10 + num2 % 10 + num3 % 10
print(sum3(12, 23, 34))

二、高阶函数

实参高阶函数和返回值高阶函数
实参高阶：参数是函数的函数
返回值高阶函数：返回值是函数的函数

1.函数的参数的确定方法

# x可以传任何数据

def func1(x):
    print(x)


# x可以传int str float list bool 元组

def func2(x):
    print(x * 2)


# x可以传列表、字符串、元组、字典

def func3(x):
    print(x[1])


# x只能传列表

def func4(x):
    print(x.append(100))

1)func5、func6是一个实参高阶函数

# x必须是不需要传参就可以调用的函数

def func5(x):
    print(x())


# x必须是一个可以接收两个实参的函数，并且函数的返回值是数字

def func6(x):
    print(x(10, 20) + 30)

2)func7是一个返回值高阶函数

def func7():
    def func8():
        print('abc')
    return func8()

三、常见的实参高阶函数

注意：函数的参数入轨是函数，提供实参方式有两种：1.直接使用匿名函数 2.使用普通函数的函数名

1.max,min,sorted(sort)

1）max(序列) ---- 直接比较序列中元素的大小求最大值

2）max(序列, key=函数) ---- 根据函数指定的比较规则比较序列中元素的大小获取最大值
函数要求：a.有且只有一个参数(代表序列中的每个元素)
b.需要一个返回值(返回值代表比较对象 ---- 将参数看成序列中的元素，返回值对应的位置描述清楚比较对象和元素之间的关系)

1)求nums中

nums = [19, 23, 90, 34, 56, 78]
print(max(nums))

2）求nums中个位数最大的元素

nums = [19, 23, 90, 34, 56, 78]
print(max(nums, key=lambda item: item % 10))

3）求nums中绝对值最大的元素

# 补充：abs(数据)  -  返回数据的绝对值

nums = [19, 23, -90, 34, -56, 78]
print(max(nums, key=lambda item: item**2))

4）求students中分数最高的学生

students = [
    {'name': '小明', 'age': 19, 'score': 73},
    {'name': '小红', 'age': 22, 'score': 99},
    {'name': '小花', 'age': 32, 'score': 80},
    {'name': '张三', 'age': 20, 'score': 77}
]
print(max(students, key=lambda item: item['score']))

5）按照年龄的大小对students中元素从小到大排序

print(sorted(students, key=lambda item: item['age']))

6）将names中所有的元素按照每个名字的长度从大到小排序

names = ['路飞', '乌索布', '索罗', '鲁班7号', '烬']
print(sorted(names, key=lambda item: len(item), reverse=True))

7）求nums中各个位数之和最大的元素

nums = [123, 98, 562, 90, 990, 1000]
print(max(nums, key=lambda n: sum(int(x) for x in str(n))))


def max_num(n):
    s = 0
    for i in str(n):
        s += int(i)
    return s


print(max(nums, key=max_num))

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

1. map(函数, 序列)
   函数的要求：
   a.有且只有一个参数(代表序列中的每个元素)
   b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)

2. map(函数, 序列1, 序列2)
   函数的要求：
   a.有且只有2个参数(代表序列中的每个元素)
   b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)

3. map(函数, 序列1, 序列2, 序列3)
   函数的要求：
   a.有且只有3个参数(代表序列中的每个元素)
   b.有一个返回值(就是新序列中的元素 - 在这儿通过参数来描述新序列中的元素和原序列中元素的关系)

map(函数, 序列1, 序列2, 序列3…)

案例:将nums中所有的元素乘以2

nums = [19, 23, 90, 34, 56, 78]
result = map(lambda item: item * 2, nums)
print(list(result))

练习：使用map函数提取nums中所有元素的十位数

nums = [68, 1023, 23.34, 145.89, 192]

# [6, 2, 2, 4, 9]

result1 = map(lambda item: int(item) // 10 % 10, nums)
print(list(result1))

练习2：将学科和班号合并成班级名称

subjects = ['Python', 'java', 'h5']
nums = [2206, 2214, 2219]

# ['python2206', 'java2214', 'h52219]

result2 = map(lambda item1, item2: item1 + str(item2), subjects, nums)
print(list(result2))

练习3：根据提供的学生信息，创建学生字典

names = ['张三', '李四', '王五', '小明']
genders = ['男', '女', '男', '男']
tels = ['1110', '12091', '27181', '18231']

# [{'name': '张三', 'gender':'男', 'tel': '1110'}, ....]

result3 = map(lambda item1, item2, item3: {'names': item1, 'gender': item2, 'tel': item3}, names, genders, tels)
print(list(result3))

练习4：使用map函数来创建字典

keys = ['name', 'age', 'gender', 'tel']
values = ['小明', 18, '男', '110']

# {'name': '小明', 'age': 18, ...}

result3 = map(lambda item1, item2: (item1, item2), keys, values)
print(dict(result3))

练习5：使用map函数将nums中所有的偶数除以2，所有的奇数乘以2

nums = [1, 4, 5, 7, 8]

# [2, 2, 10, 14, 4]

result4 = map(lambda i: i // 2 if i % 2 == 0 else i * 2, nums)
print(list(result4))

3.reduce - 将序列中所有的元素合并成一个数据

reduce(函数, 序列, 初始值) - 将序列中的元素按照函数制定的规则合并成一个数据
函数的要求：a.有且只有两个参数(第一个参数只向初始值，第二个参数代表序列中的每个元素)
b.有一个返回值(用来描述合并规则)

案例：求nums中所有元素的和

from functools import reduce

nums = [12, 30, 89, 76, 55]

# 12 + 30 + 89 + 76 + 55

result = reduce(lambda i, item: i+item, nums, 0)
print(result)

案例：求nums中所有元素的乘积

nums1 = [12, 30, 89, 76, 55]

# 12 * 30 * 89 * 76 * 55

result = reduce(lambda i, item: i*item,nums1,1)
print(result)

案例：求nums中所有元素的个位数和

nums2 = [12, 30, 89, 76, 55]

# 2+0+9+6+5

result = reduce(lambda i, item: i+item%10, nums2, 0)
print(result)

案例：将nums中所有元素合并成一个数字

nums3 = [12, 30, 89, 76, 55]

# 1230897655

result = reduce(lambda i, item: i+str(item), nums3, '')
print(result)

案例：将list1中所有字符串的最后一个字符合并成一个新中字符串

list1 = ['anm', 'abc', 'hello', 'world']

# 'mcod'

result = reduce(lambda i, item: i+item[-1], list1, '')
print(result)

4.filter(自学)

四、迭代器

1.什么是迭代器(iter)

容器型数据类型：
迭代器作为容器打印的时候无法显示元素；无法通过len获取迭代器中的个数；
如果要使用迭代器中的元素必须将元素从迭代器中取出来，而且一旦取出来就无法再放回去。

2.怎么创建迭代器

1)将其他序列转换成迭代器

2)创建生成器

a = iter('abc')
b = iter([10, 20, 30, 40])

3.怎么获取迭代器中的元素

注意：不管以什么方式获取到了迭代器中的元素，对应的元素一定会从迭代器中消失

1）查单个：next(迭代器)

print(next(a))      # a
print(next(a))      # b
print(next(a))      # c

# print(next(a))      # 报错！

2）遍历

for x in b:
    print(x)

五、生成器

1.什么是生成器

容器型数据类型(生成器作为容器不具备同时保存多个数据的能力，具备的是创建多个数据的能力)

打印生成器也无法查看生成器中的元素；生成器无法统计个数；
获取生成器中的元素，也是取一个少一个。（生成器获取元素的方法和迭代器一样）

2.怎么创建生成器

调用带有yield关键字的函数就可以得到一个生成器

def func1():
    print('abc')
    yield
    return 100


result = func1()
print(f'result:{result}')

3.生成器的元素 - 控制生成器产生数据的个数和产生的值

执行创建生成器的函数的函数体会遇到几次yield，对应的生成器就可以创建多少个数据;
每次遇到yield的时候，yield后面的数据就是这个生成器能够创建的值。

def func2():
    for x in range(5):
        yield x*2

g2 = func2()
print(next(g2))
print(next(g2))
print(next(g2))
print(next(g2))