python中參數傳遞

『壹』 python中函數參數傳遞問題

對於可變參數默認是引用傳值, 但是不能去修改它的指向, 一旦修改就是按值傳遞.

#coding=utf-8
deff(a):
a=[0]
print(a)

if__name__=='__main__':
a=[1,2,3]
f(a)
print(a)

上面的代碼對a重新賦值, 試圖改變a的指向, 那麼這時的a就是一個新的局部變數, 而非全局變數a

像a[0] = 100, a.append(0)的操作不會觸發上述規則, 和你的輸出一樣

『貳』 python參數傳遞是值傳遞還是引用傳遞

首先還是應該科普下函數參數傳遞機制，傳值和傳引用是什麼意思？

函數參數傳遞機制問題在本質上是調用函數（過程）和被調用函數（過程）在調用發生時進行通信的方法問題。基本的參數傳遞機制有兩種：值傳遞和引用傳遞。

值傳遞（passl-by-value）過程中，被調函數的形式參數作為被調函數的局部變數處理，即在堆棧中開辟了內存空間以存放由主調函數放進來的實參的值，從而成為了實參的一個副本。值傳遞的特點是被調函數對形式參數的任何操作都是作為局部變數進行，不會影響主調函數的實參變數的值。

引用傳遞(pass-by-reference)過程中，被調函數的形式參數雖然也作為局部變數在堆棧中開辟了內存空間，但是這時存放的是由主調函數放進來的實參變數的地址。被調函數對形參的任何操作都被處理成間接定址，即通過堆棧中存放的地址訪問主調函數中的實參變數。正因為如此，被調函數對形參做的任何操作都影響了主調函數中的實參變數。

在python中實際又是怎麼樣的呢？

先看一個簡單的例子：

結論：python不允許程序員選擇採用傳值還是傳引用。Python參數傳遞採用的肯定是「傳對象引用」的方式。這種方式相當於傳值和傳引用的一種綜合。如果函數收到的是一個可變對象（比如字典或者列表）的引用，就能修改對象的原始值－－相當於通過「傳引用」來傳遞對象。如果函數收到的是一個不可變對象（比如數字、字元或者元組）的引用，就不能直接修改原始對象－－相當於通過「傳值'來傳遞對象。

『叄』 Python 的函數是怎麼傳遞參數的

對象vs變數
在python中，類型屬於對象，變數是沒有類型的，這正是python的語言特性，也是吸引著很多pythoner的一點。所有的變數都可以理解是內存中一個對象的「引用」，或者，也可以看似c中void*的感覺。所以，希望大家在看到一個python變數的時候，把變數和真正的內存對象分開。
類型是屬於對象的，而不是變數。
這樣，很多問題就容易思考了。
例如：

對象vs變數
12
nfoo = 1 #一個指向int數據類型的nfoo（再次提醒，nfoo沒有類型）lstFoo = [1] #一個指向list類型的lstFoo，這個list中包含一個整數1

可更改(mutable)與不可更改(immutable)對象
對應於上一個概念，就必須引出另了另一概念，這就是可更改（mutable）對象與不可更改（immutable）對象。
對於python比較熟悉的人們都應該了解這個事實，在python中，strings, tuples, 和numbers是不可更改的對象，而list,dict等則是可以修改的對象。那麼，這些所謂的可改變和不可改變影響著什麼呢？
可更改vs不可更改
12345
nfoo = 1nfoo = 2lstFoo = [1]lstFoo[0] = 2

代碼第2行中，內存中原始的1對象因為不能改變，於是被「拋棄」，另nfoo指向一個新的int對象，其值為2
代碼第5行中，更改list中第一個元素的值，因為list是可改變的，所以，第一個元素變更為2。其實應該說，lstFoo指向一個包含一個對象的數組。賦值所發生的事情，是有一個新int對象被指定給lstFoo所指向的數組對象的第一個元素，但是對於lstFoo本身來說，所指向的數組對象並沒有變化，只是數組對象的內容發生變化了。這個看似void*的變數所指向的對象仍舊是剛剛的那個有一個int對象的list。
如下圖所示：

Python的函數參數傳遞：傳值？引用？
對於變數（與對象相對的概念），其實，python函數參數傳遞可以理解為就是變數傳值操作，用C++的方式理解，就是對void*賦值。如果這個變數的值不變，我們看似就是引用，如果這個變數的值改變，我們看著像是在賦值。有點暈是吧，我們仍舊據個例子。
不可變對象參數調用
12345
def ChangeInt( a ): a = 10nfoo = 2 ChangeInt(nfoo)print nfoo #結果是2

