day-10-函式進階-名稱空間-有解無憂

形參角度

萬能引數*args和**wkargs，

一個*可以接受所有的實參，
- *args，約定俗稱：args
- 函式定義時，*代表聚合，他將所有的位置引數聚合成一個元組，賦值給了args

def eat(*args):
    print(args, type(args))
    print('我請你吃，%s,%s,%s' % args)
    
eat('小吃', '泡面', '熊掌')
# 輸出：
('小吃', '泡面', '熊掌') <class 'tuple'>
我請你吃，小吃,泡面,熊掌

函式的定義時：兩個**將所有的關鍵字引數聚合到一個字典中，將這個字典賦值給了kwargs

def func(**kwargs):
    print(kwargs)
?
func(name='小楊',age='22')
# 輸出：
{'name': '小楊', 'age': '22'}

形參角度的引數的順序：*args的位置？
- args得到實參的前提，sex必須被覆寫了，如果放在所有形參之前，就會導致args獲取全部的引數，形參獲取不到引數，所以要放在形參的默認關鍵字引數之間，
```
def func(a, b, sex='男', *args):    如：def func(a, b, *args，sex='男')：
    print(a, b)
    print('sex:', sex)
    print(args)
?
func(1, 2, 3, 4, 5, 6, 7)
# 輸出：
1 2
sex: 3
(4, 5, 6, 7)
```

形參角度的引數的順序：**kwargs的位置要放在形參的默認關鍵字之后，不然kwargs就會獲取所有的關鍵字引數，導致默認關鍵字引數就沒有意義了，就直接報錯，

def func(a, b, *args, sex='男', **kwargs):
    print(a, b)
    print('sex:', sex)
    print(args)
    print(kwargs)
?
func(1, 2, 3, 4, 5, 6, 7,name='小楊',age=22)
?
# 輸出：
1 2
sex: 男
(3, 4, 5, 6, 7)
{'name': '小楊', 'age': 22}

*的魔性用法

* **在函式的呼叫時，*代表打撒，（只要是可迭代物件）

def func(*args):
    print(args)  # 需要這樣時（1,2,3,22,33）
?
func([1, 2, 3], [22, 33])   # 正常情況下
func(*[1, 2, 3], *[22, 33])  # 相當于  func（1,2,3,22,33）
?
# 輸出：
([1, 2, 3], [22, 33])
(1, 2, 3, 22, 33)

**代表打撒字典，（僅限于字典）

def func(*args, **kwargs):
    print(args)
    print(kwargs)
?
func({'name': '小楊'}, {'age': 22})
print('-----------------')
func(**{'name': '小楊'}, **{'age': 22})  # 相當于  func(name = '小楊‘, age = 22)
# 輸出
({'name': '小楊'}, {'age': 22})
{}
-----------------
()
{'name': '小楊', 'age': 22}

僅限關鍵字引數（了解）
- 形參角度的第四個引數：僅限關鍵字引數，只能寫在*args和**kwargs之間的關鍵字引數，不是位置引數，必須以關鍵字引數傳值，

形參的最終順序

形參角度最終的順序：位置引數，*args，默認引數，僅限關鍵字引數（默認引數和僅限關鍵字引數位置可以互換的），**kwargs，

def func(a, b, *args, sex='男', hobby, **kwargs):  # hobby是僅限關鍵字引數
    print(a, b)                                   # 而且必須傳值
    print(args)
    print('sex:', sex)
    print('hobby', hobby)
    print(kwargs)
?
func(1, 2, 3, 4, 5, 6, 7,name='小楊',age=22, hobby='籃球')
# 輸出
1 2
(3, 4, 5, 6, 7)
sex: 男
hobby 籃球
{'name': '小楊', 'age': 22}

在函式定義的時候代表聚合，在函式的執行的時候代表打撒

名稱空間：也叫命名空間
1. 全域名稱空間（當前py檔案）
  - 隨著代碼的執行，解釋器會在記憶體開辟一個空間叫做全域名稱空間，里面存盤著代碼執行程序中的變數與值的對應關系，如果是遇到函式就記錄函式名和函式體記憶體地址的對應關系，會隨著整個代碼的結束而清除空間，
  - 總結：全域名稱空間記錄著整個檔案里面的變數與值，以及函式名與函式體的對應關系，
2. 臨時名稱空間：也叫區域名稱空間
  - 和全域名稱空間類似，在代碼運行程序中遇到要運行的函式時，解釋器會在記憶體中在開辟一個臨時名稱空間，用于存盤函式運行時所呼叫的函式體內部的變數與值的對應關系，會隨著函式的結束而消失，
  - 如果在代碼運行還沒結束時，又遇到了第二個或第三個或更多需要呼叫的函式時，會每運行一個函式就開辟一個新的臨時名稱空間，隨著函式的結束而消失，
  - 總結：臨時名稱空間里面記錄著，函式運行時函式體里面的變數與值的對應關系，而且隨著函式的結束而消失
