函式引數的兩大類

1. 形式引數
    在函式定義階段從左往右依次寫入的變數名就叫形式引數，簡稱"形參"
        def func(a,b):
            pass
        
        # 這裡的a和b就是形式引數，形參
2. 實際引數
    在函式呼叫階段從左往右依次寫入的變數值就叫實際引數，簡稱"實參"
        func(1, 2)
        # 這裡的1和2就是實際引數
 
'''
    形參和實參是什麼樣的關係
        形參相當於變數名，實參相當於變數值
        他們兩個在函式呼叫階段臨時繫結，函式執行結束立馬斷開聯絡
 
'''

# 形參的表現形式就一種
# 實參的表現形式有多種

位置引數

位置引數
    # 從左往右依次寫入的資料就是位置引數
位置形參
    # 在定義函式的時候，從左往右依次寫入的變數名就是位置形參
位置實參
    # 在函式呼叫階段，從左往右依次寫入的變數值就是位置實參
    
 # 寫一個可以比較兩個數字大小的函式，哪個大返回哪個值
        
def my_max(a, b):
    print(a, b)
    if a > b:
        return a
    else:
        return b

res = my_max(1, 2)
 
print(res)
    
# 關鍵字實參
    my_max(b=1, a=2)  # 關鍵字引數
    通過形參名=變數值的形式傳遞
 
'''
    位置形參和位置實參的關係：
        位置實參從左往右依次傳遞給位置實參（一一對應）
'''

預設引數

預設形參：
    在函式定義階段，兩種情況：
        1. 如果你沒有給形參傳遞值，就使用預設的
        2. 如果你給形參傳遞了值，就使用你給的

# 使用者註冊功能：
def register(name, age, gender='male'):
    print('%s:%s:%s' % (name, age, gender))

 
# 練習題2：
x = 100


def index(a, b, c=x):
    print(a, b, c)


x = 200
index(1, 2)

'''
    第一種解釋：
        函式在定義階段，已經把值固定死了
    第二種解釋：
        變數名與變數值在記憶體中的關係判斷
        
'''

可變長引數

1. 無論我在函式呼叫階段傳遞多少個位置實參都可以
def index(x, y, *a):
    print(x, y)
    print(a)


# index(1, 2, 3, 4)
# index(1, 2, 3, 4, 5, 6, 7, 8)
# index()
# index(1, 2, 3)
# index(1, 2, 3, 4, 5, 6)

# index()
index(1, 2)
index(1, 2, 3, 4, 5, 6)
'''
*在形參中的使用：
    接收多餘的位置實參，把多餘的實參賦給*號後面的變數名，（元組形式）
'''

2. 無論我在函式呼叫階段傳遞多少個關鍵字實參都可以
# 2. 無論我在函式呼叫階段傳遞多少個關鍵字實參都可以
def index(a, b, **x):
    print(x)


# index() # {}
index(a=1, b=2, c=3)  # {'a': 1, 'b': 2, 'c': 3}

'''
**號在形參中的使用：
    接收多餘的關鍵字引數，把多餘的關鍵字引數賦給了**號後面的變數名，以字典的格式
'''

3. 無論我在函式呼叫階段傳遞多少個位置引數和關鍵字引數都可以

def index(u, z=100, *a,  **b, ):
    print(a)
    print(b)
    print(u)


# index()
index(1, 2, x=1, y=2)
'''
    預設引數只要不放在**後面都可以
    *號後面和**號後面的變數名可以任意命名
        但是，在python中推薦使用
            *args   => arguments
            **kwargs  => keyword arguments
        def func(a, b, c, *args, **kwargs):
            pass
'''

# *號和**號在實參中的使用：
def index(a, b, c):
    # print(args)
    print(a, b, c)


# l = [11, 22, 33]
t = (11, 22, 33)


# index(l)
# index(l[0], l[1], l[2]) # index(11, 22, 33)

# index(*l)  # index(11, 22, 33)

'''**號在實參中的使用'''
def func(username, password):
    print(username, password)


d = {'username': 'jason', 'password': 222}
# func(d['x'], d['y'])
func(**d)  # func(username='jason',password=222)
func(username='jason', password=222)

名稱空間的概念

1. 什麼是名稱空間？
    就是繫結變數名和變數值的地方
    
2. 名稱空間的分類:
    -1 內建名稱空間
        在python直譯器中
         len()
         print()
         open()
            
    -2 全域性名稱空間
        # 在py檔案中，定格寫的都是全域性名稱空間
        name = 'ly'
        def func():  # func函式名就在全域性名稱空間中
            pass
        a = [11, 22, 33]
        # for i in a:  # i 也在全域性名稱空間中
        #     print(i)
        # 
        # print(i)

        while True:
            x = 123  # 也在
            break
            
        # 檢視全域性的名稱空間
        print(globals())
    -3 區域性名稱空間
        # 在函式體中存在的都是區域性的
        def index(a, b, c):
            x = 222
            y = 111
            # 檢視區域性的名稱空間
            print(locals())
       index(1, 2, 3)

名字查詢順序

查詢順序：
    1. 看自己位置在哪裡：
        如果在區域性：區域性    >>>    全域性    >>>  內建
        如果在全域性： 全域性   >>>  內建
        
 # 區域性名稱空間的巢狀：
    
def f1():
    # x = 222

    def f2():
        # x = 333

        def f3():
            # x = 444

            def f4():
                # x = 555

                def f5():
                    # x = 666
                    print(x)
                f5()
            f4()
        f3()
    f2()
f1()