day10:函式的實參&形參

李博倫發表於2020-07-18
函式

函式的引數 (引數:配合函式運算的值)
引數:
      (1)形參:形式引數,在函式的定義處
      (2)實參:實際引數,在函式的呼叫處

形參: 普通形參(位置) , 預設形參 , 普通收集形參 , 命名關鍵字形參 , 關鍵字收集形參
實參: 普通實參,關鍵字實參

遵循原則:
形參和實參要一一對應

1.普通形參

# 1.普通形參
# 函式的定義處
"""hang,lie是函式的普通形參"""
def s_star(hang,lie):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        i+=1
        
# 函式的呼叫處
"""10,10 是函式的實際引數"""
s_star(10,10)
s_star(3,8)

2.預設形參

# 2.預設形參
def s_star(hang=10,lie=10):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        i+=1
        
# 函式的呼叫處
"""
在函式呼叫時:
    如果給予實參,那麼直接使用實際引數
    如果沒有給予實參,那麼使用引數預設自帶的值 
"""
s_star() # 10行10列小星星
s_star(3,8) # 3行8列小星星
s_star(4) # 4行10列小星星

3.普通形參+預設形參 

預設形參必須跟在普通形參的身後,順序是一定的

# 3.普通形參 + 預設形參
# 函式的定義處
"""預設形參必須跟在普通形參的身後,順序是一定的"""
def s_star(hang,lie=10):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        i+=1
        
# 函式的呼叫處
s_star(3,3) # 3行3列
s_star(3) # 3行10列
s_star() # error

4.關鍵字實參

關鍵字實參是對具體的某個引數賦值,具體的順序可以打亂

# 4.關鍵字實參
"""關鍵字實參是對具體的某個引數賦值,具體的順序可以打亂"""
# 函式的定義處
def s_star(hang,a,b,c,d,lie=10):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        
        i+=1

# 函式的呼叫處
s_star(hang=4,a=1,b=2,c=3,d=4,lie=5)
s_star(c=3,d=4,lie=5,hang=4,a=1,b=2) # 關鍵字實參引數順序可以打亂

5.普通實參+關鍵字實參

關鍵字實參必須跟在普通實參的身後,順序是一定的

# 5.普通實參 + 關鍵字實參
def s_star(hang,a,b,c,d,lie=10):
    i = 0
    while i < hang:
        j = 0
        while j < lie:
            print("*",end="")
            j+=1
        print()
        
        i+=1

# 函式的呼叫處
"""關鍵字實參必須跟在普通實參的身後,順序是一定的"""    
s_star(5,6,99,c=7,d=8,lie=9)
s_star(c=7,d=8,lie=9,5,6,99) # error 關鍵字實參必須跟在普通實參的後面
s_star(5,1,c=2,d=3,lie=10,b=5) # ok
s_star(5,1,c=2,d=3,lie=10,a=5) # error 重複給a賦值,錯誤

6.要注意區分預設形參和關鍵字實參

預設引數和關鍵字實參 在寫法上一模一樣
預設形參是在函式的定義處
關鍵字實參是在函式的呼叫處

7.普通收集引數 *args

"""
1.普通收集引數:    專門用來收集多餘的沒人要的普通實參
    def func(*args):
        code...
    *args => arguments(引數)
    在args這個引數的前面加上一個*表達普通收集引數,形成一個元組
"""

# 基本使用
def func(a,b,c,*args):
    print(a,b,c) # 1 2 3
    print(args) # (4,5,6,7,8)
    
func(1,2,3,4,5,6,7,8)

# 計算任意個數的累加和
def func(*args):
    total = 0
    for i in args:
        total += i
    print(total)
    
func(1,2,3,4,6,10,11,100)

8.關鍵字收集引數 **kwargs

"""
2.關鍵字收集引數 : 專門用來收集多餘的沒人要的關鍵字實參
    def func(**kwargs):
        code1...
    **kwargs => keyword arguments
    在kwargs引數的前面加上2個**表達關鍵字收集引數,形成一個字典
"""

# 基本使用
def func(a=1,b=2,c=3,**kwargs):
    print(a,b,c)
    print(kwargs) # {'f': 1, 'g': 2, 'j': 3}

func(f=1,g=2,j=3,a=15,b=16,c=17)

# 任意個數字符串的拼接
"""
班長:宋雲傑
班花:劉彩霞
班草:劉子濤
吃瓜群眾:牧樹人,晏國彰,劉聰
"""