3. 內置名稱空間：（builtins.py檔案）
  - Python原始碼提供的一些內置空間，print input.......
  - 像print input......等等其他就在內置名稱空間里面
4. 加載順序，取值順序，
  - 加載順序：內置名稱空間---->全域名稱空間---->區域名稱空間（函式執行時）
  - 取值順序（就近原則，LEGB原則）：（從區域找時）區域名稱空間----->全域名稱空間----->內置名稱空間
    - 根據實際情況來找，從區域找時從區域開始，從全域找時從全域開始，全域沒有在找內置，
    - 取值順序是單向不可逆的，例如：
```
input = '小楊'  # 運行到這里時全域已經記錄了  （當這里被注釋了，全域沒有了這條記錄）
def func():
    input = '紅紅'  # 此函式被呼叫時，這里屬于區域，且已經被記錄了
    print(input)
?
print(input)   # 這是從全域開始找的
func()          # 呼叫函式，這是從區域開始找
# 輸出：
小楊
紅紅
?
---------------------------------------------------------
?
# input = '小楊'   當這里被注釋了，全域沒有了這條記錄
def func():
    input = '紅紅'  # 此函式被呼叫時，這里屬于區域，且已經被記錄了
    print(input)
?
print(input)   # 這是從全域開始找的，全域沒有，就從內置里面找，
func()          # 呼叫函式，這是從區域開始找
# 輸出：
<built-in function input>
紅紅
```
5. 作用域，兩個作用域
  - 全域作用域
    - 內置名稱空間 + 全域名稱空間，（不能取區域作用域的變數）
  - 區域作用域
    - 區域名稱空間，可以取全域作用域的變數（參考，不可修改）
      - 也可以取它上一級的區域名稱空間變數（同樣不可修改，只能參考），列如：
        
        def func(): count = 1 # 在區域命名空間1里創建count變數 def func2(): count = 100 # 這叫在區域命名空間2里創建了一個新的變數 print(count) func2() func() # 輸出： 100 ? --------------------------------------------- ? def func(): count = 1 # 在區域命名空間1里創建count變數 def func2(): count += 1 # 這叫修改，全域命名空間1的 count 自加1 print(count) func2() func() # 輸出：會報錯 UnboundLocalError: local variable 'count' referenced before assignment
    - 為什么區域作用域不能改變全域作用域的變數
      - 當Python解釋器讀取到區域作用域時，發現了你對一個變數進行了修改的操作，決議器會認為你在區域已經定義過了這個區域變數了，他就從區域找這個區域變數，沒有就報錯了，（個人有爭議）
```
count = 1
def func():
    count = 100    # 這叫在區域作用域里面創建了一個新的不是修改
    print(count)
    
func()
# 輸出：
100
?
--------------------------------------------------------------
?
count = 1
def func():
    count += 1    # 這叫修改，全域作用域的 count 自加1
    print(count)
    
func()   # 會報錯
# 輸出：
UnboundLocalError: local variable 'count' referenced before assignment
```

函式的嵌套（高階函式）

看懂這三道題也就差不多了：執行順序，

def func1():
    print('in func1')
    print(3)
?
?
def func2():
    print('in func2')
    print(4)
?
func1()
print(1)
func2()
print(2)

def func1():
    print('in func1')
    print(3)
?
?
def func2():
    print('in func2')
    func1()
    print(4)
?
print(1)
func2()
print(2)

def fun2():
    print(2) 
    
    def fun3():
        print(6)
    print(4)
    fun3()
    print(8)
?
print(3)
fun2()
print(4)

內置函式 globals locals

globals

回傳的是字典：字典里面的鍵值對：全域作用域的所有內容，

content = '全域作用域'
def func():
    name = '小楊'
    age = 22
?
print(globals())
# 輸出：
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0161BEC8>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:\\Users\\YS\\Desktop\\Python全堆疊\\day10\\python.py', '__cached__': None, 'content': '全域作用域', 'func': <function func at 0x016A5460>}

locals

回傳的是字典：字典里面的鍵值對：當前作用域的所有內容

content = '全域作用域'
def func():
    name = '小楊'
    age = 22
    def func2():
        a = 666
    print(locals())    # 當前作用域func()
?
func()
?
# 輸出：
{'name': '小楊', 'age': 22, 'func2': <function func.<locals>.func2 at 0x01CB5418>}

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/275664.html

標籤：Python

上一篇：【Java提高】-- Java8新特性匯總（兩小時高效率學習Java8新特性知識）

下一篇：1、簡單的變數和資料型別

day-10-函式進階-名稱空間

形參角度

名稱空間：也叫命名空間

函式的嵌套（高階函式）

內置函式 globals locals