1. 今日內容

1.1 函數的參數

*的魔性用法

函數形參最終順序

1.2名稱空間

全局名稱空間，局部名稱空間，內置名稱空間

取值順序與加載順序

作用域

內置函數：globals() locals()

1.3 高階函數（函數的嵌套）

1.4關鍵字：global nonlocal

2. 內容詳細

2.1 函數的參數

昨天我們從形參角度，講了兩種參數，一個是位置參數，位置參數主要是實參與形參從左至右一一對應，一個是默認值參數，默認值參數，如果實參不傳參，則形參使用默認參數。那么無論是位置參數，還是默認參數，函數調用時傳入多少實參，我必須寫等數量的形參去對應接收， 如果不這樣，那么就會報錯：

          
            def eat(a,b,c,):
print('我請你吃：',a,b,c) 
eat('蒸羊羔','蒸熊掌','蒸鹿尾兒','燒花鴨') # 報錯
          
        

如果我們在傳參數的時候不很清楚有哪些的時候,或者說給一個函數傳了很多實參,我們就要對應寫很多形參,這樣很麻煩，怎么辦？,我們可以考慮使用動態參數也叫萬能參數

2.11 形參的第三種:動態參數

動態參數分為兩種:動態接受位置參數 *args，動態接收關鍵字參數**kwargs.

動態接收位置參數：*args

我們按照上面的例子繼續寫，如果我請你吃的內容很多，但是我又不想用多個參數接收，那么我就可以使用動態參數*args

          
            def eat(*args):
print('我請你吃：',args)
eat('蒸羊羔兒','蒸熊掌','蒸鹿尾兒','燒花鴨','燒雛雞','燒子鵝')
# 運行結果：
#我請你吃： ('蒸羊羔兒', '蒸熊掌', '蒸鹿尾兒', '燒花鴨', '燒雛雞', '燒子鵝')
          
        

解釋一下上面參數的意義：首先來說args，args就是一個普通的形參，但是如果你在args前面加一個，那么就擁有了特殊的意義：在python中除了表示乘號，他是有魔法的。+args，這樣設置形參，那么這個形參會將實參所有的位置參數接收，放置在一個元組中，并將這個元組賦值給args這個形參，這里起到魔法效果的是 * 而不是args，a也可以達到剛才效果，但是我們PEP8規范中規定就使用args，約定俗成的。
練習：傳入函數中數量不定的int型數據，函數計算所有數的和并返回。

          
            def my_max(*args):
n = 0
for i in args:
n += i
return n
          
        

動態接收關鍵字參數: kwargs**

實參角度有位置參數和關鍵字參數兩種，python中既然有*args可以接受所有的位置參數那么肯定也有一種參數接受所有的關鍵字參數，那么這個就是 kwargs，同理這個 是具有魔法用法的，kwargs約定俗成使用作為形參。舉例說明：**kwargs，是接受所有的關鍵字參數然后將其轉換成一個字典賦值給kwargs這個形參。

          
            def func(**kwargs):
print(kwargs) # {'name': '太白金星', 'sex': '男'}
func(name='太白金星',sex='男')
          
        

我們看一下動態參數的完成寫法：

          
            def func(*args,**kwargs):
    print(args) # ('蒸羊羔兒', '蒸熊掌', '蒸鹿尾兒')
    print(kwargs) # {'name': '太白金星', 'sex': '男'}
func('蒸羊羔兒', '蒸熊掌', '蒸鹿尾兒',name='太白金星',sex='男')
          
        

如果一個參數設置了動態參數，那么他可以接受所有的位置參數，以及關鍵字參數，這樣就會大大提升函數拓展性，針對于實參參數較多的情況下，解決了一一對應的麻煩。

2.12 * 的魔性用法

剛才我們研究了動態參數，其實有的同學對于魔法用法 * 比較感興趣，那么那的魔性用法不止這么一點用法，我們繼續研究：

函數中分為打散和聚合。

函數外可以處理剩余的元素。

函數的打散和聚合

聚合

剛才我們研究了，在函數定義時，如果我只定義了一個形參稱為args，那么這一個形參只能接受幾個實參？ 是不是只能當做一個位置參數對待？它只能接受一個參數：

          
            def eat(args):
    print('我請你吃：',args) # 我請你吃： 蒸羊羔兒
eat('蒸羊羔兒')
          
        

但是如果我給其前面加一個* 那么args可以接受多個實參，并且返回一個元組，對吧？ （**kwargs也是同理將多個關鍵字參數轉化成一個字典返回）所以在函數的定義時： *起到的是聚合的作用。

打散

