python之高阶函数

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)))

例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)))

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

a, b, c = map(int, input(‘请输入三个数：’).split())
print(a,b,c)

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))))

例3：拿出一个字符串中的非空元素

def not_empty(s):
    return s and s.strip()

print(list(filter(not_empty,['A', '', 'B', None, 'C', '  '])))

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')))

例：有一个整数列表(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))