這時發生了什麼，有一個int對象2，和指向它的變數nfoo，當傳遞給ChangeInt的時候，按照傳值的方式，復制了變數nfoo的值，這樣，a就是nfoo指向同一個Int對象了，函數中a=10的時候，發生什麼？（還記得我上面講到的那些概念么），int是不能更改的對象，於是，做了一個新的int對象，另a指向它（但是此時，被變數nfoo指向的對象，沒有發生變化），於是在外面的感覺就是函數沒有改變nfoo的值，看起來像C++中的傳值方式。
可變對象參數調用
12345
def ChangeList( a ): a[0] = 10lstFoo = [2]ChangeList(lstFoo )print nfoo #結果是[10]

當傳遞給ChangeList的時候，變數仍舊按照「傳值」的方式，復制了變數lstFoo 的值，於是a和lstFoo 指向同一個對象，但是，list是可以改變的對象，對a[0]的操作，就是對lstFoo指向的對象的內容的操作，於是，這時的a[0] = 10，就是更改了lstFoo 指向的對象的第一個元素，所以，再次輸出lstFoo 時，顯示[10]，內容被改變了，看起來，像C++中的按引用傳遞。

『肆』 python如何將可選參數或關鍵字參數從一個函數傳遞到另一個函數

使用函數參數列表中的*和**說明符收集參數;這會將位置參數作為元組，將關鍵字參數作為字典。然後，您可以使用*和**調用另一個函數時傳遞這些參數：

def f(x, *args, **kwargs):
...
kwargs['width'] = '14.3c'
...
g(x, *args, **kwargs)

『伍』 Python 的函數是怎麼傳遞參數的

Python 的函數傳遞參數：
Python 傳參數可以理解為 C 的 const 指針（your_type* const your_variable），它所指向的對象可以被修改產生副作用，但變數本身不能修改指向其他對象。這個和 C++ 的 reference 差不多。
所以如果一定要產生 C 的修改指針指向其他對象的效果，用 list、dict 或其他自定義的 mutable 對象包裝是一個辦法，但我認為這樣是一種不良實踐。在 C 語言中用參數輸出結果有非常多的理由：

C 語言沒有 tuple，不能返回多值，除非聲明一個 struct 類型。這種情況下劃分 in 參數和 out 參數成為一種慣例
C 語言沒有異常機制，返回值一般要保留給 errno
但這些情況在 Python 中都是不存在的

『陸』 python怎麼向類中的函數傳遞參數

Python中函數參數的傳遞是通過「賦值」來傳遞的。但這條規則只回答了函數參數傳遞的「戰略問題」，並沒有回答「戰術問題」，也就說沒有回答怎麼賦值的問題。函數參數的使用可以分為兩個方面，一是函數參數如何定義，二是函數在調用時的參數如何解析的。而後者又是由前者決定的。函數參數的定義有四種形式：

1. F(arg1,arg2,...)
2. F(arg2=<value>,arg3=<value>...)
3. F(*arg1)
4. F(**arg1)

第1 種方式是最「傳統」的方式：一個函數可以定義不限個數參數，參數（形式參數）放在跟在函數名後面的小括弧中，各個參數之間以逗號隔開。用這種方式定義的函數在調用的時候也必須在函數名後的小括弧中提供相等個數的值（實際參數），不能多也不能少，而且順序還必須相同。也就是說形參和實參的個數必須一致，而且想給形參1的值必須是實參中的第一位，形參與實參之間是一一對應的關系，即「形參1=實參1 形參2=實參2...」。很明顯這是一種非常不靈活的形式。比如："def addOn(x,y): return x + y"，這里定義的函數addOn，可以用addOn(1,2)的形式調用，意味著形參x將取值1,主將取值2。addOn(1,2,3)和addOn (1)都是錯誤的形式。
第2種方式比第1種方式，在定義的時候已經給各個形參定義了默認值。因此，在調用這種函數時，如果沒有給對應的形式參數傳遞實參，那麼這個形參就將使用默認值。比如：「def addOn(x=3,y=5): return x + y」，那麼addOn(6,5)的調用形式表示形參x取值6，y取值5。此外，addOn(7)這個形式也是可以的，表示形參x取值7，y取默認值5。這時候會出現一個問題，如果想讓x取默認值，用實參給y賦值怎麼辦？前面兩種調用形式明顯就不行了，這時就要用到Python中函數調用方法的另一大絕招 ──關健字賦值法。可以用addOn(y=6)，這時表示x取默認值3，而y取值6。這種方式通過指定形式參數可以實現可以對形式參數進行「精確攻擊」，一個副帶的功能是可以不必遵守形式參數的前後順序，比如：addOn(y=4,x=6)，這也是可以的。這種通過形式參數進行定點賦值的方式對於用第1種方式定義的函數也是適用的。
上面兩種方式定義的形式參數的個數都是固定的，比如定義函數的時候如果定義了5個形參，那麼在調用的時候最多也只能給它傳遞5個實參。但是在實際編程中並不能總是確定一個函數會有多少個參數。第3種方式就是用來應對這種情況的。它以一個*加上形參名的方式表示，這個函數實際參數是不一定的，可以是零個，也可以是N個。不管是多少個，在函數內部都被存放在以形參名為標識符的tuple中。比如：

