python函數傳遞引用傳遞

① python 函數中，參數是傳值，還是傳引用

首先還是應該科普下函數參數傳遞機制，傳值和傳引用是什麼意思？
函數參數傳遞機制問題在本質上是調用函數（過程）和被調用函數（過程）在調用發生時進行通信的方法問題。基本的參數傳遞機制有兩種：值傳遞和引用傳遞。
值傳遞（passl-by-value）過程中，被調函數的形式參數作為被調函數的局部變數處理，即在堆棧數森中開辟了內存空間以存放由主調函數放進來的實參的值，從而成為了實參的一個副本。值傳遞的特點是被調函數對形式參數的任何操作都是作為局部變數進行，不會影響主調函數的實參變數的值。
引用傳遞(pass-by-reference)過程中，被調函數的形式參數雖然也作為局部變數在堆棧中開辟了內存空間，但是這時存放的是由主調函數放進來的實參變數的地址。被調函數對形參的任何操作都被處理成間接定址，即通過堆棧中存放的地址訪問主調函數中的實參變數。正因為如此，被調函數對形參做的任何操作都影響了主調函數中的實參掘掘變數。
在python中實際又是怎麼樣的呢？
先看一個簡單的例子：

from ctypes import *
import os.path
import sys

def test(c):
print "test before "
print id(c)
c+=2
print "test after +"
print id(c)
return c

def printIt(t):
for i in range(len(t)):
print t[i]

if __name__=="__main__":
a=2
print "main before invoke test"
print id(a)
n=test(a)
print "main afterf invoke test"
print a
print id(a)

運行後結果如下：

>>>
main before invoke test
39601564
test before
39601564
test after +
39601540
main afterf invoke test
2
39601564

id函數可以獲得對象的內存地址.很明顯從上面例子可以看出，將a變數作為參數傳遞給了test函數，傳遞了a的一個引用，把a的地址傳遞過去了，所以在函數內獲取的變數C的地址跟變數a的地址是一樣的，但是在函數內，對C進行賦值運算，C的值從2變成了4，實際上2和4所佔的內存空間都還是存判畢核在的，賦值運算後，C指向4所在的內存。而a仍然指向2所在的內存，所以後面列印a，其值還是2.
如果還不能理解，先看下面例子

>>> a=1
>>> b=1
>>> id(a)
40650152
>>> id(b)
40650152
>>> a=2
>>> id(a)
40650140

a和b都是int類型的值，值都是1，而且內存地址都是一樣的，這已經表明了在python中，可以有多個引用指向同一個內存（畫了一個很挫的圖，見諒），在給a賦值為2後，再次查看a的內存地址，都已經變化了

而基於最前面的例子，大概可以這樣描述：

那python函數傳參就是傳引用？然後傳參的值在被調函數內被修改也不影響主調函數的實參變數的值？再來看個例子。

from ctypes import *
import os.path
import sys

def test(list2):
print "test before "
print id(list2)
list2[1]=30
print "test after +"
print id(list2)
return list2

def printIt(t):
for i in range(len(t)):
print t[i]

if __name__=="__main__":
list1=["loleina",25,'female']
print "main before invoke test"
print id(list1)
list3=test(list1)
print "main afterf invoke test"
print list1
print id(list1)

實際值為：

>>>
main before invoke test
64129944
test before
64129944
test after +
64129944
main afterf invoke test
['loleina', 30, 'female']
64129944

發現一樣的傳值，而第二個變數居然變化，為啥呢？
實際上是因為python中的序列：列表是一個可變的對象，就基於list1=[1,2] list1[0]=[0]這樣前後的查看list1的內存地址，是一樣的。

>>> list1=[1,2]
>>> id(list1)
64185208
>>> list1[0]=[0]
>>> list1
[[0], 2]
>>> id(list1)
64185208

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

分類: python 基礎語法

② python中變數的引用、可變和不可變類型、局部變數和全局變數

變數的引用

變數和數據都是保存在內存中的

變數和數據是分開存儲的

數據保存在內存中某個位置，通過地址來標記

變數保存的是數據的地址，通過地址可以找到數據在內存空間的位置

把變數保存數據地址的過程稱為引用

變數的重新賦值修改的是變數中引用數據的內存地址

變數之間的賦值實際是引用的傳遞

函數參數的傳遞，本質也是引用的傳遞

函數的返回值本身也是引用的傳遞

可變和不可變類型

不可變類型，內存中的數據不允許被修改：數字類型（int,bool,float,complex,long(2,x)、字元串、元組（tuple）

可變類型，內存中的數據可以被修改：列表list、字典dict

無論是可變還是不可變數據類型，通過賦值語句，都會改變變數的引用

Hash函數只能接收不可變數據類型，字典的鍵也只能是不可變數據類型，字典的value值可以是任意數據類型

