Python基礎-11函式

11.函式

? ? 函式在Python占有非常重要的地位，可以實作代碼復用，增強代碼可讀性等等，在Python在函式通常被分為常規函式、匿名函式和高階函式，

11.1常規函式

? ? 在Python定義一個函式使用def關鍵字，其格式如下所示：

def functionName(para1,para2,...,paran)
   """docString"""
   doSomething
   # comment
   return result

Python中函式如果沒有顯式宣告回傳值，則默認回傳為None

? ? 在Python中函式非常靈活，既可以簡單呼叫，也可以傳入非常復雜的引數從簡到復雜的引數形態如下所示：

• 1.位置引數：即按指定的順序進行傳遞引數
• 2.默認引數：即如果引數沒有傳遞值，則使用其定義時的默認值
• 3.可變引數：即傳遞的引數個數不確定，其定義格式為*args
• 4.關鍵字引數：即傳遞的引數是鍵值對形式傳遞，其定義格式為**kwargs
• 5.命名關鍵字引數：即用于限制關鍵字引數的名字，呼叫時關鍵字名稱必須使用函式定義的引數名
• 6.引陣列合：各種引數型別的組合

11.1.1 位置引數

? ? 位置引數的示例如下所示：

• def：宣告函式的關鍵字
• function_name:函式名稱
• arg:位置引數
• docstring:函式的說明資訊，一般用來描述函式的功能，傳遞的引數意義和回傳的值說明等資訊，如果函式中有寫docstring，可以使用help(函式名稱)查看
• statement ：函式主體，標志該的主要代碼功能

? ? 示例代碼如下所示：

# 函式定義
def func(name,age):
    print(f"name is {name} , age is {age}")
# 函式傳遞引數
func("Surpass",28)

在位置引數中，引數的傳遞是按照對應的順序進行傳遞，呼叫函式時，傳遞的引數個數必須函式定義的引數個數保持一致

11.1.2 默認引數

? ? 在位置引數中傳遞的引數個數必須與函式定義的引數個數一致，否則則會出現報錯，那有沒有那種，在呼叫函式不想傳遞所有引數，但又希望未傳遞的引數使用一個固定的值，如何操作？能完成這種操作的氷是默認引數，如下所示：

• arg2=v:引數名稱=默認值，呼叫引數，如果沒有給其傳遞值，則使用默認值，如果有傳遞值，則使用傳遞過來的值

# 函式定義
def func(name,age=25):
    print(f"name is {name} , age is {age}")
# 函式傳遞引數
func("Surpass")

? ? 在上面示例中，如果age未傳遞值，則函式中的age值就是25，如果傳遞的值為28，則age為28

使用默認引數的引數一定要置于位置引數之后，否則會出現報錯

? ? 在一個函式可以使用多個默認引數，這時則會出現另一個情況，傳遞的引數過多，無法記住順序，此時傳遞的引數會失去其相應的意義，針對這種情況，可以使用引數名稱=引數值形式進行傳遞值，如下所示：

# 函式定義
def func(name,age=25,weight=55,city="shanghai"):
    print(f"name is {name} , age is {age},weight is {weight},now in {city}")
# 函式傳遞引數
func("Surpass",city="wuhan",weight=60,age=28)

11.1.3 可變引數

? ? 如果傳遞的引數個數是固定，可以使用位置引數或默認引數，但如果傳遞的引數個數不確定時，怎么辦呢？在Python中提供了可變引數這個功能，常用*args表示，示意圖如下所示：

• *args - 可變引數，可以是從零個到任意個，自動組裝成元組

? ? 示例代碼如下所示：

# 函式定義
def func(name,age=25,weight=55,city="shanghai",*loveSport):
    print(f"name is {name} , age is {age},weight is {weight},now in {city},love sport is {loveSport}")
# 函式傳遞引數
func("Surpass",28,60,"wuhai","run","tabletennis","basketball")

輸出結果如下所示：