此時不著急給大家講這個打散，而是出一個小題：你如何將三個數據（這三個數據都是可迭代對象類型）s1 = 'alex',l1 = [1, 2, 3, 4], tu1 = ('武sir', '太白', '女神',)的每一元素傳給動態參數*args？（就是args最終得到的是 ('a','l','e','x', 1, 2, 3, 4,'武sir', '太白', '女神',）?有人說這還不簡單么？我直接傳給他們不就行了？

          
            s1 = 'alex'
l1 = [1, 2, 3, 4]
tu1 = ('武sir', '太白', '女神',)
def func(*args):
    print(args) # ('alex', [1, 2, 3, 4], ('武sir', '太白', '女神'))
func(s1,l1,tu1)
          
        

這樣肯定是不行，他會將這個三個數據類型當成三個位置參數傳給args，沒有實現我的要求。

好像你除了直接寫，沒有別的什么辦法， 那么這里就得用到我們的魔法用法 ：*

          
            s1 = 'alex'
l1 = [1, 2, 3, 4]
tu1 = ('武sir', '太白', '女神',)
def func(*args):
    print(args) # ('a', 'l', 'e', 'x', 1, 2, 3, 4, '武sir', '太白', '女神')
func(*s1,*l1,*tu1)
          
        

你看此時是函數的執行時，我將你位置參數的實參（可迭代類型）前面加上，相當于將這些實參給拆解成一個一個的組成元素當成位置參數，然后傳給args,這時候這個好像取到的是打散的作用。所以在函數的執行時：，**起到的是打散的作用。

          
            dic1 = {'name': '太白', 'age': 18}
dic2 = {'hobby': '喝茶', 'sex': '男'}
def func(**kwargs):
    print(kwargs) # {'name': '太白', 'age': 18, 'hobby': '喝茶', 'sex': '男'}
func(**dic1,**dic2)
          
        

* 處理剩下的元素

*除了在函數中可以這樣打散，聚合外，函數外還可以靈活的運用：

          
            # 之前講過的分別賦值
a,b = (1,2)
print(a, b) # 1 2
# 其實還可以這么用：
a,*b = (1, 2, 3, 4,)
print(a, b) # 1 [2, 3, 4]
*rest,a,b = range(5)
print(rest, a, b) # [0, 1, 2] 3 4
print([1, 2, *[3, 4, 5]]) # [1, 2, 3, 4, 5]
          
        

2.13 形參的順序

到目前為止，從形參的角度我們講了位置參數，默認值參數，動態參數*args，**kwargs，還差一種參數，需要講完形參順序之后，引出。先不著急，我們先看看已經講的這些形參他的排列順序是如何的呢？

首先，位置參數，與默認參數他兩個的順序我們昨天已經確定了，位置參數必須在前面，即 ：位置參數，默認參數。

那么動態參數*args，**kwargs放在哪里呢？

動態參數*args，肯定不能放在位置參數前面，這樣我的位置參數的參數就接收不到具體的實參了：

          
            # 這樣位置參數a,b始終接收不到實參了，因為args全部接受完了
def func(*args,a,b,sex='男'):
print(args)
print(a,b)
func(1, 2, 3, 4, 5)
          
        

那么動態參數必須在位置參數后面，他可以在默認參數后面么？

          
            # 這樣也不行，我的實參的第三個參數始終都會將sex覆蓋掉，這樣失去了默認參數的意義。
def func(a,b,sex='男',*args,):
print(args) # (4, 5)
print(sex) # 3
print(a,b) # 1 2
func(1, 2, 3, 4, 5)
          
        

所以*args一定要在位置參數與默認值參數中間： 位置參數，*args，默認參數 。

那么我的 kwargs放在哪里？ kwargs可以放在默認參數前面么？

          
            # 直接報錯：因為**kwargs是接受所有的關鍵字參數，如果你想改變默認參數sex，你永遠也改變不了，因為
# 它會先被**kwargs接受。
def func(a,b,*args,**kwargs,sex='男',):
print(args) # (4, 5)
print(sex) # 3
print(a,b) # 1 2
print(kwargs)
func(1, 2, 3, 4, 5)
          
        

所以截止到此：所有形參的順序為：**位置參數，*args，默認參數， kwargs。

2.14 形參的第四種參數：僅限關鍵字參數

僅限關鍵字參數是python3x更新的新特性，他的位置要放在*args后面， kwargs前面（如果有 kwargs），也就是默認參數的位置，它與默認參數的前后順序無所謂，它只接受關鍵字傳的參數：

          
            # 這樣傳參是錯誤的，因為僅限關鍵字參數c只接受關鍵字參數
def func(a,b,*args,c):
print(a,b) # 1 2
print(args) # (4, 5)
# func(1, 2, 3, 4, 5)
# 這樣就正確了：
def func(a,b,*args,c):
print(a,b) # 1 2
print(args) # (3, 4)
print(5)
func(1, 2, 3, 4, c=5)
          
        

這個僅限關鍵字參數從名字定義就可以看出他只能通過關鍵字參數傳參，其實可以把它當成不設置默認值的默認參數而且必須要傳參數，不傳就報錯。

所以形參角度的所有形參的最終順序為：**位置參數，*args，默認參數，僅限關鍵字參數， kwargs。

          
            課間考一道題：
def foo(a,b,*args,c,sex=None,**kwargs):
print(a,b)
print(c)
print(sex)
print(args)
print(kwargs)
# foo(1,2,3,4,c=6)
# foo(1,2,sex='男',name='alex',hobby='old_woman')
# foo(1,2,3,4,name='alex',sex='男')
# foo(1,2,c=18)
# foo(2, 3, [1, 2, 3],c=13,hobby='喝茶')
# foo(*[1, 2, 3, 4],**{'name':'太白','c':12,'sex':'女'})
          
        

2.2 名稱空間，作用域

2.21 名稱空間：

接下來我們講的內容，理論性的偏多，就是從空間角度，內存級別去研究python。首先我們看看什么是全局名稱空間：

在python解釋器開始執行之后, 就會在內存中開辟一個空間, 每當遇到一個變量的時候, 就把變量名和值之間的關系記錄下來, 但是當遇到函數定義的時候, 解釋器只是把函數名讀入內存, 表示這個函數存在了, 至于函數內部的變量和邏輯, 解釋器是不關心的. 也就是說一開始的時候函數只是加載進來, 僅此而已, 只有當函數被調用和訪問的時候, 解釋器才會根據函數內部聲明的變量來進行開辟變量的內部空間. 隨著函數執行完畢, 這些函數內部變量占用的空間也會隨著函數執行完畢而被清空.

我們首先回憶一下Python代碼運行的時候遇到函數是怎么做的，從Python解釋器開始執行之后，就在內存中開辟里一個空間，每當遇到一個變量的時候，就把變量名和值之間對應的關系記錄下來，但是當遇到函數定義的時候，解釋器只是象征性的將函數名讀如內存，表示知道這個函數存在了，至于函數內部的變量和邏輯，解釋器根本不關心。

等執行到函數調用的時候，Python解釋器會再開辟一塊內存來儲存這個函數里面的內容，這個時候，才關注函數里面有哪些變量，而函數中的變量回儲存在新開辟出來的內存中，函數中的變量只能在函數內部使用，并且會隨著函數執行完畢，這塊內存中的所有內容也會被清空。

我們給這個‘存放名字與值的關系’的空間起了一個名字-------命名空間。

代碼在運行伊始，創建的存儲“變量名與值的關系”的空間叫做全局命名空間；

在函數的運行中開辟的臨時的空間叫做局部命名空間也叫做臨時名稱空間。

現在我們知道了，py文件中，存放變量與值的關系的一個空間叫做全局名稱空間，而當執行一個函數時，內存中會臨時開辟一個空間，臨時存放函數中的變量與值的關系，這個叫做臨時名稱空間，或者局部名稱空間。

其實python還有一個空間叫做內置名稱空間：內置名稱空間存放的就是一些內置函數等拿來即用的特殊的變量：input，print，list等等，所以，我們通過畫圖捋一下：

那么這就是python中經常提到的三個空間。

總結:

\1. 全局命名空間--> 我們直接在py文件中, 函數外聲明的變量都屬于全局命名空間

\2. 局部命名空間--> 在函數中聲明的變量會放在局部命名空間

\3. 內置命名空間--> 存放python解釋器為我們提供的名字, list, tuple, str, int這些都是內置命名空間

2.22 加載順序：

所謂的加載順序，就是這三個空間加載到內存的先后順序，也就是這個三個空間在內存中創建的先后順序，你想想他們能是同時創建么？肯定不是的，那么誰先誰后呢？我們捋順一下：在啟動python解釋器之后，即使沒有創建任何的變量或者函數，還是會有一些函數直接可以用的比如abs(-1),max(1,3)等等，在啟動Python解釋器的時候，就已經導入到內存當中供我們使用，所以肯定是先加載內置名稱空間，然后就開始從文件的最上面向下一行一行執行，此時如果遇到了初始化變量，就會創建全局名稱空間，將這些對應關系存放進去，然后遇到了函數執行時，在內存中臨時開辟一個空間，加載函數中的一些變量等等。所以這三個空間的加載順序為：內置命名空間(程序運行伊始加載)->全局命名空間(程序運行中：從上到下加載)->局部命名空間(程序運行中：調用時才加載。

2.23 取值順序：

取值順序就是引用一個變量，先從哪一個空間開始引用。這個有一個關鍵點：從哪個空間開始引用這個變量。我們分別舉例說明：

          
            # 如果你在全局名稱空間引用一個變量，先從全局名稱空間引用，全局名# 稱空間如果沒有，才會向內置名稱空間引用。
input = 666
print(input) # 666
# 如果你在局部名稱空間引用一個變量，先從局部名稱空間引用，
# 局部名稱空間如果沒有，才會向全局名稱空間引用，全局名稱空間在沒有，就會向內置名稱空間引用。
input = 666
print(input) # 666
input = 666
def func():
    input = 111
    print(input) # 111
func()
          
        

所以空間的取值順序與加載順序是相反的，取值順序滿足的就近原則，從小范圍到大范圍一層一層的逐步引用。

2.24 作用域

作用域就是作用范圍, 按照生效范圍來看分為全局作用域和局部作用域

全局作用域: 包含內置命名空間和全局命名空間. 在整個文件的任何位置都可以使用(遵循 從上到下逐?執行).

局部作用域: 在函數內部可以使用.

作?域命名空間:

1. 全局作用域: 全局命名空間 + 內置命名空間

2. 局部作?域: 局部命名空間

2.25 內置函數globals(),locals()

這兩個內置函數放在這里講是在合適不過的，他們就直接可以反映作用域的內容，有助于我們理解作用域的范圍。

globals(): 以字典的形式返回全局作用域所有的變量對應關系。

locals(): 以字典的形式返回當前作用域的變量的對應關系。

這里一個是全局作用域，一個是當前作用域，一定要分清楚，接下來，我們用代碼驗證：

          
            # 在全局作用域下打印，則他們獲取的都是全局作用域的所有的內容。
a = 2
b = 3
print(globals())
print(locals())
'''
{'__name__': '__main__', '__doc__': None, '__package__': None,
'__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001806E50C0B8>, 
'__spec__': None, '__annotations__': {},
'__builtins__': 
            
              , 
'__file__': 'D:/lnh.python/py project/teaching_show/day09~day15/function.py',
'__cached__': None, 'a': 2, 'b': 3}
'''

# 在局部作用域中打印。
a = 2
b = 3
def foo():
    c = 3
    print(globals()) # 和上面一樣，還是全局作用域的內容
    print(locals()) # {'c': 3}
foo()
            
          
        

2.3 高階函數（函數的嵌套）

其實我們見到了嵌套這個詞不陌生，之前我們講過列表的嵌套，列表的嵌套就是一個列表中還有列表，可能那個列表中還有列表......那么顧名思義，函數的嵌套，就是一個函數中，還有函數。

想要玩明白函數的嵌套，關鍵點：只要遇見了函數名+()就是函數的調用. 如果沒有就不是函數的調用，吃透這一點就算明白了。那么我們舉例練習：找同學依次說出下面代碼的執行順序

          
            # 例1：
def func1():
    print('in func1')
    print(3)
def func2():
    print('in func2')
    print(4)
func1()
print(1)
func2()
print(2)

# 例2：
def func1():
    print('in func1')
    print(3)
def func2():
    print('in func2')
    func1()
    print(4)
print(1)
func2()
print(2)
# 例3：
def fun2(): 
    print(2) 
    def fun3(): 
        print(6) 
    print(4) 
    fun3() 
    print(8)
print(3)
fun2()
print(5)
          
        

2.4 關鍵字：global、nonlocal

global

講這個關鍵字之前，先給大家看一個現象：

          
            a = 1
def func():
    print(a)
func()
a = 1
def func():
    a += 1 # 報錯
func()
          
        

局部作用域對全局作用域的變量（此變量只能是不可變的數據類型）只能進行引用，而不能進行改變，只要改變就會報錯，但是有些時候，我們程序中會遇到局部作用域去改變全局作用域的一些變量的需求，這怎么做呢？這就得用到關鍵字global：
global第一個功能：在局部作用域中可以更改全局作用域的變量。

          
            count = 1
def search():
    global count
    count = 2
search()
print(count)
          
        

利用global在局部作用域也可以聲明一個全局變量。

          
            def func():
    global a
    a = 3
func()
print(a)
          
        

所以global關鍵字有兩個作用：

1，聲明一個全局變量。

2，在局部作用域想要對全局作用域的全局變量進行修改時，需要用到 global(限于字符串，數字)。

nonlocal

nonlocal是python3x新加的功能，與global用法差不多，就是在局部作用域如果想對父級作用域的變量進行改變時，需要用到nonlocal，當然這個用的不是很多，了解即可。

          
            def add_b():
    b = 42
    def do_global():
        b = 10
        print(b)
        def dd_nonlocal():
            nonlocal b
            b = b + 20
            print(b)
        dd_nonlocal()
        print(b)
    do_global()
    print(b)
add_b()

nonlocal關鍵字舉例
          
        

nonlocal的總結：

1，不能更改全局變量。

2，在局部作用域中，對父級作用域（或者更外層作用域非全局作用域）的變量進行引用和修改，并且引用的哪層，從那層及以下此變量全部發生改變。