Python基礎語法：函數

1 函數定義

1.1 函數概述

在程式設計中，函數的使用可以提升代碼的復用率和可維護性。

提升代碼的復用率： 程式設計中，一些代碼的功能是相同的，操作是一樣的，只不過針對的數據不一樣。此種情況下，可以將這種功能寫成一個函數模塊，要使用此功能時只需調用這個函數模塊就可以了。
提升代碼的可維護性： 使用函數後，實現了代碼的復用，某個功能需要核查或修改時，只需要核查或修改此功能相對應的函數就可以了。對功能的修改可以使調用該函數的所有模塊同時生效，極大提升了代碼的可維護性。

內建函數：內建函數也叫內置函數，即系統已經定義好的函數，開發者可以直接調用。為了使開發者對內函數和自定義函數有一個直觀的認識，下麵給出一個簡單示例。

調用系統內建函數pow()：

pow(2, 4)

自定義函數func()：

def func(a, b):
    return a ** b


func(2, 4)

上述代碼中，首先調用了Python語言的內建函數pow()進行冪運算；
然後，自定義了一個函數func()，功能是輸出a的b次冪；最後調用了自定義函數func()，輸出相應的結果。可以看出，Python語言中函數的定義和使用都是非常便捷的。

1.2 函數的定義

在Python語言中，函數通常是由函數名、參數列表以及一系列語句組成的函數體構成的。函數定義的一般格式如下：

def 函數名(參數列表)：
    函數體

例如：

def hello():
    print("hello")
    print("world!")

以上實例定義的hello()函數雖然不包含任何參數，但是函數名後的一對括弧是不能省略的。在實際應用中，稍複雜的函數通常都會包含一個或多個參數。

下列代碼定義了一個計算矩形面積的函數area()和一個歡迎信息列印函數welcome()。

# 計算矩形面積的函數area()
def area(width, height):
    return width * height


# 輸出漢英信息的函數
def welcome(name):
    print("Welcome ", name)


# 調用welcome函數
welcome('張三')
# 調用area函數
w = 4
h = 9
print("with=", w, "height=", h, "area=", area(w, h))

上述代碼中，首先定義了area()和welcome()兩個函數，其中函數area()提供了width（寬）和height（高）兩個參數，函數welcome()函數只提供了一個參數name。然後，分別調用了area()和welcome()函數，在控制台輸出了相應的結果，結果如下：

Welcome  張三
with= 4 height= 9 area= 36

以下代碼定義了無任何操作的空函數nop()。

def nop():
    pass

在Python代碼中，pass語句通常可以用來作為占位符，表示什麼操作都不執行。比如在項目起始階段，如果還沒想好函數具體實現時，可以先放置一個pass語句，讓代碼先成功運行起來。待項目框架搭建完畢後，在進行相應的具體實現。

通常情況下，在Python語言中定義一個具有特定功能的函數需要符合以下規則：

• 函數代碼塊以def關鍵字開頭，後接函數標識符名稱和形參列表；
• 任何傳入的參數和自變數必須放在圓括弧內；
• 函數的第一行語句可以選擇性地使用文檔字元串（即函數說明）；
• 函數內容以冒號起始，並且嚴格統一縮進；
• 函數都有返回值，預設返回None。

1.3 形參和實參

在編程語言中，函數定義時用的是形參，調用時用的是實參

形參（parameter），全稱為"形式參數"，不是實際存在的變數，又稱虛擬變數。形參是在定義函數名和函數體的時候使用的參數，目的是用來接收調用該函數時傳入的參數。

實參(argument)，全稱為"實際參數"，是在調用時傳遞給函數的參數。實參可以是常量、變數、表達式、函數等。無論實參是何種類型的量，在進行函數調用時，它們都必須具有確定的值，以便把這些值傳送給形參。

形參和實參的功能是數據傳送。

在調用函數時，實參將賦值給形參。必須註意實參的個數、類型應與形參要一一對應，並且實參必須要有確定的值。形參的作用域一般僅限函數體內部，而實參的作用域根據實際設置而定。

以計算面積的函數為例：

