python函数式编程

函数式编程

简介：一种编程范式

1. 把计算视为函数而非指令
2. 纯函数式编程：不需要变量，没有副作用，测试简单
3. 支持高阶函数，代码简单

高阶函数：

能接收函数做参数的函数

• 变量可以指向函数
• 函数的参数可以接收变量
• 一个函数可以接收另一个函数作为参数
• 能接收函数作为参数的函数被称为高阶函数

eg1：

def add(x,y,f):
   return f(x)+f(y)
print add(0,4,math.sqrt)    #注意不是math.sqrt()

eg2：

def format_name(s):
    return s[0].upper()+s[1:].lower()
print map(format_name, ['adam', 'LISA', 'barT'])

eg3:

def is_sqr(x):
    if int(math.sqrt(x)) == math.sqrt(x):
        return x
print filter(is_sqr, range(1, 101))

python 中返回函数（一个函数执行的结果是返回另一个函数）

eg:1

def calc_sum(lst):
    def lazy_sum():
        return sum(lst)
    return lazy_sum

使用f的时候并没有调用它(延迟求值)

>>> f = calc_sum([1, 2, 3, 4])
>>> f
0x1037bfaa0>   

>>> f()
10

eg2:

def calc_prod(lst): 
   def lazy_prod():
       def prod(x,y):
           return x*y
       return reduce(prod,lst)
   return lazy_prod

f = calc_prod([1, 2, 3, 4])
print f()

python闭包：

概念：内层函数引用了外层函数的变量（参数也算变量），然后返回内层函数的情况，称为闭包（Closure）。（如上calc_prod函数中，内部的reduce函数引用了 外部的lst变量）

闭包的特点是返回的函数还引用了外层函数的局部变量，所以，要正确使用闭包，就要确保引用的局部变量在函数返回后不能变。

eg1：

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())

结果不是1，4，9 而是9，9，9，因为return的时候fs里面三个函数都没有执行，参数都是i，在调用的时候才开始执行，而此时i已经变成的。因此，返回函数不要引用任何循环变量，或者后续会发生变化的变量。（take this sentence in mind）

**注意：**python函数加不加括号问题

1、不带括号时，调用的是这个函数本身 （比如上面函数式编程）
2、带括号（此时必须传入需要的参数），调用的是函数的return结果（加括号就是调用了）

python匿名函数：

利用lambda表达匿名返回值而不是return

def is_not_empty(s):
   return s and len(s.strip()) > 0

化简为：

print filter(lambda s: s and len(s.strip())>0, ['test', None, '', 'str', '  ', 'END'])

python装饰器decorator

接收 一个函数对其包装然后返回一个新函数，用于对原函数功能进行增加又不想修改原函数的代码

def f1(x):
    return x*2
def newf(f):
    def fn(x)：
        print('new functions')
        return f(x)
    return fn

使用方法

g1 = newf(f1)
print g1(5)
or
f1 = new_fn(f1)
print f1(5)

这样就彻底隐藏了f1函数

python内置的@语法用来简化装饰器的调用

@newf
def f1(x)
    return x*2

等价于

def f1(x):
    return x*2
f1 =newf(f1)

即把f1包含在了newf里面并返回一个函数名还是f1的新的函数，因而在调用f1时，原来的newf也同时被执行了。想想@log就能明白了，执行@log下面的函数时，log也被打印出来，而新函数的函数名还是@log下面的函数名

def log1(f):
      print("print log")
      return f
@log1
def d(x):
    print(x)

output

print log
1

把d(x)变成了

def d(x):
   print("print log")
   print(x)

装饰器模块后续更新：