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

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

  • 1、高阶函数
    • 1.1 Python 函数
    • 1.2 高阶函数
    • 1.3 实现计数器的高阶函数
    • 1.4 注意以下两个函数的区别
      • 1.4.1 函数内嵌套函数
      • 1.4.2 函数内部返回全局函数
  • 2、内建高阶函数
    • 2.1 排序 sorted
      • 2.1.1 语法
      • 2.1.2 示例
    • 2.2 过滤 filter
      • 2.2.1 语法
      • 2.2.2 示例
    • 2.3 映射 map
      • 2.3.1 语法
      • 2.3.2 示例
  • 3、柯里化
    • 3.1 概念
    • 3.2 示例

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

你可能感兴趣的:(Python,python)