# 計算矩形面積的函數area()
def area(width, height):
    return width * height


# 調用area函數
w = 4
h = 9
print("with=", w, "height=", h, "area=", area(w, h))

上述代碼中，函數area()定義處的width和height就是形式參數，函數體外定義的變數w和h是實際參數。可以看到，把實參w和h傳入函數體後，就把相應的值賦值給了形參width和height。形參width和height的作用域只限於area()函數體內，而實參w和h作用域則根據外部調用處的設置而定。

對於函數形參列表，預設情況下函數調用時的參數值與參數列表聲明中定義的順序是一致。Python語言也允許函數調用時參數順序與聲明時不一致，即顯示指明關鍵字參數，並根據參數的指定進行賦值。

def func(x, y):
    print('x+y=', x + y)
    print('x*y=', x * y)


# 等效於func(x=3,y=2)，也等效於func(3,2)
func(y=2, x=3)

上述代碼中，函數func()定義時形式參數的順序是func(x, y)，但是調用時實際參數的順序確是func(y = 1, x = 2)。這是因為Python語言中提供了一種關鍵字參數的機制，可以給開發者提供更大的靈活性。

1.4 函數的返回值

函數的返回值是函數執行完成後，系統根據函數的具體定義返回給外部調用者的值。

在實際開發中，有時不僅僅要執行某個函數的功能，而且還需要把該函數的執行結果作為其他函數或功能的計算單元。所以，函數返回值是非常有用的

在Python語言中，當函數運行到return語句時即執行完畢，同時將結果返回。因此，可以在函數內部通過條件判斷和迴圈設置實現較複雜的邏輯，並返回預期的結果。如果沒有return語句，函數體內所有語句執行完畢後預設返回None。

# 函數定義
def add(x, y):
    print('x+y=', x + y)
    return x + y


# 函數調用
result = add(y=1, x=2)
print(result)

上述代碼中，定義的add()函數返回“x+y”的運算結果。可以看到，調用該函數後，把該函數的返回值賦值給了變數result ，最後輸出了變數result 的值。

另外需要註意的是，在Python語言中，函數也可以有多個返回值，例如：

# 函數定義
def add(x, y):
    print('x+y=', x + y)
    print('x*y=', x * y)
    return x + y, x * y


# 函數調用
a, b = add(y=1, x=2)
print(a, b)

上述代碼中，定義的add()函數有連個返回值，分別是“x+y”和“x*y”。可以看到，調用該函數後，把該函數的返回值分別賦值給變數a，b，最後輸出了變數a和變數b的值。

註意： 返回值和接收變數的對應關係，是按照順序一一對應的

2 函數分類

2.1 內置函數

Python語言中自帶的函數叫做內建函數，這些內建函數對大部分常用操作進行有效封裝，可以直接調用，為開發提供了極大便利。由於內建函數是Python語言內置的函數，因此不需要導入任何函數庫即可直接調用，常用的內建函數如圖所示。

在Python語言中，除內建函數外的其他類型函數通常被稱為第三方函數。

• 第三方函數一般是由其它開發者或組織針對某些特定需求編寫的函數庫，並共用給大家使用。Python語言的強大功能，也正是得益於其豐富的第三方函數庫。不管是內建函數，還是第三方函數，在Python語言中都可以非常方便的使用。
• 要成功調用一個內建函數或第三方函數，首先需要知道的是該函數的準確名稱和參數列表信息。如求絕對值的內建函數abs()有一個數值類型參數。

以下代碼演示了內建函數abs()的調用過程及內建函數max()的調用。

abs(100)
abs(-10)
max(1, 2)
max(-2, 0, 4, 1)

從上述代碼可以看出，內建函數max（）可以同時返回多個數值的最大值，而其他編程語言中的類似函數一般只能接收兩個變數。Python語言中內建函數的功能強大可見一斑。

Python語言常用的內建函數還包括數據類型轉換函數，以下代碼演示了常用類型轉換函數的方法。

print("int('12'):", int('12'))
print("int(12.3):", int(12.3))
print("float('12.3'):", float('12.3'))
print("str(1.23):", str(1.23))
print("str(10):", str(10))
print("bool(1):", bool(1))
print("bool(''):", bool(''))