對這個函數的調用addOn() addOn(2) addOn(3,4,5,6)等等都是可以的。

與第3種方式類似，形參名前面加了兩個*表示，參數在函數內部將被存放在以形式名為標識符的dictionary中。這時候調用函數必須採用key1=value1、key2=value2...的形式。比如：

1. def addOn(**arg):
2. sum = 0
3. if len(arg) == 0: return 0
4. else:
5. for x in arg.itervalues():
6. sum += x
7. return sum

那麼對這個函數的調用可以用addOn()或諸如addOn(x=4,y=5,k=6)等的方式調用。

上面說了四種函數形式定義的方式以及他們的調用方式，是分開說的，其實這四種方式可以組合在一起形成復雜多樣的形參定義形式。在定義或調用這種函數時，要遵循以下規則：

1. arg=<value>必須在arg後
2. *arg必須在arg=<value>後
3. **arg必須在*arg後

在函數調用過程中，形參賦值的過程是這樣的：
首先按順序把「arg」這種形式的實參給對應的形參
第二，把「arg=<value>」這種形式的實參賦值給形式
第三，把多出來的「arg」這種形式的實參組成一個tuple給帶一個星號的形參
第四，把多出來的「key=value」這種形式的實參轉為一個dictionary給帶兩個星號的形參。
例子：

1. def test(x,y=5,*a,**b):
2. print x,y,a,b

就這么一個簡單函數，來看看下面對這個函數調用會產生什麼結果：
test(1) ===> 1 5 () {}
test(1,2) ===> 1 2 () {}
test(1,2,3) ===> 1 2 (3,) {}
test(1,2,3,4) ===> 1 2 (3,4)
test(x=1) ===> 1 5 () {}
test(x=1,y=1) ===> 1 1 () {}
test(x=1,y=1,a=1) ===> 1 1 () {'a':1}
test(x=1,y=1,a=1,b=1) ===> 1 1 () {'a':1,'b':1}
test(1,y=1) ===> 1 1 () {}
test(1,2,y=1) ===> 出錯，說y給賦了多個值
test(1,2,3,4,a=1) ===> 1 2 (3,4) {'a':1}
test(1,2,3,4,k=1,t=2,o=3) ===> 1 2 (3,4) {'k':1,'t':2,'o':3}

『柒』 python類可以傳遞參數嗎

python類可以傳遞參數。方法是：採用__init__初始化方法進行對象傳參，實例化時傳入所需參數。
在Python中類傳遞參數一般採用__init__的方法進行傳遞，如下：
列印結果表示我們傳入的'xiaoming'和15已經成功傳遞到實例xiaoming對象中。
推薦課程：Python入門與進階教學視頻（極客學院）

『捌』 python中參數傳遞的方式是什麼

python中一切皆對象，函數中參數傳遞的是對象的引用。
1在函數中改變變數指向的對象，即指向不同對象。
當在函數中修改傳遞進來的變數指向另一個對象時，實參的對象不會改變。

『玖』 Python 的函數是怎麼傳遞參數的

標准形式是 func(*args, **kwargs)

args及kwargs是Python函數接受的可變參數

*args表示任何多個無名參數，它是一個tuple

**kwargs表示關鍵字參數，它是一個dict

示例代碼：

deffoo(*args,**kwargs):
print'args=',args
print'kwargs=',kwargs
print'**********************'
if__name__=='__main__':
foo(1,2,3)
foo(a=1,b=2,c=3)
foo(1,2,3,a=1,b=2,c=3)
foo(1,'b','c',a=1,b='b',c='c')

運行結果：

args=(1,2,3)
kwargs={}
**********************
args=()
kwargs={'a':1,'c':3,'b':2}
**********************
args=(1,2,3)
kwargs={'a':1,'c':3,'b':2}
**********************
args=(1,'b','c')
kwargs={'a':1,'c':'c','b':'b'}
**********************