Python 高阶函数、高阶内建函数及柯里化 详解

1、高阶函数

1.1 Python 函数

• 函数在 Python 里是一等公民（First-Class Object）
• 函数也是对象，是可调用对象
• 函数可以作为普通变量，也可以作为函数的参数、返回值

1.2 高阶函数

在数学和计算机科学中，高阶函数（High-order Function）应当至少满足下面一个条件的函数：

• 接受一个或多个函数作为参数
• 输出一个参数

1.3 实现计数器的高阶函数

def counter(base):
    def _counter(step=1):
        nonlocal base
        base += step
        return base
    return _counter

# 基数是0，步长为2的技术器
counter1 = counter(base=0)
for i in range(3):
    print(counter1(step=2))
    
# Out
2
4
6

1.4 注意以下两个函数的区别

1.4.1 函数内嵌套函数

# == 如果无法比较内容，就等效为 is
# 例如 函数对象 无法比较内容 就直接比较内存地址
def counter(base):
    def _counter(step=1):
        nonlocal base
        base += step
        return base
    return _counter

f1 = counter(5)
f2 = counter(5)
print('f1 = {}, f2 = {}'.format(f1, f2))
print('f1_id = {}, f2_id = {}'.format(id(f1), id(f2)))
print('f1() = {}, f2() = {}'.format(f1(), f2()))
print('f1()_id = {}, f2()_id = {}'.format(id(f1()), id(f2())))
print(f1 == f2)
print(f1() == f2())

f1 = <function counter.<locals>._counter at 0x00000000078B13A8>, f2 = <function counter.<locals>._counter at 0x00000000078B1558>
f1_id = 126555048, f2_id = 126555480
f1() = 6, f2() = 6
f1()_id = 8791210553808, f2()_id = 8791210553808
False
True

1.4.2 函数内部返回全局函数

# == 如果无法比较内容，就等效为 is
# 例如 函数对象 无法比较内容 就直接比较内存地址
inc_num = 100
def inc(step=1):
    return inc_num+1

def counter(base=0):
    print(id(inc))
    return inc
print(1, inc, id(inc), id(inc()))
counter()
print(2, inc, id(inc), id(inc()))
f1 = counter(5)
f2 = counter(7)
print('f1 = {}, f2 = {}'.format(f1, f2))
print('f1_id = {}, f2_id = {}'.format(id(f1), id(f2)))
print('f1() = {}, f2() = {}'.format(f1(), f2()))
print('f1()_id = {}, f2()_id = {}'.format(id(f1()), id(f2())))
print(f1 == f2)
print(f1() == f2())

1 <function inc at 0x0000000008032C18> 134425624 8791210556816
134425624
2 <function inc at 0x0000000008032C18> 134425624 8791210556816
134425624
134425624
f1 = <function inc at 0x0000000008032C18>, f2 = <function inc at 0x0000000008032C18>
f1_id = 134425624, f2_id = 134425624
f1() = 101, f2() = 101
f1()_id = 8791210556816, f2()_id = 8791210556816
True
True

2、内建高阶函数

2.1 排序 sorted

2.1.1 语法

• sorted(iterable, /, *, key=None, reverse=False)
• sorted函数是返回新列表
• 注意与list.sort()（就地修改，返回结果是None）的区别

2.1.2 示例

• sorted 函数 与 list sort 方法 的区别

  list1 = [1, 2, 3]
  list2 = sorted(list1, key=lambda x:6-x) # 不影响原列表，返回新列表
  print(list1, list2)
  
  # [1, 2, 3] [3, 2, 1]
  

  list1 = [1, 2, 3]
  list2 = list1.sort(key=lambda x:6-1) # 就地修改
  print(list1, list2)
  
  # [1, 2, 3] None
  

• sorted 函数

  list3 = [1, 2, 3, 'a', 'b', 'A']
  list4 = sorted(list3, key=str)
  list5 = sorted(list3, key=str, reverse=True)
  for i in [list3, list4, list5]:
      print(i)
  for j in list3:
      print(ord(str(j)), end=' |=| ')
  

  [1, 2, 3, 'a', 'b', 'A']
  [1, 2, 3, 'A', 'a', 'b']
  ['b', 'a', 'A', 3, 2, 1]
  49 |=| 50 |=| 51 |=| 97 |=| 98 |=| 65 |=| 
  

  # ord() 内建函数帮助
  Signature: ord(c, /)
  Docstring: Return the Unicode code point for a one-character string.
  Type:      builtin_function_or_method
  

2.2 过滤 filter

2.2.1 语法

• filter(self, /, *args, **kwargs)
• filter(function or None, iterable) --> filter object
• 对可迭代对象进行遍历，返回一个迭代器
• function参数是一个参数的函数，且返回值应该是bool类型，或其返回值等效布尔值
• function参数如果是None，可迭代对象的每一个元素自身等效布尔值

2.2.2 示例

# 过滤出列表中既不能被3整除也不能被2整除的值
iter1 = filter(lambda x:x%3!=0 and x%2!=0, list(range(10)))
# 返回一个迭代器
print(iter1, type(iter1))
print(list(iter1))

<filter object at 0x0000000007B02E88> <class 'filter'>
[1, 5, 7]

# function 参数如果是`None`，可迭代对象的每一个元素自身等效布尔值
print(list(filter(None, range(5))))
print(list(filter(None, range(-5, 5))))
print(list(filter(None, [0, False, True, [], [1], {
     }, {
     1}])))

[1, 2, 3, 4]
[-5, -4, -3, -2, -1, 1, 2, 3, 4]
[True, [1], {
     1}]

# if fn(element): yield element
print(list(filter(lambda x:True, range(5))))
print(list(filter(lambda x:False, range(5))))
print(list(filter(lambda x:None, range(5))))

[0, 1, 2, 3, 4]
[]
[]

2.3 映射 map

2.3.1 语法

• map(self, /, *args, **kwargs)
• map(func, *iterables) --> map object
• 对多个可迭代对象的元素，按照指定的函数进行映射
• 返回一个迭代器

2.3.2 示例

iter2 = map(lambda x:x+1, range(5))
print(iter2, type(iter2))
print(list(iter2))

<map object at 0x0000000007B295C8> <class 'map'>
[1, 2, 3, 4, 5]

print(list((map(lambda x:x**2, range(1,6)))))
print(dict((map(lambda x:(x, x**2), range(1,6)))))
print(dict((map(lambda x, y:(x, y**2), 'abcde', range(1,4)))))

[1, 4, 9, 16, 25]
{
     1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{
     'a': 1, 'b': 4, 'c': 9}

# set 集合是无序的
dict(map(lambda x,y:{
     x, y}, 'abcde', range(10)))

# {0: 'a', 1: 'b', 2: 'c', 3: 'd', 'e': 4}

3、柯里化

3.1 概念

• 将原来接受多个参数的函数变成新的接受一个参数的过程的过程
• 新的函数返回一个以原有第二个参数为参数的函数
• 比如讲 z=f(x, y) 转为 z=f(x)(y)

3.2 示例

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

add(4, 5)
# 9

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

add(4)(5)
# 9

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

add(4, 5, 6)
# 15

def add(x):
    def _add(y):
        def _add1(z):
            return x + y + z
        return _add1
    return _add

add(4)(5)(6)
# 15