初學python，調用固定參，不固定參函數遇到的問題（持續更新）

函數調用時的參數傳遞方式：（調用函數） 傳遞方式有如下四種： 位置傳參 序列傳參 關鍵字傳參 字典關鍵字傳參
---------------------------------------------------yu---

（1）位置傳參：
實際參數(實參)的對應關係與形式參數(形參)對應關係是按位置依次對應的
實參的個數和形參的個數要嚴格一直
實例：

def myfun1(a, b, c):   # 形參
            print(a)
            print(b)
            print(c)
      # 調用
      myfun1(1, 2, 3)   # 實參

（2）序列傳參
序列傳參是指在函數調用過程當中，用*將序列拆解後按位置進行傳遞的方式
序列傳參時，序列拆解的位置將與形參一一對應
序列的位置信息對應相應的參數
實例：

# 假設已經有序列可用
      L1 = [11,22,33]
      T1 = (4.4,5.5,6.6)
      S1 = "ABC"
      myfun1(*L1)
      myfun1(*T1)
      myfun1(*S1)

（3）關鍵字傳參：
關鍵字傳參是指傳參時，按形參的名稱給形參賦值
實參和形參按形參名進行匹配（能夠不按位置順序進行匹配）
實例：

# 關鍵字傳參
      myfun1(c = 33, b = 22, a = 11)

（4）字典關鍵字傳參：
是指實參爲字典，將字典用**拆解後進行關鍵字傳參
實例：

d1 = {"c":33, "b":22, "a":11}
      myfun1(**d1)

說明：字典的鍵名和形參名必須一
字典的鍵名必須爲字符串，並符合關鍵字的命名
字典的鍵名要在形參中存在

（5）函數的綜合
傳參方式，在能肯定每一個形參否能惟一匹配一個實參的狀況也能夠任意傳參
傳參時，位置傳參和序列傳參要先於關鍵字傳參和字典關鍵子傳參
實例： myfun1(100, *[200, 300])

myfun1(*[10,20],30)
         myfun1(*[10], 20, *[30])
         myfun1(100, **{"c":300, "b":200})
         myfun1(**{"c":300, "b":200}, a = 100)
         myfun1(b = 200, c = 300, 100)   # 錯的

注意傳參時：
一、不可變類型的數據做爲函數參數傳入時，函數內部不會改變變量的原數據的值
二、可變類型的數據做爲函數參數傳遞時，函數內部能夠改變原數據，多用與返回更多函數執行結果
實例：寫一個函數，在函數內輸入一些整數，

（1）把全部奇數放入全局列表odds中
  （2）把全部的偶數放入全局的列表evens中
odds = []
evens = []
def input_number(o, e):
    while True:
        n = int(input("請輸入整數："))
        if n < 0:
            break
        # 若是n爲奇數則添加列表odds中
        if n % 2 == 1:
            o.append(n)
        else: # 若是n爲偶數則添加到列表evens中
            e.append(n)
input_number(odds, evens)
print(odds)   # 此列表將被修改
print(evens)    # 此列表也將被修改

二、函數參數的定義規則（建立函數）
函數的缺省參數：
語法：def 函數名(形參名1 = 默認實參1, 形參名2 = 默認實參2, ....):

語句塊

實例：如下示意函數的缺省參數
def info(name, age=1, address="未填寫"):

print(name, "住在：", address, "今年：", age, "歲")

info("莊AC", 23, "北京")
info("莊AC", 23)
說明：（1）缺省參數必須自右至左依次存在，若是一個參數有缺省參數，則其右側的全部參數都必須有缺省參數

如：def test_fn(a, b = 10, c):    # 是錯的
     （2）缺省參數能夠有0個或多個，甚至所有都有缺省參數

三、函數的參數定義方式：

位置形參
 星號元組形參
 命名關鍵字形參
 雙星號字典形參

（1）位置形參語法：
def 函數名(形參名1, 形參名2, 形參名3,......):

語句塊

（2）星號元組形參語法：
def 函數名(*元組形參名):

語句塊

做用：收集多餘的位置傳參
實例：

