第十章:函數-函數一

01. - 函數 - 函數簡介

(1).函數

函數也是一個對象
函數就是可以用來保存一些可以執行的代碼,並且可以在需要的時候,對這些代碼(語句)進行多次調用
語法
def 函數名([形參1,形參2…]):
代碼塊

函數中保存的代碼塊不會立即執行,需要調用函數代碼纔會執行

(2). 調用函數

                      **函數對象()**

定義一個函數
def fn():
    print('這個是我們第一個函數') 
    print('哈哈哈')
    print('同學們好')
    print('又到了週末')  
    
    
print(fn)     # <function fn at 0x000001E2E9A43EA0>   #  這個是fn,是函數對象
# fn是:函數對象 , fn()是:調用函數
fn()
fn()
fn()
fn()       
>>>                # 這個是fn(),是調用函數
這個是我們第一個函數
哈哈哈
同學們好
又到了週末
這個是我們第一個函數
哈哈哈
同學們好
又到了週末
這個是我們第一個函數
哈哈哈
同學們好
又到了週末
這個是我們第一個函數
哈哈哈
同學們好
又到了週末

02.- 函數 - 函數的參數

函數名必須按照標識符的命名規範
(可以包含字母, 數字,下混線 ,但是不能以數字開頭)

函數的參數:
在定義函數的時候,可以在函數後面的括號定義不等的形參
多個形式我們用逗號隔開
形參(形式餐宿) 定義形參就相當於在函數內部聲明瞭變量,但不是賦值
實參(實際參數) 指定了形參,那麼你在調用函數的時候必須傳遞實際參數,實際參數將會賦值給對應的形參,就是你有幾個形參就需要傳遞幾個實參

定義一個函數  求任意兩個數的和

def fn(a,b):
    print(a,'+',b,'=',a+b)
fn(2,3)
fn(222,666)
>>>
2 + 3 = 5
222 + 666 = 888

03. - 函數 - 函數的傳遞方式

1.默認值

定義形參的時候可以給形參指定默認值
指定了默認值之後,如果用戶傳遞了實參默認值不會發揮任何作用
如果用戶沒有傳遞,則默認值會發揮作用

def fn(a,b,c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)

fn(1,2,3)   # a = 1  b = 2  c = 3  # 指定了默認值之後,如果用戶傳遞了實參默認值不會發揮任何作用
fn(1,2)     # a = 1  b = 2  c = 20  # 如果用戶沒有傳遞,則默認值會發揮作用

2.實參的傳遞方式:

