函式的返回值

1、什麼是返回值
返回值是一個函式的處理結果

2、為什麼要有返回值
如果我們需要在程式中拿到函式的處理結果做進一步的處理，則需要函式必須有返回值


3、函式的返回值的應用
函式的返回值用return去定義
格式為：
return 值

注意：
1、return是一個函式結束的標誌，函式內可以有多個return，
但只要執行一次，整個函式就會結束執行

2、return 的返回值無型別限制，即可以是任意資料型別
3、return 的返回值無個數限制，即可以用逗號分隔開多個任意型別的值
0個：返回None，ps：不寫return預設會在函式的最後一行新增return None
1個:返回的值就是該值本身
多個：返回值是元組

def max2(x,y): #x=3000,y=2000
    if x > y:
        return x #return 3000
    else:
        return y #reuturn 2000

res=max2(3000,2000)

annual_salary=res * 12

print(annual_salary)

def foo():
    print(1)
    print(2)
    print(3)
    return [1,2,3],'a',('a','b'),{1,2}
    print(4)
    print(5)
    print(6)

res=foo()
print(res)
 

def bar():
    print(1)
    print(1)
    print(1)
    print(1)
    return
    print(2)
    print(3)
    print(4)
res=bar()
print(res)

呼叫函式

1 什麼是呼叫函式
    函式名(...)即呼叫函式，會執行函式體程式碼，直到碰到return結束或者一直執行完畢所有程式碼

2 為何要呼叫函式
    用函式的功能

3、函式呼叫分為三種形式
    max2(1,2)
    res=max2(3000,2000) * 12
    res=max2(max2(1000,2000),3000)
 

def foo():
    print(1)
    print(2)
    print(3)
    return None
res=foo()
print(res)


def max2(x,y):
    if x > y:
        return x
    else:
        return y

#形式一：
# max2(1,2)

#形式二：
# res=max2(3000,2000) * 12
# print(res)

#形式三：
res=max2(max2(1000,2000),3000)
print(res)

函式的引數

總的分類：
#1、形參：在函式定義階段括號內定義的引數，稱之為形式引數，簡稱形參，本質就是變數名
def foo(x,y): #x=1,y=2
    print(x)
    print(y)
#2、實參：在函式呼叫階段括號內傳入的值，稱之為實際引數，簡稱實參，本質就是變數的值
foo(1,2)


詳細的分類：
一、位置引數：
位置形參：在函式定義階段，按照從左到右的順序依次定義的形參，稱之為位置形參
特點：但凡是按照位置定義的形參，都必須被傳值，多一個不行，少一個也不行
def foo(x,y):
    print('x:',x)
    print('y:',y)

位置實參：在函式呼叫階段，按照從左到右的順序依次定義的實參，稱之為位置實參
# 特點：按照位置為對應的形參依次傳值
foo(1,2)
foo(2,1)

二、關鍵字實參:在呼叫函式時，按照key=value的形式為指定的引數傳值，稱為關鍵字實參
特點：可以打破位置的限制，但仍能為指定的形參賦值
foo(y=2,x=1)

注意：
1、可以混用位置實參與關鍵字實參，但位置實參必須放在關鍵字實參的前面
foo(1,y=2)
foo(y=2,1) # 關鍵字實參只能放在位置實參後面，否則會報錯：SyntaxError: positional argument follows keyword argument

2、可以混用，但不能對一個形參重複賦值
foo(1,y=2,x=10)

三：預設引數：在函式定義階段，就已經為形參賦值，該形參稱為預設形參
特點：在定義階段就已經被賦值，意味著在呼叫可以不用為其賦值

def foo(x,y=10):
    print('x:',x)
    print('y:',y)
foo(1)
foo(1,3)

注意：
1、位置形參必須放到預設形參的前面，否則報語法錯誤

def foo(x=1,y):
    pass

2、預設引數的值只在定義階段賦值一次，即預設引數的值在函式定義階段就已經固定死了
即預設引數的值在函式定義階段就已經固定死了#

m=10
def foo(x=m,y=11):
    print(x)
    print(y)
m=1111111111111111111111111111111111111111111111111111111111
foo()

3、預設引數的值通常應該定義不可變型別

def register(name,hobby,hobbies=[]):
    hobbies.append(hobby)
    print('%s的愛好' %name,end=':')
    print(hobbies)

register('egon','play')
register('alex','piao')
register('lxx','燙頭')

