按"指針"傳遞 python中 變數賦值、參數傳遞都是通過"指針"拷貝的方式進行的 。除了按"指針"拷貝,還有一種按值拷貝的方式,關於按值、按指針拷貝的細節,參見 "按值傳遞 vs. 按指針傳遞" 。 所以在python中,變數賦值、參數傳遞,都只是拷貝了源數據的一個地址,而不會拷貝記憶體中完整的數據 ...
按"指針"傳遞
python中變數賦值、參數傳遞都是通過"指針"拷貝的方式進行的。除了按"指針"拷貝,還有一種按值拷貝的方式,關於按值、按指針拷貝的細節,參見按值傳遞 vs. 按指針傳遞。
所以在python中,變數賦值、參數傳遞,都只是拷貝了源數據的一個地址,而不會拷貝記憶體中完整的數據對象副本。所以,如果在函數內部修改變數指向的數據對象,會影響函數外部的數據。
例如:
def f(x):
print(x+3)
a=4
f(a)
在將a
賦值給本地變數x的時候,只是拷貝了a目前保存的地址給x,使得x也保存了記憶體中數據對象4的地址。
如果傳遞的數據對象是可變數據對象(例如列表),那麼在函數內部修改它,會影響函數外部的原始數據對象:
L1=[11,22,33,44]
def f(x):
x[0] += 1
f(L1)
print(L1) # 輸出:[12, 22, 33, 44]
顯然,在函數內部修改x[0]
的值,函數外部原始的L1也發生了改變。因為L1賦值給x的時候,只是拷貝了一份L1所指向列表的地址給x,使得x也指向這個列表。
為了避免這種情況,可以新創建一份列表的副本,然後傳遞給函數參數。
L1=[11,22,33,44]
def f(x):
x[0] += 1
f(L1[:])
print(L1) # 輸出:[11, 22, 33, 44]
上面傳遞給函數參數x的是L1[:]
,它會在記憶體中創建一個新的列表副本,所以x指向的是這個新的副本列表,修改它不會影響原始的列表L1。
函數參數
Python的函數對參數和返回值方面非常寬鬆,參數變數可以是任意數據類型,返回值也一樣,只需使用變數名代替它們即可。
例如,下麵的參數x可以是任意類型的結構,可以是數值、字元串、列表、字典等等類型。返回值語句return同理。
def f(x):
print(x)
return x
f(2)
f("haha")
實際上,上面調用函數時是按照參數位置進行傳參對本地變數x進行賦值的。除此之外,還可以指定為key=value
的方式進行傳參。例如:
f(x=2)
f(x="haha")
按位置傳參
如果是多個參數,則按從左到右的順序進行參數變數的賦值:
def f(x,y,z):
print(x)
print(y)
print(z)
f(2,3,4)
調用f(2,3,4)
的時候,會按照從左向右的位置方式對本地變數x、y、z賦值:x=2,y=3,z=4
。
按關鍵字key/value方式傳值
python還支持key=value
的方式設置函數調用時的參數,使用key=value
的方式賦值時,順序不重要。這種函數調用時的傳值方式稱為"關鍵字傳值"。
例如:
def f(x,y,z):
print(x)
print(y)
print(z)
f(x=3,y="haha",z=4)
也可以打亂順序:
f(x=3,z=4,y="haha")
還可以將key=value
和位置傳參的方式進行混合:
f(3,"haha",z=4)
但混合按位置傳參方式的時候,位置參數必須在其它傳參方式的前面,不僅此處結合key=value
時如此,後文中位置參數結合其它方式傳參也都如此:位置參數必須在最前面。
例如,下麵的傳參方式是錯的:
f(z=4,3,"haha")
參數預設值
在def或lambda聲明函數的時候,可以通過var=default
的方式指定參數的預設值。
例如:
def f(x=3):
print(x)
f(4)
f("haha")
f()
上面的f(4)
和f("haha")
都對函數f()的本地變數x進行了賦值。但是最後一個調用語句f()
未賦值,而是使用參數的預設值3。
設置參數預設值時,如果函數有多個參數,則帶預設值參數後面必須放在最後面。例如:
# 正確
def f(x,y,z=4)
def f(x,y=1,z=4)
# 錯誤
def f(x,y=4,z)
只要為參數設置了預設值,那麼調用函數的時候,這個參數就是可選的,可有可無的,如果沒有,則採用預設值。
def f(x,y=2,z=4):
print(x)
print(y)
print(z)
# 不採用任何預設值
f(2,3,4)
# 採用z的預設值
f(2,3)
# 採用y的預設值
# 此時z必須按key=value的方式傳值
f(2,z=5)
# y、z都採用預設值
f(2)
變長參數:*
對於任意長度的參數,可以在def
聲明的函數中使用*
將各位置參數收集到一個元組中。例如:
def f(*args):
print(args)
f(1,2,3,4)
上面調用f(1,2,3,4)
的時候,將所有參數都收集到了一個名為args的元組中。所以上面的函數將輸出:
(1, 2, 3, 4)
既然是元組,就可以對參數進行迭代遍歷:
def f(*args):
for arg in args:
print(arg)
f(1,2,3,4)
必須註意,*
是按位置收集參數的。
def f(x,y,*args):
print(x)
print(y)
for arg in args:
print(arg)
f(1,2,3,4)
按照從左向右的傳參規則,首先將1賦值給x,將2賦值給y,然後將剩餘所有的位置參數收集到args元組中,所以args=(3,4)
。
如果*
後面還有參數,則調用函數的時候,後面的參數必須使用key=value
的方式傳遞,否則會收集到元組中,從而導致參數缺少的問題:
def f(x,*args,y):
print(x)
print(y)
for arg in args:
print(arg)
# 正確
f(1,3,4,y=2)
# 錯誤
f(1,2,3,4)
上面調用f(1,3,4,y=2)
的時候,會按照位置參數對x賦值為1,然後將所有位置參數收集到元組args中,因為y=2
是非位置參數傳值方式,所以args=(3,4)
。
如果為上面的y設置預設值:
def f(x,*args,y=2)
那麼f(1,2,3,4)
會將(2,3,4)
都收集到元組args中,然後y採用預設值2。
變長參數:**
除了可以使用*
將位置參數收集到元組中,還可以使用**
將key=value
格式的參數收集到字典中。
例如:
def f(x,**args):
print(x)
print(args)
f(1,a=11,b=22,c=33,d=44)
上面首先按位置傳參的方式賦值x=1
,然後將剩餘的所有key=value
參數收集到名為args的字典中。所以,args字典的內容為:
{'a': 11, 'b': 22, 'c': 33, 'd': 44}
既然是將參數收集到字典中,就可以使用字典類的工具操作這個字典。例如,遍歷字典。
在**
的後面不能出現任何其它類型的參數。例如,下麵的都是錯誤的def定義方式:
def f(x,**args,y)
def f(x,**args,y=3)
def f(x,**args,*t)
只能將位置參數或者*
的收集放在**
的前面。
def f(x,y,**args)
def f(x,*args1,**args2)
函數調用時的*和**
除了在def定義函數時,參數中可以使用*
或**
收集參數,在函數調用的時候也可以使用*
或**
分別解包元組(列表或其它對象)、字典。一定要註意區分函數定義和函數調用時的*
、**
,它們的用法是不通用的。
例如,解包元組:
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
T=(1,2,3,4)
f(*T)
*
除了可以解包元組,還可以解包其它可迭代對象,例如列表。甚至是字典也能解包,只不過*
解包的字典得到的是key組成的參數列表,和value無關:
D=dict(a=11,b=22,c=33,d=44)
f(*D)
# 輸出:
a
b
c
d
而**
解包的字典則是key=value
組成的參數列表。以下是函數調用時使用**
進行解包,字典D中的key名稱必須和def中定義的參數名稱相同:
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
D=dict(a=11,b=22,c=33,d=44)
f(**D)
# 輸出:
11
22
33
44
在函數調用時,可以混合位置參數、關鍵字參數、*
解包參數、**
解包參數。用法非常的靈活:
def f(a,b,c,d):
print(a)
print(b)
print(c)
print(d)
f(*(1,2),**{'d':4,'c':3})
f(1,*(2,3),**{'d':4})
f(1,c=3,*(2,),**{'d':4})
f(1,*(2,3),d=4)
f(1,*(2,),c=3,**{'d':4})
上面調用函數時的效果都等同於f(1,2,3,4)
。
keyword-only參數形式
keyword-only的參數傳值方式表示def中如果使用了*
,那麼在調用函數時,它後面的參數必須只能使用關鍵字傳值。其實在前面的內容中已經出現過幾次與之相關的說明。
另外註意,*
才是keyword-only開關,**
不是,雖然**
也有自己的一些語法限制:任意類型的參數定義都必須在**
之前,包括keyword-only類型的參數。這個前面已經解釋過了。
例如:
def f(a,*b,c):
print(a,b,c)
按照keyword-only的規則,被*b
收集的位置參數不包括c,這個c必須只能使用關鍵字的方式傳值,否則就被當作位置參數被收集到元組b中。
# 正確
f(1,2,3,c=4)
# 錯誤
f(1,2,3,4)
# 錯誤
f(1,c=4,2,3)
其中最後一個錯誤和如何def的定義無關,而是函數調用時的語法錯誤,前面已經解釋過:位置參數必須放在最前面。
還可以直接使用*
而非*args
的方式,這表示不收集任何參數,但卻要求它後面的參數必須按照關鍵字傳值的方式。
def f(a,*,b,c):
print(a,b,c)
以下是正確和錯誤的調用方式示例:
# 正確
f(1,b=2,c=3)
f(1,c=3,b=2)
f(b=2,c=3,a=1)
# 錯誤
f(1,2,3)
f(1,2,c=3)
f(1,b=2,3)
不過,keyword-only後面的參數可以使用參數預設值。
def f(a,*,b,c=3)
那麼c是可選的,但如果給定,則必須按關鍵字方式傳值。
參數定義和參數傳值的規則
對於函數定義中的參數,有3種方式:普通位置參數、*
開啟的keyword-only參數、**args
收集參數。它們之間的規則是:
**args
必須在最後面
*
或*args
後面可以是普通參數,但是函數調用傳值時,它後面的參數必須按照關鍵字的方式指定
所以,函數定義時參數的通用形式為:其中c和d必須使用關鍵字傳值方式
def f(a,b, *,c,d, **dicts)
def f(a,b, *args,c,d, **dicts)
對於函數調用中的參數,有:普通位置參數、關鍵字參數、*
解包參數、**
解包參數。它們之間的規則時:
- 普通位置參數必須在最前面
**
解包必須在最後面
- 關鍵字參數和
*
解包參數只要求在上述兩種參數形式中間,順序可以隨意
所以,函數調用時的傳參形式為:
f(a,b,c, *(d,e,f),g=1,h=2, **dict(j=3,k=4))
f(a,b,c, d=1,e=2,*(f,g,h), **dict(j=3,k=4))
例如:
def f(a,*b,c,**d):
print(a,b,c,d)
f(1, 2,3, c=4, x=5,y=6)
f(1, c=4,*(2,3), **dict(x=5,y=6))
f(1, *(2,3),c=4, **dict(x=5,y=6))
f(1, *(2,3), **dict(c=4,x=5,y=6))
f(1, 2,3, **dict(c=4,x=5,y=6))
函數註解(annotations)
python函數有一個名為__annotations__
的屬性(可以使用dir(Func_Name)來查看)。它表示函數的註解。
函數的註解使得參數變得更規範、更通用,它有點類似於強調數據類型。但它們僅僅只是註解,只是給人看,用來起提示作用的,不會對實際的調用有任何影響。
例如,下麵是沒有給註解的函數參數,也就是平時見到的參數方式:
def myfunc(a,b,c):
return a+b+c
myfunc(1,2,3)
函數的註解分兩種:參數註解和返回值註解。
- 參數註解:定義在各參數名之後,使用冒號分隔參數和參數的註解
- 返回值註解:定義在參數列表之後,冒號之前,使用瘦箭頭
->
分隔
例如:
def myfunc(a:'string',b:[1,5],c:int)->int:
return a+b+c
print( myfunc(1,2,3) )
print( myfunc("a","b","c") )
雖然上面的函數註解提示了參數a是一個字元串,b是一個列表,c是一個int類型的數據,以及返回值是一個int類型的值,但在函數調用的時候,這些"強調"並沒有發生影響,只不過在使用該函數的時候,如果使用IDE編寫代碼,會有代碼提示。
可以通過函數的__annotations__
屬性查看函數的註解:
print(myfunc.__annotations__)
輸出:
{'a': 'string', 'b': [1, 5], 'c': <class 'int'>, 'return': <class 'int'>}
可以只對其中一個或多個參數進行註解。
如果使用了註解,還要設置參數的預設值,則預設值需要在註解的後面。例如:
def f(a:'string'=4):
函數註解只對def語句有效,對lambda無效,因為lambda已經限制了函數的定義方式。