python中的实例方法、静态方法、类方法、类变量和实例变量浅析

这篇文章主要介绍了python中的实例方法、静态方法、类方法、类变量和实例变量浅析。。。
一、实例方法

实例方法就是类的实例能够使用的方法。如下：

class Foo:
    def __init__(self, name):
        self.name = name
    def hi(self):
        print self.name

if __name__ == '__main__':
    f = Foo('python')
    f.hi()
    print type(f)
    print type(Foo)
    print id(f)
    print id(Foo)

运行结果为：
python
<type 'instance'>
<type 'classobj'>
45491424
8351224
可以看到，Foo的type为classobj（类对象，python中定义的类本身也是对象），f的type为instance（实例）。
而hi()是实例方法，所以f.hi()会输出'python'。实例方法的第一个参数默认为self，代指调用该方法的当前实例。
self不是一个关键字，而是约定的写法。__init__()是生成实例时默认(自动)调用的实例方法。
也可以将Foo的定义改为以下形式，运行依然正确：

class Foo:
    def __init__(this, name): #第一个参数写成self，是一种约定的（习惯上的）写法，并不是必须的。写成this也可以。
        this.name = name
    def hi(here): #第一个参数写成self，是一种约定的（习惯上的）写法，并不是必须的。写成here（或其他）也可以。
        print here.name

if __name__ == '__main__':
    f = Foo('python')
    f.hi()
    print type(f)
    print type(Foo)
    print id(f)
    print id(Foo)

内置函数id用来查看对象的标识符，下面是其doc内容：

>>> print id.__doc__
id(object) -> integer

Return the identity of an object.  This is guaranteed to be unique among
simultaneously existing objects.  (Hint: it's the object's memory address.)
>>>

二、静态方法
静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。
使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法：

class Foo:
    def __init__(self, name):
        self.name = name
    def hi(self):
        print self.name
    #静态方法属于类，所有实例可以共享
    #静态方法可以（在没有生成实例的时候）通过类名直接调用，因此没有self参数
    @staticmethod
    def add(a, b):
        print a + b

if __name__ == '__main__':
    Foo.add(1, 2)#通过类名直接调用静态方法
    f=Foo('python')
    f.hi()
    f.add(1,2)   #通过实例调用静态方法

运行结果如下：
3
python
3
注意，很多编程语言不允许实例调用静态方法。python可以！！！
三、类方法
类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。
类对象和实例都可以调用类方法：

class Foo:
    name = 'python!'#类属性，可以通过类名直接访问
    #使用@classmethod装饰器定义类方法，其第一个参数是类，约定写为cls
    @classmethod
    def hi(cls, x):
        print cls.name * x

if __name__ == '__main__':
    f=Foo()
    f.hi(2)   #通过实例调用类方法
    Foo.hi(3) #通过类名调用类方法

运行结果如下：
python!python!
python!python!python!
注意，很多其他的编程语言不允许实例调用类方法。python可以!!!
四、super
super用来执行父类中的函数，例如：

class Foo(object):
    def hi(self):
        print 'hi,Foo'

class Foo2(Foo):
    def hi(self):
        super(Foo2,self).hi()
        print 'hi,Foo2'

if __name__ == '__main__':
    f2 = Foo2()
    f2.hi()

运行结果：
hi,Foo
hi,Foo2
注意，Foo类必须继承某个类（并且这个继承链开始于object类！！！），如果改成下面的形式，就会报错：

class Foo:　#此处应该继承object类
    def hi(self):
        print 'hi,Foo'

class Foo2(Foo):
    def hi(self):
        super(Foo2, self).hi() #通过super来调用父类中的方法，要求继承链开始于object类，否则报错：TypeError

if __name__ == '__main__':
    f2 = Foo2()
    f2.hi()

五、类变量和实例变量
类变量定义在类的定义之后，实例变量则是以为self.开头。例如：

class Foo(object):
    val = 0 #类变量
    def __init__(self):
        self.val = 1 #实例变量

if __name__ == '__main__':
    f= Foo()
    print f.val    # 1
    print Foo.val  # 0

实例也能够访问类变量，如下：

class Foo(object):
    val = 0 #类变量。当实例自己没有val变量，却硬要访问val时，实际上访问的是类的val变量
    def __init__(self):#生成实例时，实例自身并没有val变量
        pass
if __name__ == '__main__':
    f = Foo()
    print f.val   # 0  访问的实际上是类的val变量
    print Foo.val # 0

另外，可以通过以下方式访问类变量：

class Foo(object):
    val = 3 #类变量
    def __init__(self,x):
        print 'Foo.__init__ is called!'
        self.val=x
if __name__ == '__main__':
    f = Foo(10)
    print f.__class__     #查看实例f所属的类
    print f.__class__.val #查看类变量val
    print Foo.val         #查看类变量val

运行结果：
Foo.__init__ is called!
<class '__main__.Foo'>
3
3
还可以这样访问类变量：

class Foo(object):
    val = 3 #类变量，可以通过类名直接访问
    def __init__(self):
        pass
    #定义类方法，可以通过类名直接调用
    @classmethod
    def echo(cls):
        print cls.val
if __name__ == '__main__':
    Foo.echo()  # 3

六、如何调用父类的构造函数
子类（派生类）并不会自动调用父类（基类）的__init__方法，例如：

class Foo(object):
    def __init__(self):
        self.val = 1

class Foo2(Foo):
    def __init__(self):
        print self.val #报错 AttributeError: 'Foo2' object has no attribute 'val'

if __name__ == '__main__':
    f2 = Foo2()

调用父类的init方法有两种，第一种：

class Foo(object):#也可以不继承object
    def __init__(self):
        self.val = 1

class Foo2(Foo):
    def __init__(self):
        Foo.__init__(self)#通过该方法调用父类的__init__方法，并不要求继承链开始于object类
        print self.val

if __name__ == '__main__':
    f2 = Foo2()

第二种：

class Foo(object):#继承链必须开始于object类（新式类）
    def __init__(self):
        self.val = 1

class Foo2(Foo):
    def __init__(self):
        super(Foo2,self).__init__()#通过super调用父类的方法，要求继承链必须开始于object类
        print self.val

if __name__ == '__main__':
    f2 = Foo2()

上述两种方法的运行结果均为：1

 原文链接：http://www.jb51.net/article/49402.htm