函數初識

定義:

　　將一些代碼進行封裝,減小重複代碼

基本結構:

　　def 函數名+():

　　　　函數體

　　函數名+()　　　　調用:函數名+小括號

執行流程:

　　1,先定義,不會執行
　　2,調用,會執行定義好的語句
　　3..定義好的語句

返回值: return

　　1,不寫return返回的是None,寫了return不寫值返回的仍是None

def make(): pass return make()

　　2,return就是將內容返回給了調用者,多個返回值是元祖,返回的內容不受限制

　　3,函數中當執行到return的時候就結束了,return如下代碼都不執行,並終止這個函數

def func(): print('今天週一') print('明天週三') return　　　　　　　　　　ps:print('後天週四')不執行
     print('後天週四') print(func())

靜態參數

　　形參,定義函數時在上面的就是形參

　　實參,下面調用的參數是實參,形參和實參的數量要一一對應

　　傳參,從實參到形參的過程

　　在正常狀況下,實參中添加一個元素,形參也要對應的添加一個元素

位置參數:

def func(addr,age):　　　　位置參數,按照位置向上賦值

　　print(f'我站在{addr}的操場,靜靜地看着{age}的你')
　　print(f'你站在{addr}的江邊,看着來往的{age}的人')
func('學校',21) 
func('黃浦江',21) 　　　　　　　　　　ps:實參和形參要上下一一對應

默認參數(關鍵字參數):

def func(em,msg):　　　　　　　　形參中稱做默認參數,實參中稱做關鍵字參數 print(f'小明的目標是{msg},並體驗{em}') func(em='長空棧道',msg='華山')

混合參數:

def func(name,age,level,sex='男'): print(f'我叫{name},年齡{age},學歷{level},性別{sex}') func('小明',18,'碩士')
　　ps:性別爲默認參數

參數的使用規則：　

形參:位置參數>默認參數　　 實參:位置參數>關鍵字參數　　 混合參數:帶等號的參數要放在最後

動態參數:

位置參數的萬能傳參:

　　 *args(一個規範),對數據進行封裝打包,能接收全部的位置參數；*,表明聚合打包,形參中若是用到動態參數,位置參數>動態位置參數

def eat(*args): print(args) eat('包子','餃子','饅頭','米飯') 輸出結果爲:('包子','餃子','饅頭','米飯')是元祖類型

實例:

def eat(a,b,*args): 　　　　　　　　　　  ps:當a,b寫在*args以前,會被正常賦值 　　print(a,b,args) eat('包子','餃子','豆漿','油條') 輸出結果爲:包子,餃子,('豆漿','油條') def eat(*args,a,b):    　　　　　　　　　　　　ps:若是a,b寫在*args以後,數據都會被args接收 　　print(a,b,args) eat('包子','餃子','豆漿','油條') 輸出結果爲:('包子','餃子','豆漿','油條')

如今嘗試過聚合打包了,那確定也是能夠打散的

def eat(a,b,*args) print(a,b,*args) 　　　ps:print中加*,打包的元素會被打散,就會打印出下面的結果 eat('包子','餃子','豆漿','油條') 輸出結果爲:包子,餃子,豆漿,油條

再來一個實例:

lst = [12,3,4,16] def func(*args): print(*args)　　  args加星,輸出結果爲:   12,3,4,16 func(*lst) lst = [12,3,4,16] def func(*args): print(args)　　  args不加星,輸出結果爲:(12,3,4,16) func(*lst)

默認參數的萬能傳參

　　**kwargs,接收的全部的關鍵字參數,形參中若是用到動態默認參數,默認參數>動態默認參數

例1:

def eat(**kwargs): 接收全部的關鍵字參數 print(kwargs) eat(a=12,b=13,c=16) 輸出結果爲:{'a':12,'b':13,'c':16}

例2:

def eat(a,b,**kwargs):        兩顆星聚合打包,獲得的是一個字典    
    print(a,b,kwargs)
eat(a=12,c=16,b=13,d=18)    
　　　　　　　　　　　　　　輸出結果爲:12,13,{'c':16,'d':18}

默認參數的打散

　例3:

def eat(a,b=2,**kwargs): print(a,b,*kwargs)             *,一顆星打散,獲取的是字典的鍵;**不能打散 eat(a=12,c=16,b=13,d=18) 　　　　　　　　　　　　　　輸出結果爲:12,13,c,d(b的值被改變)

例4-1:

dic = {"1":22,"2":55} def func(**kwargs): print(kwargs)             kwargs,獲得字典; func(**dic)        　　　　　　 # *dic,會報錯 兩顆*,打散的效果爲:{"1":22,"2",55}

