前言

最近在學(xué)習(xí)深度學(xué)習(xí)，已經(jīng)跑出了幾個(gè)模型，但Pyhton的基礎(chǔ)不夠扎實(shí)，因此，開始補(bǔ)習(xí)Python了，大家都推薦廖雪峰的課程，因此，開始了學(xué)習(xí)，但光學(xué)有沒有用，還要和大家討論一下，因此，寫下這些帖子，廖雪峰的課程連接在這里：廖雪峰
Python的相關(guān)介紹，以及它的歷史故事和運(yùn)行機(jī)制，可以參見這篇：python介紹
Python的安裝可以參見這篇：Python安裝
Python的運(yùn)行模式以及輸入輸出可以參見這篇：Python IO
Python的基礎(chǔ)概念介紹，可以參見這篇：Python 基礎(chǔ)
Python字符串和編碼的介紹，可以參見這篇：Python字符串與編碼
Python基本數(shù)據(jù)結(jié)構(gòu)：list和tuple介紹，可以參見這篇：Python list和tuple
Python控制語(yǔ)句介紹：ifelse，可以參見這篇：Python 條件判斷
Python控制語(yǔ)句介紹：循環(huán)實(shí)現(xiàn)，可以參見這篇：Python循環(huán)語(yǔ)句
Python數(shù)據(jù)結(jié)構(gòu)：dict和set介紹Python數(shù)據(jù)結(jié)構(gòu)dict和set
目錄：

• 前言
• 函數(shù)
  • 抽象
• 調(diào)用函數(shù)
  • 調(diào)用abs函數(shù)：
  • 數(shù)據(jù)類型轉(zhuǎn)換
  • 小結(jié)
• 定義函數(shù)
  • 空函數(shù)
  • 參數(shù)檢查
  • 小結(jié)
• 函數(shù)參數(shù)
  • 位置參數(shù)
  • 默認(rèn)參數(shù)
  • 可變參數(shù)
  • 關(guān)鍵字參數(shù)
  • 命名關(guān)鍵字參數(shù)
  • 參數(shù)組合
  • 小結(jié)
• 遞歸函數(shù)
  • 尾遞歸優(yōu)化
  • 小結(jié)
  • 漢諾塔實(shí)現(xiàn)

函數(shù)

我們知道圓的面積計(jì)算公式為：

S=πr2S=πr2

當(dāng)我們知道半徑r的值時(shí)，就可以根據(jù)公式計(jì)算出面積。假設(shè)我們需要計(jì)算3個(gè)不同大小的圓的面積：

r1 = 12.34
r2 = 9.08
r3 = 73.1
s1 = 3.14 * r1 * r1
s2 = 3.14 * r2 * r2
s3 = 3.14 * r3 * r3
當(dāng)代碼出現(xiàn)有規(guī)律的重復(fù)的時(shí)候，你就需要當(dāng)心了，每次寫3.14 * x * x不僅很麻煩，而且，如果要把3.14改成3.14159265359的時(shí)候，得全部替換。
有了函數(shù)，我們就不再每次寫s = 3.14 * x * x，而是寫成更有意義的函數(shù)調(diào)用s = area_of_circle(x)，而函數(shù)area_of_circle本身只需要寫一次，就可以多次調(diào)用。
基本上所有的高級(jí)語(yǔ)言都支持函數(shù)，Python也不例外。Python不但能非常靈活地定義函數(shù)，而且本身內(nèi)置了很多有用的函數(shù)，可以直接調(diào)用。

抽象

