參數：
兩大類： 形參 和 實參
1、形參：在函數定義階段括號內定義的參數，稱為形式參數 本質就是變量的名
def foo (x,y):
print(x)
print(y)
2、實參：在函數調用階段括號內定義的參數，稱為實際參數 本質就是變量的值
foo(1,2)
print(x) # 這是函數體以外的內容 程序不會執行沒有定義 x
詳細的分類： #####################################################33
一、位置參數：在函數定義階段，按照從左到右的順序定義的形參，稱為位置形參
特點：但凡是按照位置定義的形參。都必須被傳值，多一個不行，少一個也不行
def foo (x,y):
print('x:',x)
print('y:',y)
foo(1,2)
輸出
x: 1
y: 2
位置參數：在函數調用階段，按照從左到右的順序定義的形參，稱為位置實參
特點：按照位置為對應的形參依次傳值
二、關鍵字實參：在調用函數時，按照key=value的形式為指定的參數傳值，稱為關鍵字實參
特點：打破位置的限制，但仍能為指定的形參賦值
foo(y=1,x=2) # 這是指名道姓的給傳參打破了 位置不能改變
注意：
可以混用位置實參與關鍵字實參，但位置實參必須放在關鍵字實參的前面
foo(y=2,1) SyntaxError: positional argument follows keyword argument
foo(1,y=2)
可以混用，但不能對一個形參重復賦值
foo(1,y=2,x=3) #報錯
三：默認參數：在函數定義階段，就已經為形參賦值，該形參稱為默認形參
特點：在定義階段就已經賦值，意味着在調用可以不用為其賦值
def foo(x,y=2):
print('x:',x)
print('y:',y)
foo(1) # y已經賦值了 可以只賦值給x
foo(1,3) # 也可以賦值 那么形參中的y=2 就消掉了
輸出
x: 1
y: 2
x: 1
y: 3
注意：
1、位置形參必須放到默認形參的前面，否則報語法錯誤
def fff(x=1,y) # x=1 放后面
pass
2、默認參數的值只在定義階段賦值一次即默認參數的值在函數定義階段就已經固定死了
m=10
def foo(x=m,y=11)
print(x)
print(y)
m=1111111111 # 定義階段已經固定死了
foo() #不需要傳值
輸出10 11
3默認的參數通常應該定義為不可變類型
總結：
實參的應用：取決於個人習慣
形參的應用：
1.位置形參：大多數情況下的調用值都不一樣，就應該將參數定義位置形參
2.默認形參：大多數情況下的調用值都一樣，就應該將參數定義默認形參
def register(name,age,sex='male'): #sex = 'male' 性別定義男性是默認形參
print(name)
print(age)
print(sex)
register('egon:',18)
register('小腦袋:',46,'female')
register('大腦袋:',78)
register('alse:',33)
輸出
egon:
18
male
小腦袋:
46
female
大腦袋:
78
male
alse:
33
male
四 可變長參數： 指的是在調用函數時，傳入的參數個數可以不固定
而調用函數時，傳值的方式無非兩種，一種位置實參，一種關鍵字實參
所以對應着，形參也必須有兩種解決方案，來分別接受溢出的位置實參（*）與關鍵字實參（**）
1/形參中某個參數帶*
形參中的*會將溢出的位置實參全部接受，然后存儲元組的形式，然后把元組賦值給*后的變量名
def foo (x,y,*z):
print(x)
print(y)
print(z)
foo(1,2,3,4,5,6,7)
輸出
1
2
(3, 4, 5, 6, 7)
比如求和的需求就需要可變長參數
def my_sum(*nums):
res=0
for num in nums : # 從元組里取出一個一個值
res+=num #就是將上一個num的值+1 等同於num+=1
return res
print(my_sum(1,2,3,4,5))
輸出
15
2/實參中的參數也可以帶*
實參中帶*的，*會將該參數循環取出，打散成位置實參
以后但凡碰到實參中帶*的，他就是位置實參，應該立刻打散成位置實參去看
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,*m): # m 是個變量名
print(x)
print(y)
print(z)
print(m)
foo(1,2,3,4,5,6,7,*[8,9,10,11]) # 流程是先從調用開始 foo=(1,2,3,4,5,6,7,8,9,10,11)
1賦給x 2賦給y3賦給z 其他都被*存成元組
注意：約定 形參中的變量名寫法都是：*args
1/形參中某個參數帶**
形參中的**會將溢出的關鍵字實參全部接受，然后存儲字典的形式，然后把字典賦值給**后的變量名
def foo(x,y,**z): # x=1,y=2,z={'c'=5,'b'=4,'a'=3} 字典沒有順序
print(x)
print(y)
print(z)
foo(1,2,a=3,b=4,c=5)
2/實參中的參數也可以帶**，該參數必須是字典
實參中帶**的，**會將該參數循環取出，打散成位置關鍵字實參
以后但凡碰到實參中帶**的，他就是關鍵字實參，應該立刻打散成位置關鍵字實參去看
def foo(x,y,z):
print(x)
print(y)
print(z)
# foo(1,2,**{'a':1,'b':2,'c':3}) #foo(1,2,c=3,b=2,a=1)
# 報錯 1 給x 2 給y 后面就傳不了了因為沒有遵循形參一一對應的標准
foo(**{'z':3,'y':2,'x':10})
# 輸出
10
2
3
注意：約定 形參中的變量名寫法都是：**kwargs
def wrapper (*args,**kwargs):
print(args)
print(kwargs)
wrapper(1,2,3,4,5,6,x=2,c=4,b=5)
輸出
(1, 2, 3, 4, 5, 6)
{'x': 2, 'c': 4, 'b': 5}
輸出 兩種形式 元組和 字典
def index(name,age,sex):
print('welecome %s:%s:%s to index page' %(name,age,sex))
print(name,age,sex)
def wrapper (*args,**kwargs): #def wrapper (**kwargs):
index(*args,**kwargs) #index(**kwargs)
wrapper(name='egon',age=18,sex='male')
輸出
welecome egon:18:male to index page
egon 18 male
強調 但凡要調用一個函數把參數轉給內部的一個函數 就用 * ** 模式
了解知識點：
五+++++++++++++++++++++++++++
命名關鍵字形參：
在函數定義階段，后面的參數都是命名關鍵字參數。
特點：
在傳值時，必須按照key=value傳。並且key必須是命名關鍵字指定的參數名
def register(x,y,z,**kwargs):
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)
register(1,2,3,name='egon',age=18)
更簡單
def register(x,y,z,*,name,age):
pass
register(1,2,3,age=18,name='egon')
和下面都一樣
def register(x,y,z,*args,name,age):
print(name)
print(args)
print(age)
print(x)
print(y)
print(z)
register(1,2,3,4,5,6,7,age=18,name='egon')
輸出
egon
(4, 5, 6, 7)
18
1
2
3