函數一

函數

1、靈魂三問？

一、什麼是函數？

函數就是一種工具，能夠重複調用

二、爲何要用函數？

a:爲了防止代碼冗餘

b:爲了加強代碼的可讀性，簡介

三、怎麼用函數？

關鍵字def後面空格加函數名加一個小括號後面跟一個重要的冒號

如def login():

OK，那咱們定義好了函數要怎麼使用函數呢，若是說定義函數是製造工具，那麼調用函數就是使用工具。

2、函數的返回值return

一、不寫return，默認返回None
def index():
    print('hello world')


print(index())
>>>hello world
None#此時由於沒有一個值接受返回值，因此是None

二、只寫return，只有結束函數體代碼的效果，返回None
def index():
    print('hello world')
    return


print(index())
>>>hello world
None

三、寫return None
def index():
    print('hello world')
    return None


print(index())
>>>hello world
None

四、return返回一個值
a = 1
b = 2
def home():

    if a > b:
        return a
    else:
        return b


res = home()
print(res)
>>>2

五、返回多個值
a = 1                     
b = 2                     
c = '3'                   
d = [4, 5]                
e = {'name': 'yafeng'}    
                          
def func(a, b, c, d, e):  
    return a, b, c, d, e  
>>>(1, 2, '3', [4, 5], {'name': 'yafeng'})

3、函數的參數

這裏有幾個點須要注意：
函數是先定義，後調用，在定義階段只檢測語法，不會執行任何代碼

一、形參
形參是在定義函數時，裏面小括號中的參數，用來接收參數，就至關於變量名
二、實參
實參是在函數調用階段後面小括號中的參數，把數據傳到函數內部用，至關於定義變量時的變量值
a = 5
b = 2
def index(a):  # 形參:至關於變量名

    if a > b:
        print(a)
    else:
        print(b)


index(a)  # 實參：至關於變量值
>>>5

三、位置參數：
    經過位置進行傳參
   關鍵字參數：
    指定參數進行傳參
 注意：位置參數必定不能在關鍵字參數的前面，連用的時候也不可對同一個形參重複賦值
>>> def register(name,age,sex): #定義位置形參：name，age，sex，三者都必須被傳值
...     print('Name:%s Age:%s Sex:%s' %(name,age,sex))
>>> register() #TypeError：缺乏3個位置參數

四、關鍵字參數：
在調用函數時，實參能夠是指定值的形式，即key=value的形式，稱爲關鍵字參數凡是按
照這種形式定義的實參，能夠徹底不按照從左到右的順序定義，但仍能爲指定的形參賦值

>>> register(sex='male',name='yafeng',age=18)
Name:yafeng Age:18 Sex:male

五、默認參數：
在定義階段就已經傳入參數，
若是你在實參的時候傳入了一個新的參數，就會使用新參數
默認參數在傳值的時候，一般應不要將可變類型當作參數傳遞
def reg(username, password, gender='male'):
    print(f"用戶名：{username}，密碼:{password},性別：{gender}")

reg('tank','dsb')
reg('jason','dsb')
reg('egon','xsb')
reg('xiaohong','dmm','female')
>>>用戶名：tank，密碼:dsb,性別：male
用戶名：jason，密碼:dsb,性別：male
用戶名：egon，密碼:xsb,性別：male
用戶名：xiaohong，密碼:dmm,性別：female

六、一個小問題（如何不打印別人的愛好）
def reg(hobby, l1=[]):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"愛好：{l1}")

#
reg(hobby='生蠔')
reg('大保健')
reg('女教練')
>>>愛好：['生蠔']
愛好：['生蠔', '大保健']
愛好：['生蠔', '大保健', '女教練']

第一種解決方案：
def reg(hobby, l1=None):  
    if l1 == None:
        l1 = []
    l1.append(hobby)
    print(f"愛好：{l1}")

#
reg(hobby='生蠔')
reg('大保健')
reg('女教練')
>>>愛好：['生蠔']
愛好：['大保健']
愛好：['女教練']

第二種解決方案：
def reg(hobby, l1):  # 四個形參
    l1.append(hobby)
    print(f"愛好：{l1}")


reg('生蠔', [])
reg('大保健', [])
reg('女教練', [])
>>>愛好：['生蠔']
愛好：['大保健']
愛好：['女教練']

4、可變長參數

• *args的用法

*args:接收全部溢出的位置參數
    接收的值都被存入一個元組
    官方認證：*args
    只要有*就有可變長參數的效果

    *:打散你傳入容器類型
>>> def foo(x,y,z=1,*args): #在最後一個形參名args前加*號
...     print(x)
...     print(y)
...     print(z)
...     print(args)
... 
>>> foo(1,2,3,4,5,6,7)  #實參一、二、3按位置爲形參x、y、z賦值，多餘的位置實參四、五、六、7都被*接收，以元組的形式保存下來，賦值給args，即args=(4, 5, 6,7)

1
2
3
(4, 5, 6, 7)

• *kwargs的用法

**kwargs:接收全部溢出的關鍵字參數
        接收的值都被存入一個字典

    官方認證：**kwargs
def func(a, b, c, d,**kw):
    print(a, b, c, d,kw)


func(1, 2, c=3, d=4, e=5, f=6)
>>>1 2 3 4 {'e': 5, 'f': 6}

若是咱們事先生成了一個字典，也能夠傳值給*kwargs
>>> def foo(x,y,**kwargs):
...     print(x)
...     print(y)
...     print(kwargs)
... 
>>> dic={'a':1,'b':2} 
>>> foo(1,2,**dic) #**dic就至關於關鍵字參數a=1，b=2，foo(1,2,**dic)等同foo(1,2,a=1,b=2)
1
2
{'a': 1, 'b': 2}

• 嵌套的用法

def foo(a, b, c, d, e, f):
    print(a, b, c, d, e, f)


def bar(*args, **kwargs):
    foo(*args, **kwargs)


bar(1, 2, 3, d=10, e=20, f=30)
>>>1 2 3 10 20 30