自定義函式的分類

無參函式、有參函式和空函式

無參函式：

在函式定義階段，括號內沒有引數。

def index():    # 定義無參函式，括號內沒有引數
    print('今天你吃飯了嗎')


index()    # 呼叫無參函式，括號內也不用寫引數

有參函式：

在函式定義階段，括號內有引數，這個引數類似於變數名。

def index(a):    # 定義有參函式，括號內要有引數，類似於變數值
    print('嘿嘿嘿 妹紙有事衝我來', a)


index(123)    # 呼叫有參函式，括號內也必須要有引數，類似於變數的值

空函式：

在函式定義階段，函式體程式碼是用pass或者...佔位。空函式能讓整體的程式框架更加簡潔清晰，增強程式碼的可讀性和使用效率。

def index():    # 定義一個空函式
    pass    # 函式體程式碼用pass語句或者'...'佔用替代

函式的返回值return

函式的返回值其實就是在呼叫的函式執行完畢之後，返回給呼叫者的結果。

s = 'hello world'
res = len(s)  # 將len函式的返回值賦值給變數res
print(res)

返回值return的用法：

• 當函式體程式碼沒有return關鍵字的時候，返回值是None。

# 定義一個函式
def index():
    print('春困秋乏夏打盹兒')    
# 呼叫這個函式並給變數名賦值
res = index()
 
print(res)  # None  返回值是以布林值的方式存在

• 當函式體程式碼寫了return關鍵字，但是沒有跟任何值得時候，返回值也是None。

# 定義一個函式
def index():
    print('春困秋乏夏打盹兒')
    return  # 函式的返回值關鍵字


# 呼叫這個函式並給變數名賦值
res = index()
print(res)  # None  返回值是以布林值的方式存在

• 當函式體程式碼寫了return關鍵字，並且跟了資料，那麼寫什麼就返回什麼。如果寫的是值，那麼直接返回值(這個值可以是任意資料型別)；如果寫的是變數名，那麼返回變數名指向的值。

# 定義一個函式
def index():
    print('春困秋乏夏打盹兒')
    name = 'jason'    # 變數的賦值
    return name  # 函式的返回值關鍵字


# 呼叫這個函式並給變數名賦值
res = index()
print(res)  # jason

• return關鍵字後面還可以跟多個值，值與值之間用逗號隔開，函式呼叫結束時會自動組織成元組的形式。

# 定義一個函式
def index():
    print('春困秋乏夏打盹兒')
    return 111, 'jason', 222  # 函式的返回值是多個，值之間用逗號隔開


# 呼叫這個函式並給變數名賦值
res = index()
print(res)  # (111,'jason',222) 輸出是以元組的形式存在

• 當函式體程式碼遇到return關鍵字的時候，會立刻結束函式執行。類似於迴圈語句當中的break關鍵字。

函式的引數

函式的引數可以分為兩大類：分為形式引數和實際引數，簡稱形參和實參。

形參：

函式在定義階段括號內寫的引數；形參即在定義函式時，括號內宣告的引數，形參本質就是一個變數名，用來接收外部傳來的值。

實參：

函式在呼叫階段括號內寫的引數；實參即在呼叫函式時，括號內傳入的值，值可以是常量、變數、表示式或三者的組合。

形參與實參的關係：

形參類似於是變數名、實參類似於是變數的值。

在呼叫有參函式的時候實參（值）的值會賦給形參（變數名），此時實參會與形參臨時繫結；這種關係只在函式呼叫的時候存在；函式執行結束之後自動解除繫結。

# 定義函式
def index(a, b):  # a和b就是index函式的形參
    print(a, b)


# 呼叫函式
index(1, 2)  # 1和2就是index函式的實參

note：

實參1會臨時繫結給形參a,實參2會臨時繫結給形參b,在函式體程式碼執行期間，可以通過形參直接使用到實參；函式體程式碼執行完畢之後，解除繫結形參，ab處於沒有繫結值得狀態，等待下一次函式呼叫然後再傳入實參進行繫結......。

位置引數

位置引數就是指按位置順序定義的引數，分為位置形參和位置實參兩種。

位置形參：

在定義函式時，按照從左到右的順序依次定義形參,稱為位置形參，凡是按照這種形式定義的形參都必須被被傳值；即在函式定義階段括號內從左往右依次填寫的變數名。

def index(name,pwd):  # name和pwd就是位置形參
    pass

位置實參：

在呼叫函式時，按照從左到右的順序依次定義實參，稱為位置實參，凡是按照這種形式定義的實參會按照從左到右的順序與形參一一對應；即在函式呼叫階段括號內從左往右依次傳入的真實資料。

index('jason',123)  # jason和123就是位置實參

位置引數的特點：

