當前位置:首頁 » 編程語言 » python帶參數

python帶參數

發布時間: 2022-03-05 11:47:19

python如何將值傳遞參數

python將值傳遞參數的方法:

將值賦給變數url,然後調用函數,將url寫到函數名後面的括弧中,這樣就可以將值傳遞給函數的參數y了

示例代碼如下:

執行結果如下:

更多Python知識,請關註:Python自學網!!

⑵ python怎樣接收參數

Python中函數參數的傳遞是通過「賦值」來傳遞的,函數參數的接收傳遞有四種形式:

1. F(arg1,arg2,...)

2. F(arg2=,arg3=...)

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=必須在arg後

2. *arg必須在arg=後

3. **arg必須在*arg後

在函數調用過程中,形參賦值的過程是這樣的:

首先按順序把「arg」這種形式的實參給對應的形參

第二,把「arg=」這種形式的實參賦值給形式

第三,把多出來的「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 傳參數cmd怎麼往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');

⑷ cmd怎麼往python中傳參數

假如你寫了一個文件test.py,你需要三個參數,你運行時:
python test.py arg1 arg2 arg3
在test.py中讀取這幾個參數:
#!/bin/python
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
這樣會給出輸出:
Number of arguments: 4 arguments.
Argument List: ['test.py', 'arg1', 'arg2', 'arg3']
不知道你要問的是不是這個。

⑸ python中函數參數帶 ' :'

def __init__(self, root: TreeNode):

等效於

def __init__(self, root):

: TreeNode只是對root參數的說明。


python 是弱類型語言,解釋器不會對root傳入的數據類型做限制,但你的這個類,是希望創建實例,傳入的是TreeNode類對象,所以通過這種方式來提醒引用者。

⑹ 如何運行 帶參數sys argv的python程序

按照Python教程中的做法
編寫using_sys.py

在cmd中執行腳本
先是只執行python using_sys.py

看一下結果

然後,添加一些參數
python using_sys.py helloworld

再查看一下結果:

接下來分析一下:首先import sys是導入模塊,這就是告訴python,我們可以使用sys模塊,而sys模塊包含了與python解釋器和它的環境有關的函數
其次,當python執行import sys語句的時候,它在sys.path變數中所列目錄中尋找sys.py模塊,如果找到了這個文件,這個模塊的主塊中的語句被運行,然後這個模塊將能夠被你使用
然後,sys.argv表示sys模塊中的argv變數,實際上,sys.argv是一個字元串的列表,其包含了命令行參數的列表,即使用命令行傳遞給你的程序的參數。
特別注意:腳本的名稱總是sys.argv列表的第一個參數,而在命令行腳本後的參數是sys.argv列表中的第二個元素,而參數之間以空格區分

10
最後就是sys.path包含了輸入模塊的目錄名列表,sys.path的第一個字元串是腳本當前的路徑。

11
以上內容說明了sys.argv是干什麼的,以及其內容及意思。

⑺ python函數中參數帶有一個星號

*代表的是參數個數不確定的情況;帶一個星號(*)參數的函數傳人的參數存儲為一個元組(tuple);而帶兩個星號(*)參數的函數傳人的參數則存儲為一個字典(dict);由於傳入的參數個數不定,所以當與普通參數一同使用時,必須把帶星號的參數放在最後。

⑻ python 函數參數帶*是啥意思

  1. *代表的是參數個數不確定的情況;

  2. 帶一個星號(*)參數的函數傳人的參數存儲為一個元組(tuple);

  3. 而帶兩個星號(*)參數的函數傳人的參數則存儲為一個字典(dict);

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

⑼ python傳入參數的問題

python在定義函數的時候,存在兩種特殊定義,*和**的傳值方式,正是因為這兩種定義,python 函數的傳值,非常靈活,在cpp編程的時候,不支持方法重載,因為沒必要了。。。

在參數前面加個*號,表明這個函數會將這個變數代表的內容,轉換為一個元祖,所以函數可以接收N個元素,這N個元素在函數裡面轉成一個元祖。比如這種

deffun1(*a):#定義
print(a)#1輸出
print(*a)#2輸出
x=[1,2,3]
fun1(x)#1調用
fun1(*x)#2調用
fun(1,2,3)#3調用

因為fun1定義的時候,告訴函數,x可以接受N個對象,這個對象在函數裡面會轉成一個元祖保存,所以在1調用的時候,x在fun1函數裡面會被當成一個元祖,但我們知道,x其實是一個元祖,1調用的時候,就傳了一個對象進去。所以,結果如下

([1,2,3],) #1輸出

[1,2,3] #2輸出

為啥?1輸出,清楚無誤的告訴print(print也是函數,也支持*args方式傳值),你直接把a對象列印出來,a對象是啥?一個包含1個對象的元祖,所以就是(x,)這樣的結果。那2輸出呢?2輸出在調用的時候,在a對象前面已經拆解了元祖,所以,傳給print函數的,是一個對象,就是x了。

同理,在2調用的時候,因為x對象被拆開,所以,func1被傳入多個值,此時的a是一個元素和x相同的元祖。所以2調用的1輸出,就是一個值,就是(1,2,3)。2輸出,因為被拆解了再傳給print,所以,print其實被傳入了多個值,然後將這些值全部列印出來,所以結果是1,2,3.

那3調用呢?其實本質和2調用是一樣的

那雙星號呢?雙星號是拆解key-val格式對的內容,在函數定義的時候,是默認講傳入的產生轉為字典。而規律和上面說的單星號一致。如果用單星號去拆解key-val對象,只會拆解出key。後面的就不多說了。

為啥單引號拆解key-val對象,可以拆出key呢。。。源代碼就這么執行的,為啥當初設計,理由是啥。。。不清楚。。

熱點內容
手機手勢密碼忘了怎麼辦 發布:2025-01-12 17:14:51 瀏覽:486
這手機配置有什麼顏色的電視機 發布:2025-01-12 17:02:19 瀏覽:933
閣源碼 發布:2025-01-12 16:48:08 瀏覽:131
組裝機箱搭建伺服器 發布:2025-01-12 16:46:58 瀏覽:512
風險資產配置理論有哪些 發布:2025-01-12 16:46:13 瀏覽:982
小程序分銷源碼 發布:2025-01-12 16:42:41 瀏覽:48
linux查看系統硬體 發布:2025-01-12 16:34:26 瀏覽:969
安卓手機怎麼設置獨享標志 發布:2025-01-12 16:27:56 瀏覽:933
我的世界如何把材質包放進伺服器 發布:2025-01-12 16:11:14 瀏覽:57
使用hmailserver搭建郵件伺服器 發布:2025-01-12 16:05:43 瀏覽:810