函數(shù)式編程

函數(shù)是Python內(nèi)建支持的一種封裝，我們通過把大段代碼拆成函數(shù)，通過一層一層的函數(shù)調(diào)用，就可以把復(fù)雜任務(wù)分解成簡(jiǎn)單的任務(wù)，這種分解可以稱之為面向過程的程序設(shè)計(jì)。函數(shù)就是面向過程的程序設(shè)計(jì)的基本單元。

而函數(shù)式編程（請(qǐng)注意多了一個(gè)“式”字）——Functional Programming，雖然也可以歸結(jié)到面向過程的程序設(shè)計(jì)，但其思想更接近數(shù)學(xué)計(jì)算。

我們首先要搞明白計(jì)算機(jī)（Computer）和計(jì)算（Compute）的概念。

在計(jì)算機(jī)的層次上，CPU執(zhí)行的是加減乘除的指令代碼，以及各種條件判斷和跳轉(zhuǎn)指令，所以，匯編語言是最貼近計(jì)算機(jī)的語言。

而計(jì)算則指數(shù)學(xué)意義上的計(jì)算，越是抽象的計(jì)算，離計(jì)算機(jī)硬件越遠(yuǎn)。

對(duì)應(yīng)到編程語言，就是越低級(jí)的語言，越貼近計(jì)算機(jī)，抽象程度低，執(zhí)行效率高，比如C語言；越高級(jí)的語言，越貼近計(jì)算，抽象程度高，執(zhí)行效率低，比如Lisp語言。

函數(shù)式編程就是一種抽象程度很高的編程范式，純粹的函數(shù)式編程語言編寫的函數(shù)沒有變量，因此，任意一個(gè)函數(shù)，只要輸入是確定的，輸出就是確定的，這種純函數(shù)我們稱之為沒有副作用。而允許使用變量的程序設(shè)計(jì)語言，由于函數(shù)內(nèi)部的變量狀態(tài)不確定，同樣的輸入，可能得到不同的輸出，因此，這種函數(shù)是有副作用的。

函數(shù)式編程的一個(gè)特點(diǎn)就是，允許把函數(shù)本身作為參數(shù)傳入另一個(gè)函數(shù)，還允許返回一個(gè)函數(shù)！

Python對(duì)函數(shù)式編程提供部分支持。由于Python允許使用變量，因此，Python不是純函數(shù)式編程語言。

高階函數(shù)

高階函數(shù)英文叫Higher-order function。什么是高階函數(shù)？我們以實(shí)際代碼為例子，一步一步深入概念。

變量可以指向函數(shù)

以Python內(nèi)置的求絕對(duì)值的函數(shù)abs()為例，調(diào)用該函數(shù)用以下代碼：

>>> abs(-10) 10

但是，如果只寫abs呢？

>>> abs <built-in function abs>

可見，abs(-10)是函數(shù)調(diào)用，而abs是函數(shù)本身。

要獲得函數(shù)調(diào)用結(jié)果，我們可以把結(jié)果賦值給變量：

>>> x = abs(-10) >>> x 10

但是，如果把函數(shù)本身賦值給變量呢？

>>> f = abs >>> f <built-in function abs>

結(jié)論：函數(shù)本身也可以賦值給變量，即：變量可以指向函數(shù)。

如果一個(gè)變量指向了一個(gè)函數(shù)，那么，可否通過該變量來調(diào)用這個(gè)函數(shù)？用代碼驗(yàn)證一下：

>>> f = abs >>> f(-10) 10

成功！說明變量f現(xiàn)在已經(jīng)指向了abs函數(shù)本身。直接調(diào)用abs()函數(shù)和調(diào)用變量f()完全相同。

函數(shù)名也是變量

那么函數(shù)名是什么呢？函數(shù)名其實(shí)就是指向函數(shù)的變量！對(duì)于abs()這個(gè)函數(shù)，完全可以把函數(shù)名abs看成變量，它指向一個(gè)可以計(jì)算絕對(duì)值的函數(shù)！

