Pyton--高阶函数

一.高阶函数
高阶函数指的是接受函数作为输入或输出的函数，即实参是一个函数名，函数的返回值是一个函数。Python中内置了几个常用的高阶函数，比如map( )函数、reduce( )函数、filter( )函数和sorted( )函数。
函数本身也可以赋值给变量，变量可以指向函数

def fun(x,y,f):  
    return f(x),f(y)  ##定义一个函数
a = fun(-10,36,abs)  ##将函数赋值给一个变量
print(a)  ##通过变量来调用函数 
abs  ##python中的内置函数，用来取绝对值

二.map()函数
1.map()函数的用法
接收两个参数，一个是函数，一个是序列
将传入的函数依次作用到序列的每一个元素，并且把结果作为新的序列返回
2.map()函数的练习
（1）对于一个序列[-1,3,-4,-5]的每一个元素求绝对值

list1 = [-1,3,-4,-5]
list2 = map(abs,list1)  ##将abs函数依次作用于list1中的每一个元素，并且将结果作为一个新列表返回
print(list(list2))

[1, 3, 4, 5]

（2）对于每个元素求阶乘

import random
def fun(x):  ##定义阶乘函数
    res = 1
    for i in range(1,x+1):
        res = res*i
    return res
li = [random.randint(2,7) for i in range(10)]  ##随机获取列表，列表元素在2～7之间，并且生成10个元素
print(li)
print(list(map(fun,li)))

[4, 3, 3, 2, 5, 2, 5, 7, 7, 6]
[24, 6, 6, 2, 120, 2, 120, 5040, 5040, 720]

（3）对于每一个元素求平方

li = [2,5,9,8,4,11]
def power(x):
    a = x**2
    return a
li2=map(power,li)
print(list(li2))

[4, 25, 81, 64, 16, 121]

（4）将输入的字符转化为大写

str = 'ansdkkv'
def char(s):
    return s.upper()  ##定义函数，将字符串里的元素全部转换为大写
str2 = map(char,str)
print(''.join(list(str2)),type(str2))  ##将str2中的元素以空连接并输出

ANSDKKV <class 'map'>

三.reduce()函数
1.reduce()函数的用法
把一个函数作用在一个序列上，这个函数必须接收两个参数
reduce把结果继续和序列的下一个元素做累积计算
reduce(f,[x1,x2,x3,x4]) = f(f(f(x1,x2),x3),x4)
python2中：reduce是内置函数
python3中 from functools import reduce
2.reduce()函数的练习
（1）计算1-9的阶乘

from functools import reduce
def multi(x,y):
    return x*y
print(reduce(multi,range(1,10)))

（2）计算1-9的和

def add(x,y):
    return x+y
print(reduce(add,range(1,10)))

四.filter过滤函数
1.filter函数的用法
和map()类似的，也接收一个函数和一个序列
但是和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True或者False决定保留还是丢弃该元素
2.filter函数的练习
（1）找出1-1000之间的偶数

def fun(num):
    if num%2 == 0:
        return True
    else:
        return False
print(list(filter(fun,range(1000))))

（2）找出1-100之间的素数

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