局部變數

1.在函數內部定義的變數就是局部變數（作用范圍只能是當前函數內部）

2.在函數外部無法直接訪問局部變數

3.不同的函數中可以定義同名的局部變數

4.局部變數的生命周期：從定義變數時開始，到函數運行結束

全局變數

1.在所有函數外邊定義的變數就是全局變數

2.讓所有函數都能訪問到，可以作為函數通信的橋梁

3.一般情況下，為了和普通變數的區別，需要加上g_或gl_前綴

4.全局變數一般放在所有函數的最上面

5.在函數內部修改全局變數，必須要加上global關鍵字，如果不加global只是定義了一個同名的局部變數

函數的多個返回值

③ python中視圖函數傳值的數據類型可以傳對象嗎

python的一切數據類型都是對象。但是python的對象分為不可變對象和可變對象。python的變數是引用，對python變數的賦值是引用去綁定該對象。

可變對象的數據發生改變，例如列表和字典，引用不會更改綁定對象，畢竟本身就是用於增刪改查的，頻液擾繁地產茄漏生新對象必然導致開銷巨大，只需要該對象內部變化就行；但對於綁定了不可變對象的引用，對象一旦改變就會使引用綁定新的對象。

這一點也會顫埋爛反應到函數的參數上。python的傳值方式是「傳對象」引用。python的函數，形參實際上是引用，實參便是對象綁定到該引用上。本質是形參會被作為函數的局部變數，在開辟的函數的棧內存中被聲明。

簡要來講：

如果參數是數，則類似值傳遞，

如果參數是列表和字典，則類似引用傳遞。

每個對象都會有個id, 可以用id()驗證以上說法：

這個函數的參數是列表，是可變對象。

④ Python中 傳遞值 和 傳遞引用 的區別解析

傳遞值是把值做一份拷貝，傳入函數
傳遞引用是把變數的地址傳入函數，只要值變更，就會生效

⑤ Python裡面的函數怎麼按引用傳遞參數

如果你用C給Matlab寫過MEX程序，那麼這個問題是很容易理解的（好像每次討論Python問題時我總是把Matlab搬了出來…… 《在Matlab中把struct當成Python中的Dictionary使用》《Matlab和Python的幾種數據類型的比較》）。
既然提到了MEX，就簡單說一下：
一個Matlab可能形如
function ret=add3(a,b,c)
如果在C的層面實現這個函數，就會看到另一種景象：
void mexFunction(int nlhs,mxArray * plhs[],int nrhs,const mxArray * prhs[])
a,b,c三個參數的地址放在一個指針數組里，然後把這個指針數組的首地址作為參數prhs傳遞給函數，這說明Matlab函數的參數是傳遞指針的，而不是值傳遞。
縱然是傳遞的指針，但是卻不能在函數里改變實參的值，因為標記為「const」了。
Python是開放源碼的，我沒有看。所以下面很多東西是猜的。
Python在函數的參數傳遞時用的什麼手法？實驗一下（使用ActivePython2.5）：
首先介紹一個重要的函數：
>>> help(id)
Help on built-in function id in mole __builtin__:
id(...)
id(object) -> integer
Return the identity of an object. This is guaranteed to be unique among
simultaneously existing objects. (Hint: it's the object's memory address.)
看最後括弧里那句：Hint:it's the object's address.（它是對象的地址）
有了這個函數，下面的事情就方便多了。
>>> a=0
>>> id(a)
3630228
>>> a=1
>>> id(a)
3630216
可以看出，給a賦一次值，a的address就改變了。在C的層面看，（也許真實情況不是下面的樣子，但作為一個類比應該還是可以的）：
void * pa;
pa=malloc(sizeof(int));
*(int *)pa=0;
free(pa);
pa=malloc(sizeof(int));
*(int *)pa=1;
Python中每次賦值會改變變數的address，分配新的內存空間，所以Python中對於類型不像C那樣嚴格要求。
下面看看Python函數參數傳遞時到底傳的什麼：
有一個函數：
>>> def changeA(a):
... print id(a)
... a=100
... print id(a)
設定一個變數var1：
>>> var1=10
>>> id(var1)
3630108
>>> changeA(var1)
3630108
3631012
>>> var1
10
調用函數後，從兩次print的結果可以看出，傳遞確實是地址。但是即便如此，在函數內對形參的修改不會對實參造成任何實質的影響，因為對形參的重新賦值，只是改變了形參所指向的內存單元（changeA里兩次調用print id(a)得到不同的結果），卻沒有改變實參的指向。在C的層面看也許類似下面的情節：
void changeA(void * pa)
{
pa=malloc(sizeof(int));
*(int *)pa=100;
free(pa);
}
精通C的你一眼就看出這個函數永遠也改變不了它外面的世界。
也就是說雖然傳遞的是地址，但像changeA這樣的函數改變不了實參的值。
也許會感到困擾？不，我已經在Matlab中習慣了。
一個最典型的例子就是Matlab中刪除結構體成員的rmfield函數（參見《Matlab筆記三則》），
（Matlab版本7.0.1）
如果想刪除結構體patient的name成員，用
rmfield(patient, 'name');
是永遠達不到目的的（就像試圖用雙手抓住自己的領子，把自己提到空中）；
迷途知返的做法是：
patient = rmfield(patient, 'name');