如果把a(bǔ)bs指向其他對(duì)象，會(huì)有什么情況發(fā)生？

>>> abs = 10 >>> abs(-10) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: 'int' object is not callable

把a(bǔ)bs指向10后，就無法通過abs(-10)調(diào)用該函數(shù)了！因?yàn)閍bs這個(gè)變量已經(jīng)不指向求絕對(duì)值函數(shù)而是指向一個(gè)整數(shù)10！

當(dāng)然實(shí)際代碼絕對(duì)不能這么寫，這里是為了說明函數(shù)名也是變量。要恢復(fù)abs函數(shù)，請(qǐng)重啟Python交互環(huán)境。

注：由于abs函數(shù)實(shí)際上是定義在import builtins模塊中的，所以要讓修改abs變量的指向在其它模塊也生效，要用import builtins; builtins.abs = 10。

傳入函數(shù)

既然變量可以指向函數(shù)，函數(shù)的參數(shù)能接收變量，那么一個(gè)函數(shù)就可以接收另一個(gè)函數(shù)作為參數(shù)，這種函數(shù)就稱之為高階函數(shù)。

一個(gè)最簡(jiǎn)單的高階函數(shù)：

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

當(dāng)我們調(diào)用add(-5, 6, abs)時(shí)，參數(shù)x，y和f分別接收-5，6和abs，根據(jù)函數(shù)定義，我們可以推導(dǎo)計(jì)算過程為：

x = -5 y = 6 f = abs f(x) + f(y) ==> abs(-5) + abs(6) ==> 11 return 11

用代碼驗(yàn)證一下：

>>> add(-5, 6, abs) 11

編寫高階函數(shù)，就是讓函數(shù)的參數(shù)能夠接收別的函數(shù)。

小結(jié)

把函數(shù)作為參數(shù)傳入，這樣的函數(shù)稱為高階函數(shù)，函數(shù)式編程就是指這種高度抽象的編程范式。

map/reduce

Python內(nèi)建了map()和reduce()函數(shù)。

如果你讀過Google的那篇大名鼎鼎的論文“MapReduce: Simplified Data Processing on Large Clusters”，你就能大概明白map/reduce的概念。

我們先看map。map()函數(shù)接收兩個(gè)參數(shù)，一個(gè)是函數(shù)，一個(gè)是Iterable，map將傳入的函數(shù)依次作用到序列的每個(gè)元素，并把結(jié)果作為新的Iterator返回。

舉例說明，比如我們有一個(gè)函數(shù)f(x)=x2，要把這個(gè)函數(shù)作用在一個(gè)list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()實(shí)現(xiàn)如下：

現(xiàn)在，我們用Python代碼實(shí)現(xiàn)：

>>> def f(x): ... return x * x ... >>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> list(r) [1, 4, 9, 16, 25, 36, 49, 64, 81]

map()傳入的第一個(gè)參數(shù)是f，即函數(shù)對(duì)象本身。由于結(jié)果r是一個(gè)Iterator，Iterator是惰性序列，因此通過list()函數(shù)讓它把整個(gè)序列都計(jì)算出來并返回一個(gè)list。

你可能會(huì)想，不需要map()函數(shù)，寫一個(gè)循環(huán)，也可以計(jì)算出結(jié)果：

L = [] for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]: L.append(f(n)) print(L)

的確可以，但是，從上面的循環(huán)代碼，能一眼看明白“把f(x)作用在list的每一個(gè)元素并把結(jié)果生成一個(gè)新的list”嗎？

所以，map()作為高階函數(shù)，事實(shí)上它把運(yùn)算規(guī)則抽象了，因此，我們不但可以計(jì)算簡(jiǎn)單的f(x)=x2，還可以計(jì)算任意復(fù)雜的函數(shù)，比如，把這個(gè)list所有數(shù)字轉(zhuǎn)為字符串：

>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9])) ['1', '2', '3', '4', '5', '6', '7', '8', '9']

只需要一行代碼。

