Python 函数式编程与高阶函数

高阶函数

把函数作为参数传入，这样的函数称为高阶函数。

def func1(x, y, f):
    return f(x) + f(y)
# 把函数作为参数传入参数的时候，不要加括号
num = func1(-10, 2, abs)
# abs代表取绝对值函数，表示调用这个函数，获取它的返回值
print(num)

常用高阶函数-map

给定列表，计算f(x)=x*x

lst = [1, 2, 3, 4, 5, 6, 7] 
print([x*x for x in lst])  #列表推导式
re = (x*x for x in lst)
print([x for x in re])   #生成器表达式

一般来说，接收俩个参数，第一个参数是要作用的函数，第二个是要作用的可迭代对象。
map后面可以接收多个可迭代对象，那传入几个可迭代对象，前面的函数就要接收几个参数。

单个参数

lst = [1, 2, 3, 4, 5, 6, 7]  
def f1(x):
    return x * x
print(list(map(f1, lst)))    # 一个可迭代对象
#[1, 4, 9, 16, 25]

多个参数

lst = [1, 2, 3, 4, 5, 6, 7]
lst2 = [10, 20, 30, 40, 50]
def f1(x, y):
    return x * x, y * y
print(list(map(f1, lst, lst2)))  # 俩个可迭代对象
#[(1, 100), (4, 400), (9, 900), (16, 1600), (25, 2500)]

匿名函数作参数

lst = [1, 2, 3, 4, 5, 6, 7]
lst2 = [10, 20, 30, 40, 50]
print(list(map(lambda x, y: x + y, lst, lst2)))
#[11, 22, 33, 44, 55]

练习

• 有列表[1,2,3,4,5]，将所有元素转换成str:[‘1’,‘2’,‘3’,‘4’,‘5’]

lst1 = [1, 2, 3, 4, 5]
print(list(map(lambda i: f'{i}', lst1)))  # 写法一
print(list(map(lambda x:str(x), lst1)))   # 写法二
print(list(map(str,lst1)))                # 写法三

• 有列表字符串’span’，将各字符转换成对应的ascii码的列表[115, 112, 97, 109]

str1 = "span"
print(list(map(ord, str1)))  # 写法一
print(list(map(lambda x:ord(x), b))) # 写法二

• 有列表[-1,-2,0,1,2]，将各元素转换成绝对值[1, 2, 0, 1, 2]

lst3 = [-1, -2, 0, 1, 2]
print(list(map(abs, lst3))) # 写法一
print(list(map(lambda x:abs(x), c)))# 写法二

• [0.000564, 0.456723, 0.5, 0.71345] 将里面的数值换算成百分比，保留俩位小数

c = [0.000564, 0.456723, 0.5, 0.71345]

#方法1 format函数
print(list(map(lambda x:format(x,'.2%'), c)))
#方法2 x*100
print(list(map(lambda x:'%.2f%%'%(x*100), c)))

结果: ['0.06%', '45.67%', '50.00%', '71.34%']

#####保留俩位小数#####
b = [1.239865,4.56,3.2,9.82356]

#方法1
print(list(map(lambda x:'%.2f'%x, b)))
#方法2
print(list(map(lambda x:round(x,2), b)))

结果: [1.24, 4.56, 3.2, 9.82]

常用高阶函数-filter

将filter的第一个参数传入一个函数，第二个参数是可迭代对象。
将可迭代对象的每个值交给传入的函数处理，如果结果为真，保留这个值，否则丢弃

#####保留奇数#####
def is_odd(n):
    return n % 2 == 1
print(list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7])))
||
||等同于
||
print(list(filter(lambda x: x % 2, [1, 2, 3, 4, 5, 6, 7])))
# 结果：[1, 3, 5, 7]

练习

