python之高阶函数

Bertha 。 2022-05-16 10:06 210阅读 0赞

## 1. 高阶函数定义 ##

*  实参是一个函数名;
 *  函数的返回值是一个函数;
    
    1） 函数本身也可以赋值给变量,即:变量可以指向函数。

print(abs(-10))
    f = abs
    print(f(-10))

2）传递的参数包含函数名.  
变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之为高阶函数。

def fun(x,y, f):
        return f(x), f(y)
    print(fun(-10, 34, abs))

## 2.内置高阶函数 ##

1）.map() 函数

接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元素,并把结果作为新的 list 返回。

print(list(map(abs,[-1,2,-3])))

例1：求1～10的所有阶乘

def factoria(x):
        """对于x求阶乘"""
        res = 1
        for i in range(1, x + 1):
            res = res * i
        return res
    
    li = range(1,11)
    print(list(map(factoria, li)))

![这里写图片描述][70]

例2：利用 map() 函数,把用户输入的不规范的英文名字,变为首字母大写,其他小  
写的规范名字

L1 = ['adam', 'LISA', 'barT']
    from functools import reduce
    def bad(name):
        name = name[0].upper() + name[1:].lower()
        return name
    print(list(map(bad,L1)))

![这里写图片描述][70 1]

例3：要求用户输入3个数字 ; 依次将接收的三个数转换为整形， 并赋值给a,b,c

> a, b, c = map(int, input(‘请输入三个数：’).split())  
> print(a,b,c)  
> ![这里写图片描述][70 2]

2)reduce（）函数

*  PYTHON2中， 为内置函数
 *  PYTHON3中， 导入reduce, **from functools import reduce**

reduce 把一个函数作用在一个序列\[x1, x2, x3…\]上,这个函数必须接收两个参数,reduce 把结果继续和序列的下一个元素做累积计算。  
例：求10的阶乘

from functools import reduce       ##导入reduce函数
    def multi(x, y):
        return x * y
    print(reduce(multi, range(1, 10)))

3）filter（）函数

filter() 也接收一个函数和一个序列。和 map() 不同的时,  
filter() 把传入的函数依次作用于每个元素,然后根据返回值是 True，还是 False 决定保留还是丢弃该元素。

例1：删除10以内的奇数，保留偶数

def idodd(x):                                  
        if x%2 == 0:
            return  True
        else:
            return  False       # 函数内容可以直接写为： return x % 2 == 0 
    print(list(filter(idodd, range(1,11))))

例2：拿出1～100之间的所有素数

def isPrime(num):
        for i in range(2, num):
            if num % i == 0:
                return   False
        else:
            return True
    
    print(list(filter(isPrime, range(2,101))))

![这里写图片描述][70 3]  
例3：拿出一个字符串中的非空元素

def not_empty(s):
        return s and s.strip()
    
    print(list(filter(not_empty,['A', '', 'B', None, 'C', ' '])))

![这里写图片描述][70 4]

## 3.sorted函数 ##

1.  **li.sort()和sorted()两种方法的区别**
    
    1). 列表里面提供了sort方法， 其他数据结构没有.sorted方法可以对任何可迭代对象排序.  
    2).sort方法支持原地排序(变量排序后， 变量本身改变), sorted排序后返回一个新的列表,并不改变原变量的内容.

共同之处：  
默认sort和sorted方法由小到大进行排序,但当 reverse=True时， 由大到小进行排序.

li = [1,2,6,21324,67,2,23]
    li.sort(reverse=True)
    print(li)

li = [1,2,6,21324,67,2,23]
    print(sorted(li, reverse=True))

**2. 对于列表里面嵌套列表进行排序.\*\***

info = [
        # 商品名称 商品数量 商品价格
        ('apple3', 200, 32),
        ('apple4', 40, 12),
        ('apple1', 40, 2),
        ('apple2', 1000, 23),
    ]
    sorted_by_count(x):  # x = ('apple3', 200, 32)
        return x[1]
    
    def sorted_by_price(x):  # x = ('apple3', 200, 32)
        return x[2]
    # 先按照商品数量由小到大进行排序， 如果商品数量一致， 则按照商品价格由小到大进行排序.
    def sorted_by_count_price(x):  # x = ('apple3', 200, 32)
        return x[1], x[2]
    
    print(sorted(info, key=sorted_by_count))
    # 按照商品的价格进行排序, key代表排序的关键字
    print(sorted(info, key=sorted_by_price))
    print(sorted(info, key=sorted_by_count_price))
    # 先按照商品数量由小到大进行排序， 如果商品数量一致， 则按照商品价格由小到大进行排序

3.**对于字典里面嵌套字典进行排序**  
这里要引入**匿名函数**  
匿名函数  
•当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便。  
•关键字 lambda 表示匿名函数,冒号前面的 x 表示函数参数  
• 匿名函数有只能有一个表达式,不用写 return ,返回值就是该表达式的结果。  
• 因为匿名函数没有名字,不必担心函数名冲突。 此外,匿名函数也是一个函数对象,也可以把匿名函数赋值给一个变量

例：

d = {
        '003':{
            'name':'apple1',
            'count':100,
            'price':10
        },
        '002': {
            'name': 'apple1',
            'count': 200,
            'price': 2
        },
    }
    
    print(d.items())   # [(id, {}), (), ()]
    
    
    
    print(sorted(d.items(), key=lambda x: x[1]['count']))  #x:{'name': 'apple1', 'count': 100, 'price': 10} 
    print(sorted(d.items(), key=lambda x: x[1]['price']))
    ####如果直接对字典进行调用，就要进行两次索引
    print(sorted(d.values(), key=lambda x: x['count']))
    print(sorted(d.values(), key=lambda x: x['price']))
    ####如果直接对字典的values值进行调用，进行一次索引即可
    
    from operator import  itemgetter
    print(sorted(d.values(), key=itemgetter('count')))
    print(sorted(d.values(), key=itemgetter('price')))
    print(sorted(d.values(), key=itemgetter('price', 'count')))

![这里写图片描述][70 5]  
例：有一个整数列表(10个元素)， 要求调整元素顺序, 把所有的奇数放在前面， 偶数放在后面，

import random
    li = [random.randint(1, 10) for i in range(10)]
    print(li)
    print(sorted(li, key=lambda x: 1 if x % 2 == 0 else 0))
    print(sorted(li, key=lambda x:  x%2==0))

![这里写图片描述][70 6]

[70]: /images/20220516/8a8fd53553d94a2fba4ab57a1dd646cb.png
[70 1]: /images/20220516/e1f750565872495790ebb7df026beb47.png
[70 2]: /images/20220516/28f2e823bc924b2985195ea41303bbd8.png
[70 3]: /images/20220516/770f8aec71664377a3c3337f531cd114.png
[70 4]: /images/20220516/9ef9c0c3bf654350a40ca9be5836c5b9.png
[70 5]: /images/20220516/aed68225996648c1add55a47f4965ef0.png
[70 6]: /images/20220516/f91cc8bb025e4a0c8a600dcf6a4ca817.png