函数式编程

lambda表达式

函数： 最大程度复用代码

存在问题： 如果函数很小，很短，则会造成啰嗦
如果函数被调用次数少，则会造成浪费
对于阅读者来说，造成阅读流程的被迫中断

# 1. 以lambda开头
# 2. 紧跟一定的参数（如果有的话）
# 3. 参数后用冒号和表达式主题隔开
# 4. 只是一个表达式，所以，没有return
stm=lambda x,y,z:x+y*10+z*100
print(stm(1,2,3))=>321

函数名称是变量，则可以被当做参数传入另一个函数
高阶函数

def funC(n, f):
    return f(n) * 3
def funD(n):
    return n*10
print(funC(9,funD))=>270        

map函数

原意就是映射，即把集合或者列表的元素，每一个元素都按照一定规则进行操作，生成一个新的列表或者集合
map函数是系统提供的具有映射功能的函数，返回值是一个迭代对象

def square(x):
    return x**2
rst=map(square,[1,2,3,4,5])
print([i for i in ret])=>[1, 4, 9, 16, 25]

reduce

原意是归并，缩减
把一个可迭代对象最后归并成一个结果
对于作为参数的函数要求： 必须由两个参数，必须由返回结果
reduce([1,2,3,4,5]) == f( f(f(f(1,2),3), 4),5)
reduce 需要导入functools包

from functools import reduce

# 定义一个操作函数
# 加入操作函数只是相加
def myAdd(x,y):
    return x + y
    
# 对于列表[1,2,3,4,5,6]执行myAdd的reduce操作
rst = reduce( myAdd, [1,2,3,4,5,6] )
print(rst)=>21

filter 函数

过滤函数： 对一组数据进行过滤，符合条件的数据会生成一个新的列表并返回
跟map相比较：
相同：都对列表的每一个元素逐一进行操作
不同：
map会生成一个跟原来数据想对应的新队列
filter不一定，只要符合条件的才会进入新的数据集合
filter函数怎么写：
利用给定函数进行判断
返回值一定是个布尔值
调用格式： filter(f, data), f是过滤函数， data是数据

def isEven(a):
    return a % 2 == 0
l = [3,4,56,3,2,3,4556,67,4,4,3,23455,43]
rst = filter(isEven, l)
print([i for i in rst])=>[4, 56, 2, 4556, 4, 4]

高阶函数-排序

把一个序列按照给定算法进行排序
key: 在排序钱对每一个元素进行key函数运算，可以理解成按照key函数定义的逻辑进行排序
python2 和 python3 相差巨大

#排序
a=[234,22312,123,45,43,2,3,66723,34]
al=sorted(a,reverse=False)#al=sorted(a)
print(al)=>[2, 3, 34, 43, 45, 123, 234, 22312, 66723]
bl=sorted(a,reverse=True)
print(bl)=>[66723, 22312, 234, 123, 45, 43, 34, 3, 2]

a = [-43,23,45,6,-23,2,-4345]
al=sorted(a,key=abs)
print(al)=>[2, 6, 23, -23, -43, 45, -4345]

#key=str.lower
#字符串小的，排序

返回函数

def myF4( *args):
    def myF5():
        rst = 0
        for n in args:
            rst += n
        return rst
    return myF5
f5 = myF4(1,2,3,4,5,6,7,8,9,0)
f5()=>45

闭包

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

def count():
    # 定义列表，列表里存放的是定义的函数
    fs = []
    for i in range(1,4):
        # 定义了一个函数f
        # f是一个闭包结构
        def f():
            return i*i
        fs.append(f)
    return fs

f1,f2,f3 = count()
print(f1())=>9
print(f2())=>9
print(f3())=>9

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

f1,f2,f3 = count2()
print(f1())=>1
print(f2())=>4
print(f3())=>9

装饰器

在不改动函数代码的基础上无限制扩展函数功能的一种机制，本质上讲，装饰器是一个返回函数的高阶函数
装饰器的使用： 使用@语法， 即在每次要扩展到函数定义前使用@+函数名

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()=>
Time:  Thu Feb 14 17:25:10 2019
Hello world

偏函数

print(int("123456",base=8))=>42798
print(int(12.88))=>12

def int16(x,base=16):
    return int(x,base)
print(int16("12345"))=>74565

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

import functools
int16=functools.partial(int,base=16)
print(int16("12345"))=>74565