Python第六章-函數06-高階函數

函數的進階應用

二、高階函數

進階函數, 英文叫 Higher-order Function.

那麼什麼是高階函數呢?

在說明什麼是=高階函數之前, 我們需要對函數再做進一步的了解!

2.1 函數的本質

函數的本質是什麼？

函數和函數名到底是一種什麼關系？

在python中，一切皆對象，那麼函數也不例外，也是一種對象。

從本質上看，一個函數與一個整數沒有本質差別，僅僅是他們的資料類型不同而已！

看下面的代碼：

def foo():
    pass


print(foo)  # 這裡隻列印了函數名, 并沒有調用 foo 函數

print(abs)  # 直接列印内置函數, 而沒有調用
           

說明:

1. 從結果可以看出來, 直接把函數本身列印出來了, 自定義的函數與

   at

   後面的可以了解成函數在記憶體中的位址
2. 如果是 python 内置函數會告訴你這是個内置函數.
3. 你可以把函數想象中以前的數字一樣, 僅僅表示記憶體中的一個對象.

函數名和函數的關系

其實函數名和以前的變量名沒有本質的差別, 變量名是指向對象的一個符号, 那麼函數名也是指向對象的一個符号.

動态把函數名指派給新變量

函數名其實就是一個指向函數對象的變量.

那麼我們是不是可以再建立一個變量也指向那個函數對象呢?

答案是肯定的!

def foo():
    print("我是 foo 函數内的代碼")


a = foo

print(a)
print(foo)

a()
           

說明:

1. 你會發現直接列印

   a 和 foo

   的結果完全一樣, 證明他們确實是指向了同一個函數對象
2. 調用

   a()

   執行的就是

   foo

   函數内的代碼. 因為他們其實就是一個對象.

給函數名重新指派

既然函數名是變量名, 那麼函數名也應該可以重新指派!

def foo():
    print("我是 foo 函數内的代碼")


foo = 3

foo()
           

說明:

因為函數名已經被指派為了整數,是以再調用就會抛出異常.

2.2 高階函數

通過前面的了解, 我們已經知道函數名其實僅僅是一個普普通通的變量名而已.

那麼是不是也意味着:函數也可以作為參數傳遞呢?

答案是肯定的!

一個可以接收函數作為參數的函數就是高階函數!

一個最簡單的高階函數

def foo(x, y, f):  # f 是一個函數
    """
    把 x, y 分别作為參數傳遞給 f, 最後傳回他們的和
    :param x:
    :param y:
    :param f:
    :return:
    """
    return f(x) + f(y)


def foo1(x):
    """
    傳回參數的 x 的 3次方
    :param x:
    :return:
    """
    return x ** 3


r = foo(4, 2, foo1)    

print(r)    # 72
           

說明:

1. 這裡的

   foo

   就是高階函數, 因為他接收了一個函數作為參數.

2. foo1

   作為參數傳遞給了

   foo

   , 而且

   foo

   中的局部變量

   f

   接收了

   foo

   傳遞過來的資料, 那麼最終是

   foo

   和

   f

   同時指向了同一個對象.

總結

編寫高階函數，就是讓函數的參數能夠接收其他的函數。

把函數作為參數傳入，這樣的函數稱為高階函數，函數式程式設計就是指這種高度抽象的程式設計範式。

2.3 高階函數另一種形式：把函數作為傳回值

高階函數除了可以接受函數作為參數外，還可以把函數作為結果值傳回。

def foo():
    x = 10

    def temp():
        nonlocal x
        x += 10 #x=x+10
        return x

    return temp

f = foo()

print(f())
print(f())
           

說明:

1. 調用

   foo()

   得到的一個函數, 然後把函數指派給變量

   f

   , 這個時候

   f

   和

   foo

   内部的

   temp

   其實指向了同一個函數對象.
2. 傳回的函數每調用一次都會把

   foo

   的局部變量

   x

   增加 10 .是以兩次調用分别得到 20 和 30.
3. 傳回通路了外部函數的局部變量或者全局變量的函數,這種函數就是閉包.

2.4 内置高階函數

高階函數在函數式程式設計語言中使用非常的廣泛.

本節簡單介紹幾個常用的高階函數.

清單的排序,

map/reduce

,

filter

等

2.4.1 排序sort()

2.41 sort()預設排序

到目前為止, 大家應該對清單已經比較熟悉了: 清單是有序, 允許重複.

