參數類型：
    1、必填參數，位置參數(positional arguments，官方定義，就是其他語言所說的參數) 
    2、默認值參數，非必傳
    3、可變參數，非必傳，不限制參數個數，比如說給多個人發郵件，發郵件的人數不確定
    4、關鍵字參數，非必傳，不限制參數個數，會把傳過來的關鍵字參數，放到一個字典裏面，傳參的時候必須得用k=v這樣子來傳
    5、命名關鍵字參數

1. 位置參數：其他語言沒有分參數的種類是因為只有這一種參數，所有參數都遵循按位置一一對應的原則。
       定義：就是在給函數傳參數時，按照順序，依次傳值。

def power(n,m):
    result
 
=1
    while n>1:
        n = n-1
        result=result*m
    return result

res=power(5,3)
print(res) #輸出結果：81

#解釋說明：
#    函數power(n,m)中有兩個參數，m和n,這兩個參數都是位置參數，調用的時候，傳入的兩個值按照順序，依次賦值給m和n。

2. 默認值參數：完全等同於C++，引入默認參數是為了在某些情境下提供方便。

定義：就是在寫函數的時候直接給參數傳默認的值，調用的時候，默認參數已經有值，就可以不用再傳值了。

作用：最大的好處就是降低調用函數的難度。

形式: 參數名 = 默認值

def students(name,grade,gender=‘Male‘):
    print(name,grade,gender)

students(‘Kitty‘,3)  ##有了默認參數之後，gender這個參數即使不提供 也可以調用函數gender被賦了的默認值Male
students(‘Lily‘,2,‘Famale‘) 

# 以上輸出結果如下：
# Kitty 3 Male
# Lily 2 Famale

默認參數需要註意的地方

a. 默認參數必須在最右端(最後)，這樣才能被解釋器正確識別，否則會產生二義性。

def fun(a=10, b): #
 
這裏會報錯：SyntaxError: non-default argument follows default argument
    return a + b  
fun(10)  

#二義性：這個20究竟是賦值給a的還是b的
#人都無法分辨清楚，解釋器就更不行了

b. 默認參數一定要指向不變對象！

def defaultzero(list = []):  #我們的本意是提供的list參數為0時 返回只有一個0的list
    list.append(0)
    return list
print(defaultzero())  #輸出：[0]
print(defaultzero())  #輸出：[0, 0] 顯然重復調用的時候結果不是我們所期望的

#解決方案 使用None
def defaultzero1(list = None):
    if list == None:
        list = []
        list.append(0)
    return list
print(defaultzero1()) #輸出：[0]
print(defaultzero1()) #輸出：[0] 重復調用的時候，也輸出相同

#這說明list是一個對象
#事實上Python所有的數據類型其實都是對象

結果說明python解釋器會將默認參數作為一個公共對象來對待，多次調用含有默認參數的函數，就會進行多次修改。
因此定義默認參數時一定要使用不可變對象(int、float、str、tuple)。使用可變對象語法上沒錯，但在邏輯上是不安全的，代碼量非常大時，容易產生很難查找的bug。

3. 可變參數：Python函數提供了可變參數，來方便進行參數個數未知時的調用。可變參數將以tuple形式傳遞。

定義：可變參數就是傳入的參數個數是可變的，可以是0個，1個，2個，……很多個。

作用：就是可以一次給函數傳很多的參數

特征（格式）：*args 【*參數 （即在參數前加*號）】

def power(*args):
    result=0
    for n in args:
        result=result+n*n
    return result

# 調用函數1
tupleArray=(1,2,3)
# *tupleArray這種方式很常見，很重要
print(power(*tupleArray))  #輸出結果：14

# 調用函數2
listArray=[1,2,3]
# *listArray這種方式很常見，很重要
# *listArray表示把listArray這個list中所有元素作為可變參數傳進去
print(power(*listArray))  #輸出結果：14

#調用函數3
print(power(1,2,3))  #輸出結果：14

請註意: *在C語言中是取內容運算符，變量前加該符號意為指針變量，Python中只是一個標識符，表示將以tuple形式傳遞，星號本身有”全部的”意思, 兩者無任何關系，下同。

4. 關鍵字參數：Python的可變參數以tuple形式傳遞，而關鍵字參數則是以dict形式傳遞。 即可變參數傳遞的是參數值，關鍵字參數傳遞的是參數名:參數值鍵值對。

定義：關鍵字參數允許你傳入0個或任意個含參數名的參數，這些關鍵字參數在函數內部自動組裝為一個dict。在調用函數時，可以只傳入必選參數：
作用：擴展函數的功能
特征：**kw 這是慣用寫法，建議使用，容易被理解

def person(name, age, **kw):
    print(‘name:‘, name, ‘age:‘, age, ‘other:‘, kw)