def func(**kwargs):
    print(kwargs)
    # 定義一個字典,存放每一位同學的身份
    dic = {"monitor":"班長","class_flower":"班花","class_grass":"班草"}
    strvar1 = ""
    strvar2 = ""
    
    # 遍歷字典中的鍵值對
    for k,v in kwargs.items():
        print(k,v) # monitor 宋雲傑  class_flower 劉彩霞 class_grass 劉子濤 ....
        # 判斷鍵是否在字典當中,如果在,獲取對應的身份,拼裝成字串
        if k in dic:
            strvar1 += dic[k] + ":" + v + "\n" # 班長 + ":" + 宋雲傑 + '\n'
        else:
            strvar2 += v + ","
    
    # 去掉右邊多餘的\n和,形成最後的效果
    print(strvar1.strip())
    print("吃瓜群眾:"+ strvar2.rstrip(","))
    


func(monitor="宋雲傑",class_flower="劉彩霞",class_grass="劉子濤",eatgua1="牧樹人",eatgua2="晏國彰",eatgua3="劉聰")

9.命名關鍵字引數

# 3.命名關鍵字引數
"""
定義命名關鍵字引數的兩種方式:
    (1)def func(a,b,*,c) c是命名關鍵字
    (2)def func(*args,c,**kwargs) c是命名關鍵字引數
    在函式呼叫時,必須使用命名關鍵字引數來進行賦值
"""
# 定義方式一
def func(a,b,*,d,c):
    print(a,b) # 1 2
    print(d) # 3
    print(c) # 10
    
func(1,2,d = 3,c=10)

# 定義方式二
def func(*args, c, **kwargs):
    print(args) # (1, 2, 3, 4, 5, 6)
    print(c) # 100
    print(kwargs) # {'a': 1, 'b': 2, 'd': 6}

func(1, 2, 3, 4, 5, 6, a=1, b=2, d=6, c=100)

10.關於* 和 ** 的使用方法

* 和 ** 在函式的定義處,用來做收集操作,打包
* 和 ** 在函式的呼叫處,用來做打散操作,解包

# * 解包列表
def func(a,b,*,c,d):
    print(a,b)
    print(c,d)  
lst = [1,2]
# *把列表裡面的所有元素拿出來,當成引數一個一個賦值給func進行呼叫
func(*lst,c=3,d=4)

# ** 解包字典
def func(a,b,*,c,d):
    print(a,b)
    print(c,d)
dic = {"c":3,"d":4}
# **把字典裡面的所有元素拿出來,拼裝成鍵=值的引數形式,賦值給func進行呼叫
func(1,2,**dic,) # func( c=3, d=4 )

# *和**的組合
func(*lst,**dic)
strvar = "abc"
print(*strvar)

11.形參定義的順序

當所有引數都在一起的時候,按照什麼順序定義呢?
引數定義的順序:普通引數 -> 預設引數 -> 普通收集引數 -> 命名關鍵字引數 -> 關鍵字收集引數
收集到所有的實參: def func(*args,**kwargs)

12.關於所有引數混合的練習題

def f1(a, b, c=0, *args, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)

def f2(a, b, c=0, *, d, **kw):
    print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)

# 以上兩個函式 列印結果

# 第一題
f1(1, 2) # a=1,b=2,c=0,args=(),kw={}
f1(1, 2, c=3) # a=1,b=2,c=3,args=(),kw={}
f1(1, 2, 3, 'a', 'b') # a=1,b=2,c=3,args=(a,b),kw={}
f1(1, 2, 3, 'a', 'b', x=99) # a=1,b=2,c=3,args=(a,b),kw={x:99}
f2(1, 2, d=99, ext=None) # a=1,b=2,c=0,d=99,{ext:None}

# 第二題
args = (1, 2, 3, 4)
kw = {'d': 99, 'x': '#'}
f1(*args, **kw) # a=1,b=2,c=3,args=(4,),kw={d:99,x:#}

# 第三題
myargs = (1, 2, 3)
mykw = {'d': 88, 'x': '#'}
f2(*myargs, **mykw) #a=1,b=2,c=3,d=88,kw={x:#}

# 第四題
def f1(a, b, c=0, *args,d,**kw):
    print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    print(d)
f1(1,2,3, 'a', 'b',d=67, x=99,y=77) #a=1,b=2,c=3,args=(a,b),kw={x:99,y:77}  d:67

 

相關文章