1. 位置形參與位置實參在繫結關係的時候就是按照從左往右的順序依次繫結。
2. 位置形參與位置實參的個數要一致，多一個不行，少一個也不行。

def index(a, b):    # 定義一個有參函式
    print(a, b)  # 外界傳入什麼實參這裡就列印什麼


index(1, 2)    # 呼叫有參函式，實參1和2
index('jason', 123)    # 呼叫有參函式，實參'jason'和123
# NOTE:
index()  # 呼叫的時候不傳實參不可以
index(111)  # 傳少了也不行
index(111, 222, 333)  # 傳多了也不行

關鍵字引數

在呼叫函式時，實參可以是key=value的形式，稱為關鍵字引數，凡是按照這種形式定義的實參，可以完全不按照從左到右的順序定義，但仍能為指定的形參賦值。關鍵字引數只能出現在實參當中。

def index(a, b):    # 定義一個有參函式
    print(a, b)

# 呼叫這個有參函式
index(b=111, a=222)  # 指名道姓的說形參a接收資料222 b接收資料111

NOTE：

需要注意在呼叫函式時，實參也可以是按位置或按關鍵字的混合使用，但必須保證關鍵字引數在位置引數後面，且不可以對一個形參重複賦值！！！

def index(a, b):
    print(a, b)


# NOTE:
index(b=333, 222)  # 報錯 關鍵字引數必須放在位置引數的後面
index(222, a=111)  # 報錯 形參只能指向一個實參
index(222, b=111)  # 可以 相當於位置引數

預設引數

在定義函式時，就已經為形參賦值，這類形參稱之為預設引數。當函式有多個引數時，需要將值經常改變的引數定義成位置引數，而將值改變較少的引數定義成預設引數。

NOTE:

預設引數的出現也打破了形參與實參之間個數一致的情況。

1、預設引數必須定義在位置引數的後面。

2、預設引數的值僅僅能在函式定義的階段被賦值一次。

例如編寫一個註冊學生資訊的函式，如果大多數學生的性別都為男，那完全可以將形參sex定義成預設引數。

def register(name, age, gender='男'):
    print("""
    學員姓名:%s
    學員年齡:%s
    學員性別:%s
    """ % (name, age, gender))


register('jason', 18)    # 不傳就使用預設的  男
register('kevin', 28)    # 不傳就使用預設的  男
register('jerry', 22, '美女')  # 傳了就使用自己的

可變長引數

引數的長度可變指的是在呼叫函式時，實參的個數可以不固定，而在呼叫函式時，實參的定義無非是按位置或者按關鍵字兩種形式，這就要求形參提供兩種解決方案來分別處理兩種形式的可變長度的引數。

• 可變長度的位置引數

*號在形參中，可以接收多餘的位置引數，並組織成元組的形式賦值給*號後面的變數名，即，溢位的位置實參，都會被接收，以元組的形式儲存下來賦值給該形參。

def func(*a):    # 多變數形參
    print(a)


func()  # ()
func(1, 2)  # (1, 2)
func(1, 2, 3, 4, 5, 6)  # (1, 2, 3, 4, 5, 6)

def index(a, b, *ag):
    print(a, b, ag)


index(999)  # 會報錯  因為形參a，b的存在，意味著index函式最少要給兩個引數
index(1, 2)  # 1 2 ()
index(1, 2, 3, 4, 5, 6, 7)  # 1 2 (3, 4, 5, 6, 7)
index(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)  # 1 2 (3, 4, 5, 6, 7, 8, 9, 10)

• 可變長度的關鍵字引數

**在形參中，用於接收多餘的關鍵字引數，在呼叫函式時，溢位的關鍵字引數，都會被接收，以字典的形式儲存下來賦值給該形參。

def index(a, b, **k):    # **k關鍵字形參，可以接受多個關鍵字引數
    print(a, b, k)


index(a=1, b=2)  # 1 2 {}
index(a=1, b=2, c=3, name='jason')  # 1 2 {'c': 3, 'name': 'jason'}
index(1, 2, name='jason', age=18, pwd=123)  # 1 2 {'name': 'jason', 'age': 18, 'pwd': 123}

def func(**k):
    print(k)


func()  # {}
func(a=1, b=2)  # {'a': 1, 'b': 2}
func(a=1, b=2, c=3, d=4)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}

定義函式的時候，如果不確定這個函式將來需要多個實參，那麼可以採用*a和**k組合的方法。

def func(*a, **k):
    print(a, k)


func()  # () {}
func(1, 2, 3, 4, name='jason', age=18)  # (1, 2, 3, 4) {'name': 'jason', 'age': 18}

NOTE：

*和**在形參中的使用，後面的變數名並不是關鍵，但是針對這兩個特殊符號後面的變數名，有推薦的寫法：

def index(*args, **kwargs):
    pass