python函數參數傳遞

① python怎麼給函數傳參

函數參數傳遞機制問題在本質上是調用函數（過程）和被調用函數（過程）在調用發生時進行通信的方法問題。基本的參數傳遞機制有兩
種：值傳遞和引用傳遞。
推薦：Python教程
值傳遞（passl-by-value）過程中，被調函數的形式參數作為被調函數的局部變數處理，即在堆棧中開辟了內存空間以存放由主調函數放
進來的實參的值，從而成為了實參的一個副本。值傳遞的特點是被調函數對形式參數的任何操作都是作為局部變數進行，不會影響主調函
數的實參變數的值。
引用傳遞(pass-by-reference)過程中，被調函數的形式參數雖然也作為局部變數在堆棧中開辟了內存空間，但是這時存放的是由主調函
數放進來的實參變數的地址。被調函數對形參的任何操作都被處理成間接定址，即通過堆棧中存放的地址訪問主調函數中的實參變數。正
因為如此，被調函數對形參做的任何操作都影響了主調函數中的實參變數。

更多技術請關注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中函數參數傳遞問題

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

#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 定義的函數的參數傳遞是怎麼樣的

Python變數沒有賦值，都是引用。

大多語言，是聲明一個變數，給它分配一個空間保存一個值，也就是賦值。

Python則是給一個值分配一個空間，變數=這個值，只是這個變數引用了這個值的地址，也就是說，a=1,b=1,c=1,Python只分配了一個空間，保存這個值1。 a,b,c都引用了這個地址。

⑤ 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如何將可選參數或關鍵字參數從一個函數傳遞到另一個函數

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

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

⑦ Python如何向函數傳遞參數

s=[3,2,5,1]
sorted(s,reverse=True)
默認reverse=False，排序為正序。傳入reverse=True，排序就是倒序

⑧ Python 函數中，參數是傳值，還是傳引用

這個問題的答案無外乎這幾種說法:傳值，傳引用，對於可變對象是傳引用，不可變對象是傳值。

傳引用

先看下面這個例子:

>>> def foo(n):
... print id(n)
... n = 3
... print id(n)
>>> n = 2
>>> id(n)
31030000L
>>> foo(n)
31030000L
31029976L
>>> n
2
>>> id(n)
31030000L

由foo中兩次輸出不相等可以看出，傳引用說法並不成立。

傳值

來看下面的例子：

>>> def foo(n):
... print n
... n.append(3)
... print n
>>> n = [1, 2, 4, 8]
>>> foo(n)
[1, 2, 4, 8]
[1, 2, 4, 8, 3]
>>> n
[1, 2, 4, 8, 3]

按傳值的說法，一個值傳進來，在函數內改動並不會影響變數本身的值，上面例子中n變數本身的值也被改變了，說明傳值的說法也不對。

3.可變對象傳引用，不可變對象傳值

相比上面兩種說法，這種說法似乎更靠譜，傳播也更為廣泛，那它到底對不對呢?

>>> def foo(n):
... print id(n)
... n = ['1', '2', '3']
... print id(n)
... print n
>>> n = [1,2,3,4,5,6]
>>> id(n)
35637576
>>> foo(n)
35637576
35916168
['1', '2', '3']
>>> n
[1, 2, 3, 4, 5, 6]

按照可變對象傳引用的說法，上面list類型是可變對象，應該傳引用，這foo方法中兩次調用id應該輸出一樣的值，更改的結果也應該影響到外部變數，但結果顯然不是這樣的，這說明，這種說法也是不正確的。

那麼Python傳值的方法到底是什麼樣呢？其實Python中的函數參數所遵循的是傳對象(call by object)，或者叫做穿對象的引用(call by object reference)。在調用函數時，將變數整個對象傳入，對於可變對象的修改，在函數內外均可見；而對於不可變對象，因為其並不能真正意義上被賦值，修改是通過生成新的對象來實現的。

下面來一個有趣的例子作為結尾:

>>> def bar(a = []):
... print id(a)
... a.append(7)
... print a
>>> for _ in range(5):
... bar()
#結果輸出請自己動手實踐，原因應該不難理解

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

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

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

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

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

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

先看一個簡單的例子：

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

⑩ python中兩個函數間參數傳遞問題

defplus(a,b):
z=a+1
c=b+5
return(z,c)

(q,w)=plus(1,2)

plud(q,w)

##我這里假設a=1,b=2
##首先plus(1,2),得到z=2,c=7，通過return讓(q,w)=(z,c)的值,然後plud(q,w)即可實現將z,c的值傳遞給下一個函數