① python和靜態方法問題，怎麼解決
在學習python代碼時，看到有的類的方法中第一參數是cls，有的是self，經過了解得知，python並沒有對類中方法的第一個參數名字做限制，可以是self，也可以是cls，不過根據人們的慣用用法，self一般是在實例方法中使用，而cls則一般在類方法中使用，在靜態方法中則不需要使用一個默認參數。在下面的代碼中，InstanceMethod類的方法中，第一個參數是默認的self，在這里可以把self換成任何名字來表示，不會有任何影響。在類調用的時候，需要滿足參數的個數要求（參數中含有*args是例外)，例如13行中，類調用沒有參數的時候，會提示錯誤。同樣，實例方法的參數個數也應該滿足要求，例如16行中也會報錯。實例方法的一個主要特點就是需要綁定到一個對象上，python解析器會自動把實例自身傳遞給方法，如14行所示，而直接使用InstanceMethod.f1()調用方法是不行的。
12345678910111213
class InstanceMethod(object): def __init__(self, a): self.a = a def f1(self): print 'This is {0}.'.format(self) def f2(self, a): print 'Value:{0}'.format(a)if __name__ == '__main__': # im = InstanceMethod() im = InstanceMethod('233') im.f1() # im.f2() im.f2(233)
靜態方法和類方法都需要使用修飾器，分別使用的是staticmethod和classmethod。靜態方法是和類沒有關系的，我覺得就是包裝在類中的一般方法，如下例子中，調用靜態方法使用實例和不使用實例都是可以的。類方法中，默認的第一個參數使用的是cls，類方法也可以不需要實例而直接使用類調用。對於這三種不同的方法，使用方法如下例所示。那麼問題來了，既然有了實例方法，類方法和靜態方法與之相比又有什麼好處呢？
在類方法中，不管是使用實例還是類調用方法，都會把類作為第一個參數傳遞進來，這個參數就是類本身。如果繼承了這個使用類方法的類，該類的所有子類都會擁有了這個方法，並且這個方法會自動指向子類本身，這個特性在工廠函數中是非常有用的。靜態方法是和類與實例都沒有關系的，完全可以使用一般方法代替，但是使用靜態方法可以更好的組織代碼，防止代碼變大後變得比較混亂。類方法是可以替代靜態方法的。靜態方法不能在繼承中修改。
123456789101112131415161718
class test(object): def instance_method(self): print 'This is {0}'.format(self) @staticmethod def static_method(): print 'This is static method.' @classmethod def class_method(cls): print 'This is {0}'.format(cls)if __name__ == '__main__': a = test() a.instance_method() a.static_method() a.class_method() print '----------------------------------------' # test.instance_method() test.static_method() test.class_method()
② python類方法和靜態方法的區別
面相對象程序設計中，類方法和靜態方法是經常用到的兩個術語。
邏輯上講：類方法是只能由類名調用；靜態方法可以由類名或對象名進行調用。
在C++中，靜態方法與類方法邏輯上是等價的，只有一個概念，不會混淆。
而在python中，方法分為三類實例方法、類方法、靜態方法。代碼如下：
class Test(object):
def InstanceFun(self):
print("InstanceFun");
print(self);
@classmethod
def ClassFun(cls):
print("ClassFun");
print(cls);
@staticmethod
def StaticFun():
print("StaticFun");
t = Test();
t.InstanceFun();＃ 輸出InstanceFun，列印對象內存地址「<__main__.Test object at 0x0293DCF0>」
Test.ClassFun(); # 輸出ClassFun，列印類位置 <class '__main__.Test'>
Test.StaticFun(); # 輸出StaticFun
t.StaticFun(); # 輸出StaticFun
t.ClassFun(); # 輸出ClassFun，列印類位置 <class '__main__.Test'>
Test.InstanceFun(); # 錯誤，TypeError: unbound method instanceFun() must be called with Test instance as first argument
Test.InstanceFun(t); # 輸出InstanceFun，列印對象內存地址「<__main__.Test object at 0x0293DCF0>」
t.ClassFun(Test); # 錯誤 classFun() takes exactly 1 argument (2 given)
可以看到，在PYTHON中，兩種方法的主要區別在於參數。實例方法隱含的參數為類實例self，而類方法隱含的參數為類本身cls。
靜態方法無隱含參數，主要為了類實例也可以直接調用靜態方法。
所以邏輯上類方法應當只被類調用，實例方法實例調用，靜態方法兩者都能調用。主要區別在於參數傳遞上的區別，實例方法悄悄傳遞的是self引用作為參數，而類方法悄悄傳遞的是cls引用作為參數。
Python實現了一定的靈活性使得類方法和靜態方法，都能夠被實例和類二者調用
③ python中self和cls的區別
self 一般指類的實例
cls 一般用在 @classmethod 裝飾下的類的方法，cls 指的是類，cls() 可以得到類的實例。
④ 為什麼類B的__new__方法的第一個參數是self，而不是cls，還有就是為什麼類B的__init__方法沒有被調用
self,cls都不是python的關鍵字，只不過是一個習慣上的標志符名，換成其它任意標志符名也是一樣的，僅僅是占個位，由python解釋器自動傳遞該參數。__new__是類級別的方法，雖然它寫的self，但實際這個self指代的類本身。
你B實例化時帶了兩個參數，但類__init__方法定義里並沒有帶兩個參數的，所以只調用了帶兩參數的__new__，沒調用__init__了。
⑤ Python 中的 classmethod 和 staticmethod 有什麼具體用途
兩個都是裝飾器，staticmethod是將類的函數聲明為靜態方法，這樣可以直接通過類調用該方法，而不用實例話該對象。
例如
class A（）：
@staticmethod
def test（self）：
print 「hehe」
A.test() 這樣就能調用。
classmethod，是將該裝飾器修飾的函數，第一個參數變為cls（平常是self）。
self指向該類的實例，也就是一個對象，cls指向這個類本身
class A（）：
@classmethod
def test（cls）：
cls.__init__()
print 「hehe」
a = A()
a.test()
這個時候，在test里可以對類進行初始化等等。
就是其修飾的函數，一個是對類的對象操作，一個是對類本身操作
⑥ python cls不能調用self的變數么
普通的方法，第一個參數需要是self，它表示一個具體的實例本身。
如果用了staticmethod，那麼就可以無視這個self，而將這個方法當成一個普通的函數使用。
而對於classmethod，它的第一個參數不是self，是cls，它表示這個類本身。
>>> class A(object):
def foo1(self):
print "Hello",self
@staticmethod
def foo2():
print "hello"
@classmethod
def foo3(cls):
print "hello",cls
>>> a = A()
>>> a.foo1() #最常見的調用方式，但與下面的方式相同
Hello <__main__.A object at 0x9f6abec>
>>> A.foo1(a) #這里傳入實例a，相當於普通方法的self
Hello <__main__.A object at 0x9f6abec>
>>> A.foo2() #這里，由於靜態方法沒有參數，故可以不傳東西
hello
>>> A.foo3() #這里，由於是類方法，因此，它的第一個參數為類本身。
hello <class '__main__.A'>
>>> A #可以看到，直接輸入A，與上面那種調用返回同樣的信息。
<class '__main__.A'>
⑦ python編程 關於類當中一個方法的問題
我想這里你應該不理解的是__new__和__init__的區別所在，下面我就為您解釋一下：
1. 當你需要控制產生一個實例，用__new__；而當你需要控制實例的初始化，用__init__。我們一般在定義Class的時候會先用__init__進行初始化。
2. __new__是創建實例的第一步，之所以是第一步是因為它負責返回這個實例。然而，__init__並不返回任何東西，它只負責當實例被創建之後去初始化這個實例。
3. 總體而言，不需要重復寫__new__除非需要生成一個不可改變的類型，比如字元串，整型，或者數組(tuple)。
那麼在這里，v = cls.__new__(cls, object)就是創建一個實例並返回這個實例。cls就是指你創建的cls本身，就像在__init__(self, param_1, param_2)中的self一樣，而object則是用來初始化的，作用和__init__一樣。由於你這里處理的是數組tuple，這是不可改變的(immutable)類型，所以需要寫__new__，否則是不需要寫的。
下面我給你一個我寫的定義點和向量的類，程序如下：
class Point:
def __init__(self,x,y):
self.x = x
self.y = y
def __str__(self):
return '(' + str(self.x) + ', ' + str(self.y) + ')'
class Vector:
def __init__(self,start_point,end_point):
self.start = start_point
self.end = end_point
def __str__(self)
return "[" + str(self.end.x - self.start.x) + "," + str(self.end.y - self.start.y) + "]"
def length_vector(self):
return math.sqrt( ((self.start.x - self.end.x) *
(self.start.x - self.end.x))
+ ((self.start.y - self.end.y) *
(self.start.y - self.end.y)))
希望能夠幫到你，如果不懂可追問，望採納！
⑧ python3 中定義類函數參數中加 self 和不加的區別在哪
class A:
def fun():
pass
# 這種就是靜態函數，一般用裝飾器 @staticmethod 修飾
class B:
def fun1(self):
pass
# 這種就是成員函數，類實例可以直接調用
@classmethod
def fun():
pass
# 這種是類函數，要求第一個參數表示類（ cls ）。也就是說，除了裝飾器 @classmethod 外，還要求它的定義如 def fun(cls,...)。這是通過類直接調用的，如 A1.fun(...)
昨天也碰到了相同的問題，我在 notebook 裡面有些：
⑨ Python中靜態方法和類方法的區別
靜態方法是調用時跟具體實例沒有關聯的方法，不需要使用self和cls參數。
類方法是調用的時候，要使用類的相關成員的方法，需要使用cls參數，但不用self參數。
參考：劉江的Python教程