def funs(*args):
       # args綁定一個元組，此元組內的元素是爲了剩餘的位置傳參
       print("施參個數是：", len(args))
       print("args綁定", args)
   funs()  # 以無參調用
   funs(1, 2, 3, 4)
   funs("ABC", 1, 2.3, 4+5J)

（3）命名關鍵字形參語法：
def 函數名(*, 命名關鍵字形參):
語句塊
或
def 函數名(*args, 命名關鍵字形參):
語句塊
做用：全部的命名關鍵字形參，必須用關鍵字傳參或字典關鍵字傳參進行參數傳遞
實例：

def fn(*, a, b):
       print("a的值爲：", a)
       print("b的值爲：", b)
   # fn(1, 2)  # 錯的，a和b　必須是用關鍵字傳參
   fn(a = 1, b = 2)  #必須這麼傳
   fn(b = 0, a = 20)
   fn(**{"b":200, "a":100})

---

def f2(*args, a, b):
       print("args=", args)
       print("a=", a)
       print("b=", b)
   f2(1, 2, 3, 4, a=100, b=200)
   f2(a=100, b=200)

（4）雙星號字典形參語法：
def 函數名(**字典形參名):
語句塊

做用：收集多餘的關鍵字傳參（例如：dict()）,一般只有一個
實例：

def func(**kwagrs):  # kwagrs綁定一個字典
       print("參數個數：", len(kwagrs))
       print("kwagrs的值爲：", kwagrs)
   func(name="zhuang", age=35, address="dgas")
   func()

（5）函數參數自左至右的順序爲：
位置形參， 星號元組形參， 命名關鍵字形參， 雙星號字典形參
實例：

def fn(a, b, *args, c, **kwargs):
      pass
fn(100,200,300,400,c=5.5,d=6.6,e=7.7)
fn(10,*"AB",20,*{"a":100, "b":200, "c":300})

# ----------如下函數能夠接受任意的位置傳參和關鍵字傳參------------
def fn(args, *kwargs):

---

---

---

---

額外部分一：

python函數參數支持帶星號*的非固定個數參數，如：

def getInfos(msg,*users):
    for u in users:
        print(u)

在調用時，能夠往users傳入一個元組或列表，若是傳入的列表或元組前帶星號，剛傳入後會自動拆包。具體的不一樣用法有不一樣的效果，以下：

一、不定形參傳入元組。

getInfos('msg',('aa','bb') )

輸出：

('aa', 'bb')

二、不定形參傳入帶星元組。

getInfos('msg',*('aa','bb') )

輸出：

aa
bb

三、不定形參傳入列表。

getInfos('msg',['aa','bb'] )

輸出：

['aa', 'bb']

---

光看結果可能像是列表！！！！！！！！！！！！！但其實返回的就是一個元組
可經過如下代碼進行驗證：

#!/usr/bin/python3
def getInfos(msg,*users):
    users[0]="hh"
    for u in users:
        print(u)
a = ['aa','bb']
getInfos('msg',a )

結果：

Traceback (most recent call last):
  File "/tmp/653879115/main.py", line 7, in 
    getInfos('msg',a )
  File "/tmp/653879115/main.py", line 3, in getInfos
    users[0]="hh"
TypeError: 'tuple' object does not support item assignment

exit status 1

---

這代表是一個元組。

四、不定形參傳入帶星列表。

getInfos('msg',*['aa','bb'] )

輸出 ：

aa
bb

五、直接傳入多個值。

getInfos('msg', 'aa','bb')

輸出：

aa

額外部分二：

看以下例子：

def singalStar(common, *rest):
    print("Common args: ", common)
    print("Rest args: ", rest)

第一種方式，星號（*）參數不傳參：

singalStar("hello")
     
    #Common args:  hello
    #Rest args:  ()

第二種方式，傳多個值（個數大於或等於函數定義時的參數個數）：

singalStar("hello", "world", 000)
     
    #Common args:  hello
    #Rest args:  ('world', 0)

不難看出，上述方式中，星號參數把接收的參數合併爲一個元組。

第三種方式，居然星號參數把接收的參數做爲元組，那麼咱們直接傳元組類型的值：

singalStar("hello", ("world", 000))
     
    #Common args:  hello
    #Rest args:  (('world', 0),)