def register(name,hobby,hobbies=None):
    if hobbies is None:
        hobbies=[]
    hobbies.append(hobby)
    print('%s的愛好' %name,end=':')
    print(hobbies)

register('egon','play')
register('alex','piao')
register('lxx','燙頭')

總結：
實參的應用：取決於個人習慣，
形參的應用：
1、位置形參：大多數情況下的呼叫值都不一樣，就應該將該引數定義成位置形參
2、預設形參：大多數情況下的呼叫值都一樣，就應該將該引數定義成預設形參

def register(name,age,sex='male'):
    print(name)
    print(age)
    print(sex)


register('egon',18,)
register('大腦門',73,'female')
register('小腦門',84,)
register('大高個',18,)

四：可變長引數：指的是在呼叫函式時，傳入的引數個數可以不固定
而呼叫函式時，傳值的方式無非兩種，一種位置實參，另一種時關鍵字實參
所以對應著，形參也必須有兩種解決方案，來分別接收溢位的位置實參(*)與關鍵字實參(**)

1、形參中某個引數帶*
形參中的*會將溢位的位置實參全部接收，然後儲存元組的形式，然後把元組賦值給*後的變數名

def foo(x,y,*z): #x=1,y=2,z=(3,4,5,6,7)
    print(x)
    print(y)
    print(z)
foo(1,2,3,4,5,6,7)

應用
def my_sum(*nums):
    res=0
    for num in nums:
        res+=num
    return res

print(my_sum(1,2,3,4,5))

2、實參中的引數也可以帶*
實參中帶*，*會將該引數的值迴圈取出，打散成位置實參
ps：以後但凡碰到實參中帶*的，它就是位置實參，應該立馬打散成位置實參去看

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

foo(1,*[2,3]) #foo(1,2,3)
foo(1,*'he') #foo(1,'h','e')
foo(1,*(2,3,4)) #foo(1,2,3,4)

def foo(x,y,z,*args):
    print(x)
    print(y)
    print(z)
    print(args)

foo(1,2,3,4,5,6,7,*[8,9,10,11]) #foo(1,2,3,4,5,6,7,8,9,10,11)

注意：約定俗成形參中的*變數名的寫法都是：*args


1、形參中某個引數帶**
形參中的**會將溢位的關鍵字實參全部接收，然後儲存字典的形式，然後把字典賦值給**後的變數名

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

foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) #foo(1,2,c=3,b=2,a=1,z=3)
foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3)

2、實參中的引數也可以帶**,該引數必須是字典
實參中帶**，**會將該引數的值迴圈取出，打散成關鍵字實參
ps：以後但凡碰到實參中帶**的，它就是關鍵字實參，應該立馬打散成關鍵字實參去看

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

foo(1,2,**{'a':1,'b':2,'c':3,'z':3}) #foo(1,2,c=3,b=2,a=1,z=3)
foo(**{'z':3,'x':1,'y':2}) #foo(y=2,x=1,z=3)

注意：約定俗成形參中的**變數名的寫法都是：**kwargs

def index(name,age,sex):
    print('welecome %s:%s:%s to index page' %(name,age,sex))

def wrapper(*args,**kwargs): #args=(1,),kwargs={'x': 1, 'y': 2, 'z': 3}
    index(*args,**kwargs) #index(*(1,),**{'x': 1, 'y': 2, 'z': 3}) #index(1,x=1,y=2,z=3)

wrapper(name='egon',sex='male',age=18)

五 命名關鍵字形參:在函式定義階段，*後面的引數都是命名關鍵字引數(**)
特點：在傳值時，必須按照key=value的傳，並且key必須命名關鍵字引數指定的引數名

def register(x,y,z,**kwargs): #kwargs={'b':18,'a':'egon'}
    if 'name' not in kwargs or 'age' not in  kwargs:
        print('使用者名稱與年齡必須使用關鍵字的形式傳值')
        return
    print(kwargs['name'])
    print(kwargs['age'])
register(1,2,3,a='egon',b=18)


def register(x,y,z,*args,name='egon',age):
    print(args)
    print(name)
    print(age)
register(1,2,3,4,5,6,7,age=18)


def foo(x,y=1,*args,z=1,a,b,**kwargs):
    pass


foo(1,*[1,2,3],a=1,**{'x':1,'y':2}) #foo(1,1,2,3,a=1,y=2,x=1)


foo(1,2)
foo(x=1,y=2)


open('a.txt', 'w', encoding='utf-8')