name is Surpass , age is 28,weight is 60,now in wuhai,love sport is ('run', 'tabletennis', 'basketball')

? ? 除了直接傳遞多個引數之外，還可以將所有引數先封裝成元組，再傳遞引數前面添加*(用于解包，拆散元組)

# 函式定義
def func(name,age=25,weight=55,city="shanghai",*loveSport):
    print(f"name is {name} , age is {age},weight is {weight},now in {city},love sport is {loveSport}")
# 函式傳遞引數
func("Surpass",28,60,"wuhai",*("run","tabletennis","basketball"))

在使用可變引數時，如果有默認引數需要傳遞值時，此時不能使用引數名稱=引數值進行傳遞，需要按照位置引數的形式進行傳遞值，否則會被當成關鍵字傳遞

11.1.4 關鍵字引數

? ? 關鍵字引數，傳遞的引數是以鍵值對形式進行傳遞，類似于默認引數，一般表示語法為**kwargs，但請注意區別，示意圖如下所示：

• **kw - 關鍵字引數，可以是從零個到任意個，自動組裝成字典，

? ? 可變引數與關鍵字引數的區別如下所示：

• 可變引數和關鍵字引數都可以傳遞零到任意個引數
• 可變引數會將傳遞的引數封裝成元組
• 關鍵字引數會將傳遞的引數封裝成字典

# 函式定義
def func(name,age=25,weight=55,city="shanghai",*loveSport,**kwargs):
    print(f"name is {name} , age is {age},weight is {weight},now in {city},love sport is {loveSport},kwargs is {kwargs}")
# 函式傳遞引數
func("Surpass",28,60,"wuhai",*("run","tabletennis","basketball"),otherinfoA="otherinfoA",otherinfoB="otherinfoB")

輸出結果如下所示：

name is Surpass , age is 28,weight is 60,now in wuhai,love sport is ('run', 'tabletennis', 'basketball'),kwargs is {'otherinfoA': 'otherinfoA', 'otherinfoB': 'otherinfoB'}

? ? 除了直接傳遞多個關鍵字引數之外，還可以將所有引數先封裝成字典，再傳遞引數前面添加**(用于解包，拆散字典)

11.1.5 命名關鍵字引數

? ? 對于關鍵字引數，函式的呼叫方可以傳入任意不受限制的關鍵字引數和及其對應的值，如果要限制關鍵字引數的名字，則需要使用命名關鍵字引數，如只接受city和job作為關鍵字，其定義方式如下所示：

? ? 使用命名關鍵字引數需要注意的事項如下所示：

• 1.命名關鍵字引數需要使用分隔符為*
• 2.命名關鍵字引數必須傳入引數名，否則將報錯
• 3.如果函式定義已經存在可變引數，則后面跟著的命名關鍵字引數就不再需要分隔符*
• 4.命名關鍵字引數也可以定義默認值來簡化呼叫
• 5.位置引數和命名關鍵字引數之間必須使用分隔符*加以區分，否則則視為位置引數

1.定義命名關鍵字引數

? ? 命名關鍵字引數和位置使用分隔符*進行區分，呼叫時必須傳遞引數，否則會報錯

def person(name,age,*,height,weight):
    print(f"name is {name},age is {age} , height is {height} , weight is {weight}")

person("Surpass",28,height=190,weight=69)

輸出結果為：

name is Surpass,age is 28 , height is 190 , weight is 69

2.使用可變引數，命名關鍵字引數不再需要分隔符*

def person(name,age,*args,height,weight):
    print(f"name is {name},age is {age} , args is {args},height is {height} , weight is {weight}")

person("Surpass",28,1,2,height=190,weight=69)

輸出結果為：

name is Surpass,age is 28 , args is (1, 2),height is 190 , weight is 69

3.命名關鍵字引數可設定其默認值來簡化呼叫

def person(name,age,*args,height=189,weight):
    print(f"name is {name},age is {age} , args is {args},height is {height} , weight is {weight}")

person("Surpass",28,1,2,weight=69)

輸出結果為：

