Python学习笔记（四）函数式编程

最新推荐文章于 2021-09-20 20:26:38 发布

hermanncain

最新推荐文章于 2021-09-20 20:26:38 发布

阅读量521

点赞数

分类专栏： Python 文章标签： python 函数式编程 map-reduce 闭包

本文链接：https://blog.csdn.net/hermanncain/article/details/50984966

版权

Python 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

函数式编程

高阶函数

将函数作为参数传入另一个函数

map/reduce

map

map(函数名,Iterable对象）将函数作用在Iterable对象的每一个元素，返回Iterator。Iterator是惰性的，因此如果要浏览结果需要list(map(…))转化。使用map而非for循环，代码逻辑更清晰，抽象程度更高，可读性强

reduce

结构和map相同，但它是把结果和迭代对象的下一个元素做累计计算，即reduce(f, [x1,x2,x3]) = f(f(x1,x2),x3)。对于形式较为简单的函数，可以使用lambda来简化代码，可以省去def f的部分（见练习3的解答）。

lambda函数是个好东西，C++11新标准也引入了lambda函数。

练习1：规范化英文名，将一个英文名List中的各个元素首字母大写其他字母小写

def normalize(name):
    return name.capitalize()#Python中有直接实现str规范化的函数

L = ['lia', 'wR', 'BAR', 'Ra']
print(list(map(normalize, L)))

练习2：求积

from functools import reduce

def prod(L):
    return reduce(lambda x, y: x*y, L)

print(prod([1,2,3,4]))

练习3：字符串转化为浮点数

from functools import reduce

def char2num(c):
    return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[c]

def str2float(s):
    s1,s2 = s.split('.')#Python提供str的split分割函数实现根据分隔符切片
    return reduce(lambda x,y: x*10+y, map(char2num, s1))+reduce(lambda x,y: x/10+y, map(char2num, s2[::-1]))/10

print(str2float('123.456'))

filter

filter()和map()类似，也将一个函数作用于一个序列，但会根据返回值剔除元素。同样地，filter也返回惰性序列，完成计算结果需要list(fitler())

使用埃氏筛选法构造素数生成器：

#先构造从3开始的奇数生成器
def _odd_iter():
    n = 1
    while True:
        n += 2
        yield n

#筛选函数
def _not_divisible(n):
    return lambda x: x%n>0

#构造素数生成器
def primes():
    yield 2
    it = _odd_iter() #从3开始的奇数序列
    while True:
        n = next(it) #序列的第一个数
        yield n
        it = filter(_not_divisible(n), it) #过滤掉n的倍数，剩下的数组成新的序列

#生成素数
for n in primes():
    if n < 1000:
        print(n)
    else:
        break

练习：回数生成器

def is_palindrome(n):
    return str(n) == str(n)[::-1] #[::-1]的使用获得了非常简洁的代码，一行搞定
output = filter(is_palindrome, range(1,1000))
print(list(output))

sorted

排序函数sorted(序列, key = 函数, reverse = False），将函数作用于序列之后，根据结果序列，从小到大重排序列。如果reverse = True则反向排列

返回函数

函数也可以作为返回值。

def f1(...):
    ...
    def f2():
        ...
    return f2

f = f1(...)
g = f2(...)

函数返回时并未执行，调用f()时才会计算结果，这样可以在需要计算的时候才计算结果，实现延迟计算。

f2作为f1的内部函数，可以引用外部函数f1的参数和局部变量。f1返回f2时，参数和变量都保存在f2中，这种结构成为闭包Closure。注意每次返回的f2虽然形式相同，即使参数相同也是不同的函数。以上的代码中f和g是不同的。

使用闭包要注意，返回函数不要饮用任何循环变量或者后续会发生变化的变量，否则因为函数返回时并未执行，计算结果都是根据变化变量最新的值计算。如果一定要用到的话，就要再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。这样程序嵌套就变多了，显得臃肿

匿名函数

lambda 变量：表达式实现匿名函数。可以用它赋值给变量来定义函数f = lambda ...，可以作为返回值，可以作为参数传入函数。不过表达式只能有一个，因此支持情形的比较简单

装饰器

使用装饰器可以在不修改函数定义的情况下给函数增加功能。比如下面这个装饰器让函数调用时先打印hello再执行函数：

def log(f):
    def wrapper(*args, **kw):
        print('hello')
        return f(*args, **kw)
    return wrapper

@log
def now():
    print('now')

now()

log(f)返回的是一个函数。
@log称为语法糖，出现在函数定义前相当于执行了语句f = log(f)，将函数重定向到log(f)，从而扩展了f的功能。
log中的wrapper引用了log中的变量，因此是个闭包。为什么使用闭包很多人表示疑惑，我也进行了自己的思考和查阅资料。如果不用闭包而使用以下形式：

def log(f):
    print('begin')
    f()
    print('end')
    return f

@log
def f1():
    ...

注意上面的代码log返回的是f本身，则第一次调用f1之后，执行完了log的内容，f1又变成了原来的f1，并不能起到扩展功能的装饰效果。使用闭包以后每次调用f1实际上都在调用wrapper，修饰的内容才算加上去了

还可以使用带参数的装饰器，则要采取以下的形式：

def log(arg):
    def dec(f):
        def wrap():
            ...
            return f
        return warp
    return dec

@log(a1)
def f1():
    ...

此时的log(a1)相当于f1 = log(a1)(f1)，log(a1)返回dec函数，因此相当于f1 = dec(f1)，不过a1作为参数已经传递进闭包了。

f.__name__可以拿到函数名字。但函数在经过修饰之后名字会变。对于依赖函数签名的代码则需要在构造装饰器的时候传入函数名。这时候需要使用functools模块（用法见下列代码）。这一节的练习题是编写一个既支持有参数（以字符串为例）装饰器又支持无参数装饰器，还是很有难度的，交作业的网友们没有一个的代码可以跑通，在网上搜相关的内容也没有可行的。对这道题我思考了很长的时间，这里给出两个版本的解法，第二版是更符合要求的，但第一版也贴出来进行一些辨析，以加深对装饰器的理解。

#版本1
import functools

def log(text = None):
    if isinstance(text, str): 
        @functools.wraps(text)
        def dec(f):
            def wrapper():
                print('begin')
                print('%s %s' %(text, f.__name__))            
                f()
                print('end')
                return f
            return wrapper
        return dec
    else:
        def d(f):
            def wrapper():
                print('begin')
                f()
                print('end')
                return f
            return wrapper
        return d

@log('excute')
def f2():
    print('f2 is running')

@log()    #这里不符合要求
def f1():
    print('f1 is running')

f1()
f1()
f2()
f2()

仔细一看修饰f1的时候log不是标准形式的无参@log，而是@log()。如果使用后者会报错，因为f1 = log()(f1)相当于f1 = d(f1)，而@log则是f1 = log(f1)，进入else之后变成了f1 = d，没有参数传入d了，因此会报错。显然这一版本是不太符合要求的。

#版本2
import functools

def log(text):
    if isinstance(text, str): 
        @functools.wraps(text)
        def dec(f):
            def wrapper():
                print('begin')
                print('%s %s' %(text, f.__name__))            
                f()
                print('end')
                return f
            return wrapper
        return dec
    else:
        def wrapper():
            print('begin')
            text()
            print('end')
            return text
        return wrapper

@log
def f1():
    print('f1 is running')

@log('excute')
def f2():
    print('f2 is running') 

f1()
f1()
f2()
f2()