① 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教程