抽象是數(shù)學(xué)中非常常見的概念。舉個(gè)例子：
計(jì)算數(shù)列的和，比如：1 + 2 + 3 + … + 100，寫起來十分不方便，于是數(shù)學(xué)家發(fā)明了求和符號(hào)∑，可以把1 + 2 + 3 + … + 100記作：
∑1001n∑1100n
這種抽象記法非常強(qiáng)大，因?yàn)槲覀兛吹?∑ 就可以理解成求和，而不是還原成低級(jí)的加法運(yùn)算。
而且，這種抽象記法是可擴(kuò)展的，比如：
∑1001n2+1∑1100n2+1
還原成加法運(yùn)算就變成了：
(1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + … + (100 x 100 + 1)
可見，借助抽象，我們才能不關(guān)心底層的具體計(jì)算過程，而直接在更高的層次上思考問題。
類比到寫程序也是一樣，函數(shù)就是一種最基本的功能抽象的方式。

調(diào)用函數(shù)

Python內(nèi)置了很多有用的函數(shù)，我們可以直接調(diào)用。
要調(diào)用一個(gè)函數(shù)，需要知道函數(shù)的名稱和參數(shù)，比如求絕對(duì)值的函數(shù)abs，只有一個(gè)參數(shù)。可以直接從Python的官方網(wǎng)站查看文檔：官方文檔
也可以在交互式命令行通過help(abs)查看abs函數(shù)的幫助信息。

調(diào)用abs函數(shù)：

>>> abs(100) 100 >>> abs(-20) 20 >>> abs(12.34) 12.34

調(diào)用函數(shù)的時(shí)候，如果傳入的參數(shù)數(shù)量不對(duì)，會(huì)報(bào)TypeError的錯(cuò)誤，并且Python會(huì)明確地告訴你：abs()有且僅有1個(gè)參數(shù)，但給出了兩個(gè)：

>>> abs(1, 2) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: abs() takes exactly one argument (2 given)

如果傳入的參數(shù)數(shù)量是對(duì)的，但參數(shù)類型不能被函數(shù)所接受，也會(huì)報(bào)TypeError的錯(cuò)誤，并且給出錯(cuò)誤信息：str是錯(cuò)誤的參數(shù)類型：

>>> abs('a') Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: bad operand type for abs(): 'str'

而max函數(shù)max()可以接收任意多個(gè)參數(shù)，并返回最大的那個(gè)：

>>> max(1, 2) 2 >>> max(2, 3, 1, -5) 3

數(shù)據(jù)類型轉(zhuǎn)換

Python內(nèi)置的常用函數(shù)還包括數(shù)據(jù)類型轉(zhuǎn)換函數(shù)，比如int()函數(shù)可以把其他數(shù)據(jù)類型轉(zhuǎn)換為整數(shù)：

>>> int('123') 123 >>> int(12.34) 12 >>> float('12.34') 12.34 >>> str(1.23) '1.23' >>> str(100) '100' >>> bool(1) True >>> bool('') False

函數(shù)名其實(shí)就是指向一個(gè)函數(shù)對(duì)象的引用，完全可以把函數(shù)名賦給一個(gè)變量，相當(dāng)于給這個(gè)函數(shù)起了一個(gè)“別名”：

>>> a = abs # 變量a指向abs函數(shù) >>> a(-1) # 所以也可以通過a調(diào)用abs函數(shù) 1

小結(jié)

調(diào)用Python的函數(shù)，需要根據(jù)函數(shù)定義，傳入正確的參數(shù)。如果函數(shù)調(diào)用出錯(cuò)，一定要學(xué)會(huì)看錯(cuò)誤信息，所以英文很重要！

定義函數(shù)

在Python中，定義一個(gè)函數(shù)要使用def語(yǔ)句，依次寫出函數(shù)名、括號(hào)、括號(hào)中的參數(shù)和冒號(hào):，然后，在縮進(jìn)塊中編寫函數(shù)體，函數(shù)的返回值用return語(yǔ)句返回。

我們以自定義一個(gè)求絕對(duì)值的i_abs函數(shù)為例：

def i_abs(x):if x >= 0:return xelse:return -x print(i_abs(-99)) 99

請(qǐng)自行測(cè)試并調(diào)用my_abs看看返回結(jié)果是否正確。

請(qǐng)注意，函數(shù)體內(nèi)部的語(yǔ)句在執(zhí)行時(shí)，一旦執(zhí)行到return時(shí)，函數(shù)就執(zhí)行完畢，并將結(jié)果返回。因此，函數(shù)內(nèi)部通過條件判斷和循環(huán)可以實(shí)現(xiàn)非常復(fù)雜的邏輯。

如果沒有return語(yǔ)句，函數(shù)執(zhí)行完畢后也會(huì)返回結(jié)果，只是結(jié)果為None。return None可以簡(jiǎn)寫為return。

在Python交互環(huán)境中定義函數(shù)時(shí)，注意Python會(huì)出現(xiàn)…的提示。函數(shù)定義結(jié)束后需要按兩次回車重新回到>>>提示符下：

>>> def my_abs(x): ... if x >= 0: ... return x ... else: ... return -x ... >>> my_abs(-9) 9

請(qǐng)注意，函數(shù)體內(nèi)部的語(yǔ)句在執(zhí)行時(shí)，一旦執(zhí)行到return時(shí)，函數(shù)就執(zhí)行完畢，并將結(jié)果返回。因此，函數(shù)內(nèi)部通過條件判斷和循環(huán)可以實(shí)現(xiàn)非常復(fù)雜的邏輯。
如果沒有return語(yǔ)句，函數(shù)執(zhí)行完畢后也會(huì)返回結(jié)果，只是結(jié)果為None。return None可以簡(jiǎn)寫為return。

在Python交互環(huán)境中定義函數(shù)時(shí)，注意Python會(huì)出現(xiàn)…的提示。函數(shù)定義結(jié)束后需要按兩次回車重新回到>>>提示符下：

如果你已經(jīng)把my_abs()的函數(shù)定義保存為abstest.py文件了，那么，可以在該文件的當(dāng)前目錄下啟動(dòng)Python解釋器，用from abstest import my_abs來導(dǎo)入my_abs()函數(shù)，注意abstest是文件名（不含.py擴(kuò)展名）：

│>>> from abstest import my_abs
│>>> my_abs(-9)
│9
│>>> _
import的用法在后續(xù)模塊一節(jié)中會(huì)詳細(xì)介紹。

空函數(shù)

如果想定義一個(gè)什么事也不做的空函數(shù)，可以用pass語(yǔ)句：

def nop():pass

pass語(yǔ)句什么都不做，那有什么用？實(shí)際上pass可以用來作為占位符，比如現(xiàn)在還沒想好怎么寫函數(shù)的代碼，就可以先放一個(gè)pass，讓代碼能運(yùn)行起來。
pass還可以用在其他語(yǔ)句里，比如：

if age >= 18:pass

缺少了pass，代碼運(yùn)行就會(huì)有語(yǔ)法錯(cuò)誤。

參數(shù)檢查

調(diào)用函數(shù)時(shí)，如果參數(shù)個(gè)數(shù)不對(duì)，Python解釋器會(huì)自動(dòng)檢查出來，并拋出TypeError：

>>> i_abs(1, 2) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: i_abs() takes 1 positional argument but 2 were given

但是如果參數(shù)類型不對(duì)，Python解釋器就無法幫我們檢查。試試my_abs和內(nèi)置函數(shù)abs的差別：

>>> i_abs('A') Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 2, in my_abs TypeError: unorderable types: str() >= int() >>> abs('A') Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: bad operand type for abs(): 'str'

當(dāng)傳入了不恰當(dāng)?shù)膮?shù)時(shí)，內(nèi)置函數(shù)abs會(huì)檢查出參數(shù)錯(cuò)誤，而我們定義的i_abs沒有參數(shù)檢查，會(huì)導(dǎo)致if語(yǔ)句出錯(cuò)，出錯(cuò)信息和abs不一樣。所以，這個(gè)函數(shù)定義不夠完善。
讓我們修改一下i_abs的定義，對(duì)參數(shù)類型做檢查，只允許整數(shù)和浮點(diǎn)數(shù)類型的參數(shù)。數(shù)據(jù)類型檢查可以用內(nèi)置函數(shù)isinstance()實(shí)現(xiàn)：

