【python学习】函数式编程和高阶函数 map filter reduce lambda表达式 sorted 闭包 装饰器

函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定的，输出就是确定的，这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函数是有副作用的。函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数。
高阶函数包括：map，reduce，filter, sorted
匿名函数lambda
装饰器

1 map

a1 =[1,2,3,4,5,6,7,8]
def my_add(ele):
    return ele * ele
res = map(my_add,a1)
res
1
2
3
4
5
6
7
8
9

L = map(str, [1,2,3,4,5,6,7,8,9])
print(list(L))
[11, 22, 33, 44]

1
2
3
4

平行的三个list也可以

def f3(x,y,z):
    return x+y + z
L = map(f3,[1,2,3,4],[10,20,30,40],[5,6,7,8])
list(L)
1
2
3
4

2.reduce

reduce 的功能有点奇怪，其实他不是用来计算求和的，求和有点大材小用

from functools import reduce
def add(x,y):
    return x+y

sum =  reduce(add,[1,3,5,7,9])
sum
1
2
3
4
5
6

25

def fn(x,y):
    return x*10 + y
a = reduce(fn,[1,3,5,7,9])
print("reduce 执行结果:",a)
reduce 执行结果: 13579

1
2
3
4
5
6

3 filter

def is_odd(n):
    return n % 2 == 1
L = filter(is_odd,[1,2,3,4,5,6,7,8,9,10])
print(list(L))
[1, 3, 5, 7, 9]

1
2
3
4
5
6

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

L = filter(not_empty,['A','','B',None,'C',' '])
print(list(L))
1
2
3
4
5

4 sorted

sorter1 = sorted([1,3,6,-20,34])
print('升序排列:',sorter1)
升序排列: [-20, 1, 3, 6, 34]

1
2
3
4

sorter2 = sorted([1,3,6,-20,-70],key=abs,reverse=True)
print("自定义反向排序：",sorter2)
自定义反向排序： [-70, -20, 6, 3, 1]
1
2
3

# 4.2 字符串排序依照 ASCII
sorter3 = sorted(["ABC","abc","D","d"])
print("字符串排序：",sorter3)
1
2
3

字符串排序： [‘ABC’, ‘D’, ‘abc’, ‘d’]

# 4,3 忽略大小写排序
sorter3 = sorted(["ABC","abc","D","d"],key=str.lower)
print("字符串排序：",sorter3)
1
2
3

字符串排序： [‘ABC’, ‘abc’, ‘D’, ‘d’]

# 4.4 忽略大小写的字符串反向排序
sorter3 = sorted(["ABC","abc","D","d"],key=str.lower,reverse=True)
print("忽略大小写排序反向字符串排序：",sorter3)
1
2
3

5 lambda

f = lambda a,b,c:a + b +c
print("2+3+4 的结果:", f(2,3,4))
2+3+4 的结果: 9
1
2
3

L=map(lambda x:x*x,[1,2,3,4,5,6,7,8,9])
for x in L:
    print(x)
1
2
3

6 sorted的进阶

class Student:
    def __init__(self, age,name) -> None:
        self.name = name
        self.age = age

stu1 = Student(11,'aaa')
stu2 = Student(21,'ccc')
stu3 = Student(31,'ddd')

student_list = sorted([stu1,stu2,stu3],key=lambda x:x.age)
for stu in student_list:
    print('name:',stu.name,"age:",stu.age)
name: aaa age: 11
name: ccc age: 21
name: ddd age: 31
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

student_list = sorted([stu1,stu2,stu3],key=lambda x:x.age,reverse=True)
for stu in student_list:
    print('name:',stu.name,"age:",stu.age)
name: ddd age: 31
name: ccc age: 21
name: aaa age: 11
1
2
3
4
5
6

闭包

在 Python 语言中，闭包意味着要有嵌套定义，内部函数使用外部函数中定义的变量，外部函数返回内部函数名。如果调用一个函数 A，这个函数 A 返回一个函数 B，这个返回的函数 B 就叫作闭包

def func_out(num1):
    def func_in(num2):
        return num1 + num2
    return func_in

f = func_out(10)
result = f(10)
print("结果:",result)
1
2
3
4
5
6
7
8

结果: 20

装饰器

给fun1，fun2 增加写日志的功能，进出函数都要写下来，利用闭包的方式，可以不侵入原来的方法，即可完成。

import time
def writeLog(func):
    try:
        f = open("log.txt",'a')
        f.write(func.__name__)
        f.write('\t')
        f.write(time.asctime())
        f.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        f.close()
        
def fun1():

    print('功能 1')
def fun2():
    print('功能 2')
    
#不修改源代码的基础上，添加日志功能
def func_out(func):
    def func_in():
        #调用添加日志功能的方法
        writeLog(func)
        func()
    return func_in
fun_in1=func_out(fun1)
fun_in1()
fun_in2=func_out(fun2)
fun_in2()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

装饰器，更方便，就是一个语法糖 @xxx 就是 fun_in1=func_out(fun1)

import time
def writeLog(func):
    try:
        f = open("log.txt",'a')
        f.write(func.__name__)
        f.write('\t')
        f.write(time.asctime())
        f.write('\n')
    except Exception as e:
        print(e.args)
    finally:
        f.close()
 #不修改源代码的基础上，添加日志功能
def func_out(func):
    def func_in():
        #调用添加日志功能的方法
        writeLog(func)
        func()
    return func_in
 @func_out       
 ’def fun1():

    print('功能 1')
@func_out
def fun2():
    print('功能 2')
    
fun1()
fun2()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29