python全棧開發-Day8 函數

一 、引子

1、 為何要用函數之不用函數的問題

#1、代碼的組織結構不清晰，可讀性差
#2、遇到重復的功能只能重復編寫實現代碼，代碼冗余
#3、功能需要擴展時，需要找出所有實現該功能的地方修改之，無法統一管理且維護難度極大 

2、 函數是什麽？

針對二中的問題，想象生活中的例子，修理工需要實現準備好工具箱裏面放好錘子，扳手，鉗子等工具，然後遇到錘釘子的場景，拿來錘子用就可以，而無需臨時再制造一把錘子。

修理工===>程序員
具備某一功能的工具===>函數

要想使用工具，需要事先準備好，然後拿來就用且可以重復使用
要想用函數，需要先定義，再使用

3、 函數分類

#1、內置函數
為了方便我們的開發，針對一些簡單的功能，python解釋器已經為我們定義好了的函數即內置函數。對於內置函數，我們可以拿來就用而無需事先定義，如len(),sum(),max()
ps：我們將會在最後詳細介紹常用的內置函數。

#2、自定義函數
很明顯內置函數所能提供的功能是有限的，這就需要我們自己根據需求，事先定制好我們自己的函數來實現某種功能，以後，在遇到應用場景時，調用自定義的函數即可。

二 、定義函數

1、如何自定義函數？

#語法
def 函數名(參數1,參數2,參數3,...):
    ‘‘‘註釋‘‘‘
    函數體
    return 返回的值

#函數名要能反映其意義

 1 def func(user,pwd):
 2     ‘‘‘驗證用戶名密碼‘‘‘
 3     if user == ‘duoduo‘ and password == ‘123‘:
 4      
 5         return 1      #返回1
 6 
 7 user=input(‘用戶名>>: ‘).strip()
 8 pwd=input(‘密碼>>: ‘).strip()
 9 res=func(user,pwd)
10 print(res)
11 
12 # 輸入用戶名密碼正確，會得到值為1
         

2、 函數使用的原則：先定義，再調用

函數即“變量”，“變量”必須先定義後引用。未定義而直接引用函數，就相當於在引用一個不存在的變量名
#測試一
def foo():
    print(‘from foo‘)
    bar()
foo() #報錯   foo函數中函數bar還未定義

#測試二
def bar():
    print(‘from bar‘)
def foo():
    print(‘from foo‘)
    bar()
foo() #正常

#測試三
def foo():
    print(‘from foo‘)
    bar()
    
def bar():
    print(‘from bar‘)
foo() #會報錯嗎？       會！函數還未定義，無法調用

#結論:函數的使用,必須遵循原則:先定義,後調用 #我們在使用函數時,一定要明確地區分定義階段和調用階段
#具體圖解可也點這篇：http://www.cnblogs.com/ManyQian/p/8137462.html

#定義階段
def foo():
    print(‘from foo‘)
    bar()
def bar():
    print(‘from bar‘)
#調用階段
foo()

函數即“變量”，“變量”必須先定義後引用。未定義而直接引用函數，就相當於在引用一個不存在的變量名
#測試一
def foo():
    print(‘from foo‘)
    bar()
foo() #報錯

#測試二
def bar():
    print(‘from bar‘)
def foo():
    print(‘from foo‘)
    bar()
foo() #正常

#測試三
def foo():
    print(‘from foo‘)
    bar()
    
def bar():
    print(‘from bar‘)
foo() #會報錯嗎?


#結論:函數的使用,必須遵循原則:先定義,後調用
#我們在使用函數時,一定要明確地區分定義階段和調用階段

#定義階段
def foo():
    print(‘from foo‘)
    bar()
def bar():
    print(‘from bar‘)
#調用階段
foo()

3、 函數在定義階段都幹了哪些事？

#只檢測語法，不執行代碼
也就說，語法錯誤在函數定義階段就會檢測出來，而代碼的邏輯錯誤只有在執行時才會知道

4、 定義函數的三種形式

#1、無參：應用場景僅僅只是執行一些操作，比如與用戶交互，打印
#2、有參：需要根據外部傳進來的參數，才能執行相應的邏輯，比如統計長度，求最大值最小值
#3、空函數：設計代碼結構

#定義階段
def tell_tag(tag,n): #有參數
    print(tag*n)

def tell_msg(): #無參數
    print(‘hello world‘)

#調用階段
tell_tag(‘*‘,12)
tell_msg()
tell_tag(‘*‘,12)