注意:這裡的有序是指的元素的添加順序和疊代順序一緻.

但是我如果想對清單中的元素按照一定的規則排序該怎麼做?

每個

list

執行個體都有有一個方法

list.sort()

可以幫我們完成這個工作.

sort()

預設對清單中的每個元素使用

<

進行比較,小的在前,大的在後.

也就是預設是

升序排列

nums = [20, 10, 4, 5, 3, 9]
nums.sort()
print(nums)
           

2.4.2 更改排序規則

比如, 清單中存儲的是字元串, 大小寫都有, 預設是按照字母表順序來排列.

但是我們如果想忽略大小寫的進行排列. 那麼預設排序就無法滿足我們的需求了

這個時候就需要用到

key

這個參數

key

必須是一個函數, 則排序的時候, python 會根據這個函數的傳回值來進行排序.

ss = ["aa", "Aa", "ab", "Ca", "da"]


def sort_rule(ele):
    return ele.lower()


ss.sort(key=sort_rule)

print(ss)
           

2.4.3 更改為降序

預設, 添加規則之後都是使用的升序排列.

如果需要降序排列, 則需要另外一個關鍵字參數

reverse

意思是問, 是否反序, 隻要給

True

就表示降序了, 預設是

None

ss = ["aa", "Aa", "ab", "Ca", "da"]


def sort_rule(ele):
    return ele.lower()


ss.sort(key=sort_rule, reverse=True)

print(ss)
           

2.4.2 map()和filter()

函數程式設計語言通常都會提供

map, filter, reduce

三個高階函數.

在python3中,

map和filter

仍然是内置函數, 但是由于引入了清單推導和生成器表達式, 他們變得沒有那麼重要了.

清單推導和生成器表達式具有了

map和filter

兩個函數的功能, 而且更易于閱讀.

2.4.2.1

map

a = map(lambda x: x ** 2, [10, 20, 30, 40])
print(list(a))
print(type(a))
           

說明:

1. map

   函數是利用已有的函數和可疊代對象生成一個新的可疊代類型:

   map

   類型

2. map

   的參數1是一個函數, 參數2是一個可疊代類型的資料.

   map

   會擷取疊代類型的每個資料, 傳遞給參數1的函數, 然後函數的傳回值組成新的疊代類型的每個元素
3. 也可以有多個疊代器, 則參數1的函數的參數個數也會增加.
4. 新生成的疊代器類型的元素的個數, 會和最短的那個疊代器的元素的個數保持一緻.

a = map(lambda x, y: x + y, [10, 20, 30, 40], [100, 200])
print(list(a))
           

使用清單推倒實作上面的功能

使用清單比map優雅了很多, 而且也避免了參數1的函數

list1 = [10, 20, 30, 40]

list3 = [x ** 2 for x in list1]

print(list3)
           

list1 = [10, 20, 30, 40]
list2 = [100, 200]

# 注意:清單推倒中這裡是使用的笛卡爾積
list3 = [x + y for x in list1 for y in list2]

print(list3)
           

2.4.2.2

filter

對已有的可疊代類型起過濾作用, 然後生成新的可疊代類型

用法和

map

類型, 參數1也是函數, 會把當傳回值為

True

的元素添加到新的可疊代類型中.

list1 = [0, 1, 3, 4, 9, 4, 7]
# 把奇數元素取出來
print(list(filter(lambda x: x % 2 == 1, list1)))

# 清單推倒的版本
list2 = [x for x in list1 if x % 2 == 1]
print(list2)
           

2.4.2.3

reduce

python 3中, reduce不再是直接的内置函數, 而是移到了子產品

functiontools

内.

reduce

的作用, 就是把一個可疊代序列的每一進制素應用到一個具有兩個參數的函數中.

例如:

reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])

就是計算

((((1+2)+3)+4)+5)

from functools import reduce

def f(x, y):
    print("x=", x, "y=", y)
    return x + y


"""
參數1: 具有兩個參數的函數
    參數1:前面計算過的值  參數2:從可疊代類型中取得的新的值
    
參數2: 可疊代類型的資料

參數3: x的初始值, 預設是0
"""
r = reduce(f, [1, 2, 3, 4, 5], 0)
print(r)    # 15

           

示例代碼：使用

reduce

計算階乘

from functools import reduce


