python函数式编程

把函数作为参数传入，这样的函数称为高阶函数函数式编程就是指这种高度抽象的编程方式

map

map可以接受俩个参数，一个函数一个Iterable，map将 传入的函数依次作用到序列的每个元素，并把结果作为新的Iterable返回。

eg:现在需要求一个数列内每个数的平方你可能会这么写

def  fun(x)
  return x*x;
L = []
for n in [1,2,3]:
  l.append(f(n))

这样当然可以，但是你并不能一眼看出把这个循环作用。但是你可以轻松读懂下方的含义。

r = map(f,[1,2,3])
list(r)
#[1,4,9]

很简单吧，事实上，map把运算规则抽象化了。

reduce

reduce是把一个函数作用在一个序列上 ，这个函数接受俩个参数，ruduce把结果继续和序列的下一个元素做积累计算。

reduce(f,[x1,x2,x3,x4]) = f(f(f(x1,x2),x3),x4)

如果你需要把一个数组转化为一个数字，这j就很简单了可以这么写

from functools import reduce
def fn(x,y):
  return x*10+y
reduce(fn,[1,3,4,2])

如果你需要把一个字符串 改写成一个数字那

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  strToNum(s):
  def fn(x,y):
    return x*10+y;
  def charToNum(s):
    return DIGITS(s)
  return reduce(fn,(map(charToNum,s)))

这样的写法不仅省去了许多不必要的代码，而且易读。

filter

filter与map相似，只不过是通过函数，返回bool值，确定保留还是丢弃该元素,或者说filter是一个筛选函数。

#保留奇数
def isOdd(x):
  return x%2 
list(filter(idOld,[1,2,3,4,5,6]))
#1,3,5

filter使用了惰性计算，只有在取filter结果的时候，才会筛选并返回下一个筛出的元素

sorted

排序函数

sorted[36,5,-12,9,-21]
[-21,-12,5,9,36]

可接受参数自定义排序如绝对值

sorted[36,5,-12,9,-21，key=abs]
[5,9,-12,-21,36]

可以传入第三个参数实现反向排序

sorted(['bob','about','Zoo','cid'],key = str.lower,reverse = Ture)
['Zoo','cid','bob','about']

返回函数

def lazySum(*args):
  def  sum:
    ax = 0;
    for n in args
      ax += n
    return ax
  return sum
f = lazySum(1,2,3,5,6)
f
#<function lazySum.<locals>.sum at 0x101c6ed90>
f()
#17

这种将相关参数和变量保存在返回的函数中方式也成为闭包(Closure)
不过请注意

f1 =  lazySum(1,2,3,5,6)
f2 =  lazySum(1,2,3,5,6)
f1 == f2
False

f1()和f2()的调用结果互不影响

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

f1,f2,f3=count()
f1()
#9
f2()
#9
f3()
#9

这个结果是因为f1,f2,f3分别对应得到f的三个元素，然而当函数执行的时候，i已经变为3
所以一般不要引用循环变量，如果必须这么办那就创建一个函数绑定当前的参数。

def coun():
  def fs(i):
    def g():
      return i*i
    return g;
  f = []
  for i in range(1,4):
    f.apend(fs(i))
  retuen f

ok,完美解决。

匿名函数lambda

lambda x: x*x
#等同于
def f(x)
  return x*x;

偏函数

import functools
int2  = functools.partial(int,base=2)
int2('10000000')
#64

等同于固定一个函数的某些参数
当函数参数太多需要简化时，使用functools.partial可以创建一个新的函数，这个新函数可以固定一部分参数，使调用时更简单。