導航:首頁 > 編程語言 > python函數參數封包

python函數參數封包

發布時間:2023-09-19 04:12:01

A. python的函數和參數

parameter 是函數定義的參數形式
argument 是函數調用時傳入的參數實體。

對於函數調用的傳參模式,一般有兩種:

此外,

也是關鍵字傳參

python的函數參數定義一般來說有五種: 位置和關鍵字參數混合 僅位置參數 僅關鍵字參數 可變位置參數 可變關鍵字參數 。其中僅位置參數的方式僅僅是一個概念,python語法中暫時沒有這樣的設計。
通常我們見到的函數是位置和關鍵字混合的方式。

既可以用關鍵字又可以用位置調用

這種方式的定義只能使用關鍵字傳參的模式

f(*some_list) 與 f(arg1, arg2, ...) (其中some_list = [arg1, arg2, ...])是等價的

網路模塊request的request方法的設計
多數的可選參數被設計成可變關鍵字參數

有多種方法能夠為函數定義輸出:

非常晦澀

如果使用可變對象作為函數的默認參數,會導致默認參數在所有的函數調用中被共享。
例子1:

addItem方法的data設計了一個默認參數,使用不當會造成默認參數被共享。
python裡面,函數的默認參數被存在__default__屬性中,這是一個元組類型
例子2:

在例子1中,默認參數是一個列表,它是mutable的數據類型,當它寫進 __defauts__屬性中時,函數addItem的操作並不會改變它的id,相當於 __defauts__只是保存了data的引用,對於它的內存數據並不關心,每次調用addItem,都可以修改 addItem.__defauts__中的數據,它是一個共享數據。
如果默認參數是一個imutable類型,情況將會不一樣,你無法改變默認參數第一次存入的值。

例子1中,連續調用addItem('world') 的結果會是

而不是期望的

B. python 定義函數

python 定義函數:
在Python中,可以定義包含若干參數的函數,這里有幾種可用的形式,也可以混合使用:

1. 默認參數
最常用的一種形式是為一個或多個參數指定默認值。

>>> def ask_ok(prompt,retries=4,complaint='Yes or no Please!'):
while True:
ok=input(prompt)
if ok in ('y','ye','yes'):
return True
if ok in ('n','no','nop','nope'):
return False
retries=retries-1
if retries<0:
raise IOError('refusenik user')
print(complaint)

這個函數可以通過幾種方式調用:
只提供強制參數
>>> ask_ok('Do you really want to quit?')
Do you really want to quit?yes
True

提供一個可選參數
>>> ask_ok('OK to overwrite the file',2)
OK to overwrite the fileNo
Yes or no Please!
OK to overwrite the fileno
False

提供所有的參數
>>> ask_ok('OK to overwrite the file?',2,'Come on, only yes or no!')
OK to overwrite the file? test
Come on, only yes or no!
OK to overwrite the file?yes
True

2. 關鍵字參數
函數同樣可以使用keyword=value形式通過關鍵字參數調用

>>> def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
print("--This parrot wouldn't", action, end=' ')
print("if you put",voltage,"volts through it.")
print("--Lovely plumage, the",type)
print("--It's",state,"!")

>>> parrot(1000)
--This parrot wouldn't voom if you put 1000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot(action="vooooom",voltage=1000000)
--This parrot wouldn't vooooom if you put 1000000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot('a thousand',state='pushing up the daisies')
--This parrot wouldn't voom if you put a thousand volts through it.
--Lovely plumage, the Norwegian Blue
--It's pushing up the daisies !

但是以下的調用方式是錯誤的:

>>> parrot(voltage=5, 'dead')
SyntaxError: non-keyword arg after keyword arg
>>> parrot()
Traceback (most recent call last):
File "<pyshell#57>", line 1, in <mole>
parrot()
TypeError: parrot() missing 1 required positional argument: 'voltage'
>>> parrot(110, voltage=220)
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <mole>
parrot(110, voltage=220)
TypeError: parrot() got multiple values for argument 'voltage'
>>> parrot(actor='John')
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <mole>
parrot(actor='John')
TypeError: parrot() got an unexpected keyword argument 'actor'
>>> parrot(voltage=100,action='voom',action='voooooom')
SyntaxError: keyword argument repeated