1、把一个序列中的空字符串删掉，[‘A’, ‘’, ‘B’, None, ‘C’, ’ ', ‘a’, 1, 0]

lst = ['A', '', 'B', None, 'C', ' ', 'a', 1, 0]

print(list(filter(lambda x: x and x != ' ', lst)))
print(list(filter(lambda x: x and str(x).strip(), lst)))
#结果：['A', 'B', 'C', 'a', 1]

2、 水仙花数 100-999 153 = 13+53 +3**

##### 地板除+取余 #####
print(list(filter(lambda i: (i // 100) ** 3 + (i // 10 % 10) ** 3 + (i % 10) ** 3 == i, range(100, 999))))
##### 转化成str #####
def func01(x):
    num = str(x)
    return int(num[0])**3 + int(num[1])**3 + int(num[2])**3 == x
result = filter(func01,range(100,1000))
print(list(result))
#结果为 [153, 370, 371, 407]

3、100以内开平方是整数的数

print(list(filter(lambda i: (i ** 0.5).is_integer(), range(100))))
print(list(filter(lambda x:sqrt(x) in range(1, 101) , range(1, 101))))

常用高阶函数-sorted

用Python-sorted代码实现：按绝对值大小排序
sorted()函数也是一个高阶函数，它还可以接收一个key函数来实现自定义的排序 key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

对比原始的list和经过key=abs处理过的list： 
• 执行语句：sorted([36, 5, -12, 9, -21], key=abs) 
1. 原始字符：list = [36, 5, -12, 9, -21] 
2. 经过key-abs对应得到：[36, 5, 12, 9, 21] 
3. 按照keys-abs排序结果：[5, 9, 12, 21, 36] 
4. 原始字符串最终结果：[5, 9, -12, -21, 36]

列表排序

• 把一个序列中的字符串，忽略大小写排序
  序列：[‘bob’, ‘about’, ‘Zoo’, ‘Credit’]
  结果：[‘about’, ‘bob’, ‘Credit’, ‘Zoo’]

# 大写排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=lambda x: x.upper()))
# 小写排序
print(sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower))
结果：
['about', 'bob', 'Credit', 'Zoo']
['about', 'bob', 'Credit', 'Zoo']

字典排序

按照value排序

d1 = {"a": 3, "b": 4, "c": 2, "d": 5}
print(dict(sorted(d1.items(), key=lambda x: x[1])))

元组排序

#元组的排序，先比较第一个值，再比较第二个，依次类推
>>> a=[(1,2),(2,2),(1,0),(2,4),(True,False)]
>>> sorted(a)
[(1, 0), (True, False), (1, 2), (2, 2), (2, 4)]
>>> sorted(a,reverse=True)  # 注：反序 reverse=True
[(2, 4), (2, 2), (1, 2), (1, 0), (True, False)] 

字符串排序

>>> a = ["abc","defg","123456","1","sbbbfg"]
#注：按照首字母的ASCII码排序
>>> sorted(a)
['1', '123456', 'abc', 'defg', 'sbbbfg']
#注：按照字符串长度排序
>>> sorted(a,key=len)
['1', 'abc', 'defg', '123456', 'sbbbfg']

常用高阶函数-reduce

用Python-reduce代码实现：将列表[1,3,5,7,9]，变成整数13579
• reduce把一个函数作用在一个序列[x1, x2, x3, …]上
• 这个函数必须接收两个参数
• reduce把结果继续和序列的下一个元素做累积计算
• reduce(f, [x1, x2, x3, x4]) => f(f(f(x1, x2), x3), x4)

列表变整数

from functools import reduce
def fn(x, y):
    return x * 10 + y
print(reduce(fn, [1, 3, 5, 7, 9]))


print(reduce(lambda x, y: x * 10 + y, [1, 3, 5, 7, 9]))
# 结果：13579

实现int功能

def custom_int(s):
    def char_to_number(string):
        all_number_dict = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
        # 以参数string为键，取出all_number_dict里面的值
        return all_number_dict[string]

    def result_number(x, y):
        res = x * 10 + y
        return res

    return reduce(result_number, map(char_to_number, s))
s='1234'
print(custom_int(s))
print(type(custom_int(s)))

练习

1、利用map批量检测用户名是否符合规范

=> username符合规范, username不符合规范 

• 只能包含数据、字母、下划线，不以数字开头，长度在6-18之间
 filter把合法的用户名显示出来 

import re

lst = ["wy123456_789", "123", "wy#1234567", "123wyyyyyyyyyyy"]
def func01(x):
    if re.findall('^[a-zA-Z_]\w{5,17}$', x):
        return f"{x}符合规范"
    else:
        return f"{x}不符合规范"
result = map(func01, lst)
print(list(result))
# 结果：
['wy123456_789符合规范', '123不符合规范', 'wy#1234567不符合规范', '123wyyyyyyyyyyy不符合规范']

#filter把合法的用户名显示出来
print(list(filter(lambda x:re.findall('^[a-zA-Z_]\w{5,17}$', x),lst)))
#结果为 ['wy123456_789']

2、匿名函数+reduce实现 123*…*n 阶乘

#实现阶乘
from functools import reduce
n = int(input("输入"))
redu =reduce(lambda x,y:x*y,range(1,n+1))
print(redu)
#结果为 输入:4
#24

3、filter函数:找出[1-100]能被3整除的数

result = filter(lambda x: x%3==0, range(1,101))
print(list(result))

4、 map函数:求list[1-10]各项的平方

result = map(lambda x: x**2, range(1,11))
print(list(result))

5、将列表[1,4,5,9] 转换成 '1459’的字符串

a = [1,4,5,9]
b = "".join(map(str,a))
print(b)

6、有以下列表：list1=[7, -8, 5, 4, 0, -2, -5]

• 正数在前负数在后   0 4 5 7  -2 -5 -8
• 整数从小到大   
• 负数从大到小 

方法一：元组

list1 = [7, -8, 5, 4, 0, -2, -5]
list2 = sorted(list1,key=lambda x:(x<0, abs(x))) 
print(list2)
# [0, 4, 5, 7, -2, -5, -8]

方法二：过滤filter

list1 = [7, -8, 5, 4, 0, -2, -5]
list2 = filter(lambda x: x<0, list1)
list3 = filter(lambda x: x>=0, list1)
list = sorted(list3) + sorted(list2, reverse = True)
print(list) 

result=sorted(filter(lambda x:x>=0,list1))+sorted(filter(lambda x:x<0,list1),reverse=True)
print(result)

方法三：数学类方法

list1 = [7, -8, 5, 4, 0, -2, -5]
#7,15,5,4,0,9,12
print(sorted(list1, key = lambda x:max(list1) -x if x<0 else x))
#结果为 [0, 4, 5, 7, -2, -5, -8]

7、 字符串排序规则：小写<大写<奇数<偶数

• s = ‘asdf234GDSdsf23’
#排序:小写-大写-奇数-偶数
• 原理：先比较元组的第一个值，FALSE

# 这是一个字符串排序，排序规则：小写<大写<奇数<偶数
s = 'asdf234GDSdsf23'  # 注：后面的条件放前面筛选，True在后,False在前
s2 = "".join(sorted(s, key=lambda x: (x.isdigit(),x.isdigit() and int(x) % 2 == 0,x.isupper(),x)))
print(s2)       # 注：先判断是否是数字，判断是否偶数，判断是否大写
#对于a 返回(False,False,False,a)
#对于2 返回(True ,True ,False,2)
#对于G 返回(False,False,True ,G)
#对于3 返回(True ,False,False,3)
#结果为 addffssDGS33224