沒錯，你沒看錯，傳遞的元組值做爲了星號參數的元組中的一個元素。

第四種方式，可是有時候咱們想把元組值就做爲星號參數的參數值，那麼該怎麼辦呢？好辦，在元組值前加上「」便可，不過此時，就不能在加了「」的元組後，追加任何值了。

singalStar("hello", *("world", 000))

singalStar("hello", *("world", 000), "123") #error

Common args: hello

Rest args: ('world', 0)

3.帶兩個星號（*）的函數參數

帶兩個星號（*）的函數定義以下：

def doubleStar(common, **double):
        print("Common args: ", common)
        print("Double args: ", double)

第一種方式，星號（*）參數不傳值：

doubleStar("hello")

Common args: hello

Double args: {}

第二種方式，傳多個參數（個數大於或等於函數定義時的參數個數）。可是，這和單星號參數傳值方式確定不同，不然，不就亂套了嗎。

doubleStar("hello", "Test", 24) #error
doubleStar("hello", x = "Test", y = 24)

Common args: hello

Double args: {'y': 24, 'x': 'Test'}

不難發現，此時必須採用第一節的默認值傳參的「args = value」的方式。同時，「=」前的字段成了字典的鍵，「=」後的字段成了字典的值。即，雙星號參數接收的參數做爲字典。

第三種方式，有時候咱們想把字典值就做爲星號參數的參數值，那麼該怎麼辦呢？同單星號參數，在字典值前加上「**」，同時其後不能添加任何值。

#doubleStar("hello", **{"name": "Test", "age": 24}, {"name": "Test2", "age": 24})    #error
#doubleStar("hello", {"name": "Test", "age": 24})    #error
doubleStar("hello", **{"name": "Test", "age": 24})
 
#Common args:  hello
#Double args:  {'name': 'Test', 'age': 24}

在有些狀況下，單星號函數參數和雙星號函數參數是一塊兒使用的，定義以下：

def singalAndDoubleStar(common, *single, **double):
        print("Common args: ", common)
        print("Single args: ", single)
        print("Double args: ", double)

4.總結

默認值函數參數。這種函數定義時，第一個有默認值的參數後的每個參數都必須提供默認值。傳參時，能夠直接傳參，也能夠以「默認值參數名=value」的形式傳參。
單星號函數參數。單星號函數參數接收的參數組成一個元組。
雙星號函數參數。雙星號函數參數接收的參數組成一個字典。

完整的代碼以下：

def singalStar(common, *rest):
    print("Common args: ", common)
    print("Rest args: ", rest)
    
def doubleStar(common, **double):
    print("Common args: ", common)
    print("Double args: ", double)
    
def singalAndDoubleStar(common, *single, **double):
    print("Common args: ", common)
    print("Single args: ", single)
    print("Double args: ", double)
 
def defaultValueArgs(common, defaultStr = "default", defaultNum = 0):
    print("Common args", common)
    print("Default String", defaultStr)
    print("Default Number", defaultNum)   
 
if __name__ == "__main__":
    defaultValueArgs("Test")
    defaultValueArgs("Test", "default", defaultNum = 1)
     
    singalStar("hello")
    singalStar("hello", "world", 000)
    singalStar("hello", ("world", 000))
    singalStar("hello", ("world", 000), {123: 123})
    singalStar("hello", *("world", 000))
#     singalStar("hello", *("world", 000), "123")    #error
    
    doubleStar("hello")
    doubleStar("hello", x = "Test", y = 24)
    doubleStar("hello", **{"name": "Test", "age": 24})
#     doubleStar("hello", {"name": "Test", "age": 24})    #error
 
    singalAndDoubleStar("hello")
    singalAndDoubleStar("hello", "world", 000)
    singalAndDoubleStar("hello", "world", 000, {"name": "Test", "age": 24})
    singalAndDoubleStar("hello", "world", 000, **{"name": "Test", "age": 24})
    singalAndDoubleStar("hello", ("world", 000), {"name": "Test", "age": 24})
#     singalAndDoubleStar("hello", *("world", 000), {"name": "Test", "age": 24})      #error
    singalAndDoubleStar("hello", *("world", 000), **{"name": "Test", "age": 24})