輸出結果：

int('12'): 12
int(12.3): 12
float('12.3'): 12.3
str(1.23): 1.23
str(10): 10
bool(1): True
bool(''): False

上述代碼中，分別演示了內建函數int()、float()、str()和bool()的使用方法。其中，int()函數是把傳入的參數轉換為整數類型，float ()函數是把傳入的參數轉換為浮點類型，str()函數是把傳入的參數轉換為字元串類型，bool()函數是把傳入的參數轉換為布爾類型。

在Python語言中，還可以把函數名賦給一個變數，相當於給這個函數起了一個“別名”，如下代碼所示。

a = abs
print(a(-1))

這裡需註意，abs沒有小括弧，因此加了小括弧相當於調用函數了。Python語言中提供內建函數還有很多，由於篇幅限制，在此不一一列出。內建函數功能強大，理解並熟練掌握能較大提升開發效率。

2.2 自定義函數

當內建函數不能滿足要求時，開發者可以根據實際需要自定義函數。函數自定義完成後，開發者可以在其他代碼處通過函數名調用。如下代碼演示了自定義函數printme()的定義和調用過程。

# 自定義函數
def printme(str):
    "函數功能：列印傳入的字元串"
    print(str)


# 調用自定義函數
printme("調用用戶自定義函數！")
printme("再次調用用戶自定義函數！")

輸出結果：

調用用戶自定義函數！
再次調用用戶自定義函數！

上述代碼中，自定義了一個函數printme()，並對其進行兩次調用，測試相應功能。在實際開發中，涉及到大量的自定義函數。在自定義函數中，也可以調用內建函數或其他自定義函數。自定義函數和內建函數的定義方式是相同，只不過是自定義函數是有開發者定義的，而內建函數是由系統定義的。兩者的調用方式都是一樣的。

在Python語言中，內建函數可以直接使用，第三方函數需要使用import命令導入相應的庫才能使用。對於自定義函數，其定義和調用可以在同一個文件中，也可分離成不同的文件。

from test import hello

hello()

上述代碼演示了函數的定義和調用不在一個文件的情形。首先，將hello()函數定義好並保存為test.py文件，然後使用Python語言的import指令“from test import hello”將該文件導入，可以調用hello()函數了。導入時需要註意test是文件名並且不含.py擴展名。

3 函數參數

3.1 參數種類

函數參數分為可變類型和不可變類型，其調用結果是不同的。
  （1）可變類型：類似c++的引用傳遞，如列表、字典等。如果傳遞的參數是可變類型，則在函數內部對傳入參數的修改會影響到外部變數。

（2）不可變類型：類似c++的值傳遞，如整數、字元串、元組等。如果傳遞的參數是不可變類型，則在函數內部對傳入參數的修改不會影響到外部變數。

不可變類型參數實例：

def change_int(a):
    a = 10


b = 2
change_int(b)
print(b)  # 結果是2

上述實例中，有int類型的對象2，指向它的變數是b。在傳遞給change_int（）函數時，按傳值方式複製了變數b，a和b都指向了同一個int對象。在a=10時，則新生成一個int值對象10，並讓a指向它。
一個更詳細的例子，用id列印出變數的記憶體地址，可以看出函數內核函數外的記憶體發生了變化，說明用的是不同的記憶體單元，存放不同的數據：

可變類型參數實例：

def change_int(my_list):
    "修改傳入的列表"
    my_list.append([1, 2, 3])
    print("函數內修改後的變數：", my_list)


my_list = [10, 20, 30]
change_int(my_list)
print("函數外變數的值：", my_list)

在調用函數時，如果傳入的參數是可變類型，則外部變數也會被更改。在上述例子中，傳入函數的list對象和在末尾添加新內容的mylist對象用的是同一個引用。

從下圖中記憶體地址可以看出，變數的記憶體地址沒有發生變化，說明是用的同一塊記憶體：

