一、函式的建立和呼叫

1、什麼是函式

• 函式就是執行特定任務和完成特定功能的一段程式碼

2、函式建立格式

def sum(a,b): #a,b稱為形式引數，簡稱形參，形參的位置是在函式的定義處
    c=a+b
    return c

result=sum(10,60)  #10，60稱為實際引數的值，簡稱實參，實參的位置是函式的呼叫處
print(result)

運算結果：

70

3、函式呼叫的引數傳遞

• 位置實參——根據形參對應的位置進行實參傳遞
• 關鍵字實參——根據形參名稱進行實參傳遞

4、在函式的呼叫過程中，進行引數的傳遞。如果是不可變物件，在函式體的修改不會影響實參的值；如果是可變物件，在函式體中的修改會影響帶實參的值

n1=10
n2=['hello','world']
test(n1,n2)
print(n1)  #10 可以發現n1的值沒有發生改變，因為n1是不可變物件
print(n2)  #['hello', 'world', 10]  可以發現n2發生了變化，因為n2是可變物件

二、函式的返回值

1、如果函式沒有返回值【函式執行完畢之後，不需要給呼叫處提供資料】，return可以省略

2、函式的返回值，如果是1個，直接返回型別

3、函式的返回值，如果是多個，返回的結果為元組

#判斷基數與偶數
odd=[]
even=[]
def fun(lst):
    for i in lst:
        if i%2==0:
            even.append(i)
        else:
            odd.append(i)
    return odd,even

lst=[10,29,34,23,44,53,55]
print(fun(lst))  #可以發現已元組的形式輸出

三、函式引數定義

1、函式定義預設值引數——函式定義時，給形參設定預設值，只有與預設值不符的時候才需要傳遞實參

def fun(a,b=20):
    print(a,b)

#函式的呼叫
fun(100)     #100 20（在這裡可以發現，只傳入一個引數第二個引數使用預設值）
fun(100,200) #100 200

2、個數可變的位置引數

• 定義函式時，可能無法事先確定傳遞的位置實參的個數時，使用可變的位置引數
• 使用*定義個數可變的位置形參
• 結果為一個元組

def fun(*args):   #函式定義時的可變的位置引數
    print(args)

#結果以元組的形式返回
fun(10)
fun(100,200)
fun(30,40,50)

運算結果：

(10,)
(100, 200)
(30, 40, 50)

3、個數可變的關鍵字形參

• 定義函式時，無法事先確定傳遞的關鍵字實參的個數時，使用可變的關鍵字形參
• 使用**定義個數可變的關鍵字形參
• 結果為一個字典

def fun(*args):  #函式定義時的可變的位置引數，結果為一個元組
    print(args)

fun(10)
fun(10,30)
fun(30,405,50)

def fun1(**args):  ##函式定義時的可變的關鍵字引數，結果為一個字典
    print(args)

fun1(a=10)
fun1(a=10,b=20)

'''
def fun2(*args,*a):
    pass
可以發現報錯：個數可變的位置引數只能有一個；同理，個數可變的關鍵字引數也只能有一個
在一個函式的定義過程中，既有個數可變的關鍵字形參，也有個數可變的位置形參，要求是個數可變的位置形參放在個數可變的關鍵字形參之前
'''

4、函式的呼叫

將列表中的每個元素都轉換為位置實參——使用*

將字典中的每個鍵值對都轉換為關鍵字實參——使用**

def fun(a,b,c):#sa,b,c在函式的定義處，所以只是形式引數
    print('a=',a)
    print('b=',b)
    print('c=',c)

'''
函式的呼叫
'''
fun(10,20,30)#函式呼叫時的引數傳遞，稱為位置傳參
lst=[10,20,30]
#fun(lst)#不能直接把lst列表傳入函式中，因為lst相當於是一個物件
fun(*lst)#在函式呼叫中，使用*可以將列表中的每個元素都轉換為位置實參傳入

print('______________________')
fun(a=100,c=300,b=200)
dic={'a':111,'b':222,'c':333}
#fun(dic)#報錯，dic只是一個物件，需要新增**將字典裡面資料轉化為關鍵字實參
fun(**dic) #在函式呼叫時，將字典中的鍵值對都轉化為關鍵字實參傳入

5、函式的定義

def fun(a,b=10): #b是在函式的定義處，所以b是形參，而且進行了賦值，所以b稱為預設值形參
    print(a)
    print(b)

def fun2(*args): #個數可變的位置形參
    print(args)

def fun3(**args2):#個數可變的關鍵字形參
    print(args2)

fun2(10,20,30,40)   #元組
fun3(a=10,b=20,c=30)#字典

def fun4(a,b,c,d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)

#呼叫fun4函式
fun4(10,20,30,40)#位置實參傳遞
fun4(a=10,b=20,c=30,d=40)#關鍵字實參傳遞
fun4(10,20,c=30,d=40)#前兩個引數採用位置實參傳遞，後兩個引數採用關鍵字實參傳遞
'''
如果只想c,d採用關鍵字實參傳遞，這需要在建立函式的時候在c,d前加一個*
def fun4(a,b,*,c,d):
    print('a=', a)
    print('b=', b)
    print('c=', c)
    print('d=', d)
'''

四、函式變數

區域性變數：在函式內定義並使用的變數，只在函式內部有效，區域性變數使用global宣告會變成全域性變數

全域性變數：在函式體外定義的變數，可作用於函式內外

def fun(a,b):
    c=a+b
    print(c)

#print(a)  可以發現報錯，因為 a c 都是區域性變數
#print(c)

name='楊老師' #name的作用範圍為函式內部和外部都可以使用——全域性變數
print(name)

def fun2():
    print(name)
fun2()

def fun3():
    global age#使用global宣告變數，可以使得區域性變數變為全域性變數
    age=20
    print(age)
fun3()

print(age)#報錯，age是區域性變數

執行結果：

楊老師
楊老師
20
20