美文网首页python3学习
Python3(5) Python 函数式编程

Python3(5) Python 函数式编程

作者: 猿来如痴 | 来源:发表于2018-01-23 11:37 被阅读294次

    本系列主要学习Python的基本使用和语法知识,后续可能会围绕着AI学习展开。
    Python3 (1) Python语言的简介
    Python3 (2) Python语法基础
    Python3 (3) Python函数
    Python3 (4) Python高级特性
    Python3(5) Python 函数式编程
    Python支持函数式编程,允许把函数本身作为参数传入另一个函数,还允许返回一个函数!

    高阶函数

    对于一直在java中学习的人来说,高阶函数还是一个陌生、高大上的名词,它有三个特点:

    • 变量可以指向函数
    • 函数名也是变量
    • 函数可以作为参数传入

    所以高阶函数的定义:把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式。

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    def add(x, y, f):
        return f(x) + f(y)
    
    print('|x|+|y| = ',add(-5, 6, abs))
    

    输出结果:

    |x|+|y| =  11
    

    几个内置高阶函数

    map/reduce

    首先声明map函数与java中的map是两个名词,没有关联。map高阶函数的定义:map()函数接收两个参数,一个是函数,一个是Iterable,map将传入的函数依次作用到序列的每个元素,并把结果作为新的Iterator返回。

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    L = list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
    print(L)
    

    输出结果:

    ['1', '2', '3', '4', '5', '6', '7', '8', '9']
    

    将list中的元素转换成字符串。

    reduce把一个函数作用在一个序列[x1, x2, x3, ...]上,这个函数必须接收两个参数,reduce把结果继续和序列的下一个元素做累积计算。reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    from functools import reduce
    def fn(x,y):
        return x*10+y
    
    L = reduce(fn, [1,2,3,4,5])
    
    print(L)
    

    输出结果:

    12345
    

    用list 实现一个按list序列生成一个整数,它的结果就是一个最终的数。

    使用map 和 reduce 写一个字符串转整数的函数、字符串转浮点数的函数:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    from functools import reduce
    DIGITS = {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}
    def char2num(s):
        return DIGITS[s]
    def str2int(s):
        def fn(x, y):
            return x * 10 + y
        return reduce(fn, map(char2num, s))
    def str2float(s):
        n = s.index('.')
        return reduce(lambda x,y:x*10+y,map(char2num,s[:n]+s[n+1:]))/10**n
    
    print(str2int('10001'))
    print(str2float('10001.0001'))
    
    

    输出结果:

    10001
    1000.10001
    

    filter

    用于过滤序列,filter 与map定义的格式相同,参数接受一个函数,一个序列,返回一个Iterator。filter通过判断函数的返回值是否为True来丢弃一些元素。

    filter的主要应用是实现一个筛选函数:我们来实现一个素数的序列

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    def _odd_iter():
        n = 1
        while True:
            n = n + 2
            yield n
    
    def _not_divisible(n):
        return lambda x: x % n > 0
    
    def primes():
        yield 2
        it = _odd_iter() # 初始序列
        while True:
            n = next(it) # 返回序列的第一个数
            yield n
            it = filter(_not_divisible(n), it) # 构造新序列
    
    # 打印1000以内的素数:
    for n in primes():
        if n < 20:
            print(n)
        else:
            break
    

    输出结果:

    2
    3
    5
    7
    11
    13
    17
    19
    

    实现原理,依次将3,5,7,9... 的倍数筛选完,最终剩下的为素数。
    练习一个回数的筛选:从左向右读和从右向左读都是一样的数

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    def is_palindrome(n):
       return str(n) == str(n)[::-1]
    # 测试:
    output = filter(is_palindrome, range(1, 200))
    print('1~200:', list(output))
    

    输出结果:

    1~200: [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191]
    

    sorted

    sorted 排序高阶函数,它的使用非常灵活,可以传入自定义的排序函数、反向排序,在复杂的排序中核心代码还是非常的简洁。

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    L = [3,1,-5,-2,9]
    #普通的用法
    print(sorted(L))
    #反向排序
    print(sorted(L,reverse=True))
    K = ['Apple','banana','Pear','tomato']
    print(sorted(K))
    #忽略大小写
    print(sorted(K,key=str.lower))
    #反向排序
    print(sorted(K,key=str.lower,reverse=True))
    

    输出结果:

    [-5, -2, 1, 3, 9]
    [9, 3, 1, -2, -5]
    ['Apple', 'Pear', 'banana', 'tomato']
    ['Apple', 'banana', 'Pear', 'tomato']
    ['tomato', 'Pear', 'banana', 'Apple']
    

    返回函数

    高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回,我们来聊一聊返回函数的问题。
    当我们调用一个函数时,不需要立即得到结果,想在需要的时候再进行计算,那么我们就可以返回一个函数而不是直接一个结果。

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    
    def laz_count(*args):
    
        def count():
            ax = 0
            for n in args:
                ax = ax + n*n
            return ax
        return count
    
    f1 = laz_count(1, 2, 3, 4, 5,6)
    f2 = laz_count(1, 2, 3, 4, 5,6)
    print(f1())
    print(f1==f2)
    

    输出结果:

    91
    False
    

    从上面可以看出,函数返回值也是一个函数,需要再次调用才能得出结果,并且每次返回的都是一个新的函数。

    闭包

    闭包的定义与java中的内部类有些相似,闭包指的是函数再定义函数的情况,即:内部函数可以外部函数的参数和局部变量,当外部函数返回内部函数时,相关的参数和变量都保存在返回的函数中。这种行为称之为 “闭包”。

    # -*- coding: utf-8 -*-
    def count():
        fs = []
        for i in range(1,4):
            def f():
                return i*i
            fs.append(f)
        return fs
    f1, f2, f3 = count()
    
    print(f1(),f2(),f3())
    
    def count():
        fs = []
        for i in range(1, 4):
            def f(i):
                def g():
                    return i * i
                return g
            # f(i)立刻被执行,因此i的当前值被传入f()
            fs.append(f(i))
        return fs
    f1, f2, f3 = count()
    

    输出结果:

    9 9 9
    1 4 9
    

    由于返回的函数不是立即执行,在调用执行时,i变量已经成为3,如果要输出想要的值,需要再创建一个函数将变量i 与函数绑定。

    匿名函数

    匿名函数其实就是lambda 表达式的使用,lambda表达式的使用场景就是匿名函数,与java 的匿名类很相似。

    • 关键字lambda表示匿名函数,冒号前面的x表示函数参数
    • 匿名函数有个限制,就是只能有一个表达式,表达式的值就是返回值,不需要return
    • 匿名函数也可以作为函数的返回值返回
    # -*- coding: utf-8 -*-
    L = list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
    print(L)
    
    def f(x,y):
        return lambda :x*x+y*y
    x = f(2,3)
    print(x())
    

    输出结果:

    [1, 4, 9, 16, 25, 36, 49, 64, 81]
    13
    

    装饰器

    可以在这代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)。decorator就是一个返回函数的高阶函数。装饰器在java中成为装饰者模式,需要通过继承,组合来实现,python中在函数层面就可以实现。这就是python 的强大之处

    下面我们来通过示例学习,decorator的用法:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    def log(func):
        def wrapper(*args, **kw):
            print('call %s():' % func.__name__)
            return func(*args, **kw)
        return wrapper
    
    @log
    def now(x,y):
        print('2018-1-1',x,y)
    
    now(5,6)
    print(now.__name__)
    
    def now(x,y):
        print('2018-1-1',x,y)
    
    f =log(now)
    f(1,2)
    print(now.__name__)
    

    输出结果:

    call now():
    2018-1-1 5 6
    wrapper
    call now():
    2018-1-1 1 2
    now
    

    第一 我们定义了一个在函数调用开始前输出函数名的decorator
    第二 在使用装饰器时可以通过@decorator的方式注解也可以通过传入函数的方式
    第三 在使用@decorator的方式装饰器后,函数的__name__变成了 wrapper 这样显然是不合理的,我们目的是为了扩展函数的功能,不是改变函数的签名,所以python 中 内置了functools.wraps来还原函数的签名,具体如下:

    def log(text):
        def decorator(func):
            @functools.wraps(func)
            def wrapper(*args, **kw):
                print('%s %s():' % (text, func.__name__))
                return func(*args, **kw)
            return wrapper
        return decorator
    
    @log('123')
    def now(x,y):
        print('2018-1-1',x,y)
    
    now(5,6)
    print(now.__name__)
    
    def now(x,y):
        print('2018-1-1',x,y)
    
    f =log('456')(now)
    f(1,2)
    print(now.__name__)
    

    输出结果:

    123 now():
    2018-1-1 5 6
    now
    456 now():
    2018-1-1 1 2
    now
    

    这个示例中我们验证了@functools.wraps(func)的用法,并且多层嵌套自定义log输出的字段。
    下面做一个函数执行时间的练习:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import functools
    import time
    
    def metric(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kw):
            start = time.time()
            result = fn(*args, **kw)
            end = time.time()
            print('%s 执行时间 %.2fs ms' % (fn.__name__, (end - start) * 1000))
            return result
        return wrapper
    
    # 测试
    @metric
    def fast(x, y):
        time.sleep(0.0012)
        return x + y;
    
    @metric
    def slow(x, y, z):
        time.sleep(0.1234)
        return x * y * z;
    
    f = fast(11, 22)
    s = slow(11, 22, 33)
    if f != 33:
        print('测试失败!')
    elif s != 7986:
        print('测试失败!')
    

    输出结果:

    fast 执行时间 2.00s ms
    slow 执行时间 124.60s ms
    

    偏函数

    通过传入函数,和对应的规则,生成一个新的函数,方便调用 的方式成为偏函数partial

    偏函数的使用:

    #!/usr/bin/env python3
    # -*- coding: utf-8 -*-
    import functools
    
    def int2(x, base=2):
        return int(x, base)
    
    print(int2('1111'))
    
    int2 = functools.partial(int, base=2)
    
    print(int2('1111'))
    

    输出结果:

    15
    15
    

    创建偏函数时,实际上可以接收函数对象、args和*kw这3个参数,偏函数是 functools 模块中提供的一种固定某些参数来简化一些函数的调用难度的作用。

    参考

    https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/0014317848428125ae6aa24068b4c50a7e71501ab275d52000

    相关文章

      网友评论

        本文标题:Python3(5) Python 函数式编程

        本文链接:https://www.haomeiwen.com/subject/vfgooxtx.html