[1, 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

五.sorted()函数
1.sorted函数的用法
用来对可迭代对象排序的，与列表的sort函数不同，后者是在原位置上进行排序的，排序后原列表的元素顺序会发生改变，而前者是将排序后的结构生成到一个新的列表中。

a = [1,5,7,2,4,3,6]
b = a.sort()
c = [2,7,4,3,8,9,6]
d = sorted(c)
print(a)
print(b)
print(c)
print(d)

[1, 2, 3, 4, 5, 6, 7]  ##a列表的元素位置发生变化
None  ##新列表并未存放排序后的列表，在原列表上发生改变
[2, 7, 4, 3, 8, 9, 6]  ##c列表元素位置相同
[2, 3, 4, 6, 7, 8, 9]  ##新生成的列表中存放排序以后的元素

同时sorted函数还可以指定序列按照给定的条件进行排序
格式：sorted(序列,key=条件)

list1 = [2,5,-3,-6,8,4,-9]
list2 = sorted(list1,key = abs)
print(list2)

[2, -3, 4, 5, -6, 8, -9]

2.sorted()函数的练习

**（1）对商品按照条件进行排序**
info = [
    #商品名称 商品数量 商品价格
    ('apple1',200,32),
    ('apple2',40,12),
    ('apple3',1000,23),
    ('apple4',40,5)
]
#按数量进行排序,及逆向排序
def count(x):
    return x[1]
#按价格进行排序
def price(x):
    return x[2]
#先按数量排序，如果数量相同，则按照价格进行排序
def count_price(x):
    return x[1],x[2]
print(sorted(info,key=count))
print(sorted(info,key=count,reverse=True))  ##逆向排序
print(sorted(info,key=price))
print(sorted(info,key=count_price))

[('apple2', 40, 12), ('apple4', 40, 5), ('apple1', 200, 32), ('apple3', 1000, 23)]
[('apple3', 1000, 23), ('apple1', 200, 32), ('apple2', 40, 12), ('apple4', 40, 5)]
[('apple4', 40, 5), ('apple2', 40, 12), ('apple3', 1000, 23), ('apple1', 200, 32)]
[('apple4', 40, 5), ('apple2', 40, 12), ('apple1', 200, 32), ('apple3', 1000, 23)]

六.匿名函数
1.匿名函数的用法
匿名函数的关键字为 lambda，冒号前面是 形参 冒号后面是返回值 。
lambda函数能实现普通一样的功能，能传入参数，也能返回运算结果；不同的是lambda函数没有函数名，通常只有一行的表达式，函数的复杂程度也有限。
如果使用lambda（匿名）函数，map( )函数和reduce( )函数及filter( print(reduce(lambda x,y:x+y,range(10))))还能进一步简化
2.匿名函数的应用
（1）匿名函数求1-9的和 简化reduce函数

print(reduce(lambda x,y:x+y,range(10)))

（2）将输入的字符串全部以大写输出，简化map函数

str1 = 'afdkl'                           
str2 = map(lambda x:x.upper(),str1)      
print(''.join(list(str2)),type(str2))    

（3）输出1-1000之间的偶数，简化filter函数

print(list(filter(lambda x:x%2==0,range(1000))))  

七.练习测试
1.利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字
（1）函数解决

def name(n):
    n1=n[0].upper()+n[1:].lower()
    return n1
print(name('redhat'))

（2）map函数

def name(n):
    n1=n[0].upper()+n[1:].lower()
    return n1
name1=['reDhat','WeStos','luck']
name2=list(map(name,name1))
print(name2)

结果输出

['Redhat', 'Westos', 'Luck']

2.利用map和reduce编写一个str2float函数，把字符串’123.456’转换成浮点数123.456

from functools import reduce
# 将字符串的每一个元素转换为整型
def fun(x):
    a = {str(i):i for i in range(10)}
    return a[x]
# 对整数位进行计算
def func1(x,y):
    return 10*x+y
# 对小数位进行计算
def func2(x,y):
    return 0.1*x+y
s=str(input('N:'))
s1 = s.split('.')[0]  ##字符串以点隔开，整数位为索引[0]对应的元素
s2 = s.split('.')[1]  ##小数位为索引[1]对应的元素
result=reduce(func1,map(fun,s1))+0.1*reduce(func2,map(fun,s2[::-1]))
print(result)

结果输出

N:123.456
123.456

3.回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()筛选出回数

def fun(num):
    num1 = str(num)
    if num1 == num1[::-1]:
        return True
    else:
        return False
print(list(filter(fun,range(1000))))

4. 将一个字符串转换成整型

from functools import reduce
def fun(x):  ##将字符串逐次转变为整型
    a = {str(i):i for i in range(10)}  ##key值为字符串的每一个索引 value值为每一个索引对应的整型
    return a[x]
def func(x,y):
    return 10*x+y
result=reduce(func,map(fun,'123456'))
print(result)

输出结果

123456

5. 假设我们用一组tuple表示学生名字和成绩，L =[(‘Bob’, 75), (‘Adam’, 92), (‘Bart’, 66),(‘Lisa’, 88)]，按名字进行排序

L = [('Bob',75),('Adam',92),('Bart',66)]
L1 = list(sorted(L,key = lambda x:x[0]))
print(L1)

[('Adam', 92), ('Bart', 66), ('Bob', 75)]

6.给定一个整形数组， 将数组中所有的0移动到末尾， 非0项保持不变；
在原始数组上进行移动操作， 勿创建新的数组
输入:
第一行是数组长度， 后续每一行是数组的一条记录;
4
0
7
0
2
输出:
调整后数组的内容;
7
2
0
0
思路：首先利用sorted函数进行排序，将0赋值为1，将非0数赋值为0，用sorted进行比较时，即是对0和1进行比较

n = int(input('N:'))
li = [int(input()) for i in range(n)]  ##建立一个列表
print(li)
def sort(i):
    if i==0:
        return 1
    else:
        return 0
print(list(sorted(li,key=sort)))

结果输出

N:4
0
7
0
2
[0, 7, 0, 2]
[7, 2, 0, 0]

7.有一个整数列表(10个元素)，要求调整元素的顺序把奇数放在前面 偶数放在后面

import random
list1=[random.randint(1,100) for i in range (10)]
print(list1)
def sort(i):
    if i%2==0:
        return 1
    else:
        return 0
print(list(sorted(list1,key=sort)))

结果测试

[33, 64, 42, 26, 21, 32, 35, 70, 3, 99]
[33, 21, 35, 3, 99, 64, 42, 26, 32, 70]