函数进阶，10.10

最新推荐文章于 2022-12-22 00:02:42 发布

￥我的名字￥

最新推荐文章于 2022-12-22 00:02:42 发布

阅读量51

点赞数

文章标签： python 开发语言

本文链接：https://blog.csdn.net/qsh18380478760/article/details/127252272

版权

函数进阶

匿名函数

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

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

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


# 案例：写一个匿名函数求任意三个整数的个位数的和
sum3 = lambda num1, num2, num3: num1 % 10 + num2 % 10 + num3 % 10
print(sum3(1,2,3))

高阶函数

高阶函数 - 实参高阶和返回值高阶函数

实参高阶: 参数是函数的函数

返回值高阶函数：返回值是函数的函数

常见的实参高阶函数

1、max、min、sorted(sort)

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

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

# 1）求nums中值最大的元素
nums = [19, 23, 90, 34, 56, 78]
print(max(nums))
print(max(nums, key=lambda item: item))

# 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号', '烬']
names.sort(key=lambda item: -len(item))
print(names)


# 7）求nums中各个位数之和最大的元素
nums = [123, 98, 562, 90, 990, 1000]

# 方法1：
print(max(nums, key=lambda item: sum(int(x) for x in str(item))))


# 方法2：
def temp(item):
    s = 0
    for x in str(item):
        s += int(x)
    return s


print(max(nums, key=temp))

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

map(函数, 序列)

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

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

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

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

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

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

# 案例：将nums中所有的元素乘以2
nums = [2, 11, 33, 40, 9]
# [4, 22, 66, 80, 18]
result = map(lambda item: item*2, nums)
print(list(result))     # [4, 22, 66, 80, 18]

# 案例：计算三个学生的总分
score1 = [98, 78, 80]
score2 = [99, 90, 60]
# [197, 168, 140]
result = map(lambda item1, item2: item1+item2, score1, score2)
print(list(result))

# 练习1：使用map函数提取nums中所有元素的十位数
nums = [68, 1023, 23.34, 145.89, 192]
result = map(lambda item: int(item) // 10 % 10, nums)
print(list(result))

# 练习2：将学科和班号合并成班级名称
subjects = ['Python', 'java', 'h5']
nums = [2206, 2214, 2219]
# ['python2206', 'java2214', 'h52219]
result = map(lambda item1, item2: item1 + str(item2), subjects, nums)
print(list(result))


# 练习3：根据提供的学生信息，创建学生字典
names = ['张三', '李四', '王五', '小明']
genders = ['男', '女', '男', '男']
tels = ['1110', '12091', '27181', '18231']
# [{'name': '张三', 'gender':'男', 'tel': '1110'}, ....]
result = map(lambda i1, i2, i3: {'name': i1, 'gender': i2, 'tel': i3}, names, genders, tels)
print(list(result))

# 练习4：使用map函数来创建字典
keys = ['name', 'age', 'gender', 'tel']
values = ['小明', 18, '男', '110']
# {'name': '小明', 'age': 18, ...}
# [('name', '小明'), ('age', 18),...]
result = map(lambda i1, i2: (i1, i2), keys, values)
print(dict(result))


# 练习5：使用map函数将nums中所有的偶数除以2，所有的奇数乘以2
nums = [1, 4, 5, 7, 8]
# [2, 2, 10, 14, 4]
result = map(lambda item: item//2 if item % 2 == 0 else item * 2, nums)
print(list(result))

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

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

用之前必须写 from functools import reduce

# 案例：求nums中所有元素的和
nums = [12, 30, 89, 76, 55]
# 0 + 12 + 30 + 89 + 76 + 55
result = reduce(lambda i, item: i+item, nums, 0)
print(result)

# 案例：求nums中所有元素的乘积
nums = [12, 30, 89, 76, 55]
# 1 * 12 * 30 * 89 * 76 * 55
result = reduce(lambda i, item: i * item, nums, 1)
print(result)

# 案例：求nums中所有元素的个位数和
nums = [12, 30, 89, 76, 55]
# 2+0+9+6+5
# 0 + 12%10 + 30 % 10 + 89 % 10 + 76 % 10 + 55 %10
result = reduce(lambda i, item: i + item % 10, nums, 0)
print(result)

# 案例：将nums中所有元素合并成一个数字
nums = [12, 30, 89, 76, 55]
# 1230897655
# '' + '12' + '30' + ... '55'
# '' + str(12) + str(30) + ... + str(55)
result = reduce(lambda i, item: i + str(item), nums, '')
print(int(result))

# 案例：将list1中所有字符串的最后一个字符合并成一个新中字符串
list1 = ['anm', 'abc', 'hello', 'world']
# 'mcod'
result = reduce(lambda i, item: i + item[-1], list1, '')
print(result)

迭代器（iter）

容器型数据类型；

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

将其他序列转换成迭代器
```
i1 = iter('abc')
i2 = iter([10, 20, 30, 40])
```
怎么获取迭代器中元素

查单个: next(迭代器)
```
i1 = iter('abc')
print(next(i1))     # a
print(next(i1))     # b
print(next(i1))     # c
```
遍历
```
i2 = iter([10, 20, 30, 40])
for x in i2:
    print(f'x:{x}')

打印结果：
x:10
x:20
x:30
x:40
```

生成器

什么是生成器

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

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

怎么创建生成器

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

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


result = func1()   这个时候的result就是一个生成器
print(f'result:{result}')

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

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

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


g2 = func2()        #g2调用了一个带yield的函数，g2就是是一个生成器了
print(next(g2))    #取出g2的第一个值  就是0*2  结果就是0

for x in g2:
    print('====', x)   #x的值还剩下2、4、6、8  打印结果就是==== 2   ==== 4   ==== 6  ==== 8



def func3():
    print('========1===========')
    yield 100
    print('========2===========')
    yield 200
    print('========3===========')
    yield 300

g3 = func3()     #g3调用了一个带yield的函数，g3就是是一个生成器了
print(next(g3))   #取出g3的第一个值  ========1===========   100  取到yield 就不会取了
print(next(g3))    #取出g3的第2个值  ========2===========   200  从刚刚结束的位置继续取，再取到yield 就不会取了