Python 函数式编程 高阶函数

Python 函数式编程可以理解为一半函数，一半Python 。基于lambda演算的一种编程方式

lambda表达式：相当于Python的匿名函数，它可以最大复用代码。

           它不是一个代码块，仅仅是一个表达式，可以有参数，多个也行。

lambda表达式用法：

stm = lambda x,y,z:x+y*10+z*20
print stm(1,2,3)

高阶函数：把函数作为参数使用的函数

变量是可以赋值的。

def funA():
    print("aaa")
print funA
funB = funA
print funB()
print funA()

运行结果

aaa
aaa

说明funA是一个变量。funA与funB只是名称不同，函数名称是变量，则可以被当做参数传入另一个函数

def funA(n):
    return  n * 100
def funB(n):
    return funA(n) * 3
print funB(9)

def funC(n,f):
    return f(n) * 3
print(funC(9,funA) )

结果是一样的。高阶函数比较灵活，如果我们现在要扩大600倍，funB写死了。

系统高阶函数----map

类似于映射，即把集合或者列表的元素，按照一定的规则进行操作，生成一个新的列表或者集合。map函数返回值是一个迭代对象。

l1 =[i for i in range(10)]
print l1
l2 = []
for i in l1:
    l2.append(i*10)
print l2

def f(n):
    return n*10
l3 = map(f,l1)
print (type(l3))
print l3

reduce 把一个可迭代对象最后归并与一个结果，必须有两个参数，必须有一个返回结果，需要导入functools包

from functools import reduce
def myadd(x,y):
    return x+y
print(reduce(myadd,[1,2,3,4,5]))

filter函数：过滤函数 对一组数据进行过滤，符合条件的数据会生成新的列表并返回

怎么写？

利用给定函数进行判断，返回值一定个布尔值。

def isH(a):
    return a%2 == 0

print(filter(isH,[1,2,3,4,5,6,7,8,9]))

高阶函数---排序

把一个序列按照给定的算法进行排序

key：在排序前对每个元素进行key函数运算，可以理解为按照key函数定义的逻辑进行排序。

a=[-52,36,95,-45,-86,-12,56,1,0,6]
al = sorted(a,key=abs,reverse=True)
print al

返回函数：

函数可以返回一个具体的值，也可以返回一个函数作为结果

函数值作为返回值返回，被返回的函数在函数体内定义，

def myF():
    def myf1():
        print("in myF1")
        return 5
    return myf1

f = myF()
print f
print f()

调用myF,返回一个函数myf1,赋值给f.

闭包：当一个函数在内部定义函数，并且内部的函数应用外部函数的参数或者局部变量，当内部函数被当做返回值的时候，相关参数和变量保存在返回函数中。

def myf( *args):
    def myf1():
        ret = 0
        for i in args:
            ret += i
        return ret
    return myf1
f5 = myf(10,2,03,20,8)
print f5
print f5()

闭包注意事项：

def count():
    fsz = []
    for i in range(1,3):
        def f():
            return i*i
        fsz.append(f)
    return fsz

f1,f2 = count()
print(f1())
print(f2())

结果4 4

原因：返回函数引用了变量 但变量没有被立即执行，而是等到函数都返回值才统一使用。

返回闭包时，返回函数不能引用任何循环变量

解决方案：再创建一个函数，用该函数的参数绑定循环变量的当前值，无论该循环变量以后如何改变，已经绑定的函数参数值不再改变。

def count1():
    def f(j):
        def g():
            return j*j
        return g
    fs = []
    for i in range(1,3):
        fs.append(f(i))
    return fs
f1,f2 = count1()
print(f1())
print(f2())

装饰器：decrator 在不改变函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数。

使用：@语法，即在每次要扩展到函数定义前使用@+函数名

优点：一点定义，则可以装饰任何函数

import time
def printTime(f):
    def wrapper(*args,**kwargs):
        print("Time: ",time.ctime())
        return f(*args,**kwargs)
    return wrapper

@printTime
def hello2():
    print("alice")

hello2()

手动执行装饰

import time
def printTime(f):
    def wrapper(*args,**kwargs):
        print("Time: ",time.ctime())
        return f(*args,**kwargs)
    return wrapper

# @printTime
def hello2():
    print("alice")
#
# hello2()
hello2 = printTime(hello2)
hello2()

偏函数

参数固定的函数，相当于一个特定参数的函数体，functool.partial的作用：把一个函数某些函数固定，返回一个新函数

print int("123456")
print int("123456",base=8)

def in16(x,base = 16):
    return int(x,base)
print in16("123456")

import functools
in16 = functools.partial(int,base = 16)

print in16("123456")