在 Python 中，实例方法（instance method），类方法（class method）与静态方法（static method）经常容易混淆。本文通过代码例子来说明它们的区别。
 
实例方法
 
Python 的实例方法用得最多，也最常见。我们先来看 Python 的实例方法。
 
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 的类方法采用装饰器@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_inst


ik1 = 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>
 
概括来说，是否与类或者实例进行绑定，这就是实例方法，类方法，静态方法的区别。
 
参考资料
 
https://www.pythoncentral.io/difference-between-staticmethod-and-classmethod-in-python/
https://taizilongxu.gitbooks.io/stackoverflow-about-python/content/14/README.html
https://kuanghy.github.io/2015/12/19/python-variable
https://stackoverflow.com/questions/136097/what-is-the-difference-between-staticmethod-and-classmethod-in-python

python类的实例方法、静态方法和类方法区别及其应用场景
 
一、先看语法，python 类语法中有三种方法，实例方法，静态方法，类方法。
 
 
 
ps.python中self，cls的区别
 
普通实例方法，第一个参数需要是self，它表示一个具体的实例本身。
 如果用了staticmethod，那么就可以无视这个self，而将这个方法当成一个普通的函数使用。
 而对于classmethod，它的第一个参数不是self，是cls，它表示这个类本身。
 
# coding:utf-8
class Foo(object):
    """类三种方法语法形式"""

    def instance_method(self):
        print("是类{}的实例方法，只能被实例对象调用".format(Foo))

    @staticmethod
    def static_method():
        print("是静态方法")

    @classmethod
    def class_method(cls):
        print("是类方法")

foo = Foo()
foo.instance_method()
foo.static_method()
foo.class_method()
print('----------------')
Foo.static_method()
Foo.class_method()
 
运行结果如下
 
是类<class '__main__.Foo'>的实例方法，只能被实例对象调用
是静态方法
是类方法
----------------
是静态方法
是类方法
 
说明：
 
实例方法只能被实例对象调用，静态方法(由@staticmethod装饰的方法)、类方法(由@classmethod装饰的方法)，可以被类或类的实例对象调用。
 
实例方法，第一个参数必须要默认传实例对象，一般习惯用self。
 静态方法，参数没有要求。
 
类方法，第一个参数必须要默认传类，一般习惯用cls。
 
二、静态方法、类方法使用区别或者说使用场景
 
 
 
1、类方法用在模拟java定义多个构造函数的情况。
 
 由于python类中只能有一个初始化方法，不能按照不同的情况初始化类。
 
参考django https://docs.djangoproject.com/en/1.9/ref/models/instances/ 请看下面的代码。
 
# coding:utf-8
class Book(object):

    def __init__(self, title):
        self.title = title

    @classmethod
    def class_method_create(cls, title):
        book = cls(title=title)
        return book

    @staticmethod
    def static_method_create(title):
        book= Book(title)
        return book

book1 = Book("use instance_method_create book instance")
book2 = Book.class_method_create("use class_method_create book instance")
book3 = Book.static_method_create("use static_method_create book instance")
print(book1.title)
print(book2.title)
print(book3.title)
 
结果：
 
use instance_method_create book instance
use class_method_create book instance
use static_method_create book instance

Process finished with exit code 0
 
特别说明，静态方法也可以实现上面功能，当静态方法每次都要写上类的名字，不方便。

2、类中静态方法方法调用静态方法和类方法调用静态方法例子。
 下面的代码，静态方法调用另一个静态方法，如果改用类方法调用静态方法，可以让cls代替类，
 
让代码看起来精简一些。也防止类名修改了，不用在类定义中修改原来的类名。
 
# coding:utf-8
class Foo(object):
    X = 1
    Y = 2

    @staticmethod
    def averag(*mixes):
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # 在静态方法中调用静态方法
        print "在静态方法中调用静态方法"
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):  # 在类方法中使用静态方法
        print "在类方法中使用静态方法"
        return cls.averag(cls.X, cls.Y)

foo = Foo()
print(foo.static_method())
print(foo.class_method())
 
结果：
 
 
 
在静态方法中调用静态方法
 1
 在类方法中使用静态方法
 1
 
 
3、继承类中的区别 
 
从下面代码可以看出，如果子类继承父类的方法，子类覆盖了父类的静态方法，
 子类的实例继承了父类的static_method静态方法，调用该方法，还是调用的父类的方法和类属性。
 
子类的实例继承了父类的class_method类方法，调用该方法，调用的是子类的方法和子类的类属性。
 
