python類方法參數

A. 我解釋一下python的類方法為什麼要寫一個self參數

類(class)初始化之後會得到實例(instance)。
self就是用於代表初始化的到的實例。
明確地寫一個self參數，使得類的方法(method)和普通的函數(function)本質上沒有差異，所有的輸入參數都顯示地傳遞到方法/函數當中。
當然作為類的方法，作用的對象一定會是實例，因而在Python的設計之初，完全可以設計成self不作為一個參數，但是那樣就需要一個關鍵字代表實例，比如在javascript中就是this。
然而Python的哲學是"Explicit
is
better
than
implicit."，顯示要比隱示好，因此Python類的方法需要一個self參數代表實例是符合邏輯的。

B. 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}

C. python類參數有什麼用

類的變數 由一個類的所有對象（實例）共享使用。只有一個類變數的拷貝，所以當某個對象
對類的變數做了改動的時候，這個改動會反映到所有其他的實例上。

看下面例子就明白了，所有Person的實例共享一個類參數population，但每一個實例自己的參數和方法不共享

class Person:
'''Represents a person.'''
population = 0
def __init__(self, name):
'''Initializes the person's data.'''
self.name = name
print '(Initializing %s)' % self.name
# When this person is created, he/she
# adds to the population
Person.population += 1
def __del__(self):
'''I am dying.'''
print '%s says bye.' % self.name
Person.population -= 1
if Person.population == 0:
print 'I am the last one.'
else:
print 'There are still %d people left.' % Person.population
def sayHi(self):
'''Greeting by the person.
Really, that's all it does.'''
print 'Hi, my name is %s.' % self.name
def howMany(self):
'''Prints the current population.'''
if Person.population == 1:
print 'I am the only person here.'
else:
print 'We have %d persons here.' % Person.population
swaroop = Person('Swaroop')
swaroop.sayHi()
swaroop.howMany()
kalam = Person('Abl Kalam')
kalam.sayHi()
kalam.howMany()
swaroop.sayHi()
swaroop.howMany()

D. python類可以傳遞參數嗎

python類可以傳遞參數。方法是：採用__init__初始化方法進行對象傳參，實例化時傳入所需參數。
在Python中類傳遞參數一般採用__init__的方法進行傳遞，如下：
列印結果表示我們傳入的'xiaoming'和15已經成功傳遞到實例xiaoming對象中。
推薦課程：Python入門與進階教學視頻（極客學院）

E. python類的調用,方法中的參數

調用方法是對的。參數headers和message寫入到括弧即可。

t.on_message(headers, message)

self參數在調用時可以省略，因為變數 t 已經指明了。

F. python的類方法為什麼要寫一個self參數

原因有多種。首先是python中幾乎所有的東西的一級對象（一級對象的定義：http://en.wikipedia.org/wiki/First-class_object），method也不例外，比如你寫一個:
class X:
def f(self, a, b):
...
那麼可以這樣引用f：
X.__dict__['f']
或者
X.f.__func__
現在問題來了，得到f以後怎麼調用？f是一個方法，方法必須作用於對象。如果x是一個X對象，我們可以x.f(...)，但是如果是以上面的方式得到的f呢？怎麼f讓作用於某個對象？最直觀的方法就是和參數一起傳遞進去。
當然的限不同的設計也可以滿足上面制。比如不要手寫的self參數，增加this關鍵字，增加一個調用f個格式。這樣的設計和pep20第二條不符合。
為理解python的self，不妨對比一下ruby和javascript。ruby的方式是方法不是一級對象，所以繞過了這個問題。javascript沒有類，方法在調用時this會綁定到方法所屬的對象，函數調用時this綁定到window，函數做構造器調用時this綁定到新對象。這么多規則，比Python復雜。

G. Python 使用類直接調用方法的時候 要忽略第一個參數嗎

一般情況下，第一個參數是self,調用時不需要傳遞。
使用裝飾器@staticmethod修飾的方法，第一個參數不是self，因此調用時不能忽略第一個參數：

class MyTool(object):
def max_list_1(self, nums):
'''這個方法有兩個參數,但調用時不需要傳第一個參數'''
i_max = None
for i in range(len(nums)):
if i_max is None:
i_max = i
elif len(nums[i_max]) < len(nums[i]):
i_max = i
return i_max

@staticmethod
def max_list_2(nums):
'''這個方法只有一個參數'''
i_max = None
for i in range(len(nums)):
if i_max is None:
i_max = i
elif len(nums[i_max]) < len(nums[i]):
i_max = i
return i_max

data = [[1,2,3,4,5],
['a','b','c','d','e','r','t'],
[9999],]
tool= MyTool()
print(tool.max_list_1(data))
print(tool.max_list_2(data))

H. python 如何向類方法傳入參數

classhello(object):
defworld(self,msg):
printmsg
c=hello()
c.world('helloworld')

I. 關於python的類的參數

你這樣帶參數實例化，是你有一個帶參數的構造函數

J. 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)