❶ python函數的幾種參數類型
#Python 2.5 #這個可以用修飾器來完成 #但是一般不會限制參數類型 #給你個思路: def argfilter(*types): def deco(func): #這是修飾器 def newfunc(*args): #新的函數 if len(types)==len(args): correct = True for i in range(len(args)): if not isinstance(args[i], types[i]): #判斷類型 correct = False if correct: return func(*args) #返回原函數值 else: raise TypeError else: raise TypeError return newfunc #由修飾器返回新的函數 return deco #返回作為修飾器的函數 @argfilter(int, str) #指定參數類型 def func(i, s): #定義被修飾的函數 print i, s #之後你想限制類型的話, 就這樣: #@argfilter(第一個參數的類名, 第二個參數的類名, ..., 第N個參數的類名) #def yourfunc(第一個參數, 第一個參數, ..., 第N個參數): # ... # #相當於: #def yourfunc(第一個參數, 第一個參數, ..., 第N個參數): # ... #yourfunc = argfilter(第一個參數的類名, 第二個參數的類名, ..., 第N個參數的類名)(yourfunc)
❷ python中怎麼設定函數形參的類型
#Python 2.5
#這個可以用修飾器來完成
#但是一般不會限制參數類型
#給你個思路:
def argfilter(*types):
def deco(func):
#這是修飾器
def newfunc(*args):
#新的函數
if len(types)==len(args):
correct = True
for i in range(len(args)):
if not isinstance(args[i], types[i]):
#判斷類型
correct = False
if correct:
return func(*args)
#返回原函數值
else:
raise TypeError
else:
raise TypeError
return newfunc
#由修飾器返回新的函數
return deco
#返回作為修飾器的函數
@argfilter(int, str)
#指定參數類型
def func(i, s):
#定義被修飾的函數
print i, s
#之後你想限制類型的話, 就這樣:
#@argfilter(第一個參數的類名, 第二個參數的類名, ..., 第N個參數的類名)
#def yourfunc(第一個參數, 第一個參數, ..., 第N個參數):
#
...
#
#相當於:
#def yourfunc(第一個參數, 第一個參數, ..., 第N個參數):
#
...
#yourfunc = argfilter(第一個參數的類名, 第二個參數的類名, ..., 第N個參數的類名)(yourfunc)
❸ python怎麼知道函數參數類型
可以是列表。實際上，"參數可以是什麼類型"取決於函數體中定義的操作。只要該類型支持這個過程就可以。
比如
def
mmy(a):
return
a*2
可以接受整數或列表作為參數，因為列表也可以實現乘法。
想要每個元素乘2的話，
a
=
[i
*
2
for
i
in
a]
❹ python中函數參數帶 ' ：'
def __init__(self, root: TreeNode):
等效於
def __init__(self, root):
: TreeNode只是對root參數的說明。
python 是弱類型語言，解釋器不會對root傳入的數據類型做限制，但你的這個類，是希望創建實例，傳入的是TreeNode類對象，所以通過這種方式來提醒引用者。
❺ Python方法的幾種常見參數類型
無默認值參數（關鍵字參數）：
defmyfun(a):
print(a)
這是參數的最簡單形式。這個a就是無默認值參數。在調用函數時必需為無默認值參數指定值。
無默認值參數可以通過兩種方式來指定值：
#按參數定義順序不指名傳遞值
myfun('/src/image')
#無視定義順序，通過關鍵字指定值
myfun(a='/src/image')
無默認值參數在函數內部使用關鍵字作為變數名來訪問
無默認值參數可以有多個，也是一些其它參數類型的基礎。
默認值參數：
如果在定義時為參數指定一個默認值，那麼，這個參數就可以在調用時不指定值：
defmyfun(a=''):
print(a)
#不為a指定值
myfun()
#按定義順序為a指定值
myfun('/src/lib')
#通過關鍵字為a指定值
myfun(a='/src/lib')
在定義時，所有默認值參數只能出現在所有無默認值參數之後，也就是說，在函數的定義中，要先定義無默認值參數，再定義默認值參數。
不定長參數：
在參數名之前添加一個*號，則該參數稱為不定長參數。一個函數只可以有一個不定長參數。不定長參數的定義位置沒有限制，它可以定義在無默認值參數之間，也可以定義在默認值參數之後，或者它們之間的任何一個位置。
在調用時，不定長參數之後定義的無前兩種類型的參數就只能使用關鍵字來指定值了。
不定長參數在函數內部被處理為一個tuple。
def_max(*e,base=9):
print('called"_max":')
print('e:',e)
print('base:',base)
#只向不定長參數傳遞了值
#輸出:
#called"_max":
#e:(3,4,5)
#base:9
_max(3,4,5)
#也向默認值參數base傳遞了值
#輸出:
#called"_max":
#e:(3,4)
#base:5
_max(3,4,base=5)
#直接通過一個元組傳遞不定長參數的值
#輸出：
#called"_max":
#e:(3,4)
#base:5
p=(3,4)
_max(*p,base=5)
#使用混合方式傳遞不定長參數
#輸出：
#called"_max":
#e:(3,4,5,6,7)
#base:10
p1=(3,4)
p2=(6,7)
_max(*p1,5,*p2,base=10)
調用函數時如果沒有為不定長參數指定值，將導入一個空元組。
不定長關鍵字參數：
不定長關鍵字參數使用兩個星號作為前綴與其它類型的參數區分，它在函數內被導入為一個字典。調用時需要為不定長關鍵字參數給出約定的關鍵字名，賦值形式如同無默認值參數。
一般情況下，不定長參數是作為最後一個參數來定義。
defmyfun(**kw):
print(kw)
myfun(base=1,home='aaaa')
以上只是基本的調用方式，有些時候，可以有更有趣的調用方式，例如定義了一個既含無默認值參數也含默認值參數的函數：
defiter_dir(homedir,exts='*',includesubdir=False,monoinfile=False,
titlere='^[^^].*',textengine=default_textengine,
encode=None):
調用時也可以用這樣的方式來傳遞值：
kwgs={'homedir':'C:/Users/hunte/Documents/yun/阿瑟·C·克拉克',
'exts':'txt',
'includesubdir':True}
myiter=iter_dir(**kwgs)
forfileinmyiter:
pass
❻ python 函數參數的類型
1. 不同類型的參數簡述
#這里先說明python函數調用得語法為：
復制代碼
代碼如下:
func(positional_args,
keyword_args,
*tuple_grp_nonkw_args,
**dict_grp_kw_args)
#為了方便說明,之後用以下函數進行舉例
def test(a,b,c,d,e):
print a,b,c,d,e
舉個例子來說明這4種調用方式得區別：
復制代碼
代碼如下:
#
#positional_args方式
>>>
test(1,2,3,4,5)
1 2 3 4 5
#這種調用方式的函數處理等價於
a,b,c,d,e = 1,2,3,4,5
print a,b,c,d,e
#
#keyword_args方式
>>>
test(a=1,b=3,c=4,d=2,e=1)
1 3 4 2 1
#這種處理方式得函數處理等價於
a=1
b=3
c=4
d=2
e=1
print a,b,c,d,e
#
#*tuple_grp_nonkw_args方式
>>>
x = 1,2,3,4,5
>>> test(*x)
1 2 3 4
5
#這種方式函數處理等價於
復制代碼
代碼如下:
a,b,c,d,e = x
print
a,b,c,d,e
#特別說明:x也可以為dict類型,x為dick類型時將鍵傳遞給函數
>>> y
{'a': 1,
'c': 6, 'b': 2, 'e': 1, 'd': 1}
>>> test(*y)
a c b e d
#
#**dict_grp_kw_args方式
>>>
y
{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}
>>> test(**y)
1 2 6
1 1
#這種函數處理方式等價於
a = y['a']
b = y['b']
... #c,d,e不再贅述
print
a,b,c,d,e
2.
不同類型參數混用需要注意的一些細節
接下來說明不同參數類型混用的情況,要理解不同參數混用得語法需要理解以下幾方面內容.
首先要明白,函數調用使用參數類型必須嚴格按照順序,不能隨意調換順序,否則會報錯. 如 (a=1,2,3,4,5)會引發錯誤,;
(*x,2,3)也會被當成非法.
其次,函數對不同方式處理的順序也是按照上述的類型順序.因為#keyword_args方式和**dict_grp_kw_args方式對參數一一指定,所以無所謂順序.所以只需要考慮順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的順序.因此,可以簡單理解為只有#positional_args方式,#*tuple_grp_nonkw_args方式有邏輯先後順序的.
最後,參數是不允許多次賦值的.
舉個例子說明,順序賦值(positional_args)和列表賦值(*tuple_grp_nonkw_args)的邏輯先後關系:
復制代碼
代碼如下:
#只有在順序賦值,列表賦值在結果上存在羅輯先後關系
#正確的例子1
>>> x =
{3,4,5}
>>> test(1,2,*x)
1 2 3 4 5
#正確的例子2
>>>
test(1,e=2,*x)
1 3 4 5 2
#錯誤的例子
>>> test(1,b=2,*x)
Traceback (most recent call
last):
File "<stdin>", line 1, in <mole>
TypeError: test()
got multiple values for keyword argument 'b'
#正確的例子1,處理等價於
a,b = 1,2 #順序參數
c,d,e = x #列表參數
print a,b,c,d,e
#正確的例子2,處理等價於
a = 1 #順序參數
e = 2 #關鍵字參數
b,c,d = x #列表參數
#錯誤的例子,處理等價於
a = 1 #順序參數
b = 2 #關鍵字參數
b,c,d = x
#列表參數
#這里由於b多次賦值導致異常,可見只有順序參數和列表參數存在羅輯先後關系
函數聲明區別
理解了函數調用中不同類型參數得區別之後,再來理解函數聲明中不同參數得區別就簡單很多了.
1. 函數聲明中的參數類型說明
函數聲明只有3種類型, arg, *arg , **arg 他們得作用和函數調用剛好相反.
調用時*tuple_grp_nonkw_args將列表轉換為順序參數,而聲明中的*arg的作用是將順序賦值(positional_args)轉換為列表.
調用時**dict_grp_kw_args將字典轉換為關鍵字參數,而聲明中**arg則反過來將關鍵字參數(keyword_args)轉換為字典.
特別提醒：*arg
和 **arg可以為空值.
以下舉例說明上述規則:
復制代碼
代碼如下:
#arg, *arg和**arg作用舉例
def
test2(a,*b,**c):
print a,b,c
#
#*arg 和
**arg可以不傳遞參數
>>> test2(1)
1 () {}
#arg必須傳遞參數
>>>
test2()
Traceback (most recent call last):
File "<stdin>", line 1,
in <mole>
TypeError: test2() takes at least 1 argument (0 given)
#
#*arg將順positional_args轉換為列表
>>>
test2(1,2,[1,2],{'a':1,'b':2})
1 (2, [1, 2], {'a': 1, 'b': 2})
{}
#該處理等價於
a = 1 #arg參數處理
b = 2,[1,2],{'a':1,'b':2} #*arg參數處理
c =
dict() #**arg參數處理
print a,b,c
#
#**arg將keyword_args轉換為字典
>>>
test2(1,2,3,d={1:2,3:4}, c=12, b=1)
1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:
4}}
#該處理等價於
a = 1 #arg參數處理
b= 2,3 #*arg參數處理
#**arg參數處理
c =
dict()
c['d'] = {1:2, 3:4}
c['c'] = 12
c['b'] = 1
print
a,b,c
2. 處理順序問題
函數總是先處理arg類型參數,再處理*arg和**arg類型的參數.
因為*arg和**arg針對的調用參數類型不同,所以不需要考慮他們得順序.
復制代碼
代碼如下:
def test2(a,*b,**c):
print
a,b,c
>>> test2(1, b=[1,2,3], c={1:2, 3:4},a=1)
Traceback (most
recent call last):
File "<stdin>", line 1, in
<mole>
TypeError: test2() got multiple values for keyword argument
'a'
#這里會報錯得原因是,總是先處理arg類型得參數
#該函數調用等價於
#處理arg類型參數:
a = 1
a = 1
#多次賦值,導致異常
#處理其他類型參數
...
print a,b,c
>>> def foo(x,y):
... def bar():
... print
x,y
... return bar
...
#查看func_closure的引用信息
>>> a =
[1,2]
>>> b = foo(a,0)
>>>
b.func_closure[0].cell_contents
[1, 2]
>>>
b.func_closure[1].cell_contents
0
>>> b()
[1, 2] 0
#可變對象仍然能被修改
>>> a.append(3)
>>>
b.func_closure[0].cell_contents
[1, 2, 3]
>>> b()
[1, 2, 3] 0
❼ 簡述python函數中參數的幾種形態
在調用函數時，通常會傳遞參數，函數內部的代碼保持不變，針對 不同的參數處理不同的數據。
有位置傳參、關鍵字傳參、默認值參數、多值參數等。
1、參數傳遞
形參和實參：
形參：定義 函數時的 參數變數
實參：調用 函數時，使用的參數變數
參數傳遞的過程，就是 把實參的引用 傳遞給 形參 ，使用實參的值來執行函數體的過程。
在 Python 中，函數的 實參/返回值 都是是靠 引用 來傳遞來的
2、位置實參
按照參數位置，依次傳遞參數，這是最普通的方式。