例4-2:

dic = {"1":22,"2":55} def func(**kwargs): print(*kwargs) *kwargs,獲取的是字典的鍵 func(**dic)             輸出內容爲:1,2(字典的鍵)

例4-3:

dic = {"1":22,"2":55} def func(**kwargs): print(kwargs.values()) func(**dic) 輸出結果爲:dict_values([22, 55])

形參遵循的規則:

　　位置參數>動態位置參數>默認參數>動態默認參數def func(*args,**kwargs)

函數註釋

def func(*args,**kwargs):　　　註釋時,要加上函數一塊兒註釋,否則未出現縮進錯誤

''' 
:param args: 　 萬能的位置參數 
:param kwargs: 萬能的默認參數 
:return : 返回值 
''' 
print(args) 
print(kwargs) 
return args

print(func.__doc__)　　　　　　　　查看函數的註釋

名稱空間

　　內置空間,全局空間,局部空間(局部空間的變量不能共享)

加載順序

　　內置空間>全局空間>局部空間

取值順序:

　　局部空間>全局空間>內置空間

python中的關鍵字存儲在內置空間，py文件中頂頭寫的內容就存在全局空間，函數內寫的變量是存在局部空間

def func(): a = 1 局部空間 print(a) func()

此時,a就是存在局部空間的變量

a = 10
def func(): print(a) 局部空間沒有,到全局找 func() 

　　而在這個函數中,a是一個全局變量,當print(a)時,局部空間沒有變量a,就到全局找

命名空間

　　內置+全局構成一個空間,　　　　　　經過globals(),來查看全局做用域的內容

　　局部空間　　　　　　　　　　　　　經過locals()來查看局部做用域的內容

函數嵌套

　　在嵌套函數中,要一層一層的往下找,同級別的也要遵照從上到下的順序.那接下來就經過一些實例來講明函數的嵌套，更好地瞭解函數的執行流程

1    def func(): 
4        func1()
6        print(1)
2    def func1():
5        print(2)
3    func            輸出結果爲: 2,1　　　　　　ps:最左側數字爲函數的執行流程 

示例5.1，簡單嵌套

要注意的是，函數執行完還有一個回退的過程

1    def func():
7        func1()
9        print(1)
2    def func2():
5        print(33)
6        func()
3    def func1():
8        print(2)
4    func2()            輸出結果爲:33,2,1　　　　　　左側數字是函數嵌套的執行流程

示例5.2

在這個嵌套中,函數的執行流程仍是比較容易梳理出來的

1   def func():
3       print(1)
4       def func1():
7           print(2)
8           func3()
5       def func3():
9           print(4)          
6         func1()
2   func()                      按照這樣的流程,輸出結果爲:1,2,4


def func():
    print(1)
    def func1():
        print(2)
        func3()
        def func2():    但在這裏添加一個func2時,它是func1局部空間裏的一個數據,是不能共享的
            print(4)
    　　     def func3():
        　　     print(4)
        func2()               在調用func2時,先到func3裏找,找不到會報錯    
    func1()
func()

示例5.3

要注意：局部空間的變量不能共享

def func1():                
    print(1)                
    def func2():                
        print(2)            
        def func3():            
            print(3)            
        def func6():            
            print(6)
            func3()              
            def func4():            
                print(4)        
                def func7():        
                    print(7)        
                func7()            
                def func5():        
                    print(5)        
                func5()            
            func4()                
        func6()                
    func2()                    
func1()                            輸出結果爲:1,2,6,3,4,7,5

示例5.4

global修改全局變量

a = 10 
def func():
    global a            #  申明要修改全局變量a的值,若是全局沒有
     a = 20 
     print(a)
func()
print(a) 　　　　　　　　　輸出結果爲20,20

示例6.1

a = 10
def func():
    global b        
    b = 100
     print(a)
    print(locals())        # {},空字典是存放局部做用域裏的一個容器
func()
print(b)　　　　　　　　　　　　輸出結果爲:10,100

示例6.2

nonlocal修改局部變量

n = 1
def func():
    n = 10
    def func1():
        print(n)
    func1()
func()
print(n)　　　　　輸出結果爲:10,1(10是局部的func1裏沒有,尋找的是func裏的n=10;1是最後的print打印的全局變量)

正常狀況

n = 1
def func():
    n = 10
    def func1():
        nonlocal n     　　　　　　修改離得最近上一層的變量值,若是沒有,繼續往上找
        n = 100        　　　　　　直到局部變量的最外層
        print(n)
    func1()
func()
print(n)　　　　　　　　　　　　　　　輸出結果爲:100,1

nonlocal修改局部變量