Python的函數定義中有兩種特殊的情況,即出現*,**的形式。
*用來傳遞任意個無名字參數,這些參數會以一個元組的形式訪問
**用來傳遞任意個有名字的參數,這些參數用字典來訪問
(*name必須出現在**name之前)

>>> def cheeseshop1(kind,*arguments,**keywords):
print("--Do you have any",kind,"?")
print("--I'm sorry, we're all out of",kind)
for arg in arguments:
print(arg)
print("-"*40)
keys=sorted(keywords.keys())
for kw in keys:
print(kw,":",keywords[kw])

>>> cheeseshop1("Limbuger","It's very runny, sir.","It's really very, very runny, sir.",shopkeeper="Michael Palin",client="John",sketch="Cheese Shop Sketch")
--Do you have any Limbuger ?
--I'm sorry, we're all out of Limbuger
It's very runny, sir.
It's really very, very runny, sir.
----------------------------------------
client : John
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
>>>

3. 可變參數列表
最常用的選擇是指明一個函數可以使用任意數目的參數調用。這些參數被包裝進一個元組,在可變數目的參數前,可以有零個或多個普通的參數
通常,這些可變的參數在形參列表的最後定義,因為他們會收集傳遞給函數的所有剩下的輸入參數。任何出現在*args參數之後的形參只能是「關鍵字參數」
>>> def contact(*args,sep='/'):
return sep.join(args)

>>> contact("earth","mars","venus")
'earth/mars/venus'

4. 拆分參數列表
當參數是一個列表或元組,但函數需要分開的位置參數時,就需要拆分參數
調用函數時使用*操作符將參數從列表或元組中拆分出來
>>> list(range(3,6))
[3, 4, 5]
>>> args=[3,6]
>>> list(range(*args))
[3, 4, 5]
>>>

以此類推,字典可以使用**操作符拆分成關鍵字參數

>>> def parrot(voltage,state='a stiff',action='voom'):
print("--This parrot wouldn't", action,end=' ')
print("if you put",voltage,"volts through it.",end=' ')
print("E's", state,"!")

>>> d={"voltage":"four million","state":"bleedin' demised","action":"VOOM"}
>>> parrot(**d)
--This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !

5. Lambda
在Python中使用lambda來創建匿名函數,而用def創建的是有名稱的。
python lambda會創建一個函數對象,但不會把這個函數對象賦給一個標識符,而def則會把函數對象賦值給一個變數
python lambda它只是一個表達式,而def則是一個語句

>>> def make_incrementor(n):
return lambda x:x+n

>>> f=make_incrementor(42)
>>> f(0)
42
>>> f(2)
44

>>> g=lambda x:x*2
>>> print(g(3))
6
>>> m=lambda x,y,z:(x-y)*z
>>> print(m(3,1,2))
4

6. 文檔字元串
關於文檔字元串內容和格式的約定:
第一行應該總是關於對象用途的摘要,以大寫字母開頭,並且以句號結束
如果文檔字元串包含多行,第二行應該是空行

>>> def my_function():
"""Do nothing, but document it.

No, really, it doesn't do anything.
"""
pass

>>> print(my_function.__doc__)
Do nothing, but document it.

No, really, it doesn't do anything.

C. 簡單談談Python中函數的可變參數

簡單談談Python中函數的可變參數
在Python中定義函數,可以用必選參數、默認參數、可變參數和關鍵字參數,這4種參數都可以一起使用,或者只用其中某些,但是請注意,參數定義的順序必須是:必選參數、默認參數、可變參數和關鍵字參數。

可變參數( * )

可變參數,顧名思義,它的參數是可變的,比如列表、字典等。如果我們需要函數處理可變數量參數的時候,就可以使用可變參數。

我們在查看很多Python源碼時,經常會看到 某函數(*參數1, **參數2)這樣的函數定義,這個*參數和**參數就是可變參數,一時會讓人有點費解。其實只要把函數可變參數的定義搞清楚了,就不難理解了。

當我們不知道需要用幾個參數來定義函數的時候,可變參數就可以大展手腳了。

在Python里,帶 * 的參數就是用來接受可變數量參數的。

如果一個函數定義如下:
def functionTest(*args):
....
....
....

調用時我們可以的這樣調用:
functionTest(1)
或者
functionTest(1,2)
或者
functionTest(1,2,3)

