Python学习week6-高阶函数与柯里化

1、高阶函数

1.1、Fist Class Object

• 函数在python中是一等公民；
• 函数也是对象，可调用对象；
• 函数可以作为普通变量，参数，返回值等等；

1.2、什么是高阶函数？

# 高阶函数至少满足下面二个条件中的一个：

①：接收一个或者多个函数作为参数；

②：返回为一个函数；

def counter(base):
    def warpper(sep=1):
        nonlocal base
        base+=sep
        return base
    return warpper

f1=counter(5)
f2=counter(5)

print(f1==f2)   # Fasle
print(f1 is f2) # Fasle
'''
分析：
'=='一般比较的是值，'is'比较的是对象;
由于这里f1与f2是经过2次函数调用所产生的对象，所以f1 is f2 返回Fasle能理解
而f1 == f2 看似返回的值是一样的，但仔细分析，f1与f2得到的值内存地址，是不同的地址
f1调用时创建一个warpper对象，调用结束后返回warpper对象地址给f1
f2调用的时候会再次创建一个warpper对象（前一个warpper对象在f1调用完成后已经弹栈，所以再次调用会产生新的对象），调用结束后返回warpper
地址给f2,所以f1 得到的是完全与f2不同的值；
'''
print(f1,'f1-id:',id(f1),'\n',f2,'f2-id:',id(f2))
'''
运行结果：
<function counter.<locals>.warpper at 0x00000289B3D19D08> f1-id: 2790450633992 
<function counter.<locals>.warpper at 0x00000289B3D19B70> f2-id: 2790450633584
'''

2、自定义sort函数

# 自定义实现sort

### 版本一
def my_sort(iter,revers=False,key=lambda a,b:a>b):
    ret=[]
    # def compare(a, b):
    #     return a > b
    for x in iter:
        for i,y in enumerate(ret):
            flag= key(x,y) if revers else  not key(x,y)
            if flag:
                ret.insert(i,x)
                break
        else:
            ret.append(x)
    return ret
print(my_sort('2456713',revers=True))

####版本二
def my_sort(iter,revers=False,key=int): # sorted内部的key就是做的类型转换；
    ret=[]
    # def compare(a, b):
    #     return a > b
    for x in iter:
        for i,y in enumerate(ret):
            flag= key(x)>key(y) if revers else  key(x)>key(y)
            if flag:
                ret.insert(i,x)
                break
        else:
            ret.append(x)
    return ret
print(my_sort('2456713',revers=True))

# 版本三：
def my_sort(iter,revers=False,key=lambda a,b:a>b):
    ret=[]
    # def compare(a, b):
    #     return a > b
    for x in iter:
        for i,y in enumerate(ret):
            # flag= key(x)>key(y) if revers else  key(x)>key(y)
            if key(x,y):
                ret.insert(i,x)
                break
        else:
            ret.append(x)
    return ret
print(my_sort('2456713',revers=True))

3、内建函数与高阶函数

3.1、sorted

# 语法：sorted(iterable,[,key],[,reverse])

# 作用：排序

# 返回一个新的列表，对一个可迭代对象的所有元素排序，排序规则为key定义的函数，revers表示排序是否反转（即可定义升序或者降序）

3.2、filter

# 语法：filter(function,iterable)

# 作用：过滤可迭代对象的元素， 返回一个迭代器；

# function是一个具有一个参数的函数，返回为bool；

'''
过滤rang(10)里面不能被3整除的的数;
'''
g=filter(lambda x:x%3==0,range(10))
print(list(g))
'''
运行结果：[0, 3, 6, 9]
'''

3.3、map

# 语法：map(function,*iterables)  ==>map object

# 对多个可迭代对象的元素按照指定函数进行映射，返回一个迭代器；

def foo(x):
    return x%5,x

# for i in range(500):
#     res=foo(i)
#     print(res)

d=dict(map(lambda x:(x%5,x),range(500)))
print(d) # {0: 495, 1: 496, 2: 497, 3: 498, 4: 499}

l=map(lambda x:divmod(x,2),range(10))
print(list(l)) # [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1), (3, 0), (3, 1), (4, 0), (4, 1)]

l=map(lambda x,y:(x*100,y*100),range(1,4),range(10,40))

print(list(l)) # [(100, 1000), (200, 1100), (300, 1200)]

4、柯里化

4.1、什么是柯里化？

# 指的是将原来接收2个参数的函数变成新的接收一个参数的函数的过程；新的函数返回一个以原有第二个参数作为参数的函数；

# 例如：将加法函数柯里化过程

def add1(x,y):
    return x + y

# 柯里化
def add2(x): # 通过嵌套函数就可以把函数转换成柯里化函数
    def _add(y):
        return x + y
    return _add

print(add1(1,2)) # 3

# 柯里化后调用
print(add2(1)(2)) # 3