Python函数式编程初级学习

函数式编程即函数可以作为参数传入函数，也可以返回函数。

1.高阶函数

    函数可以作为参数传入函数。

    def add(x,y,f):

        return f(x)+f(y)

    调用add函数add（3,-4,abs) ,结果为7

2.map/reduce

   def f(x):

       return x*x

    map(f,[1,2,3,4,5]) 返回的是一个Iterator，用list（）可以把它全部显示出来。map（）的作用即把f函数作用于第二个Iterable参数的每一个元素上。

    def add(x,y):

        return x+y

    reduce(add,[1,2,3,4,5])返回的同样也是一个Iterator。

    上一个语句就相当于add(add(add(add(1,2),3),4),5).所以reduce（）接收的第一个函数参数就只能是接收两个参数的函数。

map/reduce都是高阶函数

3.filter/sorted

   （1） 以输出素数为filter（）的例子

    ①初始数列直接考虑奇数列，除2之外偶数均非素数

        def _odd_iter():

          n=1
          while True:#这是一个生成器，所以不用担心没有退出条件的问题
             n=n+2
             yield n

    ②排除条件

        def _delete(n):

         return lambda x: x % n >0

 ③输出素数

   def primes():

           yield 2  #因为2不在初始奇数列中，所以先输出2
           it=_odd_iter()#初始数列
           while True:
              n=next(it) 
              yield n

              it = filter(_delete(n),it)  #filter（）将it中_delete（）作用后为False的                                                                                                     #元素都删除

    ④限定一个输出范围 否则将无限输出下去

        for n in primes():

       if n < 1000:
          print(n)
       else:
          break

（2）sorted()

    L=[('Bob',75),('Adam',92),('Bart',66),('Lisa',88)]

       def by_name(t):
           return t[0]
        L2=sorted(L,key=by_name) #类似map，key参数接收的函数也是作用于L的每一个元素

                                 #所以这里返回的就是Bob，Adam，Bart，Lisa，然后再对L的元素排序

                                 #key只是排序依据，不改变L
        print(L2)
      def by_score(t):
          return t[1]
       L3=sorted(L,key=by_score)
       print(L3)

Output:[('Adam', 92), ('Bart', 66), ('Bob', 75), ('Lisa', 88)]
       [('Bart', 66), ('Bob', 75), ('Lisa', 88), ('Adam', 92)]

对于str，sorted（）是按ASCII来排序的，所以大写会排在小写之前

L=['Credit','about','Zoey','Bart','effect']

print(sorted(L))

OUTPUT：['Bart', 'Credit', 'Zoey', 'about', 'effect']

print(sorted(L,reverse=True))  #reverse参数为反转

Output:['effect', 'about', 'Zoey', 'Credit', 'Bart']  

4.返回函数

    高阶函数不仅可以接收函数作为参数，还可以返回函数。

   当调用函数不需要立刻得到结果，而是想以后的需要的时候再计算结果，可以返回函数。

    def lazy_sum(*args):
    def sum():
        ax=0
        for n in args:
            ax=ax+n
        return ax
    return  sum

f=lazy_sum(1,2,3,4,5)

   当运行之后，lazy_sum返回一个sum函数，赋值给f，lazy_sum（）由args的传入的相关参数和变量也都保存在f中，但还未计算，等到调用时f会使用这些参数并计算。这种现象称为“闭包”。

   因为f是当调用时才计算结果

   def count():
     fs=[]
     for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
     return fs #因为fs.append(f)中f是一个函数，所以这里也有返回函数的意思
   f1,f2,f3=count()
   print(f1())#这里调用时,上面一句3个函数都已经返回了，此时的i已经变成3，所             
              #以接下来调用f2,f3，它们保存的参数i都为3,所以最后结果都是9

   print(f2())

   print(f3())

Output：9

        9

        9

所以返回函数时，返回函数里不要有可能会变化的变量。

5.匿名函数

   其实就是一个简易的函数定义式

   如def f(x):

        return x*x

 写成匿名函数就lambda x : x*x  #冒号左边的x是参数，右边是返回式

6.装饰器(Decorator)

   在运行代码期间动态增加功能，但又不改变函数原来的定义。

  import functools

   def log(func):
      @functools.wraps(func) #相当于wrapper.__name__=func.__name__,如果没有这一句，运行now.__name__就会得到wrapper，因为log返回的函数是wrapper
      def wrapper(*args,**kw):
          print('call %s():'%func.__name__) #打印日志
          return func(*args,**kw) #调用函数
      return  wrapper   #所以log(now)即返回wrapper函数,wrapper函数的功能就是先打印日志，再调用输入的函数
   @log
  def now():  #这两句相当于now=log(now)
    print('2016.8.10')
  print(now())

Output:

call now():
2016.8.10

7.偏函数

  import functools
   int2 =functools.partial(int,base=2) #把某个函数的某个参数设一个默认值，生成一个新的函数
   print(int2('100000'))

   print(int2('12345',base=8)) #这个新的函数任然是可以更改这个参数值的，只是它有一个默认的参数值

   Output:

        32 

        5349

其实就相当于

  def int2(x,base=2)

      return int(x,base)