(1) - 位置參數(例如:def fn2 (a,b)😃

(fn2(2,3) 把2賦值給a,把3複製給b

位置參數就是將對應位置的實參賦值給對應位置的形參
第一個實參賦值給形參,第二個實參賦值給第二個形參…

def fn(b = 5,a = 10,c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)
    # 位置參數和關鍵字參數可以混合使用
    # 混合使用的時候關鍵字和位置參數時,必須將位置參數寫到關鍵字參數前面
fn()                #  a = 10  b = 5  c = 20
fn(c = 8,1)     # SyntaxError: positional argument follows keyword argument
fn(1,c = 8)     # a = 10  b = 1  c = 8

(2) - 關鍵字參數

關鍵字參數,可以不按照形參定義的順序去傳遞,而是根據參數名去傳遞

def fn(a = 5,b = 10,c = 20):
    print('a =',a)
    print('b =',b)
    print('c =',c)
fn(b = 1,c = 2,a = 3)     # a = 3  b = 1  c = 2

以下都是關鍵字傳遞方式
例如: with open(‘xxx’,‘wb’,encoding=‘utf-8’,newline=)
例如:print(‘1211’,end=’’)

04. - 函數 - 實參的類型

實參的類型
實參可以傳遞任意類型的對象

def fn():
    print('這個是我們第一個函數')
    print('哈哈哈')
    print('同學們好')
    print('又到了週末')
  
    
def fn2(a):
    print('a =',a)   
b = 123              # a = 123     # 實參是什麼類型(int,str,bool,float)都可以傳遞
b = 'python'         # a = python
b = None           # a = None
b = False          # b = False
fn2(b)     # a = 123
fn2(fn)    # fn後面要不要加括號？這個時候 fn 是作爲一個實參來傳遞，
這個時候 fn 不是在調用函數     # a = <function fn at 0x0000019AB46F3EA0>
 # 這個打印結果就是  我們這個 fn 所指向的內存地址

def fn3(a,b):
    print(a + b)
fn3(132,456)
>>>
588

(1).

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    a = 20
    print('a =',a)

c = 10
fn4(c)
print('c =',c)
>>>
a = 20
c = 10

(2).

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    a = 20
    print('a =',a)

c = [1,2,3]
fn4(c)
print('c =',c)
>>>
a = 20
c = [1, 2, 3]

(3).

ef fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    a[0] = 50
    print('a =',a)

c = [1,2,3]
fn4(c)
print('c =',c)
>>>
a = [50, 2, 3]
c = [50, 2, 3]

(4).

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    a = [4,5,6]
    print('a =',a)

c = [1,2,3]
fn4(c)
print('c =',c)
>>>a = [4, 5, 6]
c = [1, 2, 3]

(5).以下一個例子是錯誤演示:

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    a = [4,5,6]
    print('a =',a)

c[1] = 22
fn4(c)
print('c =',c)
>>>
NameError: name 'c' is not defined  # 打印結果出現錯誤

(6).

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    # a = 20
    a[0] = 50
    print('a =',a,id(a))

c = 10
c = [1,2,3]
fn4(c)
print('c =',c,id(c))

>>>  #  這個時候 a 和 c指向的是一個對象
a = [50, 2, 3] 2715341369096
c = [50, 2, 3] 2715341369096

(7). 總結:如果你在傳遞的是一個可變對象的時候,而你又不希望我在函數內部的操作影響到函數外部的時候,那麼你就可以考慮傳遞一個副本.

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    # a = 20
    a[0] = 50
    print('a =',a,id(a))

c = 10
c = [1,2,3]
fn4(c.copy())     # 通過潛複製 c 來傳遞一個副本
print('c =',c,id(c))
>>>
a = [50, 2, 3] 2113919144904
c = [1, 2, 3] 2113951510280

(8). 總結:如果你在傳遞的是一個可變對象的時候,而你又不希望我在函數內部的操作影響到函數外部的時候,那麼你就可以考慮傳遞一個副本.

def fn4(a):
    # 在函數中對形參進行重新賦值,不會影響其他的變量
    # a = 20
    a[0] = 50
    print('a =',a,id(a))

c = 10
c = [1,2,3]    

fn4(c[:])           #     通過對 c 進行切片來傳遞一個副本
print('c =',c,id(c))  
>>>
a = [50, 2, 3] 2190246106056
c = [1, 2, 3] 2190246948616

05. - 函數 - 不定長參數

(1).

def sum(a,b):
    print(a + b)       #  57
sum(12,45)   


def sum(a,b):   # 這裏傳的是兩個形參
    print(a + b)
sum(12,45,46)   # 這裏傳的是三個實參    #  TypeError: sum() takes 2 positional arguments but 3 were given(類型錯誤:sum()接受2個位置參數，但給出了3個)

解決辦法:
def sum(a,b,c):     #  傳三個形參
    print(a + b + c)    
sum(12,45,46)   #  103    #   傳三個實參

(2).不定長參數

在定義函數時,可以在形參前邊加一個*號,這樣做的好處是這個形參可以獲取到所有的實參
它將會吧所有的實參保存到一個元組當中
定義一個函數,求任意數的和

def fn(*a):
    print('a =',a,type(a))  # a = (1, 2, 3, 4, 5, 6, 7) <class 'tuple'>
fn(1,2,3,4,5,6,7)

(3).定義一個函數,求任意個數的和

def sum(*a):

    # 定義一個變量,用來保存結果
    result = 0
    # 遍歷元組,並將元組中的數進行計算
    for n in a:
        result = result + n

    print(result)

sum(9,13,14,19,33,34,44,99) # 265

(4).不定長參數也可以和其他參數配合使用

def fn2(a,b,*c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,5)
>>>
a = 1
b = 2
c = (3, 4, 5)

(5). 不定長參數不是必須寫在最後,但是要注意,帶*號的參數後面所有的參數,必須以關鍵字的參數形式(a = 1,b = 2,c = 3)傳遞

def fn2(a,*b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,4,c = 5)
>>>
a = 1
b = (2, 3, 4)
c = 5

def fn2(*a,b,c):
    print('a =',a)
    print('b =',b)
    print('c =',c)

fn2(1,2,3,b = 4,c = 5)
>>>
a = (1, 2, 3)
b = 4
c = 5

(6) ** 這種形參可以接受其他的關鍵字參數,它會將這些參數統一保存到一個字典當中

自定的key就是關鍵字的名字,字典的value就是參數的值

def fn3(**a):
    print('a = ',a)      # a =  {'b': 1, 'd': 2, 'c': 3}
fn3(b = 1,d = 2,c = 3)

(7). ** 這種形參只能有一個,並且必須寫在所有參數後面

def fn3(d,c,**a):
    print('a = ',a)        #  a =  {'b': 1}
fn3(b = 1,d = 2,c = 3)

(8). (*a處理位置參數, **a處理的是關鍵字參數(a = 1,b = 2))

def fn3(b,c,**a):
    print('a = ',a)
    print('b =',b)
    print('c =',c)
fn3(b = 1,d = 2,c = 3,e = 5,f = 20)
>>>
a =  {'d': 2, 'e': 5, 'f': 20}
b = 1
c = 3

06. - 函數 - 函數的解包

1.參數的解包

def fn4(a,b,c):
    print('a = ',a)
    print('b =',b)
    print('c =',c)
    # 創建一個元組
t = (10,20,30)
# t = (10,20,30,40)
fn4(t[0],t[1],t[2])  # a = 10  b = 20  c = 30
# 傳遞形參 , 也可以在序列類型的參數添加*號,這樣他會自動將序列當中的元素以此作爲參數傳遞
# 這裏要求序列當中元素的個數必須和形參的個數保持一致(# t = (10,20,30,40))
fn4(*t)              # a = 10  b = 20  c = 30
     

ef fn4(a,b,c):
    print('a = ',a)
    print('b =',b)
    print('c =',c)
# 創建一個字典
d = {'a':1,'b':2,'c':3}

fn4(**d)  
>>>
a =  1
b = 2
c = 3