def my_abs(x):if not isinstance(x, (int, float)):raise TypeError('bad operand type')if x >= 0:return xelse:return -x

添加了參數(shù)檢查后，如果傳入錯(cuò)誤的參數(shù)類型，函數(shù)就可以拋出一個(gè)錯(cuò)誤：

>>> i_abs('A') Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 3, in my_abs TypeError: bad operand type

錯(cuò)誤和異常處理將在后續(xù)講到。
返回多個(gè)值
函數(shù)可以返回多個(gè)值嗎？答案是肯定的。
比如在游戲中經(jīng)常需要從一個(gè)點(diǎn)移動(dòng)到另一個(gè)點(diǎn)，給出坐標(biāo)、位移和角度，就可以計(jì)算出新的新的坐標(biāo)：

import mathdef move(x, y, step, angle=0):nx = x + step * math.cos(angle)ny = y - step * math.sin(angle)return nx, ny

import math語(yǔ)句表示導(dǎo)入math包，并允許后續(xù)代碼引用math包里的sin、cos等函數(shù)。

然后，我們就可以同時(shí)獲得返回值：

>>> x, y = move(100, 100, 60, math.pi / 6) >>> print(x, y) 151.96152422706632 70.0

但其實(shí)這只是一種假象，Python函數(shù)返回的仍然是單一值：

>>> r = move(100, 100, 60, math.pi / 6) >>> print(r) (151.96152422706632, 70.0)

原來返回值是一個(gè)tuple！但是，在語(yǔ)法上，返回一個(gè)tuple可以省略括號(hào)，而多個(gè)變量可以同時(shí)接收一個(gè)tuple，按位置賦給對(duì)應(yīng)的值，所以，Python的函數(shù)返回多值其實(shí)就是返回一個(gè)tuple，但寫起來更方便。

小結(jié)

定義函數(shù)時(shí)，需要確定函數(shù)名和參數(shù)個(gè)數(shù)；
如果有必要，可以先對(duì)參數(shù)的數(shù)據(jù)類型做檢查；
函數(shù)體內(nèi)部可以用return隨時(shí)返回函數(shù)結(jié)果；
函數(shù)執(zhí)行完畢也沒有return語(yǔ)句時(shí)，自動(dòng)return None。
函數(shù)可以同時(shí)返回多個(gè)值，但其實(shí)就是一個(gè)tuple。

函數(shù)參數(shù)

定義函數(shù)的時(shí)候，我們把參數(shù)的名字和位置確定下來，函數(shù)的接口定義就完成了。對(duì)于函數(shù)的調(diào)用者來說，只需要知道如何傳遞正確的參數(shù)，以及函數(shù)將返回什么樣的值就夠了，函數(shù)內(nèi)部的復(fù)雜邏輯被封裝起來，調(diào)用者無需了解。

Python的函數(shù)定義非常簡(jiǎn)單，但靈活度卻非常大。除了正常定義的必選參數(shù)外，還可以使用默認(rèn)參數(shù)、可變參數(shù)和關(guān)鍵字參數(shù)，使得函數(shù)定義出來的接口，不但能處理復(fù)雜的參數(shù)，還可以簡(jiǎn)化調(diào)用者的代碼。

位置參數(shù)

我們先寫一個(gè)計(jì)算x2x2的函數(shù)：

def power(x):return x * x

對(duì)于power(x)函數(shù)，參數(shù)x就是一個(gè)位置參數(shù)。

當(dāng)我們調(diào)用power函數(shù)時(shí)，必須傳入有且僅有的一個(gè)參數(shù)x：

>>> power(5) 25 >>> power(15) 225

