10函數的進階

動態函數

# def func(a,b,c,*args):  # 在形參位置*叫做聚合
#     print(a,b,c)
#     print(args)   # 元組形式
#
# func(1,2,3,4,5,9,6,7,8)
結果
1 2 3
(4, 5, 9, 6, 7, 8)

*args  是動態關鍵字參數,在形參位置*叫做聚合,*args會把位置參數沒有對應上的元素都'吃'掉,組成一個元組.

#位置參數大於動態參數.

# func(a=1,b=2,c=3) # 關鍵字的形式傳參

# def func(**kwargs): # 動態預設參數  #形參的時候**聚合 #    
 print(kwargs)  # 字典

# def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
#     print(a,b,c)
#     print(args,kwargs)
#     print(x, y, z)
#     # 1 2 3
#     # (1,2,3,4,5)
#     # 1 1 1
#     # {'a': 1, 'b': 1, 'c': 1}
# func(1,2,3,4,e=1,f=2,g=3)

**kwargs      動態關鍵字參數

# args 和 kwargs 是可以更換的，但是程式員約定都用它

# 用途：在不明確接收參數、數量時使用*args和**kwargs

# 位置參數>動態的位置參數

# 形參：位置>動態位置>預設參數>動態預設參數

# 實參：位置>關鍵字參數

*和**的用法:

# 在實參調用的時候 *將可迭代的對象打散，字典是將鍵取出

# 在形參出現*就是在聚合

# 在實參調用的時候，**將字典打散成  關鍵字參數（鍵=值）

# 在形參處出現**就是將關鍵字參數聚合成一個字典。

# def func(a,b,c,*args,x=1,y=1,z=1,**kwargs):
#     print(a,b,c)
#     print(args,kwargs)
#     print(x, y, z)
#     # 1 2 3
#     # (1,2,3,4,5)
#     # 1 1 1
#     # {'a': 1, 'b': 1, 'c': 1}
# func(1,2,3,4,e=1,f=2,g=3)

註意：參數arg、*args、**kwargs三個參數的位置必須是一定的。必須是(arg,*args,**kwargs)這個順序，否則程式會報錯。

1. 函數的註釋

print(aaa._doc_) 查看註釋

#     2.1 函數的註釋:
#         """ """ 官方推薦
#        查看註釋: func名.__doc__
#        查看註釋: func名.__name__

名稱空間

1. 內置空間中所有代碼——內置空間
2. 自己寫的py文件——全局空間
3. 函數中的代碼——局部空間

*註：

       載入順序：
                     內置空間——>全局空間——>局部空間

       查找值的順序：

                     局部空間——>全局空間——>內置空間——>報錯

              作用域：

                            全局作用域 內置+全局=全局作用域

                            局部作用域 函數內的就是局部作用域

a = 10

def func():
    global a        global：聲明a為全局變數。//找到要修改的值，修改後放回
    a += 1

func()
print(a)

global 和 nonloca   

global聲明全局找全量,

nonloca   

nonloca  是在函數嵌套裡面找上一級變數,但是只能在函數裡面找,不能找到全局

# 載入順序: ''' 1.內置空間 2.全局空間 3.局部空間 '''

# 取值順序: ''' 1.局部空間 2.全局空間 3.內置空間 4.找不到就報錯 '''

# 作用域: ''' 1.全局作用域  內置+全局 = 全局作用域 2.局部作用域  函數內的就是局部作用域 '''

# a = 10
# def func():
#     global a  # (聲明)我要修改a 找到要a
#     a+=1      # 修改
# func()
# print(a)

# def func():
#     global a  #(聲明我要修改a,找不到a的時候在全局創建一個 a=0)
#     a = 1  # a = 1
# func()
# print(a)

函數的嵌套:

# 第一種函數嵌套 在函數func內
# def func():
#     print(3)
#     def f():
#         print(1)
#     print(2)
#     f()
# func()
# 第一種函數嵌套 在函數func內
# def func():
#     print(3)
#     def f():
#         print(1)
#     print(2)
#     f()
# func()

# 在一個局部空間內,nonlocal會修改離他最近的那個變數,如果上一層
# 沒有就繼續向上找,直到走到局部空間頭部

# global : 在局部修改全部變數,如果沒有就創建一個新的
# nonlocal : 在局部空間內,修改離自己最近的變數,如果上一層沒有就繼續向上找,
# 直到找到局部變數的頂層,局部空間內沒有可以修改的變數,就報錯

坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑坑!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!11