• 在定義函數時，開發者把參數的名字和位置確定後，函數的介面定義就完成了。
• Python語言的函數定義非常簡單，但靈活度卻非常大。
• 函數定義中可能包含多個形參，因此函數調用中也可能包含多個實參。
• 想讓函數傳遞實參的方式有很多，可使用位置實參，要求傳入參數和定義參數的順序相同；也可使用關鍵字實參，每個實參都由變數名和值組成

3.2 位置參數

調用函數時，Python語言必須將函數調用中的每個實參都關聯到函數的相應形參。最簡單的關聯方式是基於實參的順序，這種關聯方式被稱為位置實參。下麵代碼顯示學生信息的函數，該函數輸出學生的名字及年齡。

def describe_student(person_name, student_age):
    "函數功能：顯示學生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('Jack', '24')

輸出：

my name is  Jack
Jackis24years old

上述函數describe_student()的定義表明，它需要姓名和年齡兩個參數。調用describe_student()函數時，需要按順序提供姓名和年齡參數。函數調用時，實參’Jack’ 存儲在形參person_name中，而實參’24’ 存儲在形參student_age 中。

定義了函數後，開發者可以根據需要多次調用函數。如果需要再描述一名學生，只需再次調用describe_student() 即可，如下代碼所示。

def describe_student(person_name, student_age):
    "函數功能：顯示學生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('Jack', '24')
describe_student('Bob', '17')

結果：

my name is  Jack
Jackis24years old
my name is  Bob
Bobis17years old

調用函數是一種效率極高的開發方式。如在上例中，開發者只需在函數中編寫描述學生的代碼一次，以後需要描述新學生時，都可調用這個函數，並向它提供新的學生信息。即便描述全校的學生，依然只需使用一行調用函數的代碼，就可實現所需功能。

在函數中，可根據需要使用任意數量的位置實參。Python語言將按順序將函數調用中的實參關聯到函數定義中相應的形參。但要註意的是，在使用位置實參來調用函數時，如果實參的順序不正確，結果可能出乎意料，如下代碼所示。

def describe_student(person_name, student_age):
    "函數功能：顯示學生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('18', 'Jack')

結果：

my name is  18
18isJackyears old

在上述函數調用中，開發者先指定名字，再指定學生年齡。由於實參’18’ 在前，這個值將存儲到形參person_name中；同理，‘Jack’ 將存儲到形參student_age中。在實際開發中，如果執行結果和預期不一致，請核查函數調用中實參的順序與函數定義中形參的順序是否一致。

3.3 預設參數

編寫函數時，可給每個形參指定預設值。在調用函數時，如果給形參提供了實參，Python語言將使用指定的實參值；否則，將使用形參的預設值。給形參指定預設值後，可在函數調用中省略相應的實參。使用預設值可簡化函數調用，還可清楚地指出函數的典型用法。如下方式調用describe_student（）函數會出現錯誤。

def describe_student(person_name, student_age):
    "函數功能：顯示學生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('Jack')

提示錯誤信息：

Traceback (most recent call last):
  File "D:/python_demo/demo_2.py", line 88, in <module>
    describe_student('Jack')
TypeError: describe_student() missing 1 required positional argument: 'student_age'

上述代碼中，提示的錯誤信息很明確，就是調用函數describe_student()時缺少了一個位置參數student_age。這個時候，預設參數就排上用場了

若大部分學生的年齡為18歲，開發者可以把第二個參數student_age的預設值設定為18，這樣，當開發者調用describe_student(Jack)時，相當於調用describe_student(Jack,18) ，如下代碼所示。

def describe_student(person_name, student_age='18'):
    "函數功能：顯示學生的信息"
    print("my name is ", person_name)
    print(person_name + "is" + student_age + "years old")


describe_student('Jack')
describe_student('Jack', '18')

結果：

my name is  Jack
Jackis18years old
my name is  Jack
Jackis18years old

對於年齡不是18歲的學生，就必須明確地傳入student_age，如describe_student(‘Herbie’,19)。從上面的例子可以看出，預設參數可以簡化函數的調用。

要註意的是，設置預設參數時，必選參數在前，預設參數在後，否則Python語言的解釋器會報錯。使用預設參數最大的好處是能降低調用函數的難度。編寫一個學生註冊的函數，需要傳入name和gender兩個參數。