現(xiàn)在，如果我們要計(jì)算x3怎么辦？可以再定義一個(gè)power3函數(shù)，但是如果要計(jì)算x4、x5……怎么辦？我們不可能定義無限多個(gè)函數(shù)。

你也許想到了，可以把power(x)修改為power(x, n)，用來計(jì)算xn，說干就干：

def power(x, n):s = 1while n > 0:n = n - 1s = s * xreturn s

對(duì)于這個(gè)修改后的power(x, n)函數(shù)，可以計(jì)算任意n次方：

>>> power(5, 2) 25 >>> power(5, 3) 125

修改后的power(x, n)函數(shù)有兩個(gè)參數(shù)：x和n，這兩個(gè)參數(shù)都是位置參數(shù)，調(diào)用函數(shù)時(shí)，傳入的兩個(gè)值按照位置順序依次賦給參數(shù)x和n。

默認(rèn)參數(shù)

新的power(x, n)函數(shù)定義沒有問題，但是，舊的調(diào)用代碼失敗了，原因是我們?cè)黾恿艘粋€(gè)參數(shù)，導(dǎo)致舊的代碼因?yàn)槿鄙僖粋€(gè)參數(shù)而無法正常調(diào)用：

>>> power(5) Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: power() missing 1 required positional argument: 'n'

Python的錯(cuò)誤信息很明確：調(diào)用函數(shù)power()缺少了一個(gè)位置參數(shù)n。

這個(gè)時(shí)候，默認(rèn)參數(shù)就排上用場(chǎng)了。由于我們經(jīng)常計(jì)算x2，所以，完全可以把第二個(gè)參數(shù)n的默認(rèn)值設(shè)定為2：

def power(x, n=2):s = 1while n > 0:n = n - 1s = s * xreturn s

這樣，當(dāng)我們調(diào)用power(5)時(shí)，相當(dāng)于調(diào)用power(5, 2)：

>>> power(5) 25 >>> power(5, 2) 25

而對(duì)于n > 2的其他情況，就必須明確地傳入n，比如power(5, 3)。

從上面的例子可以看出，默認(rèn)參數(shù)可以簡(jiǎn)化函數(shù)的調(diào)用。設(shè)置默認(rèn)參數(shù)時(shí)，有幾點(diǎn)要注意：

• 一是必選參數(shù)在前，默認(rèn)參數(shù)在后，否則Python的解釋器會(huì)報(bào)錯(cuò)（思考一下為什么默認(rèn)參數(shù)不能放在必選參數(shù)前面）；
• 二是如何設(shè)置默認(rèn)參數(shù)。
• 三當(dāng)函數(shù)有多個(gè)參數(shù)時(shí)，把變化大的參數(shù)放前面，變化小的參數(shù)放后面。變化小的參數(shù)就可以作為默認(rèn)參數(shù)。

使用默認(rèn)參數(shù)有什么好處？最大的好處是能降低調(diào)用函數(shù)的難度。

舉個(gè)例子，我們寫個(gè)一年級(jí)小學(xué)生注冊(cè)的函數(shù)，需要傳入name和gender兩個(gè)參數(shù)：

def enroll(name, gender):print('name:', name)print('gender:', gender)

這樣，調(diào)用enroll()函數(shù)只需要傳入兩個(gè)參數(shù)：

>>> enroll('Sarah', 'F') name: Sarah gender: F

如果要繼續(xù)傳入年齡、城市等信息怎么辦？這樣會(huì)使得調(diào)用函數(shù)的復(fù)雜度大大增加。

我們可以把年齡和城市設(shè)為默認(rèn)參數(shù)：

def enroll(name, gender, age=6, city='Guangzhou'):print('name:', name)print('gender:', gender)print('age:', age)print('city:', city)

這樣，大多數(shù)學(xué)生注冊(cè)時(shí)不需要提供年齡和城市，只提供必須的兩個(gè)參數(shù)：

>>> enroll('Sarah', 'F') name: Sarah gender: F age: 6 city: guangzhou

只有與默認(rèn)參數(shù)不符的學(xué)生才需要提供額外的信息：

enroll('Bob', 'M', 7) enroll('Adam', 'M', city='Tianjin')

可見，默認(rèn)參數(shù)降低了函數(shù)調(diào)用的難度，而一旦需要更復(fù)雜的調(diào)用時(shí)，又可以傳遞更多的參數(shù)來實(shí)現(xiàn)。無論是簡(jiǎn)單調(diào)用還是復(fù)雜調(diào)用，函數(shù)只需要定義一個(gè)。

有多個(gè)默認(rèn)參數(shù)時(shí)，調(diào)用的時(shí)候，既可以按順序提供默認(rèn)參數(shù)，比如調(diào)用enroll(‘Bob’, ‘M’, 7)，意思是，除了name，gender這兩個(gè)參數(shù)外，最后1個(gè)參數(shù)應(yīng)用在參數(shù)age上，city參數(shù)由于沒有提供，仍然使用默認(rèn)值。

