python函數初識

 

爲什麼要用函數之不用函數的問題

#一、代碼的組織結構不清晰，可讀性差
#二、遇到重複的功能只能重複編寫實現代碼，代碼冗餘
#三、功能須要擴展時，須要找出全部實現該功能的地方修改之，沒法統一管理且維護難度極大 

函數是什麼

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

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

要想使用工具，須要事先準備好，而後拿來就用且能夠重複使用
要想用函數，須要先定義，再使用

函數分類

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

#二、自定義函數
很明顯內置函數所能提供的功能是有限的，這就須要咱們本身根據需求，事先定製好咱們本身的函數來實現某種功能，之後，在遇到應用場景時，調用自定義的函數便可。

函數的定義

函數是對功能的封裝

#語法
def 函數名(形參列表):
    函數體(代碼/return)

#函數名稱最好能反映出其意義

函數的原則:先定義再調用

函數即「變量」，「變量」必須先定義後引用。未定義而直接引用函數，就至關於在引用一個不存在的變量名
#測試一
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()

返回值

return:在函數執行的時候,若是遇到retrun,直接返回,有點相似於循環中的break

若是函數什麼都不寫,不謝return,沒有返回值,獲得的是None

無return->None
return 1個值->返回1個值
return 逗號分隔多個值->元組
何時該有返回值？
　　　　調用函數，通過一系列的操做，最後要拿到一個明確的結果，則必需要有返回值
　　　　一般有參函數須要有返回值，輸入參數，通過計算，獲得一個最終的結果
何時不須要有返回值？
　　　　調用函數，僅僅只是執行一系列的操做，最後不須要獲得什麼結果，則無需有返回值
　　　　一般無參函數不須要有返回值

在函數中間return,後面加值,就返回一個值

在函數中能夠返回多個值,return 值1,值2,值3......接受到的是元組

def yue():
    print("打開手機")
    print("打開陌陌")
# 能夠終止一個函數執行
    return "大媽", "阿姨", "嫂子","姑娘"
    print("搜索一下你心儀的對象")
    print("走吧. 出去玩啊")
    print("出發!")

 # 多個返回值接收到的是元組
ret = yue()
print(ret)  #>>> ('大媽','阿姨','嫂子','姑娘')

***(重點)參數

函數執行的時候給函數傳遞信息

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

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

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

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

'''
************
hello world
************
'''

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

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                                                          

#程序的體系結構立見           

**(重點)形參

函數聲明的位置給的變量

位置參數,從左到右依次給出的參數

默認值參數,先寫位置參數,再寫默認參數,不然機器會懵逼

動態參數

引子

def chi(good_food,no_good_food,drink,ice_cream):
    print(good_food,no_good_food,drink,ice_cream)

chi("蓋澆飯","饅頭","橙汁","哈根達斯") >>> 結果:蓋澆飯 饅頭 橙汁 哈根達斯
#咱們正常人的飯量是這樣的,假設咱們這有一位飯量特別驚人的大胃王,這些食物是不夠吃的,我#們須要加量,可是這裏只有四個變量,是不夠需求的,因此就用到了動態參數,不管加多少均可以

函數的動態參數

*args 位置參數動態傳參

**kwargs 關鍵字參數動態傳參

 # 順序: 位置參數=>*args(arguments) => 默認值參數
# * 在這裏表示接收位置參數的動態傳參, 接收到的是元組
def chi(name,*food, location="北京"): # 參數名是food  *表示動態傳參
    print(name+"要吃", food,'在'+location)
chi('zkx','火鍋','法國蝸牛') #>>> zkx要吃 ('火鍋', '法國蝸牛') 在北京

順序:位置參數, *args, 默認值, **kwargs

形參的位置*,**: 有聚合做用

實參的位置*,**: 有打散做用

def chi(*foo2, **food): # 無敵傳參
    print(food)
chi('用關鍵字傳參在裏面隨便填本身想要的內容')

**(重點)實參

位置參數,按照形參的參數位置,給形參傳值

關鍵字參數,按照形參的參數名字,給形參傳值

混合參數,既用位置參數也用關鍵字參數

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

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

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


#四、可變長參數：
        可變長指的是實參值的個數不固定
        而實參有按位置和按關鍵字兩種形式定義，針對這兩種形式的可變長，形參對應有兩種解決方案來完整地存放它們，分別是*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)

#五、命名關鍵字參數：*後定義的參數，必須被傳值（有默認值的除外），且必須按照關鍵字實參的形式傳遞
能夠保證，傳入的參數中必定包含某些關鍵字
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)
結果：
2
(3, 4, 5)
3
{'c': 4, 'd': 5}

此乃重點知識！！！