# coding:utf-8
class Foo(object):
    X = 1
    Y = 14

    @staticmethod
    def averag(*mixes):  # "父类中的静态方法"
        return sum(mixes) / len(mixes)

    @staticmethod
    def static_method():  # "父类中的静态方法"
        print "父类中的静态方法"
        return Foo.averag(Foo.X, Foo.Y)

    @classmethod
    def class_method(cls):  # 父类中的类方法
        print "父类中的类方法"
        return cls.averag(cls.X, cls.Y)


class Son(Foo):
    X = 3
    Y = 5

    @staticmethod
    def averag(*mixes):  # "子类中重载了父类的静态方法"
        print "子类中重载了父类的静态方法"
        print "666 ",mixes
        return sum(mixes) / 3

p = Son()
print "result of p.averag(1,5)"
print (p.averag(1,5))
print "result of p.static_method()"
print(p.static_method())
print "result of p.class_method()"
print(p.class_method())
 
结果如下：
 
 
 
result of p.averag(1,5)
 子类中重载了父类的静态方法
 666  (1, 5)
 2
 result of p.static_method()
 父类中的静态方法
 7
 result of p.class_method()
 父类中的类方法
 子类中重载了父类的静态方法
 666  (3, 5)
 2
 
 
Process finished with exit code 0
 
 
参考网址：https://zhuanlan.zhihu.com/p/21101992

静态方法和类方法
 
Python类包含三种方法：实例方法、静态方法和类方法。其中，实例方法在前面的章节已经多次使用了。要想调用实例方法，必须要实例化类，然后才可以调用。也就是说，调用实例化方法需要类的实例(对象)。而静态方法在调用时根本不需要类的实例(静态方法不需要self参数)，这一点和其他编程语言完全一样。
 
类方法的调用方式与静态方法完全一样，所不同的是，类方法与实例方法的定义方式相同，都需要一个self参数，只不过这个self参数的含义不同。对于实例方法来说，这个self参数就代表当前类的实例，可以通过self访问对象中的方法和属性。而类方法的self参数表示类的元数据，也就是类本身，不能通过self参数访问对象中的方法和属性，只能通过这个self参数访问类的静态方法和静态属性。
 
定义静态方法需要使用@staticmethod装饰器(decorator)，定义类方法需要使用@classmethod装饰器。
 
class Myclass:
    # 实例方法
    def instancemethod(self):
        pass
    # 静态方法
    @staticmethod
    def staticmethod():
        pass
    # 类方法
    @classmethod
    def classmethod(self):
        pass
 
[例 10.9] 本例演示了如何定义实例方法、静态方法和类方法，并演示了如何调用这些方法
 
class Myclass:
    # 定义一个静态变量，可以被静态方法和类方法访问
    name = 'Bill'
    def __init__(self):
        print('Myclass的构造方法被调用')
        # 定义实例变量，静态方法和类方法不能访问该变量
        self.value = 20
    # 定义静态方法
    @staticmethod
    def run():
        # 访问Myclass类中的静态变量name
        print('*', Myclass.name, '*')
        print('Myclass的静态方法run被调用')

    # 定义类方法
    @classmethod
    # 这里self是类的元数据，不是类的实例
    def do(self):
        print(self)
        # 访问Myclass类中的静态变量name
        print('[', self.name, ']')
        print('调用静态方法run')
        self.run()
        # 在类方法中不能访问实例变量，否则会抛出异常（因为实例变量需要用类的实例访问） print(self.value)
        print('成员方法do被调用')
    # 定义实例方法
    def do1(self):
        print(self.value)
        print('<', self.name, '>')
        print(self)
# 调用静态方法run
Myclass.run()
# 创建Myclass类的实例
c = Myclass()
# 通过类的实例也可以调用类方法
c.do()
# 通过类访问类的静态变量
print('Myclass2.name', '=', Myclass.name)
# 通过类调用类方法
Myclass.do()
# 通过类的实例访问实例方法
c.do1()
 
输出结果：
 
* Bill *
Myclass的静态方法run被调用
Myclass的构造方法被调用
<class '__main__.Myclass'>
[ Bill ]
调用静态方法run
* Bill *
Myclass的静态方法run被调用
成员方法do被调用
Myclass2.name = Bill
<class '__main__.Myclass'>
[ Bill ]
调用静态方法run
* Bill *
Myclass的静态方法run被调用
成员方法do被调用
20
< Bill >
<__main__.Myclass object at 0x10d5bcd30>
 
从实例方法、静态方法和类方法的调用规则可以得出以下结论：
 