也可以不按順序提供部分默認(rèn)參數(shù)。當(dāng)不按順序提供部分默認(rèn)參數(shù)時(shí)，需要把參數(shù)名寫上。比如調(diào)用enroll(‘Adam’, ‘M’, city=’Tianjin’)，意思是，city參數(shù)用傳進(jìn)去的值，其他默認(rèn)參數(shù)繼續(xù)使用默認(rèn)值。
默認(rèn)參數(shù)很有用，但使用不當(dāng)，也會(huì)掉坑里。默認(rèn)參數(shù)有個(gè)最大的坑，演示如下：
先定義一個(gè)函數(shù)，傳入一個(gè)list，添加一個(gè)END再返回：

def add_end(L=[]):L.append('END')return L

當(dāng)你正常調(diào)用時(shí)，結(jié)果似乎不錯(cuò)：

>>> add_end([1, 2, 3]) [1, 2, 3, 'END'] >>> add_end(['x', 'y', 'z']) ['x', 'y', 'z', 'END']

當(dāng)你使用默認(rèn)參數(shù)調(diào)用時(shí)，一開始結(jié)果也是對(duì)的：

>>> add_end() ['END']

但是，再次調(diào)用add_end()時(shí)，結(jié)果就不對(duì)了：

>>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END']

很多初學(xué)者很疑惑，默認(rèn)參數(shù)是[]，但是函數(shù)似乎每次都“記住了”上次添加了’END’后的list。

原因解釋如下：
Python函數(shù)在定義的時(shí)候，默認(rèn)參數(shù)L的值就被計(jì)算出來了，即[]，因?yàn)槟J(rèn)參數(shù)L也是一個(gè)變量，它指向?qū)ο骩],是一個(gè)列表，每次調(diào)用該函數(shù)，如果改變了L的內(nèi)容，則下次調(diào)用時(shí)，默認(rèn)參數(shù)的內(nèi)容就變了，不再是函數(shù)定義時(shí)的[]了。
定義默認(rèn)參數(shù)要牢記一點(diǎn)：默認(rèn)參數(shù)必須指向不變對(duì)象！

要修改上面的例子，我們可以用None這個(gè)不變對(duì)象來實(shí)現(xiàn)：

def add_end(L=None):if L is None:L = []L.append('END')return L現(xiàn)在，無論調(diào)用多少次，都不會(huì)有問題：>>> add_end() ['END'] >>> add_end() ['END']

為什么要設(shè)計(jì)str、None這樣的不變對(duì)象呢？因?yàn)椴蛔儗?duì)象一旦創(chuàng)建，對(duì)象內(nèi)部的數(shù)據(jù)就不能修改，這樣就減少了由于修改數(shù)據(jù)導(dǎo)致的錯(cuò)誤。此外，由于對(duì)象不變，多任務(wù)環(huán)境下同時(shí)讀取對(duì)象不需要加鎖，同時(shí)讀一點(diǎn)問題都沒有。我們?cè)诰帉懗绦驎r(shí)，如果可以設(shè)計(jì)一個(gè)不變對(duì)象，那就盡量設(shè)計(jì)成不變對(duì)象。

可變參數(shù)

在Python函數(shù)中，還可以定義可變參數(shù)。顧名思義，可變參數(shù)就是傳入的參數(shù)個(gè)數(shù)是可變的，可以是1個(gè)、2個(gè)到任意個(gè)，還可以是0個(gè)。

我們以數(shù)學(xué)題為例子，給定一組數(shù)字a，b，c……，請(qǐng)計(jì)算a2 + b2 + c2 + ……。

要定義出這個(gè)函數(shù)，我們必須確定輸入的參數(shù)。由于參數(shù)個(gè)數(shù)不確定，我們首先想到可以把a(bǔ)，b，c……作為一個(gè)list或tuple傳進(jìn)來，這樣，函數(shù)可以定義如下：

def calc(num):sum = 0for n in num:sum = sum + n * nreturn sum

但是調(diào)用的時(shí)候，需要先組裝出一個(gè)list或tuple：

>>> calc([1, 2, 3]) 14 >>> calc((1, 3, 5, 7)) 84

如果利用可變參數(shù)，調(diào)用函數(shù)的方式可以簡(jiǎn)化成這樣：

>>> calc(1, 2, 3) 14 >>> calc(1, 3, 5, 7) 84

所以，我們把函數(shù)的參數(shù)改為可變參數(shù)：

def calc(*num):sum = 0for n in num:sum = sum + n * nreturn sum

定義可變參數(shù)和定義一個(gè)list或tuple參數(shù)相比，僅僅在參數(shù)前面加了一個(gè)*號(hào)。在函數(shù)內(nèi)部，參數(shù)numbers接收到的是一個(gè)tuple，因此，函數(shù)代碼完全不變。但是，調(diào)用該函數(shù)時(shí)，可以傳入任意個(gè)參數(shù)，包括0個(gè)參數(shù)：

>>> calc(1, 2) 5 >>> calc() 0

如果已經(jīng)有一個(gè)list或者tuple，要調(diào)用一個(gè)可變參數(shù)怎么辦？可以這樣做：

>>> nums = [1, 2, 3] >>> calc(nums[0], nums[1], nums[2]) 14

