按"指針"傳遞
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已經限制了函數的定義方式。