name is Surpass,age is 28 , args is (1, 2),height is 189 , weight is 69

4.如果命名關鍵引數缺少分隔符*，則將會視為位置引數

def person(name,age,height,weight):
    print(f"name is {name},age is {age} ,height is {height} , weight is {weight}")

person("Surpass",28,height=189,weight=100)

輸出結果為：

name is Surpass,age is 28 ,height is 189 , weight is 100

5.命名關鍵字引數與關鍵字引數結合

def person(name,age,*,height,weight,**kwargs):
    print(f"name is {name},age is {age} ,height is {height} , weight is {weight},kwargs is {kwargs}")

person("Surpass",28,height=189,weight=100,keyA="keyA",keyB="keyB")

輸出結果為：

name is Surpass,age is 28 ,height is 189 , weight is 100,kwargs is {'keyA': 'keyA', 'keyB': 'keyB'}

6.與其他引數型別的組合

def person(name,age,job="enginerr",*args,height,weight,**kwargs):
    print(f"name is {name},age is {age} occupation is {job},args is {args} height is {height} , weight is {weight},kwargs is {kwargs}")

person("Surpass",28,"IT",1,2,3,height=189,weight=100,keyA="keyA",keyB="keyB")

輸出結果為：

name is Surpass,age is 28 occupation is IT,args is (1, 2, 3) height is 189 , weight is 100,kwargs is {'keyA': 'keyA', 'keyB': 'keyB'}

11.1.6 引陣列合

? ? 在Python中定義函式，可以用位置引數、默認引數、可變引數、關鍵字引數和命名關鍵字引數，雖然這些引數可以進行組合使用，但也必須遵循一定的規則，引數定義的順序如下所示：

• 位置引數、默認引數、可變引數、關鍵字引數（最為常見）
• 位置引數、默認引數、可變引數、命名關鍵字引數
• 位置引數、默認引數、命名關鍵字引數、關鍵字引數
• 位置引數、默認引數、可變引數、命名關鍵字引數、關鍵字引數

? ? 可變引數和關鍵字引數的語法：

• *args:可變引數，接收后會封裝成元組
• **kwargs:關鍵字引數，接收后會封裝為字典

在Python中，雖然各種引數可以進行各種組合，但不建議使用太多的組合，否則函式比較難懂，

11.2 匿名函式

? ? 從目前所學知識來看，如果要定義一個函式必須使用def關鍵字進行定義，再實作函式體代碼，在部分情況，函式實作的功能就非常簡單，如果每次都需要定義后才能使用，會顯得非常麻煩，在Python提供了lambda運算式來簡化這一操作，使用lambda定義的函式稱之為匿名函式（因為沒有函式名稱），其運算式如下所示：

• lambda:定義匿名函式的關鍵字
• argument_list:函式的引數，與常規函式引數一致
• : 冒號，匿名函式引數與運算式的分隔符
• expression：匿名函式運算式，對應于常規函式中的函式主體代碼

? ? 示例代碼如下所示：

1.示例1

f=lambda x,y:list(range(x,y))
print(f(0,10))

# 與下面的函式功能是等效的
def f(x,y):
    print(list(range(x,y)))

輸出結果為：

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

2.示例2

f=lambda *args:print(sum(args))
f(1,2,3,4,5)

# 與下面的函式功能是等效的
def f(*args):
    print(sum(args))

輸出結果為：

15

3.示例3

f=lambda **kwargs:print(kwargs)
f(keyA="keyA",keyB="keyB",keyC="keyC")

# 與下面的函式功能是等效的
def f(**kwargs):
    print(kwargs)

輸出結果為：

{'keyA': 'keyA', 'keyB': 'keyB', 'keyC': 'keyC'}

雖然匿名函式使用方便，但要結合實際情況來，無需過度使用，如果一個函式需要被經常呼叫，需要使用def定義為常規函式

11.3 高階函式

? ? 高階函式在函式式編程中非常常見，其主要形式如下所示：

