Python学习笔记(三）函数式编程

最新推荐文章于 2020-05-27 10:55:48 发布

看那远处的行人

最新推荐文章于 2020-05-27 10:55:48 发布

阅读量163

点赞数 1

分类专栏：学习笔记文章标签： Python

本文链接：https://blog.csdn.net/MurphySecret/article/details/103010077

版权

学习笔记专栏收录该内容

23 篇文章 0 订阅

订阅专栏

高阶函数

map/reduce

Python内建了map()和reduce()函数。

map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。

还记得之前写的那个冒泡嘛，我们使用map函数试试：

L = [2, 4, 3, 1, 9, 5, 8, 6, 7, 12]


def test(l):
    if L[l] > L[l + 1]:
        a = L[l]
        L[l] = L[l+1]
        L[l + 1]=a
        
        
L2 = list(l for i in range(0, len(L) + 1) for l in range(0, len(L) - i - 1))


list(map(test,L2))
print(L)

再写一个：

L = [1, 2, 3, 4, 5]


def test(l):
    l = l + 1
    return l


L=list(map(test,L))
print(L)

我写这两个栗子时，发现如果map不放入list(),他就不会运行，所以list(map(函数,参数) 可能是它的固定式。&^%$&*粗浅的这么认为…

运行结果把L里的元素全部加了1

reduce()函数有两个参数，第一个参数是不会重置的，会一直计算直到list里所有元素都计算了，返回最终的值
先来个例子：

from functools import reduce

L = [1, 2, 3, 4, 5]


def test(x,y):
    return x + y


L=reduce(test,L)
print(L)

这个例子就是把所有元素累加起来
类似于sum(L)

filter

Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。

举个栗子：

在一个list中，删掉偶数，只保留奇数，可以这么写

def is_odd(n):
    return n % 2 == 1

L = list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
print(L

其实也可以用map，在函数里if判断，然后返回奇数。
这么简单的，就不说了。

sorted

Java里也有个sort快速排序。
sorted里放入list，默认从小到大排序
它还可以接收一个key函数来实现自定义的排序

sorted([36, 5, -12, 9, -21], key=abs)

得到绝对值从小到大：[5, 9, -12, -21, 36]
key也可以指定自定义的函数
例如：

def sortName(x):
    return x[1]

L =  [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]

L2 = sorted(L, key=sortName)

print(L2)

根据成绩默认从小到大
想要从大到小，把x[1]改成-x[1]
要想根据名字排序
改x[1]为x[0],正负同理

返回函数

顾名思义，就是把函数作为返回值

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

在这个例子中，我们在函数lazy_sum中又定义了函数sum，并且，内部函数sum可以引用外部函数lazy_sum的参数和局部变量，当lazy_sum返回函数sum时，相关参数和变量都保存在返回的函数中，这种称为“闭包（Closure）”的程序结构拥有极大的威力。

请再注意一点，当我们调用lazy_sum()时，每次调用都会返回一个新的函数，即使传入相同的参数，所以不会互相影响

闭包
当一个函数返回了一个函数后，其内部的局部变量还被新函数引用
可以理解为闭包就是：每次调用函数，都将相关的参数，局部变量保存在返回的函数里。
因为前面调用的函数不再用其他的参数和局部变量，他已经保存了一份它自己的了，所以后面调用不会影响前面调用的结果。
闭包的实现：
栗子1

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum

栗子2

def count():
    fs = []
    for i in range(1, 4):
        def f():
             return i*i
        fs.append(f)
    return fs

f1, f2, f3 = count()

这是个错误的闭包栗子，为什么呢？
因为我们每一次调用时，里面的for循环就脱缰跑完了，然后给我们返回了三个函数，然后就把最后返回的一个函数，作为最终结果了。

返回闭包时牢记一点：返回函数不要引用任何循环变量，或者后续会发生变化的变量。

那么一定要用循环变量，怎么修改呢？

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) 
    return fs

再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。

匿名函数

关键字lambda表示匿名函数，冒号前面的表示函数参数，后面的表示函数体。
举个栗子，简单的东西不多说

  f = lambda x: x * x  
  f(5) #结果为25

装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。
本质上，decorator就是一个返回函数的高阶函数。
装饰器写好后，我们可以粗鲁的理解为自定义注解

举个栗子：

def log(func):
    def wrapper(*args, **kw):
        print('调用了 %s' % func.__name__) #前面学的格式化，别忘了哦
        return func(*args, **kw) 
    return wrapper


@log
def now():
    print('2015-3-25')

这里的@log相当于执行了log(now)，得到是返回函数wrapper

我们可以粗鲁的理解这个逻辑就是：
妈妈：时刻准备作战…(@log 相当于调用log()函数，得到返回函数）
小明：我要开电视看（调用now()函数，触发装饰器）
妈妈(wrapper())：慢着！作业写完了吗（开始执行返回函数）
妈妈(wrapper())把作业检查了下，很满意的签好了名（运行返回函数的函数体）
妈妈(wrapper())：兔崽子做的不错，我给你开电视（return func(*args, **kw) 调用now函数）

添加装饰器A——A得到返回函数B——调用函数C——被A拦截，并执行B——B秀了波操作，再调用函数C

举个带参数的栗子：

def log(text):
    def decorator(func):
        def wrapper(*args, **kw):
            print('%s %s' % (text, func.__name__))
            return func(*args, **kw)
        return wrapper
    return decorator


@log('Hello')
def Murphy(x,y) :
    print('%s %s' % (x, y))
    

Murphy('I\'m','Winter')

这里的@log(‘Hello’)相当于执行了log(‘Hello’)(Murphy),得到的仍然是返回函数wrapper

wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。
(*args, **kw）就是被装饰的函数的参数
有参数和无参数差别就是多一层函数，这两种格式基本固定。

差点忘了说：
在Python中每个函数都有个__name__属性，就是函数名
可以测试一下

def demo():
    pass

print(demo.__name__)

所以我要说的是，被装饰器装饰后的函数，他的__name__属性都被变成了返回函数的属性，这怎么能行，咱又不叫修改器是吧。
为了解决这个问题，那我们就把返回函数的属性改成被装饰的函数的属性
Python内置的functools.wraps就是干这个事的

修改一下之前的代码：

def log(func):
    @functools.wraps(func) #在返回的函数上加了这一段，有参数的同理
    def wrapper(*args, **kw):
        print('调用了 %s' % func.__name__) #前面学的格式化，别忘了哦
        return func(*args, **kw) 
    return wrapper


@log
def now():
    print('2015-3-25')

偏函数

int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换：

int(‘12345’) #12345

但int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换：

int(‘12345’, base=8)#5349
int(‘12345’, 16)#74565

假设要转换大量的二进制字符串，每次都传入int(x, base=2)非常麻烦，于是，我们想到，可以定义一个int2()的函数，默认把base=2传进去：

def int2(x, base=2):
    return int(x, base)

这样，我们转换二进制就非常方便了：
int2(‘1000000’) #64
int2(‘1010101’) #85

functools.partial就是帮助我们创建一个偏函数的，不需要我们自己定义int2()，可以直接使用下面的代码创建一个新的函数int2：

int2 = functools.partial(int,base=2)

实际上固定了int()函数的关键字参数base，也就是：
int2(‘111’) = int(‘111’,base=2)

创建偏函数时，实际上可以接收函数对象、*args和**kw这3个参数
例如

max2 = functools.partial(max,10)

实际上是max2里有一个固定元素10，它也参与最大值的比较

max2 = functools.partial(max, 10)
print(max2(1, 2, 3, 4)) #打印10

看那远处的行人

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Python学习笔记(三）函数式编程

目录高阶函数map/reducefiltersorted返回函数高阶函数map/reducePython内建了map()和reduce()函数。map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。还记得之前写的那个冒泡嘛，我们使用map函数试试：L = [2, 4, 3, 1, 9, 5, 8...
复制链接

扫一扫