引數型別：
    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，定義命名的關鍵字引數在沒有可變引數的情況下不要忘了寫分隔符*，否則定義的將是位置引數。