Python-高阶函数、函数柯里化

1、高阶函数：

　　First Class Object：

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

　　高阶函数：

• • 数学概念 y = g(f(x))
  • 在数学和计算机科学中，高阶函数应当是至少满足下面的一个条件：
    • 接受一个或多个函数作为参数
    • 输出一个函数

　　　　举例1：

def counter(base):
    def inc(step=1):
        a = 1
        nonlocal base
        base += step
        return base
    return inc # 返回的并非是容器类对象

# foo = counter(1)
# print(foo())

# 函数counter 是一个高阶函数，因为满足高阶函数的一个条件：输出一个函数

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

# print(f1(),f2())
print(f1 == f2) #  Fasle  非容器类对象，或者可以直接比较的类型，没办法比较内容，所以比较地址
print(f1 is f2) #  False  比较地址
'''
inc 属于是内部函数，每次调用才会定义，就跟在counter 函数内部定义一个 a = 1是一样的，

所以，每次调用counter 时，要压栈，f1 和 f2 分别 压栈两次，每次是不一样的，都是重新压栈

所以，每次定义的 inc 也是不一样的！自然，它们的地址也是不一样
'''

　　　　举例2：

def inc(step=1):
    base = 2
    base += step
    return base

def counter(base):
    bse = 1
    a = 1
    return inc

f1 = counter(3)
f2 = counter(3)
print(f1 is f2) # True
print(f1 == f2) # True
'''
这个和上面的就不痛了，因为在全局里定义了，因为函数定义仅一份，所以每次调用的都是同一个函数
'''

2、自定义sort 函数 sorted()

　　排序问题：仿照内建函数sorted 实现一个sort函数

NO 1
def sort(iterable):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            if x > y:
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret

print(sort([1,3,2]))

no 2
def sort(iterable, reverse=False):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            flag = x > y if reverse else x < y
            if flag:
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret

print(sort((1,2,3,45,3)))


NO 3
def sort(iterable, key=lambda a,b : a > b):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            if key(x,y):
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret

print(sort((3,3,42,4,52)))


NO 4
def sort(iterable, reverse=False, key=lambda x,y:x<y):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            flag = key(x,y) if not reverse else not key(x,y)
            if flag:
                ret.insert(i,x)
                break
        else:
            ret.append(x)
    return ret

print(sort((1,2,3,4,53,2,)))

sorted(iterable, *, key=None, reverse=False) 
Return a new sorted list from the items in iterable.
 
Has two optional arguments which must be specified as keyword arguments.
 
key specifies a function of one argument that is used to extract a comparison key from each list element: key=str.lower. The default value is None (compare the elements directly).
 
reverse is a boolean value. If set to True, then the list elements are sorted as if each comparison were reversed.
 
Use functools.cmp_to_key() to convert an old-style cmp function to a key function.
 
The built-in sorted() function is guaranteed to be stable. A sort is stable if it guarantees not to change the relative order of elements that compare equal � this is helpful for sorting in multiple passes (for example, sort by department, then by salary grade).
 
For sorting examples and a brief sorting tutorial, see Sorting HOW TO.

从可迭代的项目中返回一个新的排序列表。有两个可选的参数，必须指定为关键字参数。key指定了一个参数的函数，用来从每个列表元素中提取一个比较键：键=str.下半。默认值是None（直接比较元素）。反向是布尔值。如果设置为真，那么列表元素就会显示，就好像每个比较都被颠倒了一样。使用函式工具。cmp tokey（）将旧式的cmp函数转换为akey函数。内置的排序（）函数保证是稳定的。排序是稳定的，如果它保证不改变比较相等的元素的相对顺序，这有助于在多个传递中进行排序（例如，按部门排序，然后按工资等级排序）。对于排序示例和一个简短的排序教程，请参阅排序如何。

3、内建函数-高阶函数

　　排序：sorted( iterable [, key][, reverse] )

　　过滤数据：filter( function, iterable) ---> filter object

　　映射： map（ func， *iterable） ---> map object　　

　　

　　一、sorted( iterable [, key][, reverse] ) 排序

• • • 返回一个新列表，对一个可迭代对象的所有元素排序，排序规则为key定义的函数，reverse表示是否排序翻转
    • sorted( lst, key=lambda x:6-x # 返回新列表
    • list.sort(key=lambda x: 6-x) # 就地修改
    • 注：key= 后面的表达式是比较条件，如上：把所有元素做 6-x 后在比较大小，然后再返回之前原来的元素

　　二、filter( function, iterable)

• • • 过滤可迭代对象的元素，返回一个迭代器
    • functn 一个具有一个参数的函数，返回bool
    • 例如：过滤出数列中能被3 整除的数字，
      • list( filter( lambda x:x%3 == 0 , range(18))   # [0, 3, 6, 9, 12, 15]

　　三、map ( function, *iterable) --> map object

• • • 对多个可迭代独享的元素按照指定的函数进行映射，返回一个迭代器。
      • list(map(lambda x : 2*x + 1, range(4)))

4、柯里化Currying

　　柯里化：指的是将原来接受两个参数的函数编程新的接受一个参数的函数的过程，新的函数返回一个以原有第二个参数为参数的函数。

　　　　举例 1：

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

柯里化————————》

def add(x):
    def inner(y):
        return  x + y
    return inner

print(add(2)(3))

　　　　总结：   将第二个参数 和 函数体往右挪，变成内部函数，并返回该函数的 标识符