⑥ Python函數的參數類型

Python函數的參數類型主要包括必選參數、可選參數、可變參數、位置參數和關鍵字參數，本文介紹一下他們的定義以及可變數據類型參數傳遞需要注意的地方。

必選參數（Required arguments）是必須輸入的參數，比如下面的代碼，必須輸入2個參數，否則就會報錯：

其實上面例子中的參數 num1和num2也屬於關鍵字參數，比如可以通過如下方式調用：

執行結果：

可選參數（Optional arguments）可以不用傳入函數，有一個默認值，如果沒有傳入會使用默認值，不會報錯。

位置參數（positional arguments）根據其在函數定義中的位置調用，下面是pow()函數的幫助信息:

x，y，z三個參數的的順序是固定的，並且不能使用關鍵字：

輸出：

在上面的pow()函數幫助信息中可以看到位置參數後面加了一個反斜杠 / ，這是python內置函數的語法定義，Python開發人員不能在python3.8版本之前的代碼中使用此語法。但python3.0到3.7版本可以使用如下方式定義位置參數：

星號前面的參數為位置參數或者關鍵字參數，星號後面是強制關鍵字參數，具體介紹見強制關鍵字參數。

python3.8版本引入了強制位置參數（Positional-Only Parameters），也就是我們可以使用反斜杠 / 語法來定義位置參數了，可以寫成如下形式：

來看下面的例子：

python3.8運行：

不能使用關鍵字參數形式賦值了。

可變參數 (varargs argument) 就是傳入的參數個數是可變的，可以是0-n個，使用星號（ * ）將輸入參數自動組裝為一個元組（tuple）：

執行結果：

關鍵字參數（keyword argument）允許將任意個含參數名的參數導入到python函數中，使用雙星號（ ** ），在函數內部自動組裝為一個字典。

執行結果：

上面介紹的參數可以混合使用：

結果：

注意：由於傳入的參數個數不定，所以當與普通參數一同使用時，必須把帶星號的參數放在最後。

強制關鍵字參數（Keyword-Only Arguments）是python3引入的特性，可參考：https://www.python.org/dev/peps/pep-3102/。 使用一個星號隔開：

在位置參數一節介紹過星號前面的參數可以是位置參數和關鍵字參數。星號後面的參數都是強制關鍵字參數，必須以指定參數名的方式傳參，如果強制關鍵字參數沒有設置默認參數，調用函數時必須傳參。

執行結果：

也可以在可變參數後面命名關鍵字參數，這樣就不需要星號分隔符了：

執行結果：

在Python對象及內存管理機制中介紹了python中的參數傳遞屬於對象的 引用傳遞 （pass by object reference），在編寫函數的時候需要特別注意。

先來看個例子：

執行結果：

l1 和 l2指向相同的地址，由於列表可變，l1改變時，l2也跟著變了。

接著看下面的例子：

結果：

l1沒有變化！為什麼不是[1, 2, 3, 4]呢？

l = l + [4]表示創建一個「末尾加入元素 4「的新列表，並讓 l 指向這個新的對象，l1沒有進行任何操作，因此 l1 的值不變。如果要改變l1的值，需要加一個返回值：

結果：

下面的代碼執行結果又是什麼呢？

執行結果：

和第一個例子一樣，l1 和 l2指向相同的地址，所以會一起改變。這個問題怎麼解決呢？

可以使用下面的方式：

也可以使用淺拷貝或者深度拷貝，具體使用方法可參考Python對象及內存管理機制。這個問題在Python編程時需要特別注意。

本文主要介紹了python函數的幾種參數類型：必選參數、可選參數、可變參數、位置參數、強制位置參數、關鍵字參數、強制關鍵字參數，注意他們不是完全獨立的，比如必選參數、可選參數也可以是關鍵字參數，位置參數可以是必選參數或者可選參數。

另外，python中的參數傳遞屬於對象的 引用傳遞 ，在對可變數據類型進行參數傳遞時需要特別注意，如有必要，使用python的拷貝方法。

參考文檔：

--THE END--

⑦ python函數傳對象對性能的影響