• 引數是函式
• 回傳值型別是函式

11.3.1 閉包

? ? 維基的解釋如下所示：

在計算機科學中，閉包（Closure），又稱詞法閉包（Lexical Closure）或函式閉包（function closures），是參考了自由變數的函式，這個被參考的自由變數將和這個函式一同存在，即使已經離開了創造它的環境也不例外，所以，有另一種說法認為閉包是由函式和與其相關的參考環境組合而成的物體，閉包在運行時可以有多個實體，不同的參考環境和相同的函陣列合可以產生不同的實體，

? ? Python里面的閉包是一種高階函式，回傳值為函式物件，簡單來講就是一個函式定義中參考了函式外定義的變數，并且該函式可以在其定義環境外執行，這種函式稱之為閉包，示例如下：

def outter(x):
    temp=[x]
    def add():
        temp[0]+=x
        print(temp)
    def sub():
        temp[0]-=x
        print(temp)
    return add,sub

add,sub=outter(100)
add()
sub()

輸出結果如下所示：

[200]
[100]

11.3.2 偏函式

? ? 偏函式的主要功能是把函式的一個或多個引數固定下來，使其成為一個新函式，并用于其他應用上面 ，若要使用偏函式，需要匯入以下的包，如下所示：

from functools import partial

? ? 以上的解釋看起來似懂非懂，來看看下面的示例：

tempList=[12,100,999,12412,1,-98,1209]
print(sorted(tempList))

? ? 以上的示例代碼是對串列進行排序，且默認排序為升序排序，如果需要進行倒序排序，則需要單獨添加引數reverse=True，如下所示：

sorted(tempList,reverse=True)

? ? 假設需要多次使用到這個排序函式，每次都這么寫特別麻煩，除了重寫函式之外，有沒有辦法可以固定住該函式的reverse引數？這時候輪到偏函式上場了，示例如下所示：

mySortedpartial=partial(sorted, reverse=True)
print(mySortedpartial)

輸出結果如下所示：

functools.partial(<built-in function sorted>, reverse=True)

? ? 從輸出結果來看，mySortedpartial是一個函式，單獨設定的引數被固定住了，這樣就不用每次單獨輸入這個引數了，而且函式功能依然能正常使用，如下所示：

from functools import partial

tempList=[12,100,999,12412,1,-98,1209]
print(sorted(tempList,reverse=True))

mySortedpartial=partial( sorted, reverse=True )
print(mySortedpartial(tempList))

輸出結果如下所示：

[12412, 1209, 999, 100, 12, 1, -98]
[12412, 1209, 999, 100, 12, 1, -98]

? ? 通過以上的示例，可以看出來偏函式的主要作用了，下面再來一個我們自己定義一個函式，再使用偏函式固定某個引數，如下所示：

from functools import partial

def getUserInfo(username,age,sex,country):
    userInfo = []
    userInfo.append((username,sex,age,country))
    return userInfo


if __name__ == '__main__':
    myGetUserInfo=partial(getUserInfo,sex="男",country="中國")
    print(myGetUserInfo)
    print(myGetUserInfo("Surpass",28))
    print(myGetUserInfo("Kevin",35))
    print(myGetUserInfo("Leo",38))

輸出結果如下所示：

functools.partial(<function getUserInfo at 0x000001ACCA803048>, sex='男', country='中國')
[('Surpass', '男', 28, '中國')]
[('Kevin', '男', 35, '中國')]
[('Leo', '男', 38, '中國')]

? ? 當函式的引數個數較多，且引數默認值不符合自己需求時，可以使用偏函式創建一個新的函式，來簡化呼叫，

偏函式簡單來講，可以理解為了滿足自身需求，在固定原有函式部分引數的值后，創建一個新的函式，來簡化呼叫，是不是很像給一個函式取了一個別名？

11.3.3 柯里化

柯里化是指將原來接受兩個引數的函式變為接受一個引數的函式程序，新的函式引數回傳一個以原有第二個引數為引數的函式，即g=f(x,y)轉變為g=f(x)(y)

