函数式编程：

特点：允许传递的参数是函数，且允许返回一个函数。

由于Python允许使用变量，因此，Python不是纯函数式编程语言，同样的输入可能输出不同，有副作用。纯函数式编程语言没有变量，输入和输出是确定的，无副作用。

1.高阶函数（Higher-order function）：

特点：高阶函数可以接受另一个函数作为参数，还可以把函数作为结果值返回。

变量可以指向函数，函数名也是变量, 所以可以作为参数传入函数。

　　1.1 内置的函数：函数作为参数

　　　　1%. map(func, *iterables) 【映射】

     　　 2%. reduce(function, sequence, initial=None) 【累计】

　　# 将迭代器经函数的处理返回一个新的迭代器，是一种映射。　　list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))   # 返回 ['1', '2', '3', '4', '5', '6', '7', '8', '9']    #累计计算：把序列[1, 3, 5, 7, 9]变换成整数13579   from functools import reduce   def fn(x, y):       return x * 10 + y　 reduce(fn, [1, 3, 5, 7, 9])   # 13579      # map()和reduce()合用：str’13579‘ 转化为int:13579   def char2num(s):       return {
   '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]   reduce(fn, map(char2num, '13579')) # 整理为一个函数str2int，这些函数因为就一句也可以用匿名函数写   from functools import reduce   def str2int(s):       def fn(x, y):           return x * 10 + y       def char2num(s):           return {
   '0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]       return reduce(fn, map(char2num, s))

            # 实现筛选功能

　　　　3%. filter(function, iterable)   【返回值是True则保留】

# 迭代的值def _odd_iter():    n = 1    while True:        n = n + 2        yield ndef _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) # 构造新序列# 打印30以内的素数:for n in primes():  if n < 30:      print(n)  else:      break# 找到回数def is_palindrome(n):    start = 0    end = -1    while start < len(str(n))/2:        if str(n)[start] != str(n)[end]:            return False        else:            start += 1            end -= 1    return Trueoutput = filter(is_palindrome, range(100, 200))print(output)

           # 排序

           4%. sorted(iterable, key=None, reverse=False)

# 按照绝对值排序，key传入函数sorted([36, 5, -12, 9, -21], key=abs)# [5, 9, -12, -21, 36]# 忽略大小写反向排序sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True)['about', 'bob', 'Credit', 'Zoo']

2 返回函数

　　闭包：在函数内嵌套另一个函数，嵌套函数可以引用外部函数的参数和局部变量。而相关的参数和变量保存在返回函数。

# 结果都一样def count():    fs = []    for i in range(1, 4):        def f():             return i*i        fs.append(f)    return fsf1, f2, f3 = count()#一个函数可以返回一个计算结果，也可以返回一个函数。#返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。 # 结果1，2，3def 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 fsf1, f2, f3 = count()f1()# 2次结果的不同

 

3 匿名函数 （lambda 传入: 返回）

特点：

　　无名匿名函数,不必担心函数名冲突

应用场景：

　　1. 函数很小，一句话的事情

　　2. 使用函数变量调用函数时， 如在触发事件需要传入参数的时候

# 1把匿名函数赋值给一个变量，再利用变量来调用该函数： f = lambda x: x * x# 2把匿名函数作为返回值返回，比如：def build(x, y):    return lambda: x * x + y * y

 

4  装饰器

　　向一个现有的对象添加新的功能，同时又不改变其结构

　　使用场景：

• 参数检查（Agrument checking）
• 缓存（Caching）
• 代理（Proxy）
• 提供上下文（Context Provider）

　　

import functoolsdef 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('execute')def now():    print('2015-3-25')now()# 等价于now = log('execute')(now)

 

5 偏函数

       使用场景：当函数的参数个数太多，需要简化时

　　使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分默认参数。

　　通过设定参数的默认值，可以降低函数调用的难度

# 把一个函数的某些参数给固定住（也就是设置默认值）# 进行二进制的转换def int2(x, base=2):    return int(x, base)print('1000000 =', int2('1000000'))print('1010101 =', int2('1010101'))# 等价为import functoolsint2 = functools.partial(int, base=2)print('1000000 =', int2('1000000'))print('1010101 =', int2('1010101'))