python3入门笔记四之函数式编程—高阶函数，返回函数，匿名函数，装饰器，偏函数

这是我参与更文挑战的第22天，活动详情查看： 更文挑战

函数式编程

函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！
Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言

高阶函数（Higher-order function）

特点：

1. 变量可以指向函数 即 函数本身也可以赋值给变量 x=abs x(-10) #10

2. 函数名也是变量 abs = 10 abs(-10) # TypeError: 'int' object is not callable

   注：由于abs函数实际上是定义在import builtins模块中的，所以要让修改abs变量的指向在其它模块也生效，要用import builtins; builtins.abs = 10

3. 传入函数

   既然变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数

   def add(x, y, f):
       return f(x) + f(y)
   print(add(-5, 6, abs))    
   # 11   
   复制代码

map/reduce，filter,sorted

map/reduce的概念： Google论文“MapReduce: Simplified Data Processing on Large Clusters”

这四个用法同es6.

1. map()函数接收两个参数，一个是函数，一个是Iterable 返回一个Iterator

   def f(x):
       return x**2
   a=map(f,[x for x in range(10)])
   print(next(a)) # 0
   print(list(a)) # [1, 4, 9, 16, 25, 36, 49, 64, 81]
   复制代码

   把这个list所有数字转为字符串：

   print(list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))) 
   # ['1', '2', '3', '4', '5', '6', '7', '8', '9']
   复制代码

2. reduce() 把结果继续和序列的下一个元素做累积计算:reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
   序列[1, 3, 5, 7, 9]变换成整数13579：

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

   str转换为int：

   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):
       return reduce(lambda x, y: x * 10 + y, map(char2num, s))
   print(str2int('0123456789'))     # 123456789
   复制代码

3. filter() 接收一个函数和一个序列 ，返回的是一个Iterator
   过滤出符合条件的数

   def is_odd(n):
   return n % 2 == 1
   list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]))
   复制代码

4. sorted() 接收一个序列和一个函数 sorted([36, 5, -12, 9, -21])
   按绝对值大小排序：

   sorted([36, 5, -12, 9, -21], key=abs)
   # [5, 9, -12, -21, 36]
   复制代码

   要进行反向排序，不必改动key函数，可以传入第三个参数reverse=True：

   L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)]
   def by_name(t):
       return t[0]
   L2 = sorted(L, key=by_name,reverse=True)
   print(L2)    
   复制代码

返回函数

函数作为返回值

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。

可变参数的求和(立刻返回计算结果):

def calc_sum(*args):
    ax = 0
    for n in args:
        ax = ax + n
    return ax
复制代码

返回求和的函数：

def lazy_sum(*args):
    def sum():
        ax = 0
        for n in args:
            ax = ax + n
        return ax
    return sum
f = lazy_sum(1, 3, 5, 7, 9)
f() #25
复制代码

闭包（注意！）

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

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

f1, f2, f3 = count() 
# f1() 9
# f2() 9
# f3() 9
# 全部都是9！原因就在于返回的函数引用了变量i，但它并非立刻执行。等到3个函数都返回时，它们所引用的变量i已经变成了3，因此最终结果为9。
复制代码

def count():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i)) # f(i)立刻被执行，因此i的当前值被传入f()
    return fs
for fn in count():
    print(fn())
# 1 4 9
复制代码

匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。
匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果
list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]))

lambda x: x * x  #等于
def f(x):
    return x * x
复制代码

用匿名函数有个好处，因为函数没有名字，不必担心函数名冲突。此外，匿名函数也是一个函数对象，也可以把匿名函数赋值给一个变量，再利用变量来调用该函数：

# 把匿名函数赋值给一个变量，再利用变量来调用该函数
f = lambda x: x * x
f(5)
#25
# 匿名函数作为返回值返回
def build(x, y):
    return lambda: x * x + y * y
复制代码

装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）
本质上，decorator就是一个返回函数的高阶函数

看看下面的代码，瞬间明白这个不就是Spring 的 aop思想吗，感觉像java的注解

@log
def now(a,b,*,age):
    print('2015-3-25')

def log(func):
    def wrapper(*args, **kw):
        print('call %s():' % func.__name__) # __name__获取函数对象的名字
        print( args)
        print( kw)
        return func(*args, **kw)
    return wrapper

now('1','1',age=12)
# call now():
# ('1', '1')
# {'age': 12}
# 2015-3-25
复制代码

把@log放到now()函数的定义处，相当于执行了语句：
now = log(now)
wrapper()函数的参数定义是(*args, **kw)，因此，wrapper()函数可以接受任意参数的调用。在wrapper()函数内，首先打印日志，再紧接着调用原始函数。

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('execute')
def now():
    print('2015-3-25')
    
now()
# execute now():
# 2015-3-25
复制代码

剖析： now = log(‘execute’)(now)
首先执行log(‘execute’)，返回的是decorator函数，再调用返回的函数，参数是now函数，返回值最终是wrapper函数。
函数也是对象，它有__name__等属性
所以最后会出现 now.__name__ #'wrapper' 的情况
这样子会导致有些依赖函数签名的代码执行错误

但是Python内置的functools.wraps 就是用来 把原始函数的__name__等属性复制到对应的函数中
如：

@functools.wraps(func)
    def wrapper(*args, **kw):
复制代码

修改后运行now.__name__ 。结果为 #now

偏函数

偏函数是参数固定的函数，即有默认值的函数

Python的functools模块提供了很多有用的功能，其中一个就是偏函数（Partial function）,

functools.partial就是帮助我们创建一个偏函数的，
它可以帮我们固定函数的参数，返回一个新的函数
可以接收函数对象、*args和**kw这3个参数

如 int 函数

import functools
int2 = functools.partial(int, base=2)
int2('1000000')
# 64
复制代码

如 max函数

import functools
# 实际上会把10作为*args的一部分自动加到左边 √ （廖老师的课程真给力 ☆(￣▽￣)/$:*）
max2 = functools.partial(max, 10)
max2(5, 6, 7)
# 10
复制代码

最后

欢迎小伙伴们来一起探讨问题~

如果你觉得本篇文章还不错的话，那拜托再点点赞支持一下呀?

让我们开始这一场意外的相遇吧！~

欢迎留言！谢谢支持！ヾ(≧▽≦*)o 冲冲冲！！

我是4ye 咱们下期应该……很快再见！！ ?