再看reduce的用法。reduce把一個(gè)函數(shù)作用在一個(gè)序列[x1, x2, x3, ...]上，這個(gè)函數(shù)必須接收兩個(gè)參數(shù)，reduce把結(jié)果繼續(xù)和序列的下一個(gè)元素做累積計(jì)算，其效果就是：

reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)

比方說對(duì)一個(gè)序列求和，就可以用reduce實(shí)現(xiàn)：

>>> from functools import reduce >>> def add(x, y): ... return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25

當(dāng)然求和運(yùn)算可以直接用Python內(nèi)建函數(shù)sum()，沒必要?jiǎng)佑胷educe。

但是如果要把序列[1, 3, 5, 7, 9]變換成整數(shù)13579，reduce就可以派上用場(chǎng)：

>>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> reduce(fn, [1, 3, 5, 7, 9]) 13579

這個(gè)例子本身沒多大用處，但是，如果考慮到字符串str也是一個(gè)序列，對(duì)上面的例子稍加改動(dòng)，配合map()，我們就可以寫出把str轉(zhuǎn)換為int的函數(shù)：

>>> from functools import reduce >>> def fn(x, y): ... return x * 10 + y ... >>> def char2num(s): ... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] ... >>> reduce(fn, map(char2num, '13579')) 13579

整理成一個(gè)str2int的函數(shù)就是：

from functools import reducedef str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return reduce(fn, map(char2num, s))

還可以用lambda函數(shù)進(jìn)一步簡(jiǎn)化成：

from functools import reducedef char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] def str2int(s): return reduce(lambda x, y: x * 10 + y, map(char2num, s))

也就是說，假設(shè)Python沒有提供int()函數(shù)，你完全可以自己寫一個(gè)把字符串轉(zhuǎn)化為整數(shù)的函數(shù)，而且只需要幾行代碼！

lambda函數(shù)的用法在后面介紹。

filter

Python內(nèi)建的filter()函數(shù)用于過濾序列。

和map()類似，filter()也接收一個(gè)函數(shù)和一個(gè)序列。和map()不同的是，filter()把傳入的函數(shù)依次作用于每個(gè)元素，然后根據(jù)返回值是True還是False決定保留還是丟棄該元素。

例如，在一個(gè)list中，刪掉偶數(shù)，只保留奇數(shù)，可以這么寫：

def is_odd(n):return n % 2 == 1 list(filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15])) # 結(jié)果: [1, 5, 9, 15]

把一個(gè)序列中的空字符串刪掉，可以這么寫：

def not_empty(s):return s and s.strip() list(filter(not_empty, ['A', '', 'B', None, 'C', ' '])) # 結(jié)果: ['A', 'B', 'C']

可見用filter()這個(gè)高階函數(shù)，關(guān)鍵在于正確實(shí)現(xiàn)一個(gè)“篩選”函數(shù)。

注意到filter()函數(shù)返回的是一個(gè)Iterator，也就是一個(gè)惰性序列，所以要強(qiáng)迫filter()完成計(jì)算結(jié)果，需要用list()函數(shù)獲得所有結(jié)果并返回list。

sorted

排序算法

排序也是在程序中經(jīng)常用到的算法。無論使用冒泡排序還是快速排序，排序的核心是比較兩個(gè)元素的大小。如果是數(shù)字，我們可以直接比較，但如果是字符串或者兩個(gè)dict呢？直接比較數(shù)學(xué)上的大小是沒有意義的，因此，比較的過程必須通過函數(shù)抽象出來。

Python內(nèi)置的sorted()函數(shù)就可以對(duì)list進(jìn)行排序：

>>> sorted([36, 5, -12, 9, -21]) [-21, -12, 5, 9, 36]

此外，sorted()函數(shù)也是一個(gè)高階函數(shù)，它還可以接收一個(gè)key函數(shù)來實(shí)現(xiàn)自定義的排序，例如按絕對(duì)值大小排序：

>>> sorted([36, 5, -12, 9, -21], key=abs) [5, 9, -12, -21, 36]

key指定的函數(shù)將作用于list的每一個(gè)元素上，并根據(jù)key函數(shù)返回的結(jié)果進(jìn)行排序。對(duì)比原始的list和經(jīng)過key=abs處理過的list：

