python学习22之函数式编程

一、   Python的高级特性

-----函数式编程

基于lambda演算的一种编程方式，程序中只有函数，函数可以作为参数，也可以作为返回值。纯函数式编程语言：LISP,Haskell

python函数式编程只是借鉴函数式编程的一些特点，可以理解成一半函数式一半python

主要内容：高阶函数

         返回函数

         匿名函数

         装饰器

         偏函数

 1. lambda表达式

（1） 函数：最大程度上复用代码

（2） lambda表达式：也叫匿名函数，一个表达式，函数体相对简单，不是一个代码块，就是一个表达式，可以有参数，多个参数也可以，用逗号隔开

（3） 用法：以lambda开头，紧跟一定的参数，参数后用冒号和表达式主题隔开，只是一个表达式，没有return

（4） 案例：

#计算一个数字的100倍
cf=lambda x:100*x
res=cf(89)
print(res)

2. 高阶函数

（1）  定义：Higher-order function，把函数作为参数使用的函数

（2）  函数名称本质上就是一个变量，所以可以被当做参数传入另一个函数

def funA():

    return 10

funB=funA

print(funB())

把funA以变量的形式赋值给funB,调用funB相当于调用funA

def funA(x):

    '''

    :return:返回x的100倍

    '''

    return x*100

def funB(x,f):

    '''

    :param x:传入一个数

    :param f: 传入一个函数

    :return: 先对x进行函数f操作，然后再对结果扩大3倍

    '''

    return f(x)*3

print(funB(13,funA))

（3）  系统高阶函数—map

定义：映射，把集合或者列表的元素，每一个元素按照一定的规则进行操作，生成一个新的列表或者集合

map函数是系统提供的具有映射功能的函数，返回值是一个迭代对象

接收两个参数，一个函数，一个可迭代对象，map函数将传入的函数依次作用到可迭代对象的每个元素。

#对列表中每一个元素扩大10倍

def mul10(x):

    return x*10



l1=[i for i in range(1,10)]

l2=map(mul10,l1)

l2=[i for i in l2]

print(l2)

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

def normalize(LST):
    def capitalize(s):
        return s.capitalize()
    return map(capitalize,LST)
L=['adam', 'LISA', 'barT']
r=[i for i in normalize(L)]
print(r)

（4）  reduce函数

定义：归并，缩减，把一个可迭代对象最后归并成一个结果

参数：一个函数，一个可迭代对象

对于作为参数传入的函数要求：必须有两个参数，必须有返回结果

对于reduce需要导入functools包

from functools import reduce

def addXY(x,y):

    return x+y

#对于[1,2,3,4,5,6]列表进行所有元素相加求和操作

res=reduce(addXY,[1,2,3,4,5,6])

print(res)

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

def prod(LST):
    return reduce(lambda x,y:x*y,LST)
r=prod([1,2,3,4,5])
print(r)

（5）  filter函数

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

接收两个参数，一个函数，一个序列

把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是舍弃这个元素。

跟map函数比较：

   相同：都对列表每一个元素操作

   区别：map会生成一个跟原来数据想对应的新队列，filter不一定，不符合条件的会被筛选掉

filter函数的写法：利用给定函数进行判断，返回值是布尔值

调用格式：filter(f,data):f是过滤函数，data是数据

#过滤函数，过滤掉偶数组成一个新列表

def isEven(a):

    return a%2==0

l4=[11,22,33,65,56,58,98,63,66,45,53,52]

res=filter(isEven,l4)

res=[i for i in res]

print(res)

（6）  高阶函数--排序

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

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

l4=[11,22,33,65,56,58,98,63,66,45,53,52]

l4=sorted(l4)

# l4.sort()

print(l4)

 

l4=[11,22,-33,65,-56,58,98,63,66,-45,53,52]
#按照绝对值倒序排列
new_l4=sorted(l4,key=abs,reverse=True)
print(new_l4)

 

3. 返回函数

函数可以返回具体的值，也可以返回一个函数

def myFun1():

    def myFun2():

        print("hello world")

        return 2

    return myFun2



f1=myFun1()

print(f1)#f1是一个函数

print(f1()) #可以作为函数调用f1了

4. 闭包closure

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

利用闭包返回一个计数器函数，每次调用它返回递增整数。

def createCounter():
    m=0
    def counter():
        nonlocal m #nonlocal定义外部嵌套函数内的变量
        m+=1
        return m
    return counter #返回函数
cnt=createCounter() #cnt是一个函数类型
print(cnt()) #调用cnt()才是调用函数
print(cnt())
print(cnt())

 

5. 装饰器

对函数功能进行扩展，但不能改动现有代码

在不改动函数代码的基础上无限制扩展函数功能的一种机制，本质上就是一个返回函数的高阶函数

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

def hello():

    print("hello world")

#对hello函数进行功能扩展，每次打印前输出当前时间

import time

def printTime(f):

    def wrapper(*args,**kwargs):

        print("Time:",time.ctime())

        return f(*args,**kwargs)

    return wrapper

@printTime

def hello():

    print("hello world")

hello()

6. 偏函数

int(x,base=10)将字符串x转化成十进制整数

int(x,base=2):将字符串x理解为二进制数形式，然后转化成十进制

 

定义：参数固定的函数，相当于一个有特定参数的函数体

functools.partial的作用是，把一个函数某些函数固定，返回一个新函数

比方说想要实现int(x,base=2)

import functools

int2=functools.partial(int,base=2)

print(int2("10010"))