通过实例定义的变量只能被实例方法访问，而直接在类中定义的静态变量(如本例的name变量)即可以被实例方法访问，也可以被静态方法和类方法访问。实例方法不能被静态方法和类方法访问，但静态方法和类方法可以被实例方法访问。

 
【
 
 
静态方法：
1、在被实例化之前就已经存在于内存中，
2、静态方法是类所有对象共有的方法，
3、可被类或对象调用；
非静态方法：
1、在类被实例化之后，才加载到内存中，具体存储在堆中；
2、非静态方法被对象所私有；
3、只能用对象调用（那静态方法中的非静态类呢，猜测，也一起被加载到内存）
 
 
类是封装好的，像一个模型
对象是由类实例化的，像一个具体的样本
类中的只有静态方法可以使用
 
 
类方法（静态方法）是直接可以使用类引用，不需要实例化就可以使用的方法，一般在项目中类方法都是设置为工具类使用的
 
 
】
 
 
类实例化了就是对象，
 
 
类的方法不能用，除了static方法，
 
 
对象的方法不是static的也可用，
 
 
用类名引用的就是类方法，
 
 
用对象名引用的就是对象方法。
 
 

比如
 
 
class a
a ddfdf=new a();
a.f();  //这个是类的方法，这个方法必得是静态的才行。通常用来取得类的选代器或取的类本身的一个对象
ddfdf.f();  //这个是对象方法。
 
 
 
 
 
静态方法必须定义成static的，在类被实例化以前就已经存在于内存中
静态方法是所有该类的实例也就是对象共有的方法
非静态方法，
只有在类Test被实例化以后，才被加载到内存中，具体存储在堆中，
非静态方法是每个该类的实例也就是对象所私有的
静态方法必须既可以用类名直接调用，也可以用对象来调用
非静态方法只能用对象来调用
 
 
 
 
 
类是封装好的，像一个模型；对象是由类实例化的，也就像一个具体的样本！通俗来说吧，比如说“人”就是一个类，而你就是一个实例即对象
 
 
 
 
 
类和对象的区别
1，类是一个抽象的概念，它不存在于现实中的时间/空间里，类只是为所有的对象定义了抽象的属性与行为。就好像“Person（人）”这个类，它虽然可以包含很多个体，但它本身不存在于现实世界上。
2，对象是类的一个具体。它是一个实实在在存在的东西。
3，类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何对象时，类本身不存在于内存空间中。
4，对象是一个动态的概念。每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为。对象的属性可以随着它自己的行为而发生改变。
 
 
 
 
 
一、类和对象的区别
1、定义不同
 
 
类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。
 
 
对象是具有类类型的变量。类和对象是面向对象编程技术中的最基本的概念。
 
 
2、范畴不同
 
 
类是一个抽象的概念，它不存在于现实中的时间、空间里，类知识为所有的对象定义了抽象的属性与行为。 
 
 
对象是类的一个具体。它是一个实实在在存在的东西。 
 
 
3、状态不同
 
 
类是一个静态的概念，类本身不携带任何数据。当没有为类创建任何数据时，类本身不存在于内存空间 
 
 
对象是一个动态的概念，每一个对象都存在着有别于其它对象的属于自己的独特的属性和行为，属性可以随着它自己的行为而发生改变。
 
 
二、类和对象的关系
 
 
类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。
 
 
类与对象的关系就如模具和铸件的关系 类的实例化结果就是对象，而对一类对象的抽象就是类，类描述了一组有相同属性和相同方法的对象。
 
 
扩展资料
 
 
使用类时的注意事项：
 
 
1、类的成员可以是其他类的对象，但不能以类自身的对象作为本类的成员，而类自身的指针和引用可以作为类的成员。
 
 
2、类定义必须以分号“；”结束。
 
 
3、类与结构体的区别：没有明确指定类成员的访问权限时，C++结构体的成员是公有的，而类的成员是私有的。
 
 
 
 
 
类是一个抽象的概念；
而对象是类抽象概念的实物表达；
打个比方：
比如水果摊进了一批水果（就好比是类）；
然后就去问卖家有哪些新鲜的水果；
店家说有苹果、梨、桃等等（这里的苹果、梨、桃就是对象）；
也就是说对象是类的具体表达；
而类则是对象的抽象表达。
 
 
 
 
 
类方法必须既可以用类名直接调用，也可以用对象来调用；对象方法只能用对象来调用。
 
 
 
 
 
实例方法是建立实例才有的方法
类方法是直接可以使用类引用，不需要实例化就可以使用的方法，一般在项目中类方法都是设置为工具类使用的
 
 
实例方法是必须创建了一个类的实例之后才能调用的方法 属于一个特定的实例 调用方法为 实例名.方法名();
而类方法是属于一个类的 是类的静态方法。可以一用类字节调用 ；调用方法是 类名.方法名();
类方法主要用于工具类的方法。
 
转载于:https://www.cnblogs.com/arrows/p/10407476.html