def enroll(name, gender):
    "註冊學生的信息"
    print("name:", name)
    print("gender:", gender)


enroll('Jack', 'F')

結果：

name: Jack
gender: F

def enroll(name, gender, age='18', city='Beijing'):
    "註冊學生的信息"
    print("name:", name)
    print("gender:", gender)
    print("age:", age)
    print("city:", city)


enroll('Sarah', 'F')
print('-' * 70)
enroll('Sarah', 'M', '17')

結果：

name: Sarah
gender: F
age: 18
city: Beijing
----------------------------------------------------------------------
name: Sarah
gender: M
age: 17
city: Beijing

預設參數降低了函數調用的難度，而一旦需要更複雜的調用時，又可以傳遞更多的參數來實現。無論是簡單調用還是複雜調用，函數只需要定義一個；當有多個預設參數時，調用時可以按順序提供預設參數。

預設參數很有用，但使用時要牢記一點，預設參數必須指向不可變對象，否則會出現錯誤，如下代碼所示。

def test_add(a=[]):
    a.append('END')
    return a


print(test_add([1, 2, 3]))
print(test_add(['a', 'b', 'c']))
print(test_add())
print(test_add())
print(test_add())

結果：

[1, 2, 3, 'END']
['a', 'b', 'c', 'END']
['END']
['END', 'END']
['END', 'END', 'END']

從上述代碼可以看出，預設參數是空列表[]，但是函數test_add()似乎每次都“記住了”上次添加了’END’後的list。這是因為在Python語言中，函數在定義的時候，預設參數H的值就被計算出來了，即[]。因為預設參數H也是一個變數，它指向對象[]。每次調用該函數，如果改變了H的內容，則下次調用時，預設參數的內容就變了，不再是函數定義時的[]了。

開發者也可以用None這個不可變對象來解決報錯問題，如下代碼所示。

def test_add(H=None):
    if H is None:
        H = []
    H.append('END')
    return H


print(test_add())
print(test_add())

結果：

['END']
['END']

對於str、None等類似的不可變對象一旦創建，其內部數據就不能修改，這樣就減少了由於修改數據導致的錯誤。

此外，由於對象不變，多線程環境下同時讀取對象不需要加鎖，同時讀也沒有問題。開發者在編寫程式時，如果可以設計一個不可變對象，就儘量設計成不可變對象。

3.4 不定長參數

在Python語言中，函數還可以定義不定長參數，也叫可變參數。給定一組數字a，b，c……，請計算a+b+c+ ……。要定義出這個函數，必須確定輸入的參數。開發者可以把a，b，c……作為一個list或tuple傳進來。

def calc(numbers):
    sum = 0
    for n in numbers:
        sum = sum + n
    return sum


print(calc([1, 2, 3])) # 結果是6
print(calc([1, 2, 3,4])) # 結果是10

對於以上定義的求和函數，調用的時候，需要先組裝出一個list或tuple；在Python語言中，可以在函數參數前面添加“*”號把該參數定義為不定長參數；可以看出，不定長參數的使用使得calc()函數定義和調用都變得簡潔，實例如下所示：

def calc(*numbers):
    sum = 0
    for n in numbers:
        sum = sum + n
    return sum


print(calc(1, 2, 3, 4))
print(calc())
num = [1, 2, 3]
print(calc(*num))

結果：

10
0
6

3.5 關鍵字參數

關鍵字實參是傳遞參數時使用“名稱–值”對的方式，在實參中將名稱和值關聯起來。
關鍵字實參讓開發者無需考慮函數調用中的實參順序，清楚地指出了函數調用中各個值的用途。
關鍵字參數有擴展函數的功能。

3.6 命名關鍵字參數

如果要限制關鍵字參數的名字，可以用命名關鍵字參數。和關鍵字參數**kw不同，如果沒有可變參數，命名關鍵字參數就必須加一個“”號作為特殊分隔符。如果缺少“”，Python語言解釋器將無法識別位置參數和命名關鍵字參數。例如，若只接收age和city作為關鍵字參數，可以採用如下形式。

