# -*- coding: utf-8 -*-
# @Time : 2019/11/8 11:15
# @Author : John
# @Email : 2398344557@qq.com
# @File : 高阶函数.py
# @Software: PyCharm
高阶函数与我.jpg
满足，输入：接受一个或多个函数，输出一个函数
【练习1】两数的绝对值相加
def add(x, y, f):
return f(x) + f(y) # 传入函数，进行调用
res = add(3, -6, abs) # 传入函数名
print(res)
# —— 9
【练习2】
def method():
x = 2
def double(n):
return n * x
return double
d = method()
res2 = d(10)
print(res2)
# —— 20
Python系统高阶函数
- map()
- reduce()
- filter()
- sorted()
- map(funciton, iterable)
# 1. map(funciton, iterable)
# 该函数使用函数作为自己的一个参数，
# 它可以将iterable（可迭代对象）中的数据依次传给function函数，
# 最后把处理的结果作为新的可迭代对象返回
# 【实例】把[1, 2, 3, 4, 5]变成[1, 4, 9, 16, 25]
# 非函数形式：
print([i for i in range(1, 6)]) # 输出[1, 2, 3, 4, 5]
print([i**2 for i in range(1, 6)]) # 输出[1, 4, 9, 16, 25]
# 函数形式：
# def power(x):
# return x*x
# result = map(power(), [1, 2, 3, 4, 5]) # 函数, 可迭代对象
# print(result)
# # —— TypeError: power() missing 1 required positional argument: 'x'
# -------------------
# def power(x):
# return x*x
# result = map(power, [1, 2, 3, 4, 5]) # 函数, 可迭代对象
# print(result)
# # —— <map object at 0x00000087F9188048>
# -------------------
def power(x):
return x*x
result = map(power, [1, 2, 3, 4, 5]) # 函数（一个规则）, 可迭代对象
print(list(result))
# —— [1, 4, 9, 16, 25]
# 【实例2】把[1, 2, 3, 4, 5, 6, 7, 8, 9]变成['1', '2', '3', '4', '5', '6', '7', '8', '9', ]
# 可以定义一个函数power()
def power(x):
return str(x)
result_str_1 = map(power, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(result_str_1))
# —— ['1', '2', '3', '4', '5', '6', '7', '8', '9']
# --------------
# 也可以直接传入内置函数str()
result_str_2 = map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(result_str_2))
# —— ['1', '2', '3', '4', '5', '6', '7', '8', '9']
# --------------
# ***拓展***
# 把[1, 2, 3, 4, 5, 6, 7, 8, 9]变成[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]
result3_float = map(float, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(result3_float))
# 查看数据类型
result4_type = map(type, [' xuebi ', 1, 1.0, {}, (), [], {1, 2}])
print(list(result4_type))
# —— [<class 'str'>, <class 'int'>, <class 'float'>, <class 'dict'>, <class 'tuple'>, <class 'list'>, <class 'set'>]
# 判断布尔值
result5_bool = map(bool, [1, [0], {0}, (0), 0, [], {}, ()])
print(list(result5_bool))
# —— [True, True, True, False, False, False, False, False]
# 查看id内存地址
result6_id = map(id, [1, 2, 3, 4, 5, 6, 7, 8, 9])
print(list(result6_id))
# —— [140706190963536, 140706190963568, 140706190963600, 140706190963632, 140706190963664, 140706190963696, 140706190963728, 140706190963760, 140706190963792]
# 查看长度
result7_len = map(len, [(1,), 'ab', {1, 2, 3}])
print(list(result7_len))
# —— [1, 2, 3]
- reduce(function, sequence)
从functools引入reduce：
from functools import reduce
# 2. reduce()
# reduce(func, sequence)函数，累积操作
# func函数必须接收两个参数，
# reduce会把fuc的运行结果做一个参数，
# 然后从sequence中依次取出一个数据当做另一个参数
# 【练习】1*2*3*4*5
def mul(x, y):
return x*y
li = [1, 2, 3, 4, 5]
res = reduce(mul,li)
print(res)
# —— 120
# 或：用lambda
li = [1, 2, 3, 4, 5]
# 把mul()封装起来
# mul = lambda x, y: x*y
print(reduce((lambda x, y: x*y), li))
# —— 120
# 分析：
# reduce()函数的具体运行：
# 第一次运算时从迭代对象中取出两个参数：1*2=2
# 第二次运算时将第一次运行的结果2作为第一个参数传入，然后再从迭代对象中取出3作为第二个参数传入：2*3=6
# 同理：6*4=24
# ...
# 最后返回最后一次处理结果
# 【实例2】把序列[1, 3, 5, 7, 9]变成整数13579
def fn(x, y):
return x*10+y
print(reduce(fn, [1, 3, 5, 7, 9]))
# —— 13579
# 或：把fn()封装起来
# fn = lambda x, y: x*10+y
print(reduce((lambda x, y: x*10+y), [1, 3, 5, 7, 9]))
# —— 13579
# 【实例3-1自己版】写出str转化为int的函数，把'13579'转化成13579
# 步骤：
# 1. 编写函数fn进累加移位
def fn(x, y):
return x*10+y
# 2. 编写一个函数将char转化成num，map函数中的映射模式
def lis2(x):
return int(x)
list_0 = map(lis2, '13579')
# print(list(list_0))
# 3. 使用map和reduce函数结合编写str转化为int的函数
print(reduce(fn, list_0))
# —— 13579
# 【实例3-2老师版】写出str转化为int的函数，把'13579'转化成13579
def fn(x, y):
return x*10 + y
def char2num(s):
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
return digits[s]
print(reduce(fn, map(char2num, '13579')))
# —— 13579
# 【实例3-3快到牛B版】写出str转化为int的函数，把'13579'转化成13579
print(int('13579'))
# —— 13579
# 【实例4】编写一个str2int函数，把实例3的封装起来
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(z):
def fn(x, y):
return x * 10 + y
def char2num(c):
return digits[c]
return reduce(fn, map(char2num, z))
print(str2int('13579'))
# —— 13579
# 或：用lambda；
digits = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
def str2int(z):
# 把fn()和char2num()封装起来
# fn = lambda x, y: x * 10 + y
# char2num = lambda c: digits[c]
return reduce((lambda x, y: x*10+y), map((lambda c: digits[c]), z))
print(str2int('13579'))
# —— 13579
- filter(function, iterable)
# 3. filter()
# filter(function, iterable)
# 根据函数function来过滤，
# 将iterable中的数据传入function中，
# 如果函数返回True，则保留该数据，否则就不保留
li = [i for i in range(1, 15)]
# 讲li中所有的奇数筛选出来
print(list(filter((lambda x: x % 2 == 1), li)))
# —— [1, 3, 5, 7, 9, 11, 13]
- sorted()
# 4. sorted()
# 对数据进行排序，并且返回一个新的对象，原对象不变，
# key参数可以用来指定排序的规则，
# key接受的值是一个函数
# reverse参数是指定排序的顺序（升序还是降序），默认是升序
from random import randint
# 【练习1】
li1 = [randint(-10, 10) for _ in range(5)]
print('排序前：', li1)
res = li1.sort()
print('排序后：', li1) # 这个才是
print('返回值：', res)
# —— 排序前： [-5, -4, 0, 9, 8]
# —— 排序后： [-5, -4, 0, 8, 9]
# —— None
# 【练习2】
li2 = [randint(-10, 10) for _ in range(5)]
print('排序前：', li2)
res2 = sorted(li2)
print('排序后：', li2)
print('返回值：', res2) # 这个才是
# 排序前： [6, 7, -4, -4, -7]
# 排序后： [6, 7, -4, -4, -7]
# 返回值： [-7, -4, -4, 6, 7]
# 【练习3】
li3 = [randint(-10, 10) for _ in range(5)]
print('排序前：', li3)
res3 = sorted(li3, key=abs) # 排序时按照绝对值形式排序
print('返回值：', res3) # 但输出时是排序后在加回原来的符号的新排序
# 排序前： [-10, 2, -2, 2, 2]
# 返回值： [2, -2, 2, 2, -10]
# 【练习4】
chars = ['Sylar','Bennet', 'Hiro Nakamura', 'Peter Petrelli', 'Claire']
# # 排序前：
print('排序前：', chars)
# 按照字母的长度对chars进行降序排序
chars1 = sorted(chars, key=len, reverse=True)
print('排序后：', chars1)
# 排序前： ['Sylar', 'Bennet', 'Hiro Nakamura', 'Peter Petrelli', 'Claire']
# 排序后： ['Peter Petrelli', 'Hiro Nakamura', 'Bennet', 'Claire', 'Sylar']
# 或：使用lambda
# 排序前：
print('排序前：', chars)
chars2 = sorted(chars, key=lambda x: len(x), reverse=True)
print('排序后：', chars2)
# 排序前： ['Sylar', 'Bennet', 'Hiro Nakamura', 'Peter Petrelli', 'Claire']
# 排序后： ['Peter Petrelli', 'Hiro Nakamura', 'Bennet', 'Claire', 'Sylar']
# ***拓展***
# ----------------------------------
# 复合列表结构的列表排序
# 【练习5】
grade_list = [
{'name': 'Bennet', 'grade': 90},
{'name': 'Peter', 'grade': 30},
{'name': 'Hiro', 'grade': 70},
{'name': 'Sylar', 'grade': 52}
]
print('排序前：', grade_list)
# 按照成绩进行排序
grade_list = sorted(grade_list, key=lambda d: d['grade'])
print('排序后：', grade_list)
# —— 排序前： [{'name': 'Bennet', 'grade': 90}, {'name': 'Peter', 'grade': 30}, {'name': 'Hiro', 'grade': 70}, {'name': 'Sylar', 'grade': 52}]
# —— 排序后： [{'name': 'Peter', 'grade': 30}, {'name': 'Sylar', 'grade': 52}, {'name': 'Hiro', 'grade': 70}, {'name': 'Bennet', 'grade': 90}]
# 【练习6】
stu_info = [
('wunan', 22),
('jiulin', 39),
('hanlei', 17),
('zhenqi', 90)
]
print('排序前：', stu_info)
# 按照年龄进行降序排序
stu_info = sorted(stu_info, key=lambda x: x[1], reverse=True)
print('排序后：', stu_info)
# —— 排序前： [('wunan', 22), ('jiulin', 39), ('hanlei', 17), ('zhenqi', 90)]
# —— 排序后： [('zhenqi', 90), ('jiulin', 39), ('wunan', 22), ('hanlei', 17)]
# 【练习7】
role_info = [
['kakaluote', 81],
['beijita', 90],
['dizimotong', 59],
['guixianren', 1]
]
print('排序前：', role_info)
# 按照知名度进行降序排序
role_info = sorted(role_info, key=lambda z: z[1], reverse=True)
print('排序后：', role_info)
# —— 排序前： [['kakaluote', 81], ['beijita', 90], ['dizimotong', 59], ['guixianren', 1]]
# —— 排序后： [['beijita', 90], ['kakaluote', 81], ['dizimotong', 59], ['guixianren', 1]]