list = [36, 5, -12, 9, -21] keys = [36, 5, 12, 9, 21]

然后sorted()函數(shù)按照keys進(jìn)行排序，并按照對(duì)應(yīng)關(guān)系返回list相應(yīng)的元素：

keys排序結(jié)果 => [5, 9, 12, 21, 36] | | | | | 最終結(jié)果 => [5, 9, -12, -21, 36]

我們?cè)倏匆粋€(gè)字符串排序的例子：

>>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob']

默認(rèn)情況下，對(duì)字符串排序，是按照ASCII的大小比較的，由于'Z' < 'a'，結(jié)果，大寫字母Z會(huì)排在小寫字母a的前面。

現(xiàn)在，我們提出排序應(yīng)該忽略大小寫，按照字母序排序。要實(shí)現(xiàn)這個(gè)算法，不必對(duì)現(xiàn)有代碼大加改動(dòng)，只要我們能用一個(gè)key函數(shù)把字符串映射為忽略大小寫排序即可。忽略大小寫來比較兩個(gè)字符串，實(shí)際上就是先把字符串都變成大寫（或者都變成小寫），再比較。

這樣，我們給sorted傳入key函數(shù)，即可實(shí)現(xiàn)忽略大小寫的排序：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower) ['about', 'bob', 'Credit', 'Zoo']

要進(jìn)行反向排序，不必改動(dòng)key函數(shù)，可以傳入第三個(gè)參數(shù)reverse=True：

>>> sorted(['bob', 'about', 'Zoo', 'Credit'], key=str.lower, reverse=True) ['Zoo', 'Credit', 'bob', 'about']

從上述例子可以看出，高階函數(shù)的抽象能力是非常強(qiáng)大的，而且，核心代碼可以保持得非常簡(jiǎn)潔。

小結(jié)

sorted()也是一個(gè)高階函數(shù)。用sorted()排序的關(guān)鍵在于實(shí)現(xiàn)一個(gè)映射函數(shù)。

返回函數(shù)

函數(shù)作為返回值

高階函數(shù)除了可以接受函數(shù)作為參數(shù)外，還可以把函數(shù)作為結(jié)果值返回。

我們來實(shí)現(xiàn)一個(gè)可變參數(shù)的求和。通常情況下，求和的函數(shù)是這樣定義的：

def calc_sum(*args):ax = 0 for n in args: ax = ax + n return ax

但是，如果不需要立刻求和，而是在后面的代碼中，根據(jù)需要再計(jì)算怎么辦？可以不返回求和的結(jié)果，而是返回求和的函數(shù)：

def lazy_sum(*args):def sum(): ax = 0 for n in args: ax = ax + n return ax return sum

當(dāng)我們調(diào)用lazy_sum()時(shí)，返回的并不是求和結(jié)果，而是求和函數(shù)：

>>> f = lazy_sum(1, 3, 5, 7, 9) >>> f <function lazy_sum.<locals>.sum at 0x101c6ed90>

調(diào)用函數(shù)f時(shí)，才真正計(jì)算求和的結(jié)果：

>>> f() 25

在這個(gè)例子中，我們?cè)诤瘮?shù)lazy_sum中又定義了函數(shù)sum，并且，內(nèi)部函數(shù)sum可以引用外部函數(shù)lazy_sum的參數(shù)和局部變量，當(dāng)lazy_sum返回函數(shù)sum時(shí)，相關(guān)參數(shù)和變量都保存在返回的函數(shù)中，這種稱為“閉包（Closure）”的程序結(jié)構(gòu)擁有極大的威力。

請(qǐng)?jiān)僮⒁庖稽c(diǎn)，當(dāng)我們調(diào)用lazy_sum()時(shí)，每次調(diào)用都會(huì)返回一個(gè)新的函數(shù)，即使傳入相同的參數(shù)：

>>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False

f1()和f2()的調(diào)用結(jié)果互不影響。

閉包