#案例一：
person(‘Michael‘, 30) #輸出結果：name: Michael age: 30 other: {}

#案例一：
person(‘Michael‘, 30, city=‘Beijing‘) #輸出結果：name: Michael age: 30 other: {‘city‘: ‘Beijing‘}

#案例三：
#定義一個字典數據
dictArray = {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}
#調用函數
person(‘Jack‘, 24, **dictArray )
#輸出結果 name: Jack age: 24 other: {‘city‘: ‘Beijing‘, ‘job‘: ‘Engineer‘}

#解釋說明：
#**dictArray表示把dictArray這個dict的所有key-value用關鍵字參數傳入到函數的**kw參數，kw將獲得一個dict。註意kw獲得的dict是dictArray的一份拷貝，對kw的改動不會影響到函數外的dictArray。

5. 命名關鍵字參數：Python的命名關鍵字參數對傳入的關鍵字參數做了進一步的限制。

定義：例如只接收city和job的參數，其他，不接收。
def person(name, age, *, city, job):
print(name, age, city, job)

作用：限制要傳入的參數的名字，只能傳我已命名關鍵字參數。
特征：命名關鍵字參數需要一個特殊分隔符*，而後面的參數被視為命名關鍵字參數。

def personinfo(name, age, *, gender, city): #只能傳遞gender和city參數
    print(name, age, gender, city)
personinfo(‘Steve‘, 22, gender = ‘male‘, city = ‘shanghai‘)  #輸出：Steve 22 male shanghai

關鍵字參數和命名關鍵字參數的區別在於，前者可以傳遞任何名字的參數，而後者只能傳遞*後面名字的參數。

如果函數定義中已經有了一個可變參數，後面跟著的命名關鍵字參數就不再需要一個特殊分隔符*了：

def personinfo(name, age, *args, gender, city): #args可以傳遞一個list 其後只能傳遞gedner和city參數
    print(name, age, gender, city, args)
personinfo(‘Steve‘, 22, [1,2,3,4],city = ‘shanghai‘,gender = ‘male‘)
# 輸出：Steve 22 male shanghai ([1, 2, 3, 4],)

6. 各種參數之間組合

定義：把以上五種參數組合在一起的參數組合
排放順序：在Python中定義函數，可以用必選參數、默認參數、可變參數、命名關鍵字參數和關鍵字參數，這5種參數都可以組合使用。但是請註意，參數定義的順序必須是：必選參數–>默認參數–>可變參數–>命名關鍵字參數–>關鍵字參數

可讀性是代碼的一個很重要的要求，所以盡量避免使用多種參數的組合。

#比如定義一個函數，包含若幹種參數：
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)

#在函數調用的時候，Python解釋器自動按照參數位置和參數名把對應的參數傳進去。
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 kw = {‘ext‘: None}

# 最神奇的是通過一個tuple和dict，你也可以調用上述函數：
args = (1, 2, 3, 4)
kw = {‘d‘: 99, ‘x‘: ‘#‘}
f1(*args, **kw) # 輸出：a = 1 b = 2 c = 3 args = (4,) kw = {‘d‘: 99, ‘x‘: ‘#‘}

args = (1, 2, 3)
kw = {‘d‘: 88, ‘x‘: ‘#‘}
f2(*args, **kw)# 輸出：a = 1 b = 2 c = 3 d = 88 kw = {‘x‘: ‘#‘}

#所以，對於任意函數，都可以通過類似func(*args, **kw)的形式調用它，無論它的參數是如何定義的。

小結

1，Python的函數具有非常靈活的參數形態，既可以實現簡單的調用，又可以傳入非常復雜的參數。 2，默認參數一定要用不可變對象，如果是可變對象，程序運行時會有邏輯錯誤！ 3，要註意定義可變參數和關鍵字參數的語法： *args是可變參數，args接收的是一個tuple；

**kw是關鍵字參數，kw接收的是一個dict。

4，以及調用函數時如何傳入可變參數和關鍵字參數的語法： 可變參數既可以直接傳入：func(1, 2, 3)，又可以先組裝list或tuple，再通過*args傳入：func(*(1, 2, 3))； 關鍵字參數既可以直接傳入：func(a=1, b=2)，又可以先組裝dict，再通過**kw傳入：func(**{‘a‘: 1, ‘b‘: 2})。

5，使用*args和**kw是Python的習慣寫法，當然也可以用其他參數名，但最好使用習慣用法。

6，命名的關鍵字參數是為了限制調用者可以傳入的參數名，同時可以提供默認值。 7，定義命名的關鍵字參數在沒有可變參數的情況下不要忘了寫分隔符*，否則定義的將是位置參數。

7，定義命名的關鍵字參數在沒有可變參數的情況下不要忘了寫分隔符*，否則定義的將是位置參數。

Python的參數類型