Python函数式编程（高阶函数 <map/reduce filter sorted> 返回函数 匿名函数 装饰器 偏函数）

函数式编程

将业务逻辑细化，抽象，封装成一个个功能函数，并借助语言自带的高阶函数api，将整个业务流程转化为函数之间的相互调用，这就是函数式编程。
对比：将业务逻辑细化，抽象，封装成一个个对象，并借助语言，库，组件，框架等，将整个业务流程转化为对象之间的相互调用，这就是面向对象编程。

1. 函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，还允许返回一个函数！

2. Python对函数式编程提供部分支持。由于Python允许使用变量，因此，Python不是纯函数式编程语言。

高阶函数

把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式。变量可以指向函数，函数名也是变量，函数名其实就是指向函数的变量！

map/reduce

1. map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数（只写函数名即可）依次作用到序列的每个元素，并把结果作为新的Iterator返回。map(函数，Iterable)
   reduce把一个函数作用在一个序列[x1, x2, x3, …]上，这个函数必须接收两个参数，一个是函数，一个是序列。reduce把结果继续和序列的下一个元素计算。使用reduce记得导包。reduce(函数，序列)

练习代码：

map() //对数据执行分批并行操作
reduce() //对操作所有返回值求结果

#str转换为int的函数
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]
def str2int(s):
    return reduce(lambda x,y:x*10+y,map(char2num,s))
print(str2int('13579'))

#上面的return {'0':0,'1':1,'2':2,'3':3,'4':4,'5':5,'6':6,'7':7,'8':8,'9':9}[s]也就是说,可以把{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}看成是一个字典，s是key，函数通过s参数查找字典中的key，进而获取value，返回value的值。

利用map()函数，把用户输入的不规范的英文名字，变为首字母大写，其他小写的规范名字。
# 输入：['adam', 'LISA', 'barT']，输出：['Adam', 'Lisa', 'Bart']

def normalize(name):
    return name[0].upper() + name.lower()[1:]
for n in map(normalize,['adam', 'LISA', 'barT']):  #iterator输出需要借助for循环
    print(n)

#请编写一个prod()函数，可以接受一个list并利用reduce()求积
from functools import reduce

def fun(x,y):
    return x*y #计算方法
def prod(L):
    return reduce(fun, L) #reduce(lambda x,y:x*y,L)
list = [1,3,5]
print(prod(list))

 #str转换为int的函数
from functools import reduce
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]
 # 也就是说,可以把{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}看成是一个字典，
 # s是key，函数通过s参数查找字典中的key，进而获取value，返回value的值。
def str2int(s):
    return reduce(lambda x,y:x*10+y,map(char2num,s))
print(str2int('13579'))

# 利用map和reduce编写一个str2float函数，把字符串'123.456'转换成浮点数123.456：
from functools import reduce

def str2flost(s):
    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(lambda x,y:x*10+y,map(char2num, s.split('.')[0]))
                 + reduce(lambda x,y:x*10+y, map(char2num, s.split('.')[1])) / 10 ** len(s.split('.')[1]))
print(str2flost('123.456'))

'''
s.split('.')[0] -> 以'.'为分隔符,并取序列为0的项。

10 ** len(s.split('.')[1] ->由于后面拼接的小数部分，所以需要除以（10的小数位数的次方）
'''

filter（筛选器）

Python内建的filter()函数用于过滤序列。

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

2. filter（函数，序列） ->不满足函数方法的序列（函数返回False）会被删除，满足的（True）将会保留。

3. filter()函数返回的是一个Iterator，也就是一个惰性序列，所以要强迫filter()完成计算结果，需要用list()函数获得所有结果并返回list。

#用filter求素数
def _odd_iter(): #奇数生成器
    n = 1
    while True:
        n = n + 2
        yield n

def _not_divisible(n): #筛选函数,不能被1,3,5，...整除
    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 < 1000:
        print(n)
    else:
        break

1. filter()的作用是从一个序列中筛出符合条件的元素。由于filter()使用了惰性计算，所以只有在取filter()结果的时候，才会真正筛选并每次返回下一个筛出的元素。

#回数是指从左向右读和从右向左读都是一样的数，例如12321，909。请利用filter()滤掉非回数:
# -*- coding: utf-8 -*-
is_palindrome = lambda num: str(num) == str(num)[::-1] #步长为-1则从右往左第1个（最右一个为-1）开始