def enroll(name, gender, *, age, city):
    print(name, gender, age, city)


enroll('Jack', 'M', age='18', city='Beijing')

輸出

Jack M 18 Beijing

結果報錯：

Traceback (most recent call last):
  File "D:/python_spider/python_demo/demo_2.py", line 119, in <module>
    enroll('Jack', 'M', '18', 'Beijing')
TypeError: enroll() missing 2 required keyword-only arguments: 'age' and 'city'

def enroll(name, gender, *, age='18', city):
    print(name, gender, age, city)


enroll('Jack', 'M', city='Beijing') # 結果是：Jack M 18 Beijing

註意：
*表示不定長參數
**表示不定長的關鍵字參數

3.7 參數組合

在Python語言中定義函數，開發者可以組合使用這些參數（必選參數、預設參數、可變參數、關鍵字參數和命名關鍵字參數）。註意參數定義是有順序的。定義的順序必須是：必選參數、預設參數、可變參數、命名關鍵字參數和關鍵字參數。比如要定義一個函數，包含上述若幹種參數，如下代碼所示。

def func(a, b, c=0, *args, **kw):
    print('a=', a, 'b=', b, 'c=', c, 'args=', args, 'kw=', kw)


print(func(1, 2))  
# 輸出結果：a= 1 b= 2 c= 0 args= () kw= {}
print(func(1, 2, c=3))  
# 輸出結果：a= 1 b= 2 c= 3 args= () kw= {}
print(func(1, 2, 3, 'a', 'b'))  
# 輸出結果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {}
print(func(1, 2, 3, 'a', 'b', x=4))  
# 輸出結果：a= 1 b= 2 c= 3 args= ('a', 'b') kw= {'x': 4}
args = (1, 2, 3, 4)
kw = {'x': 5}
print(func(*args, **kw))  
# 輸出結果：a= 1 b= 2 c= 3 args= (4,) kw= {'x': 5}

4 函數式編程

• 函數式編程是一種編程範式，是面向數學的抽象，其將計算描述為一種表達式求值。
• 函數式編程中的“函數”不是指電腦中的函數，而是指數學中的函數，即自變數的映射。
• 函數式編程的一個特點就是，允許把函數本身作為參數傳入另一個函數，還允許返回一個函數。
• Python語言對函數式編程提供部分支持。由於允許使用變數，所以說Python語言不是純函數式編程語言。

4.1 高階函數

接受函數為參數，或者把函數作為結果返回的函數稱為高階函數。例如，若要根據單詞的長度排序，只需把len函數傳給key參數。

fruits=['strawberry','fig','apple','cherry','raspberry','banana']
print(sorted(fruits,key=len))
# 輸出結果如下：
# ['fig', 'apple', 'cherry', 'banana', 'raspberry', 'strawberry']

fruits = ['strawberry', 'fig', 'apple', 'cherry', 'raspberry', 'banana']


def reverse(word):
    return word[::-1]


print(reverse('testing'))  # 結果是：gnitset

print(sorted(fruits, key=reverse))
# 輸出結果如下：
# ['banana', 'apple', 'fig', 'raspberry', 'strawberry', 'cherry']

註意，上述例子中列表裡的單詞沒有變，開發者只是把反向拼寫當作排序條件，因此各種漿果（berry）都排在一起。在函數式編程範式中，最為人熟知的高階函數有map、filter、reduce 和apply。其中，apply函數在Python2.3中標記為過時，在Python3已移除。

4.2 匿名函數

所謂匿名函數，即不再使用def語句這樣標準形式定義的函數。Python語言經常使用lambda來創建匿名函數。lambda 只是一個表達式，函數體比def定義的函數體要簡捷。lambda函數的語法如下所示。

lambda [arg1[,arg2],....argn]]:expression

sum = lambda arg1, arg2: arg1 + arg2
print(sum(1, 2)) # 結果是：3

上述代碼中，第一行定義了一個lambda函數，執行兩個數的和運算，並且把該lambda函數命名為sum。會面的代碼通過sum（）函數即實現了調用lambda函數的功能。