這種寫法當(dāng)然是可行的，問題是太繁瑣，所以Python允許你在list或tuple前面加一個(gè)*號(hào)，把list或tuple的元素變成可變參數(shù)傳進(jìn)去：

>>> nums = [1, 2, 3] >>> calc(*nums) 14

*nums表示把nums這個(gè)list的所有元素作為可變參數(shù)傳進(jìn)去。這種寫法相當(dāng)有用，而且很常見。
這個(gè)來自于c語(yǔ)言的對(duì)地址取值符號(hào)。

關(guān)鍵字參數(shù)

升級(jí)版的可變參數(shù)。
可變參數(shù)允許你傳入0個(gè)或任意個(gè)參數(shù)，這些可變參數(shù)在函數(shù)調(diào)用時(shí)自動(dòng)組裝為一個(gè)tuple。而關(guān)鍵字參數(shù)允許你傳入0個(gè)或任意個(gè)含參數(shù)名的參數(shù)，這些關(guān)鍵字參數(shù)在函數(shù)內(nèi)部自動(dòng)組裝為一個(gè)dict。請(qǐng)看示例：

def person(name, age, **kw):print('name:', name, 'age:', age, 'other:', kw)

函數(shù)person除了必選參數(shù)name和age外，還接受關(guān)鍵字參數(shù)kw。在調(diào)用該函數(shù)時(shí)，可以只傳入必選參數(shù)：

>>> person('Michael', 30) name: Michael age: 30 other: {}

也可以傳入任意個(gè)數(shù)的關(guān)鍵字參數(shù)：

>>> person('Bob', 35, city='Guangzhou') name: Bob age: 35 other: {'city': 'Guangzhou'} >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'}

關(guān)鍵字參數(shù)有什么用？它可以擴(kuò)展函數(shù)的功能。比如，在person函數(shù)里，我們保證能接收到name和age這兩個(gè)參數(shù)，但是，如果調(diào)用者愿意提供更多的參數(shù)，我們也能收到。試想你正在做一個(gè)用戶注冊(cè)的功能，除了用戶名和年齡是必填項(xiàng)外，其他都是可選項(xiàng)，利用關(guān)鍵字參數(shù)來定義這個(gè)函數(shù)就能滿足注冊(cè)的需求。

和可變參數(shù)類似，也可以先組裝出一個(gè)dict，然后，把該dict轉(zhuǎn)換為關(guān)鍵字參數(shù)傳進(jìn)去：

>>> extra = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, city=extra['city'], job=extra['job']) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'}

當(dāng)然，上面復(fù)雜的調(diào)用可以用簡(jiǎn)化的寫法：

extra = {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}
person(‘Jack’, 24, **extra)
name: Jack age: 24 other: {‘city’: ‘Beijing’, ‘job’: ‘Engineer’}

**extra表示把extra這個(gè)dict的所有key-value用關(guān)鍵字參數(shù)傳入到函數(shù)的**kw參數(shù)，kw將獲得一個(gè)dict，注意kw獲得的dict是extra的一份拷貝，對(duì)kw的改動(dòng)不會(huì)影響到函數(shù)外的extra。

命名關(guān)鍵字參數(shù)

對(duì)于關(guān)鍵字參數(shù)，函數(shù)的調(diào)用者可以傳入任意不受限制的關(guān)鍵字參數(shù)。至于到底傳入了哪些，就需要在函數(shù)內(nèi)部通過kw檢查。

仍以person()函數(shù)為例，我們希望檢查是否有city和job參數(shù)：

def person(name, age, **kw):
if ‘city’ in kw:
# 有city參數(shù)
pass
if ‘job’ in kw:
# 有job參數(shù)
pass
print(‘name:’, name, ‘a(chǎn)ge:’, age, ‘other:’, kw)

但是調(diào)用者仍可以傳入不受限制的關(guān)鍵字參數(shù)：

person(‘Jack’, 24, city=’Beijing’, addr=’Chaoyang’, zipcode=123456)

如果要限制關(guān)鍵字參數(shù)的名字，就可以用命名關(guān)鍵字參數(shù)，例如，只接收city和job作為關(guān)鍵字參數(shù)。這種方式定義的函數(shù)如下：

def person(name, age, *, city, job):
print(name, age, city, job)

和關(guān)鍵字參數(shù)*kw不同，命名關(guān)鍵字參數(shù)需要一個(gè)特殊分隔符，*后面的參數(shù)被視為命名關(guān)鍵字參數(shù)。

調(diào)用方式如下：

>>> person('Jack', 24, city='Beijing', job='Engineer') Jack 24 Beijing Engineer

如果函數(shù)定義中已經(jīng)有了一個(gè)可變參數(shù)，后面跟著的命名關(guān)鍵字參數(shù)就不再需要一個(gè)特殊分隔符*了：

def person(name, age, *args, city, job):print(name, age, args, city, job)

命名關(guān)鍵字參數(shù)必須傳入?yún)?shù)名，這和位置參數(shù)不同。如果沒有傳入?yún)?shù)名，調(diào)用將報(bào)錯(cuò)：

>>> person('Jack', 24, 'Beijing', 'Engineer') Traceback (most recent call last):File "<stdin>", line 1, in <module> TypeError: person() takes 2 positional arguments but 4 were given