‘‘‘
************
hello world
************
‘‘‘

#結論：
#1、定義時無參，意味著調用時也無需傳入參數
#2、定義時有參，意味著調用時則必須傳入參數

def auth(user,password):                             
    ‘‘‘                                                           
    auth function                                                 
    :param user: 用戶名                                              
    :param password: 密碼                                           
    :return: 認證結果                                                 
    ‘‘‘                                                           
    pass                                                          
                                                                  
def get(filename):                                                
    ‘‘‘                                                           
    :param filename:                                              
    :return:                                                      
    ‘‘‘                                                           
    pass                                                          
                                                                  
def put(filename):                                                
    ‘‘‘                                                           
    :param filename:                                              
    :return:                                                      
    ‘‘‘                                                           
def ls(dirname):                                                  
    ‘‘‘                                                           
    :param dirname:                                               
    :return:                                                      
    ‘‘‘                                                           
    pass                                                          

#程序的體系結構立見    

三 、調用函數

1、 調用函數

函數的調用：函數名加括號
1 先找到名字
2 根據名字調用代碼

2、函數返回值

無return->None       #沒有意義的return None 值也是None
return 1個值->返回1個值
return 逗號分隔多個值->元組

什麽時候該有返回值？
　　　　調用函數，經過一系列的操作，最後要拿到一個明確的結果，則必須要有返回值
　　　　通常有參函數需要有返回值，輸入參數，經過計算，得到一個最終的結果
什麽時候不需要有返回值？
　　　　調用函數，僅僅只是執行一系列的操作，最後不需要得到什麽結果，則無需有返回值
　　　　通常無參函數不需要有返回值

3、 函數調用的三種形式

1 語句形式：foo()
2 表達式形式：3*len(‘hello‘)
3 當中另外一個函數的參數：range(len(‘hello‘))

四 函數的參數

1、 形參與實參

#形參即變量名，實參即變量值，函數調用時，將值綁定到變量名上，函數調用結束，解除綁定

2、 具體應用

#1、位置參數：按照從左到右的順序定義的參數
        位置形參：必選參數
        位置實參：按照位置給形參傳值

#2、關鍵字參數：按照key=value的形式定義的實參
        無需按照位置為形參傳值
        註意的問題：
                1. 關鍵字實參必須在位置實參右面
                2. 對同一個形參不能重復傳值

#3、默認參數：形參在定義時就已經為其賦值
        可以傳值也可以不傳值，經常需要變得參數定義成位置形參，變化較小的參數定義成默認參數（形參）
        註意的問題：
                1. 只在定義時賦值一次
                2. 默認參數的定義應該在位置形參右面
                3. 默認參數通常應該定義成不可變類型


#4、可變長參數：
        可變長指的是實參值的個數不固定
        而實參有按位置和按關鍵字兩種形式定義，針對這兩種形式的可變長，形參對應有兩種解決方案來完整地存放它們，分別是*args，**kwargs

        ===========*args===========
        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,3,4,5)

        def foo(x,y,*args):
            print(x,y)
            print(args)
        foo(1,2,*[3,4,5])


        def foo(x,y,z):
            print(x,y,z)
        foo(*[1,2,3])

        ===========**kwargs===========
        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,a=1,b=2,c=3)

        def foo(x,y,**kwargs):
            print(x,y)
            print(kwargs)
        foo(1,y=2,**{‘a‘:1,‘b‘:2,‘c‘:3})


        def foo(x,y,z):
            print(x,y,z)
        foo(**{‘z‘:1,‘x‘:2,‘y‘:3})

        ===========*args+**kwargs===========

        def foo(x,y):
            print(x,y)

        def wrapper(*args,**kwargs):
            print(‘====>‘)
            foo(*args,**kwargs)

#5、命名關鍵字參數：*後定義的參數，必須被傳值（有默認值的除外），且必須按照關鍵字實參的形式傳遞
可以保證，傳入的參數中一定包含某些關鍵字
        def foo(x,y,*args,a=1,b,**kwargs):
            print(x,y)
            print(args)
            print(a)
            print(b)
            print(kwargs)

        foo(1,2,3,4,5,b=3,c=4,d=5)
        結果：
            1      x值
            2      y值
            (3, 4, 5)    args值
            1      a值
            3      b值
            {‘c‘: 4, ‘d‘: 5}    kwargs值

python全棧開發-Day8 函數基礎