# 测试:
output = filter(is_palindrome, range(1, 1000))
print(list(output))

sorted

Python内置的sorted()函数就可以对list进行排序。用sorted()排序的关键在于实现一个映射函数。

1. sorted()函数也是一个高阶函数，它可以接收一个key函数来实现自定义的排序，key指定的函数将作用于list的每一个元素上，并根据key函数返回的结果进行排序。

2. 默认情况下，对字符串排序，是按照ASCII的大小比较的。

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

#请用sorted()对L列表分别按名字排序
L = [('Bob', 75), ('Adam', 92), ('Bart', 66), ('Lisa', 88)] #并非键值对
'''
def by_name(L):
    return L[0]
print(sorted(L,key=by_name)) #注意key=函数名，而不是调用函数：TypeError: 'tuple' object is not callable
'''
#lambda
print(sorted(L,key = lambda x:x[0]))

#按成绩排序
print(sorted(L,key=lambda x:x[1],reverse =True))#第三个参数实现反向排序，注意要写在sorted方法里

返回函数

高阶函数除了可以接受函数作为参数外，还可以把函数作为结果值返回。一个函数可以返回一个计算结果，也可以返回一个函数。返回一个函数时，牢记该函数并未执行，返回函数中不要引用任何可能会变化的变量。

1. 当一个函数返回了一个函数后，其内部的局部变量还被新函数引用。

2. 返回的函数并没有立刻执行，而是直到调用了f()才执行。（f=外部函数）

3. 闭包：引用了自由变量的函数。

4. 返回闭包时牢记的一点就是：返回函数不要引用任何循环变量，或者后续会发生变化的变量。如果一定要引用循环变量怎么办？方法是再创建一个函数，用该函数的参数绑定循环变量当前的值，无论该循环变量后续如何更改，已绑定到函数参数的值不变。可利用lambda缩短代码。

def build(x, y):  #传入参数
    return lambda: x * x + y * y
f =build(1,2) #不会直接出结果
print(f())

匿名函数

关键字lambda表示匿名函数，冒号前面的x表示函数参数。

1. 匿名函数有个限制，就是只能有一个表达式，不用写return，返回值就是该表达式的结果。

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

3. 同样，也可以把匿名函数作为返回值返回。如：

def build(x, y):
    return lambda: x * x + y * y #参数(x,y)在函数中传入
f =build(1,2)
print(f())

1. Python对匿名函数的支持有限，只有一些简单的情况下可以使用匿名函数。

装饰器

在代码运行期间动态增加功能的方式，称之为“装饰器”（Decorator）。

1. 函数对象有一个name属性，可以拿到函数的名字。

2. 在面向对象（OOP）的设计模式中，decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现，而Python除了能支持OOP的decorator外，直接从语法层次支持decorator。Python的decorator可以用函数实现，也可以用类实现。

3. 本质上，decorator就是一个返回函数的高阶函数。

#请编写一个decorator，能在函数调用的前后打印出'begin call'和'end call'的日志。
import functools

def log(text):
    def decorator(func):
        @functools.wraps(func)  #wrapper.__name__ = func.__name__
        def wrapper(*args, **kw):
            print(text)
            print('begin call')
            func(*args,**kw)
            print('end call')
        return wrapper #只返回函数名
    return decorator
@log("excute")
def now():
    print("2015-02-56")
now()

不是很理解，以后再补充。

偏函数

偏函数和数学意义上的偏函数不一样，偏函数通过设定参数的默认值，可以降低函数调用的难度。

1. functools.partial就是帮助我们创建一个偏函数的，简单总结functools.partial的作用就是，把一个函数的某些参数给固定住（也就是设置默认值），返回一个新的函数，调用这个新函数会更简单。

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

3. 当函数的参数个数太多，需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定住原函数的部分参数，从而在调用时更简单。

#int()函数可以把字符串转换为整数，当仅传入字符串时，int()函数默认按十进制转换；
#int()函数还提供额外的base参数，默认值为10。如果传入base参数，就可以做N进制的转换

import functools

int2 = functools.partial(int,base =2) #将二进制转换为十进制
print(int2('1000'))

学习网站:www.liaoxuefeng.com