def factorial(n):
    """計算n的階乘
    :param n:
    :return:
    """
    return reduce(lambda x, y: x * y, range(1, n + 1), 1)


print(factorial(5))
print(factorial(6))
print(factorial(7))
           

三、閉包

在函數程式設計語言中, 閉包是一個比較重要且強大的特性.

python 也支援閉包.

什麼是閉包?

如果一個函數使用了外部函數的局部變量, 那麼這個函數就是一個閉包.

閉包的特點:

1. 閉包函數可以通路他所在的外部函數的局部變量. 即使外部函數已經運作結束, 對閉包函數來說仍然可以通路到外部函數的局部變量
2. 閉包通路外部函數的局部變量的值, 總是這個變量的最新的值!

3.1.定義一個閉包

def outer():
    x = 20

    def inner():
        """
        inner 函數通路了外部函數 outer 的局部變量 x, 是以這個時候 inner
        就是一個閉包函數.
        :return:
        """
        nonlocal x
        x += 10
        return x

    x = 30
    return inner


# 調用 outer, 得到的是内部的閉包函數 inner   是以 f 和 inner 其實指向了同一個函數對象
f = outer()
''' 
調用 f. f是一個閉包函數,是以他通路的總是外部變量的最新的值, 
是以 f 執行的時候 x 的值已經是30. 最終傳回的是40
'''
print(f())
           

3.2.閉包的應用

閉包很強大, 也有一些比較适合的場景!

惰性求值(lazy evaluation, 延遲求值)

def foo(msg):
    def say_msg():
        print("hello" + str(msg))

    return say_msg

say = foo("志玲")

say()
           

說明:

上面的代碼中

foo

函數僅僅是聲明了一個嵌套函數, 和把這個嵌套函數傳回.

真正的代碼其實是定義在了内部的嵌套函數中.

這種寫法就是一種惰性求值!

使用閉包保持狀态

如果需要在一系列函數調用中保持某種狀态, 使用閉包是一種非常高效的方法.

一個簡單的計數器:

def count_down(num):
    def next():
        nonlocal num
        temp = num
        num -= 1
        return temp

    return next


# 使用前面的函數計數

next = count_down(10)

while True:
    value = next()  # 每調用一次就會減少一次計數
    print(value)
    if value == 0:
        break
           

還有一些其他應用, 比如裝飾器

四、裝飾器

裝飾器也是應用閉包的一種場景.

什麼是裝飾器?

如果一個函數已經定義完成, 需要在不修改這個函數源碼的前提下給這個函數增加一些功能, 這個時候就可以使用裝飾器.

裝飾器本質上是一個函數, 其主要用途是包裝另一個函數或類.

包裝的主要目的是透明地修改和增強被包裝對象的行為.

4.1定義裝飾器

裝飾器可以用在方法上, 也可以用在類上.

目前我們隻研究方法裝飾器

其實裝飾器和 java 中的注解有點像, 但是比 java 的注解容易使用了很多.

如果我們要給函數

hello

使用裝飾器的方式增強功能, 文法如下:

@strong
def hello():
    print("我是 hello 函數中的代碼")
           

說明:

1. 在需要添加的裝飾函數上面一行使用

   @

   來添加裝飾器

2. @

   後面緊跟中裝飾器名

   strong

   , 當然你可以定于任何的名字.

3. strong

   是裝飾器, 本質上是一個函數. 他接收函數

   hello

   作為參數, 并傳回一函數來替換掉

   hello

   (當然也可以不替換).

4. hello

   使用裝飾器之後, 相當于

   hello

   函數使用下面的代碼被替換掉了.

   hello = strong(hello)

5. 在調用

   hello

   的時候, 其實是調用的

   strong()

   傳回的那個函數.

def strong(fun):  # fun 将來就是被替換的 hello
    def new_hello():
        print("我是裝飾器中的代碼, 在 hello 之前執行的")
        fun()
        print("我是裝飾器中的代碼, 在 hello 之後...執行的")

    return new_hello


@strong
def hello():
    print("我是 hello 函數中的代碼")


# 這裡調用的其實是裝飾器傳回的函數.
hello()
           

裝飾器是文法糖

嚴格來講, 裝飾器隻是文法糖.

裝飾器就是一函數, 其參數是被裝飾的函數.

綜上, 裝飾器的一大特性就是把裝飾的函數替換成其他函數, 第二大特性就是裝飾函數在加載子產品的時候就立即執行了.