由于調(diào)用時(shí)缺少參數(shù)名city和job，Python解釋器把這4個(gè)參數(shù)均視為位置參數(shù)，但person()函數(shù)僅接受2個(gè)位置參數(shù)。

命名關(guān)鍵字參數(shù)可以有缺省值，從而簡(jiǎn)化調(diào)用：

def person(name, age, *, city='Beijing', job):print(name, age, city, job)

由于命名關(guān)鍵字參數(shù)city具有默認(rèn)值，調(diào)用時(shí)，可不傳入city參數(shù)：

>>> person('Jack', 24, job='Engineer') Jack 24 Beijing Engineer

使用命名關(guān)鍵字參數(shù)時(shí)，要特別注意，如果沒有可變參數(shù)，就必須加一個(gè)* 作為特殊分隔符。如果缺少*，Python解釋器將無法識(shí)別位置參數(shù)和命名關(guān)鍵字參數(shù)：

def person(name, age, city, job):# 缺少 *，city和job被視為位置參數(shù)pass

參數(shù)組合

在Python中定義函數(shù)，可以用必選參數(shù)、默認(rèn)參數(shù)、可變參數(shù)、關(guān)鍵字參數(shù)和命名關(guān)鍵字參數(shù)，這5種參數(shù)都可以組合使用。但是請(qǐng)注意，參數(shù)定義的順序必須是：必選參數(shù)、默認(rèn)參數(shù)、可變參數(shù)、命名關(guān)鍵字參數(shù)和關(guān)鍵字參數(shù)。

比如定義一個(gè)函數(shù)，包含上述若干種參數(shù)：

def f1(a, b, c=0, *args, **kw):print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)def f2(a, b, c=0, *, d, **kw):print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

在函數(shù)調(diào)用的時(shí)候，Python解釋器自動(dòng)按照參數(shù)位置和參數(shù)名把對(duì)應(yīng)的參數(shù)傳進(jìn)去。

>>> f1(1, 2) a = 1 b = 2 c = 0 args = () kw = {} >>> f1(1, 2, c=3) a = 1 b = 2 c = 3 args = () kw = {} >>> f1(1, 2, 3, 'a', 'b') a = 1 b = 2 c = 3 args = ('a', 'b') kw = {} >>> f1(1, 2, 3, 'a', 'b', x=99) a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99} >>> f2(1, 2, d=99, ext=None) a = 1 b = 2 c = 0 d = 99 kw = {'ext': None}

最神奇的是通過一個(gè)tuple和dict，你也可以調(diào)用上述函數(shù)：

>>> args = (1, 2, 3, 4) >>> kw = {'d': 99, 'x': '#'} >>> f1(*args, **kw) a = 1 b = 2 c = 3 args = (4,) kw = {'d': 99, 'x': '#'} >>> args = (1, 2, 3) >>> kw = {'d': 88, 'x': '#'} >>> f2(*args, **kw) a = 1 b = 2 c = 3 d = 88 kw = {'x': '#'}

所以，對(duì)于任意函數(shù)，都可以通過類似func(*args, **kw)的形式調(diào)用它，無論它的參數(shù)是如何定義的。
雖然可以組合多達(dá)5種參數(shù)，但不要同時(shí)使用太多的組合，否則函數(shù)接口的可理解性很差。

小結(jié)

Python的函數(shù)具有非常靈活的參數(shù)形態(tài)，既可以實(shí)現(xiàn)簡(jiǎn)單的調(diào)用，又可以傳入非常復(fù)雜的參數(shù)。
默認(rèn)參數(shù)一定要用不可變對(duì)象，如果是可變對(duì)象，程序運(yùn)行時(shí)會(huì)有邏輯錯(cuò)誤！
要注意定義可變參數(shù)和關(guān)鍵字參數(shù)的語(yǔ)法：
*args是可變參數(shù)，args接收的是一個(gè)tuple；
**kw是關(guān)鍵字參數(shù)，kw接收的是一個(gè)dict。
以及調(diào)用函數(shù)時(shí)如何傳入可變參數(shù)和關(guān)鍵字參數(shù)的語(yǔ)法：
可變參數(shù)既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過args傳入：func((1, 2, 3))；
關(guān)鍵字參數(shù)既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過kw傳入：func({‘a(chǎn)’: 1, ‘b’: 2})。
使用*args和**kw是Python的習(xí)慣寫法，當(dāng)然也可以用其他參數(shù)名，但最好使用習(xí)慣用法。
命名的關(guān)鍵字參數(shù)是為了限制調(diào)用者可以傳入的參數(shù)名，同時(shí)可以提供默認(rèn)值。
定義命名的關(guān)鍵字參數(shù)在沒有可變參數(shù)的情況下不要忘了寫分隔符*，否則定義的將是位置參數(shù)。

遞歸函數(shù)

在函數(shù)內(nèi)部，可以調(diào)用其他函數(shù)。如果一個(gè)函數(shù)在內(nèi)部調(diào)用自身本身，這個(gè)函數(shù)就是遞歸函數(shù)。
舉個(gè)例子，我們來計(jì)算階乘n! = 1 x 2 x 3 x … x n，用函數(shù)fact(n)表示，可以看出：

