Python中必選引數、預設引數、可變引數、命名關鍵字引數、關鍵字引數的區別：

Num01–>必選引數（亦即位置引數）：

定義：就是在給函式傳引數時，按照順序，依次傳值。

先寫一個下面的函式：

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

# 呼叫函式並輸出結果
print(power(4,3))
解釋說明：
    函式power(m,n)中有兩個引數，m和n,這兩個引數都是位置引數，呼叫的時候，傳入的兩個值按照順序，依次賦值給m和n。
 

Num02–>預設引數：

定義：就是在寫函式的時候直接給引數傳預設的值，呼叫的時候，預設引數已經有值，就不用再傳值了。

作用：最大的好處就是降低呼叫函式的難度。

修改以上函式：

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

# 呼叫函式並輸出結果
print(power(4))

設定預設引數時，有兩點注意事項：

第一：必選引數在前，預設引數在後，否則python直譯器會報錯。

第二：預設引數一定要指向不變物件！指向不變物件！指向不變物件！ 
（注意：python中的字串，數字，元組都可以看做物件。）

為什麼要設計str、None這樣的不變物件呢？因為不變物件一旦建立，物件內部的資料就不能修改，這樣就減少了由於修改資料導致的錯誤。此外，由於物件不變，多工環境下同時讀取物件不需要加鎖，同時讀一點問題都沒有。我們在編寫程式時，如果可以設計一個不變物件，那就儘量設計成不變物件

Num03–>可變引數：

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

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

特徵：*args

修改程式碼如下：

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

# 呼叫函式
tupleArray=(1,2,3)
# *tupleArray這種方式很常見，很重要
print(power(*tupleArray))

listArray=[1,2,3]
# *listArray這種方式很常見，很重要
# *listArray表示把listArray這個list中所有元素作為可變引數傳進去
print(power(*listArray))
 

Num04–>關鍵字引數：

定義：可變引數允許你傳入0個或任意個引數，這些可變引數在函式呼叫時自動組裝為一個tuple。 
而關鍵字引數允許你傳入0個或任意個含引數名的引數，這些關鍵字引數在函式內部自動組裝為一個dict。在呼叫函式時，可以只傳入必選引數：

作用：擴充套件函式的功能

特徵：**kw

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

案例一：

person('Michael', 30)
name: Michael age: 30 other: {}

案例二：

#定義一個字典資料
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。

Num05–>命名關鍵字引數：

定義：只接收city和job的引數，其他，不接收。

def person(name, age, *, city, job): 
print(name, age, city, job)

作用：限制要傳入的引數的名字，只能傳我已命名關鍵字引數。

特徵：命名關鍵字引數需要一個特殊分隔符*，而後面的引數被視為命名關鍵字引數。

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

def person(name, age, *args, city, job):
    print(name, age, args, city, job)

Num06–>引數組合：

定義：把以上的五種引數組合在一起的引數組合

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