高阶函数

# -*- 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系统高阶函数

  1. map()
  2. reduce()
  3. filter()
  4. 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]]
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容