後面可以傳入多個參數。

看段實例代碼,觀察下*是怎麼具體應用的吧:

def get_sum(*numbers):
sum = 0
for n in numbers:
sum += n
return sum

#在這里寫下你的代碼來調用get_sum來求5個數字的和,並輸出這個結果
print (get_sum(1,2,3,4,5))
結果會是什麼呢?大家可以自己動手操作起來看下,以就是關於Python中函數可變參數的全部內容,希望這篇文章對大家學習或使用python能有所幫助

D. python 函數參數 是什麼意思

Python 函數定義以及參數傳遞
1.函數定義
#形如def func(args...):
doSomething123

以關鍵字def 開頭,後面是函數名和參數下面是函數處理過程。
舉例:
def add( a, b ):
return a+b12

參數可以設定默認值,如:
def add( a, b=10 ): #注意:默認值參數只會運算一次
return a+b12

默認值參數只會運算一次是什麼意思?
def func( a, b=[] ): #b的默認值指向一個空的列表,每次不帶默認值都會指向這塊內存
b.append(a) return b

print(func(1))#向默認的空列表裡加入元素1 ,默認列表裡已經是[1]print(func(2))#向默認的列表裡加入元素2,默認列表裡已經是[1,2]print(func(3,[]))#向b指向的空列表裡加入元素1 ,默認列表裡還是[1,2]print(func(4))#向默認的列表裡加入元素4,默認列表裡已經是[1,2,4]'''
結果:
[1]
[1, 2]
[3]
[1, 2, 4]
'''12345678910111213141516

這下明白為什麼默認參數只計算一次了吧,函數參數不傳遞時默認值總是指向固定的內存空間,就是第一次計算的空間。
2.參數傳遞
def func(a, b):
print('a=%d, b=%d' % (a,b) )12

在使用函數時可以如下方式,結果都是相同的
func(10,20) #不使用參數名,需要按參數順序傳遞func(a=10,b=20) #使用參數名可以不按順序傳遞func(b=20,a=10)#結果:a=10, b=20a=10, b=20a=10, b=201234567

如果函數定義形式如下方式:
def func(*args): #這種定義會把傳遞的參數包成元組
print(args,type(args))

func(10,20)#結果:#(10, 20) <class 'tuple'>1234567

舉一個和上述過程相反的例子:
def func(a,b):
print('a=%d, b=%d' % (a,b) )

a = (10, 20)
func(*a) #在調用函數使用`*`則會把元組解包成單個變數按順序傳入函數#結果:a=10, b=20123456

總結:*號在定義函數參數時,傳入函數的參數會轉換成元組,如果 *號在調用時則會把元組解包成單個元素。
另一種定義:
def func(**kw):#使用**定義參數會把傳入參數包裝成字典dict
print(kw, type(kw) )

func(a=10,b=20)#這種函數在使用時必須指定參數值,使用key=value這種形式#結果:{'b': 20, 'a': 10} <class 'dict'>12345

相反的例子:
def func(a,b):
print('a=%d, b=%d' % (a,b) )

d = {'a':10, 'b':20 }
func(**d) #在調用時使用**會把字典解包成變數傳入函數。12345
def func(*args, **kw):#這種形式的定義代表可以接受任意類型的參數
print(args,kw )12

總結:**號在定義函數參數時,傳入函數的參數會轉換成字典,如果 **號在調用時則會把字典解包成單個元素。
lambda表達式
lambda表達式就是一種簡單的函數
形如 f = lambda 參數1,參數2: 返回的計算值
例如:
add = lambda x,y: x+y
print(add(1,2))'''
結果:3
'''12345

E. Python 的函數是怎麼傳遞參數的

首先你要明白,Python的函數傳遞方式是賦值,而賦值是通過建立變數與對象的關聯實現的。
對於你的代碼:
執行 d = 2時,你在__main__里創建了d,並讓它指向2這個整型對象。
執行函數add(d)過程中:
d被傳遞給add()函數後,在函數內部,num也指向了__main__中的2
但執行num = num + 10之後,新建了對象12,並讓num指向了這個新對象——12。
如果你明白函數中的局部變數與__main__中變數的區別,那麼很顯然,在__main__中,d仍在指著2這個對象,它沒有改變。因此,你列印d時得到了2。
如果你想讓輸出為12,最簡潔的辦法是:
在函數add()里增加return num
調用函數時使用d = add(d)
代碼如下:
def add(num):
num += 10
return num
d = 2
d = add(d)
print d

F. Python的位置參數、默認參數、關鍵字參數、可變參數區別

對於python函數參數,對於初學者可能就是進入了迷宮,盡管我也是初學者,簡單總結一下。
說參數之前,先講一下兩個packing(包裹)和unpacking(解包裹):

輸出:

我總結不了這個概念,只能幫大家到這了

一、位置參數和關鍵字參數:

調用函數時根據函數定義的參數位置來傳遞參數。

注意:
有位置參數時,位置參數必須在關鍵字參數的前面,但關鍵字參數之間不存在先後順序的

二、默認參數:
用於定義函數,為參數提供默認值,調用函數時可傳可不傳該默認參數的值(注意:所有位置參數必須出現在默認參數前,包括函數定義和調用)

三、可變參數:

定義函數時,有時候我們不確定調用的時候會傳遞多少個參數(不傳參也可以)。此時,可用包裹(packing)位置參數,或者包裹關鍵字參數,來進行參數傳遞,會顯得非常方便。

1、包裹位置傳遞

我們傳進的所有參數都會被args變數收集,它會根據傳進參數的位置合並為一個元組(tuple),args是元組類型,這就是包位置傳遞。

2、包裹關鍵字傳遞

kargs是一個字典(dict),收集所有關鍵字參數

四、解包裹參數:

*args 和 **kargs ,也可以在函數調用的時候使用,稱之為解包(unpacking)

1、在傳遞元組時,讓元組的每一個元素對應一個位置參數

2、在傳遞詞典字典時,讓詞典的每個鍵值對作為一個關鍵字參數傳遞給函數

五、位置參數、默認參數、可變參數的混合使用

1、基本原則是:先位置參數,默認參數,包裹位置,包裹關鍵字(定義和調用都應遵循)

2、Python中 *args 和 **kwargs 的區別

先看個demo:

輸出結果:

分析一下:可以看到,這兩個是[Python]中的可變參數。 *args 表示任何多個無名參數,它是一個tuple; **kwargs 表示關鍵字參數,它是一個dict。並且同時使用 *args 和 **kwargs 時,必須 *args 參數列要在 **kwargs 前,否則會報語法錯誤!!!

還有個小應用場景:創建字典

其實python中就帶有dict類,使用dict(a=1,b=2,c=3)即可創建一個字典了。

*args:
重點在*,後面的args相當於一個變數名,可以自己定義的。它的本質就是將標准調用剩下的值集中轉變為元組。

從形參的角度:

從實參的角度:

從不同角度看**kwargs:

**kwargs與位置參數和默認參數混用:

超復雜混合參數混用記:

總結:

位置參數:

調用函數時所傳參數的位置必須與定義函數時參數的位置相同

關鍵字參數:

使用關鍵字參數會指定參數值賦給哪個形參,調用時所傳參數的位置可以任意

*位置參數:可接受任意數量的位置參數(元組);只能作為最後一個位置參數出現,其後參數均為關鍵字參數

**關鍵字參數:可接受任意數量的關鍵字參數(字典);只能作為最後一個參數出現

閱讀全文

與python函數參數封包相關的資料

熱點內容
網易粘土伺服器怎麼開箱子 瀏覽:486
單片機軟體開發工程師 瀏覽:170
伺服器為什麼用lamp環境 瀏覽:377
財務分析pdf下載 瀏覽:291
做游戲如何不搭建伺服器 瀏覽:612
德國是什麼伺服器 瀏覽:551
javajar部署 瀏覽:269
android菜單顯示位置 瀏覽:529
大疆自拍是哪個app 瀏覽:188
pdf夢的解析 瀏覽:608
腳步聲優化命令聽不清 瀏覽:325
程序員三大罪怎麼玩 瀏覽:729
cad列印pdf設置 瀏覽:733
國產加密演算法價格 瀏覽:602
phpobjecttojson 瀏覽:695
pdf樣式 瀏覽:749
ssid加密協議 瀏覽:354
汝州市解壓去哪個車管所 瀏覽:546
小韓api源碼 瀏覽:281
php提取手機號 瀏覽:855