注意到返回的函數(shù)在其定義內(nèi)部引用了局部變量args，所以，當(dāng)一個(gè)函數(shù)返回了一個(gè)函數(shù)后，其內(nèi)部的局部變量還被新函數(shù)引用，所以，閉包用起來簡(jiǎn)單，實(shí)現(xiàn)起來可不容易。

另一個(gè)需要注意的問題是，返回的函數(shù)并沒有立刻執(zhí)行，而是直到調(diào)用了f()才執(zhí)行。我們來看一個(gè)例子：

def count():fs = []for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count()

在上面的例子中，每次循環(huán)，都創(chuàng)建了一個(gè)新的函數(shù)，然后，把創(chuàng)建的3個(gè)函數(shù)都返回了。

你可能認(rèn)為調(diào)用f1()，f2()和f3()結(jié)果應(yīng)該是1，4，9，但實(shí)際結(jié)果是：

>>> f1() 9 >>> f2() 9 >>> f3() 9

全部都是9！原因就在于返回的函數(shù)引用了變量i，但它并非立刻執(zhí)行。等到3個(gè)函數(shù)都返回時(shí)，它們所引用的變量i已經(jīng)變成了3，因此最終結(jié)果為9。

返回閉包時(shí)牢記的一點(diǎn)就是：返回函數(shù)不要引用任何循環(huán)變量，或者后續(xù)會(huì)發(fā)生變化的變量。

如果一定要引用循環(huán)變量怎么辦？方法是再創(chuàng)建一個(gè)函數(shù)，用該函數(shù)的參數(shù)綁定循環(huán)變量當(dāng)前的值，無論該循環(huán)變量后續(xù)如何更改，已綁定到函數(shù)參數(shù)的值不變：

def count():def f(j): def g(): return j*j return g fs = [] for i in range(1, 4): fs.append(f(i)) # f(i)立刻被執(zhí)行，因此i的當(dāng)前值被傳入f() return fs

再看看結(jié)果：

>>> f1, f2, f3 = count() >>> f1() 1 >>> f2() 4 >>> f3() 9

缺點(diǎn)是代碼較長(zhǎng)，可利用lambda函數(shù)縮短代碼。

小結(jié)

一個(gè)函數(shù)可以返回一個(gè)計(jì)算結(jié)果，也可以返回一個(gè)函數(shù)。

返回一個(gè)函數(shù)時(shí)，牢記該函數(shù)并未執(zhí)行，返回函數(shù)中不要引用任何可能會(huì)變化的變量。

匿名函數(shù)

當(dāng)我們?cè)趥魅牒瘮?shù)時(shí)，有些時(shí)候，不需要顯式地定義函數(shù)，直接傳入匿名函數(shù)更方便。

在Python中，對(duì)匿名函數(shù)提供了有限支持。還是以map()函數(shù)為例，計(jì)算f(x)=x2時(shí)，除了定義一個(gè)f(x)的函數(shù)外，還可以直接傳入匿名函數(shù)：

>>> list(map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9])) [1, 4, 9, 16, 25, 36, 49, 64, 81]

通過對(duì)比可以看出，匿名函數(shù)lambda x: x * x實(shí)際上就是：

def f(x):return x * x

關(guān)鍵字lambda表示匿名函數(shù)，冒號(hào)前面的x表示函數(shù)參數(shù)。

匿名函數(shù)有個(gè)限制，就是只能有一個(gè)表達(dá)式，不用寫return，返回值就是該表達(dá)式的結(jié)果。

用匿名函數(shù)有個(gè)好處，因?yàn)楹瘮?shù)沒有名字，不必?fù)?dān)心函數(shù)名沖突。此外，匿名函數(shù)也是一個(gè)函數(shù)對(duì)象，也可以把匿名函數(shù)賦值給一個(gè)變量，再利用變量來調(diào)用該函數(shù)：

>>> f = lambda x: x * x >>> f <function <lambda> at 0x101c6ef28> >>> f(5) 25

同樣，也可以把匿名函數(shù)作為返回值返回，比如：

def build(x, y):return lambda: x * x + y * y

小結(jié)