fact(n) = n! = 1 x 2 x 3 x ... x (n-1) x n = (n-1)! x n = fact(n-1) x n

所以，fact(n)可以表示為n x fact(n-1)，只有n=1時(shí)需要特殊處理。

于是，fact(n)用遞歸的方式寫出來就是：

def fact(n):if n==1:return 1return n * fact(n - 1)

上面就是一個(gè)遞歸函數(shù)。可以試試：

>>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

如果我們計(jì)算fact(5)，可以根據(jù)函數(shù)定義看到計(jì)算過程如下：

===> fact(5) ===> 5 * fact(4) ===> 5 * (4 * fact(3)) ===> 5 * (4 * (3 * fact(2))) ===> 5 * (4 * (3 * (2 * fact(1)))) ===> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120

遞歸函數(shù)的優(yōu)點(diǎn)是定義簡(jiǎn)單，邏輯清晰。理論上，所有的遞歸函數(shù)都可以寫成循環(huán)的方式，但循環(huán)的邏輯不如遞歸清晰。

使用遞歸函數(shù)需要注意防止棧溢出。在計(jì)算機(jī)中，函數(shù)調(diào)用是通過棧（stack）這種數(shù)據(jù)結(jié)構(gòu)實(shí)現(xiàn)的，每當(dāng)進(jìn)入一個(gè)函數(shù)調(diào)用，棧就會(huì)加一層棧幀，每當(dāng)函數(shù)返回，棧就會(huì)減一層棧幀。由于棧的大小不是無限的，所以，遞歸調(diào)用的次數(shù)過多，會(huì)導(dǎo)致棧溢出。可以試試fact(1000)：

>>> fact(1000) Traceback (most recent call last):File "<stdin>", line 1, in <module>File "<stdin>", line 4, in fact...File "<stdin>", line 4, in fact RuntimeError: maximum recursion depth exceeded in comparison

解決遞歸調(diào)用棧溢出的方法是通過尾遞歸優(yōu)化，事實(shí)上尾遞歸和循環(huán)的效果是一樣的，所以，把循環(huán)看成是一種特殊的尾遞歸函數(shù)也是可以的。

尾遞歸優(yōu)化

尾遞歸是指，在函數(shù)返回的時(shí)候，調(diào)用自身本身，并且，return語(yǔ)句不能包含表達(dá)式。這樣，編譯器或者解釋器就可以把尾遞歸做優(yōu)化，使遞歸本身無論調(diào)用多少次，都只占用一個(gè)棧幀，不會(huì)出現(xiàn)棧溢出的情況。
上面的fact(n)函數(shù)由于return n * fact(n - 1)引入了乘法表達(dá)式，所以就不是尾遞歸了。要改成尾遞歸方式，需要多一點(diǎn)代碼，主要是要把每一步的乘積傳入到遞歸函數(shù)中：

def fact(n):return fact_iter(n, 1)def fact_iter(num, product):if num == 1:return productreturn fact_iter(num - 1, num * product)

可以看到，return fact_iter(num - 1, num * product)僅返回遞歸函數(shù)本身，num - 1和num * product在函數(shù)調(diào)用前就會(huì)被計(jì)算，不影響函數(shù)調(diào)用。

fact(5)對(duì)應(yīng)的fact_iter(5, 1)的調(diào)用如下：

===> fact_iter(5, 1) ===> fact_iter(4, 5) ===> fact_iter(3, 20) ===> fact_iter(2, 60) ===> fact_iter(1, 120) ===> 120

尾遞歸調(diào)用時(shí)，如果做了優(yōu)化，棧不會(huì)增長(zhǎng)，因此，無論多少次調(diào)用也不會(huì)導(dǎo)致棧溢出。

遺憾的是，大多數(shù)編程語(yǔ)言沒有針對(duì)尾遞歸做優(yōu)化，Python解釋器也沒有做優(yōu)化，所以，即使把上面的fact(n)函數(shù)改成尾遞歸方式，也會(huì)導(dǎo)致棧溢出。

小結(jié)

使用遞歸函數(shù)的優(yōu)點(diǎn)是邏輯簡(jiǎn)單清晰，缺點(diǎn)是過深的調(diào)用會(huì)導(dǎo)致棧溢出。
針對(duì)尾遞歸優(yōu)化的語(yǔ)言可以通過尾遞歸防止棧溢出。尾遞歸事實(shí)上和循環(huán)是等價(jià)的，沒有循環(huán)語(yǔ)句的編程語(yǔ)言只能通過尾遞歸實(shí)現(xiàn)循環(huán)。
Python標(biāo)準(zhǔn)的解釋器沒有針對(duì)尾遞歸做優(yōu)化，任何遞歸函數(shù)都存在棧溢出的問題。

漢諾塔實(shí)現(xiàn)

def move(n,a,b,c):if n==1:print(a +'->'+c)else:move(n-1,a,c,b)move(1,a,b,c)move(n-1,b,a,c)

總結(jié)

以上是生活随笔為你收集整理的Python学习笔记：函数的全部?jī)?nèi)容，希望文章能夠幫你解決所遇到的問題。

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