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

    原文作者:快递小可
    原文地址: https://blog.csdn.net/sxingming/article/details/52457724
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