python函數傳對象對性能有影響。在Python中，一切皆對象，Python參數傳遞採用的都是「傳對象引用」的方式。實際上，這種方式相當於傳值和傳引用的一種綜合。如果函數收到的是一個可變對象（比如字典或者列表）的引用，就能修改對象的原始值，相當於通過「傳引用」來傳遞對象。如果函數收到的是一個不可變對象（比如數字、字元或者元組）的引用，就不能直接修改原始對象，相當於通過「傳值』來傳遞對象，此時如果想改變這些變數的值，可以將這些變數申明為全局變數。

⑧ python中值傳遞還是引用傳遞

首先，Python中一切事物皆對象，變數是對對象在內存中的存儲和地址的抽象。所有的變數都可以理解是內存中一個對象的「引用」，或者，也可以看似c中void*的感覺。

python中統一都是引用傳遞，同時要注意類型是屬於對象的，而不是變數。而對象有兩種,「可更改」（mutable）與「不可更改」（immutable）對象。在python中，strings, tuples, 和numbers是不可更改的對象，而list,dict等則是可以修改的對象。

當我們寫下面語句時：

Python解釋器其實順序幹了兩件事情：

從這里可以看出strings類型是不可變數，不可變實際上指的是不會更該字元串，比如把a = '123' 變為 a ='1234' 實際上是先創建了 「1234」 再用a去指向它。
但是，像list,dict等「可更改」的變數，他們會直接再本地更改，不會進行副本拷貝。
簡言之，當在 Python 中 a = sth 應該理解為給 sth 貼上了一個標簽 a。當再賦值給 a 的時候，就好象把 a 這個標簽從原來的 sth 上拿下來，貼到其他對象上，建立新的"引用"。

既然Python只允許引用傳遞，那有沒有辦法可以讓兩個變數不再指向同一內存地址呢？

對於一個復雜對象的子對象並不會完全復制，什麼是復雜對象的子對象呢？就比如序列里的嵌套序列，字典里的嵌套序列等都是復雜對象的子對象。對於子對象，python會把它當作一個公共鏡像存儲起來，所有對他的復制都被當成一個引用，所以說當其中一個引用將鏡像改變了之後另一個引用使用鏡像的時候鏡像已經被改變了。

deep的時候會將復雜對象的每一層復制一個單獨的個體出來。 當然其中主要的操作還是地址問題。

當一個引用傳遞給函數的時候,函數自動復制一份引用,這個函數里的引用和外邊的引用沒有半毛關系了.所以第一個例子里函數把引用指向了一個不可變對象,當函數返回的時候,外面的引用沒半毛感覺.而第二個例子就不一樣了,函數內的引用指向的是可變對象,對它的操作就和定位了指針地址一樣,在內存里進行修改.

引用計數
PyObject是每個對象必有的內容，其中ob_refcnt就是做為引用計數。當一個對象有新的引用時，它的ob_refcnt就會增加，當引用它的對象被刪除，它的ob_refcnt就會減少.引用計數為0時，該對象生命就結束了。

優點:

缺點:

⑨ python函數的參數傳遞是傳值還是傳引用

那要看數據類型了，int，float，str這種就是傳值，list，dict，類的實例，自定義對象都是穿引用。

下面是示例代碼：

defchange(int1,float1,str1,dict1,obj1,list1):
int1+=1
float1+=1
str1+='changed'
dict1['none_exist_key']='none_exist_value'
obj1=None
list1.append('change')
classobj:
pass
int1=0
float1=0.0
str1='origin'
dict1={'key':'value'}
obj1=obj()
list1=['only_element']
print(int1)
print(float1)
print(str1)
print(dict1)
print(obj1)
print(list1)
change(int1,float1,str1,dict1,obj1,list1)
print('afterchange')
print(int1)
print(float1)
print(str1)
print(dict1)
print(obj1)
print(list1)

不明白可追問

⑩ python函數調用的參數傳遞

python的櫻搏衫函數參數傳遞是"引用傳遞（地址傳遞）"。

python中賦值語句的過程（x = 1）：先申請一段內存分配給一個整型對象來存儲數據1，然後讓變數x去指向這個對象，實際上就是指向這段內存（這里有點和C語言中的指針類似）。

在Python中，會為每個層次生成一個符號表，里層能調用外層中的變數，而外層不能調用里層中的變數，並且當外層和里層有同名變數時，銀培外層變數會被裡層變數屏蔽掉。函數  調用  會為函數局部變數生成一個新的符號表。

局部變數：作用於該函數內部，一旦函數執行完成，該變數就被回收。

全局變數：它是在函數外部定義的，作用域是整個文件。全局變數可以直接在函數裡面應用，但是如果要在函數內部改脊腔變全局變數，必須使用global關鍵字進行聲明。

注意 ：默認值在函數  定義  作用域被解析

在定義函數時，就已經執行力它的局部變數

python中不可變類型是共享內存地址的：把相同的兩個不可變類型數據賦給兩個不同變數a，b，a，b在內存中的地址是一樣的。