函數的高級應用
二、高階函數
高級函數, 英文叫 Higher-order Function.
那么什么是高階函數呢?
在說明什么是=高階函數之前, 我們需要對函數再做進一步的理解!
2.1 函數的本質
函數的本質是什么？
函數和函數名到底是一種什么關系？
在python中，一切皆對象，那么函數也不例外，也是一種對象。
從本質上看，一個函數與一個整數沒有本質區別，僅僅是他們的數據類型不同而已！
看下面的代碼：
def foo():
pass
print(foo) # 這里只打印了函數名, 並沒有調用 foo 函數
print(abs) # 直接打印內置函數, 而沒有調用
說明:
- 從結果可以看出來, 直接把函數本身打印出來了, 自定義的函數與
at后面的可以理解成函數在內存中的地址 - 如果是 python 內置函數會告訴你這是個內置函數.
- 你可以把函數想象中以前的數字一樣, 僅僅表示內存中的一個對象.
函數名和函數的關系
其實函數名和以前的變量名沒有本質的區別, 變量名是指向對象的一個符號, 那么函數名也是指向對象的一個符號.
動態把函數名賦值給新變量
函數名其實就是一個指向函數對象的變量.
那么我們是不是可以再創建一個變量也指向那個函數對象呢?
答案是肯定的!
def foo():
print("我是 foo 函數內的代碼")
a = foo
print(a)
print(foo)
a()
說明:
- 你會發現直接打印
a 和 foo的結果完全一樣, 證明他們確實是指向了同一個函數對象 - 調用
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
說明:
-
這里的
foo就是高階函數, 因為他接收了一個函數作為參數. -
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())
說明:
- 調用
foo()得到的一個函數, 然后把函數賦值給變量f, 這個時候f和foo內部的temp其實指向了同一個函數對象. - 返回的函數每調用一次都會把
foo的局部變量x增加 10 .所以兩次調用分別得到 20 和 30. - 返回訪問了外部函數的局部變量或者全局變量的函數,這種函數就是閉包.
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))
說明:
map函數是利用已有的函數和可迭代對象生成一個新的可迭代類型:map類型map的參數1是一個函數, 參數2是一個可迭代類型的數據.map會獲取迭代類型的每個數據, 傳遞給參數1的函數, 然后函數的返回值組成新的迭代類型的每個元素- 也可以有多個迭代器, 則參數1的函數的參數個數也會增加.
- 新生成的迭代器類型的元素的個數, 會和最短的那個迭代器的元素的個數保持一致.
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 也支持閉包.
什么是閉包?
如果一個函數使用了外部函數的局部變量, 那么這個函數就是一個閉包.
閉包的特點:
- 閉包函數可以訪問他所在的外部函數的局部變量. 即使外部函數已經運行結束, 對閉包函數來說仍然可以訪問到外部函數的局部變量
- 閉包訪問外部函數的局部變量的值, 總是這個變量的最新的值!
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 函數中的代碼")
說明:
- 在需要添加的裝飾函數上面一行使用
@來添加裝飾器 @后面緊跟中裝飾器名strong, 當然你可以定於任何的名字.strong是裝飾器, 本質上是一個函數. 他接收函數hello作為參數, 並返回一函數來替換掉hello(當然也可以不替換).hello使用裝飾器之后, 相當於hello函數使用下面的代碼被替換掉了.hello = strong(hello)- 在調用
hello的時候, 其實是調用的strong()返回的那個函數.
def strong(fun): # fun 將來就是被替換的 hello
def new_hello():
print("我是裝飾器中的代碼, 在 hello 之前執行的")
fun()
print("我是裝飾器中的代碼, 在 hello 之后...執行的")
return new_hello
@strong
def hello():
print("我是 hello 函數中的代碼")
# 這里調用的其實是裝飾器返回的函數.
hello()
裝飾器是語法糖
嚴格來講, 裝飾器只是語法糖.
裝飾器就是一函數, 其參數是被裝飾的函數.
綜上, 裝飾器的一大特性就是把裝飾的函數替換成其他函數, 第二大特性就是裝飾函數在加載模塊的時候就立即執行了.