? ? 以普通的加法函式為例：

def addA(x:int,y:int)->int:
    return x+y

通過函式嵌套，可以轉換為以下形式：

def addB(x:int)->int:
    def subadd(y:int):
        return x+y
    return subadd

對比以上兩個函式，我們來看看呼叫形式，分別如下所示：

print(addA(1,2))
g=addB(1)
print(g(2))
print("簡寫形式")
print(addB(1)(2)) #  將g=f(x,y)轉變為g=f(x)(y)

輸出結果如下所示：

3
3
簡寫形式
3

11.4 函式作用域

? ? 系統每次執行一次函式時，就會創建新的區域命名空間，該命名空間代表一個區域環境，其中包含函式的引數名稱和在函式體內賦值的變數名稱，決議這些名稱時，解釋器將首先搜索區域命名空間；如果沒有找到匹配的名稱，則會搜索全域命名命名空間，函式的全域命名空間始終是定義該函式的模塊，如果解釋器在全域命名空間中也找不到匹配值，則最侄訓檢查內置命名空間，如果仍未找到，則觸發NameError例外，

變數的搜索順序 區域命名空間->全域命名空間->內置命名空間

? ? 示例代碼如下所示：

a=12
def f():
    a=120

if __name__ == '__main__':
    print(f"呼叫函式前，變數的值{a}")
    f()
    print(f"呼叫函式后，變數的值{a}")

輸出結果如下所示：

呼叫函式前，變數的值12
呼叫函式后，變數的值12

? ? 以上示例代碼，盡管在函式f()修改了變數a的值，但回傳a的值沒有變，當變數在函式中被賦值時，這些變數始終被系結在該函式的區域命名空間中，因此函式體中的變數a參考的是一個包含值為120的全新物件，而不是外面的變數，如果要改變這個行為，可以使用關鍵字global，

global關鍵字可以明確將變數名稱宣告為屬于全域命名空間，只有在需要修改全域變數時才使用，可以放在函式任意位置且可重復使用，

a=12
b=13
def f():
    global a
    a=120
    b=130

if __name__ == '__main__':
    print(f"呼叫函式前，變數的值{a} - {b}")
    f()
    print(f"呼叫函式后，變數的值{a} - {b}")

輸出結果如下所示：

呼叫函式前，變數的值12 - 13
呼叫函式后，變數的值120 - 13

? ? 我們再來看看以下的示例：

def counter(start):
    n=start
    # 定義嵌套函式
    def show():
        print(f"current value is {n}")
    while n >0:
        show()
        n-=1

? ? 在Python中，函式是可以進行嵌套的，嵌套函式中的變數由靜態作用域限定的，即解釋器在決議名稱時首先檢查區域作用域，然后由內而外一層層檢查外部嵌套函式定義的作用域，如果找不到匹配，則搜索全域命名空間和內置命名空間，但內部函式不能給外部函式定義的區域變數重新賦值，以下這段代碼存在問題的：

def counter(start):
    n=start
    # 定義嵌套函式
    def show():
        print(f"current value is {n}")
    def decrement():
        n-=1 #Pycharm會自動檢查出這里有問題
    while n >0:
        show()
        decrement()

? ? 像這種情況，Python3中可以使用關鍵字nonlocal來解決，如下所示：

def counter(start):
    n=start
    # 定義嵌套函式
    def show():
        print(f"current value is {n}")
    def decrement():
        nonlocal n # 系結到外部的n
        n-=1
    while n >0:
        show()
        decrement()

本文地址：https://www.cnblogs.com/surpassme/p/12975455.html
本文同步在微信訂閱號上發布，如各位小伙伴們喜歡我的文章，也可以關注我的微信訂閱號：woaitest，或掃描下面的二維碼添加關注：

標籤：Python

上一篇：Python基礎-10回圈陳述句

下一篇：《自拍教程68》Python呼叫攝像頭？ 干嘛？ 錄制小視頻！！！