Python對(duì)匿名函數(shù)的支持有限，只有一些簡(jiǎn)單的情況下可以使用匿名函數(shù)。

偏函數(shù)

Python的functools模塊提供了很多有用的功能，其中一個(gè)就是偏函數(shù)（Partial function）。要注意，這里的偏函數(shù)和數(shù)學(xué)意義上的偏函數(shù)不一樣。

在介紹函數(shù)參數(shù)的時(shí)候，我們講到，通過設(shè)定參數(shù)的默認(rèn)值，可以降低函數(shù)調(diào)用的難度。而偏函數(shù)也可以做到這一點(diǎn)。舉例如下：

int()函數(shù)可以把字符串轉(zhuǎn)換為整數(shù)，當(dāng)僅傳入字符串時(shí)，int()函數(shù)默認(rèn)按十進(jìn)制轉(zhuǎn)換：

>>> int('12345') 12345

但int()函數(shù)還提供額外的base參數(shù)，默認(rèn)值為10。如果傳入base參數(shù)，就可以做N進(jìn)制的轉(zhuǎn)換：

>>> int('12345', base=8) 5349 >>> int('12345', 16) 74565

假設(shè)要轉(zhuǎn)換大量的二進(jìn)制字符串，每次都傳入int(x, base=2)非常麻煩，于是，我們想到，可以定義一個(gè)int2()的函數(shù)，默認(rèn)把base=2傳進(jìn)去：

def int2(x, base=2): return int(x, base)

這樣，我們轉(zhuǎn)換二進(jìn)制就非常方便了：

>>> int2('1000000') 64 >>> int2('1010101') 85

functools.partial就是幫助我們創(chuàng)建一個(gè)偏函數(shù)的，不需要我們自己定義int2()，可以直接使用下面的代碼創(chuàng)建一個(gè)新的函數(shù)int2：

>>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85

所以，簡(jiǎn)單總結(jié)functools.partial的作用就是，把一個(gè)函數(shù)的某些參數(shù)給固定住（也就是設(shè)置默認(rèn)值），返回一個(gè)新的函數(shù)，調(diào)用這個(gè)新函數(shù)會(huì)更簡(jiǎn)單。

注意到上面的新的int2函數(shù)，僅僅是把base參數(shù)重新設(shè)定默認(rèn)值為2，但也可以在函數(shù)調(diào)用時(shí)傳入其他值：

>>> int2('1000000', base=10) 1000000

最后，創(chuàng)建偏函數(shù)時(shí)，實(shí)際上可以接收函數(shù)對(duì)象、*args和**kw這3個(gè)參數(shù)，當(dāng)傳入：

int2 = functools.partial(int, base=2)

實(shí)際上固定了int()函數(shù)的關(guān)鍵字參數(shù)base，也就是：

int2('10010')

相當(dāng)于：

kw = { 'base': 2 } int('10010', **kw)

當(dāng)傳入：

max2 = functools.partial(max, 10)

實(shí)際上會(huì)把10作為*args的一部分自動(dòng)加到左邊，也就是：

max2(5, 6, 7)

相當(dāng)于：

args = (10, 5, 6, 7) max(*args)

結(jié)果為10。

小結(jié)

當(dāng)函數(shù)的參數(shù)個(gè)數(shù)太多，需要簡(jiǎn)化時(shí)，使用functools.partial可以創(chuàng)建一個(gè)新的函數(shù)，這個(gè)新函數(shù)可以固定住原函數(shù)的部分參數(shù)，從而在調(diào)用時(shí)更簡(jiǎn)單。

創(chuàng)作挑戰(zhàn)賽新人創(chuàng)作獎(jiǎng)勵(lì)來咯，堅(jiān)持創(chuàng)作打卡瓜分現(xiàn)金大獎(jiǎng)

總結(jié)

以上是生活随笔為你收集整理的Python进阶：函数式编程(高阶函数，map,reduce,filter,sorted,返回函数,匿名函数,偏函数)...啊啊啊...的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯(cuò)，歡迎將生活随笔推薦給好友。