4.7 Python3 进阶 - 匿名函数 & 高阶函数

>>返回主目录

源码

# lambda 函数 不建议这样使用
demo = lambda x, y: x * y if x > y else x + y
print(demo)
print(demo(2, 5))

lambda函数经常结合高阶函数一起使用

源码

# 高阶函数
# max():获取绝对值的最大值
list_data = [1, -2, 5, -6, -4, 3]

# 使用for循环
new_list = []  # 新列表用于存放绝对值后的数

for i in list_data:
    new_list.append(abs(i))  # 循环将绝对值后的数存入新列表中

new_index = new_list.index(max(new_list))  # 获取新列表中最大值的下标
number = list_data[new_index]  # 在旧列表中获取与新列表中最大值下标相同的数
print(f'绝对值后值最大的是：{number}')

# max函数结合lambda函数使用
max_abs_data = max(list_data, key=lambda k: abs(k))
print(f'绝对值后值最大的是：{max_abs_data}')  # -6

# 获取年龄最大的学生信息
students = [
    {'name': 'Poly', 'age': 12},
    {'name': 'Lily', 'age': 18},
    {'name': 'Lucy', 'age': 17}
]
max_age_student = max(students, key=lambda x: x['age'])
print(f'最成熟的学生是：{max_age_student}')

源码

# sorted():获取升序排列后的学生信息
students = [
    {'name': 'Poly', 'age': 12},
    {'name': 'Lily', 'age': 18},
    {'name': 'Lucy', 'age': 17}
]
sorted_age_student = sorted(students, key=lambda s: s['age'], reverse=False)
print(f'按照age升序排列：{sorted_age_student}')

源码

# map():只有一个序列的map函数
map_list = map(lambda x: x * x, [1, 2, 3])
print('只有一个序列的map函数：', list(map_list))
# print('只有一个序列的map函数：', map_list)  # 返回map对象地址

# 有多个序列的map函数
list_a = ['one', 'two', 'three', 'four']
list_b = ['apple', 'cherry', 'watermelon']
map_lists = list(map(lambda x, y: x + ' ' + y, list_a, list_b))
print('有多个序列的map函数：', map_lists)

源码

# reduce():会对参数序列中元素进行累积操作
print('reduce函数链接字符串：', reduce(lambda x, y: x + y, ['name', 'is', 'Portos!'], 'My'))
print('reduce函数求阶乘，5! =', reduce(lambda x, y: x * y, range(1, 6)))

源码

# filter():用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的filter对象
students_list = [
    {'name': 'Poly', 'age': None},
    {'name': '', 'age': 18},
    {'name': None, 'age': 17},
    {'name': 'Lucy', 'age': 17}
]
print('筛选元素属性都不为空的元素：', list(filter(lambda x: x.get('name') and x.get('age'), students_list)))

# 当传入function为None时，例如：
print('过滤非空元素：', list(filter(None, [1, '', 2, None, '3', ' '])))

源码

# zip():接受任意多个可迭代对象作为参数，将对象中对应的元素打包成一个tuple，然后返回一个可迭代的zip对象
list_name = ['Poly', 'Lily', 'Lucy']
list_age = [12, 18, 17]
list_height = [20, 170, 167, 180]

zip_a = list(zip(list_name))  # 只有一个迭代对象
zip_b = list(zip(list_name, list_age))  # 有多个迭代对象
zip_c = list(zip(list_name, list_age, list_height))  # 多个不同长度的迭代对象
print('zip函数只有一个迭代对象：', zip_a)
print('zip函数有两个长度相同的迭代对象：', zip_b)
print('zip函数第三个迭代对象长度不同：', zip_c)

源码

# zip()练习①：反转字典中的key-value
dict_d = {'name': 'Poly', 'age': 12}
zip_d = dict(zip(dict_d.values(), dict_d.keys()))
print('使用zip反转字典中的key-value:', zip_d)

# zip()练习②：二维矩阵变换（矩阵的行列互换）
list_e = [
    ['name_a', 'Poly', 'age_a', 12],
    ['name_b', 'Lily', 'age_b', 18],
    ['name_c', 'Lucy', 'age_c', 17]
]
zip_e = list(zip(*list_e))
print('矩阵的行列互换：', zip_e)

源码

# zip()：可使用zip(*zipped)进行解压操作
list_name = ['Poly', 'Lily', 'Lucy']
list_age = [12, 18, 17]

zip_b = list(zip(list_name, list_age))
print('zip函数打包后：', zip_b)

# 对zip_b列表进行解压
unzip_b = list(zip(*zip_b))
print('zip函数解压后：', unzip_b)

unzip_tuple_name, unzip_tuple_age = unzip_b
print('解压后分离成元组类型：', unzip_tuple_name, unzip_tuple_age)

unzip_list_name, unzip_list_age = map(list, zip(*zip_b))
print('解压后分离成列表类型：', unzip_list_name, unzip_list_age)

源码

# enumerate():用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中，返回enumerate对象
enumerate_list = [
    {'name': 'Poly', 'age': 12},
    {'name': 'Lily', 'age': 18},
    {'name': 'Lucy', 'age': 17},
    {'name': 'Lucy', 'age': 17},
    {'name': 'Portos', 'age': 18}
]
for index, value in enumerate(enumerate_list, 1):
    print(f'列表第{index}個值是：{value}')

print('若使用list的index方法获取有重复值的列表数据下标：', enumerate_list.index({'name': 'Lucy', 'age': 17}))
print('若使用list的index方法获取无重复值的列表数据下标：', enumerate_list.index({'name': 'Portos', 'age': 18}))

>>返回主目录