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，或掃描下面的二維碼添加關注：