python从设计之初就已经是一门面向对象的语言，正因为如此，在python中创建一个类和对象是很容易的。
方法包括：实例方法、静态方法和类方法，三种方法在内存中都归属于类，区别在于调用方式不同。
实例方法：由对象调用；至少一个self参数；执行普通方法时，自动将调用该方法的对象赋值给self；
类方法：由类调用； 至少一个cls参数；执行类方法时，自动将调用该方法的类复制给cls；
静态方法：由类调用；无默认参数。
实例方法
class kls(object): def __init__(self, data): self.data = data def printd(self): print(self.data)ik1 = kls('leo')ik2 = kls('lee')ik1.printd()ik2.printd()
输出：
leo lee
上述例子中，printd为一个实例方法。实例方法第一个参数为self，当使用ik1.printd()调用实例方法时，实例ik1会传递给self参数，这样self参数就可以引用当前正在调用实例方法的实例。利用实例方法的这个特性，上述代码正确输出了两个实例的成员数据。
相关推荐：《python视频教程》
类方法
python 的类方法采用装饰器@classmethod来定义，我们直接看例子。
class kls(object): num_inst = 0 def __init__(self): kls.num_inst = kls.num_inst + 1 @classmethod def get_no_of_instance(cls): return cls.num_instik1 = kls()ik2 = kls()print ik1.get_no_of_instance()print kls.get_no_of_instance()
输出：
2 2
在上述例子中，我们需要统计类kls实例的个数，因此定义了一个类变量num_inst来存放实例个数。通过装饰器@classmethod的使用，方法get_no_of_instance被定义成一个类方法。在调用类方法时，python 会将类（class kls）传递给cls，这样在get_no_of_instance内部就可以引用类变量num_inst。
由于在调用类方法时，只需要将类型本身传递给类方法，因此，既可以通过类也可以通过实例来调用类方法。
静态方法
在开发中，我们常常需要定义一些方法，这些方法跟类有关，但在实现时并不需要引用类或者实例，例如，设置环境变量，修改另一个类的变量，等。这个时候，我们可以使用静态方法。
python 使用装饰器@staticmethod来定义一个静态方法。
ind = 'on'
class kls(object): def __init__(self, data): self.data = data @staticmethod def checkind(): return ind == 'on' def do_reset(self): if self.checkind(): print('reset done for: %s' % self.data) def set_db(self): if self.checkind(): print('db connection made for: %s' % self.data)ik1 = kls(24)ik1.do_reset()ik1.set_db()
输出：
reset done for: 24 db connection made for: 24
在代码中，我们定义了一个全局变量ind，由于ind跟类kls相关，所以我们将方法checkind放置在类kls中定义。方法checkind只需检查ind的值，而不需要引用类或者实例，因此，我们将方法checkind定义为静态方法。
对于静态方法，python 并不需要传递类或者实例，因此，既可以使用类也可以使用实例来调用静态方法。
实例方法，类方法与静态方法的区别
我们用代码说明实例方法，类方法，静态方法的区别。注意下述代码中方法foo，class_foo，static_foo的定义以及使用。
class kls(object): def foo(self, x): print('executing foo(%s,%s)' % (self, x)) @classmethod def class_foo(cls,x): print('executing class_foo(%s,%s)' % (cls,x)) @staticmethod def static_foo(x): print('executing static_foo(%s)' % x)ik = kls()# 实例方法ik.foo(1)print(ik.foo)print('==========================================')# 类方法ik.class_foo(1)kls.class_foo(1)print(ik.class_foo)print('==========================================')# 静态方法ik.static_foo(1)kls.static_foo('hi')print(ik.static_foo)
输出：
executing foo(<__main__.kls object at 0x0551e190>,1)<bound method kls.foo of <__main__.kls object at 0x0551e190>>==========================================executing class_foo(<class '__main__.kls'>,1)executing class_foo(<class '__main__.kls'>,1)<bound method type.class_foo of <class '__main__.kls'>>==========================================executing static_foo(1)executing static_foo(hi)<function static_foo at 0x055238b0>
对于实例方法，调用时会把实例ik作为第一个参数传递给self参数。因此，调用ik.foo(1)时输出了实例ik的地址。
对于类方法，调用时会把类kls作为第一个参数传递给cls参数。因此，调用ik.class_foo(1)时输出了kls类型信息。
前面提到，可以通过类也可以通过实例来调用类方法，在上述代码中，我们再一次进行了验证。
对于静态方法，调用时并不需要传递类或者实例。其实，静态方法很像我们在类外定义的函数，只不过静态方法可以通过类或者实例来调用而已。
值得注意的是，在上述例子中，foo只是个函数，但当调用ik.foo的时候我们得到的是一个已经跟实例ik绑定的函数。调用foo时需要两个参数，但调用ik.foo时只需要一个参数。foo跟ik进行了绑定，因此，当我们打印ik.foo时，会看到以下输出:
<bound method kls.foo of <__main__.kls object at 0x0551e190>>
当调用ik.class_foo时，由于class_foo是类方法，因此，class_foo跟kls进行了绑定（而不是跟ik绑定）。当我们打印ik.class_foo时，输出：
<bound method type.class_foo of <class '__main__.kls'>>
当调用ik.static_foo时，静态方法并不会与类或者实例绑定，因此，打印ik.static_foo（或者kls.static_foo）时输出：
<function static_foo at 0x055238b0>
概括来说，是否与类或者实例进行绑定，这就是实例方法，类方法，静态方法的区别。
以上就是python面向对象方法的区别的详细内容。