python 高阶函数

# 高阶函数
# 数学概念 y = g(f(x))
# 高阶函数必须满足至少一个条件
#   1 接受一个或多个函数作为参数（如：f(x)）
#   2 返回一个函数对象

def counter(base):
    def inner(step = 1):        # 当成本地变量来理解
        nonlocal base
        base = base + step
        return base
    return inner

foo1 = counter(10)
foo2 = counter(10)
print(foo1 == foo2)     # false

# 自定义sort函数
# 1
lst = [1, 2, 5, 4, 2, 3, 5, 6]
def sort(iterable):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret): # 函数用于将一个可遍历的数据对象组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。
            if x > y:
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret
print(sort(lst))
# 2
lst = [1, 2, 5, 4, 2, 3, 5, 6]
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(lst))
# 3
lst = [1, 2, 5, 4, 2, 3, 5, 6]
def comp(a, b):
    return a < b
def sort(iterable, key=comp, reverse=True):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            flag = key(x, y) if reverse else key(y, x)
            if flag:
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret
print(sort(lst))
# 4
lst = [1, 2, 5, 4, 2, 3, 5, 6]
def sort(iterable, key=lambda a,b:a<b, reverse=False):
    ret = []
    for x in iterable:
        for i, y in enumerate(ret):
            flag = key(x, y) if reverse else key(y, x)
            if flag:
                ret.insert(i, x)
                break
        else:
            ret.append(x)
    return ret
print(sort(lst))

# 5 最终的高阶函数
lst = [1, 2, 5, 4, 2, 3, 5, 6]
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(lst))
print(sort(lst, lambda a,b:a>b))

# 6
lst = [1, 2, 5, 4, 2, 3, 5, 6]
def sort(iterable, key=None):
    ret = []
    if key is None:
        key = lambda a,b:a<b
    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(lst))
print(sort(lst, lambda a,b:a>b))

# 内建函数-高阶函数
# sorted(iterable[, key][, reverse]) --> 值不变
#   对一个可迭代对象的所有元素排序，返回一个新的列表，排序规则为key定义的函数，reverse表示是否反转
#   sorted(lst, key=lambda x:6-x) 返回新列表
lst = [1, 2, 5, 4, 2, 3, 5, 6, 7]
print(sorted(lst, key=lambda x:6-x))    # key函数只是用来比较，不影响排序
#   list.sort(key=lambda x:6-x) 就地修改
lst = [1, 2, 5, 4, 2, 3, 5, 6, 7]
print(lst.sort(key=lambda x:6-x))

# filter(function, iterable) --> 留下要的值 filter object
#   过滤可迭代对象的元素，返回一个迭代器
#   function一个具有一个参数的函数，返回bool
#   例：过滤出数列中能被3整除的数字
print(list(filter(lambda x:x%3==0, [1, 9, 55, -3, 78, 28, 123])))

# map(function, *iterables) --> 返回新的值 map object
# 对多个可迭代对象的元素按照指定的函数进行映射，返回一个迭代器
#   list(map(lambda x:2*x+1, range(5)))
print(list(map(lambda x:2*x+1, range(5))))
#   dict(map(lambda x:(x%5, x), range(500)))
print(dict(map(lambda x:(x%5, x), range(500)))) {0: 495, 1: 496, 2: 497, 3: 498, 4: 499}