码迷,mamicode.com
首页 > 编程语言 > 详细

Python类的继承

时间:2019-11-03 18:26:22      阅读:79      评论:0      收藏:0      [点我收藏+]

标签:魔法   派生   通过   python   pytho   隐藏   for   init   原则   

基本概念

面向对象三要素之一:继承inheritance。人类和猫类都是继承自动物类。

个体继承自父母,继承了父母的一部分特征,但也可以有自己的个性。在面向对象的世界中,从父类继承,就可以直接拥有父类的属性和方法,这样可以减少代码,多复用。子类可以定义自己的属性和方法。

先看一个不用继承的例子:

class Animal:
    def shout(self):
        print("Animal shouts")
        
a = Animal()
a.shout()

class Cat:
    def shout(self):
        print("cat shouts")
        
c = Cat()
c.shout()

结果为:
Animal shouts
cat shouts

上面的两个类虽然有关系,但是定义时并没有建立这种关系,而是各自完成定义。

动物类和猫类都有吃,但是它们的吃有区别,所以分别定义。

class Animal:
    def __init__(self,name):
        self._name = name
        
    def shout(self):#一个通用的吃方法
        print("{} shouts".format(self.__class__.__name__))
        
    @property
    def name(self):
        return self._name
        
a = Animal("monster")
a.shout()

class Cat(Animal):
    pass
        
cat = Cat("garfield")
cat.shout()
print(cat.name)


class Dog(Animal):
    pass
dog = Dog("ahuang")
dog.shout()
print(dog.name)

结果为:
Animal shouts
Cat shouts
garfield
Dog shouts
ahuang

上例可以看出,通过继承,猫类、狗类不用写代码,直接继承了父类的属性和方法。

继承

class Cat(Animal)这种形式就是从父类继承,括号中写上继承的类的列表。

父类

Animal就是Cat的父类,也称为基类、超类。

子类

Cat就是Animal的子类,也称为派生类。

定义

格式如下:

class 子类名(基类1,基类2,……):
    语句块

如果定义时,没有基类列表,等同于继承自object。在Python3中,object类就是所有对象的根基类。

class A:
    pass

#等价于

class A(object):
    pass

注意,上例在Python2中,两种写法是不同的。

Python支持多继承,继承也可以分为多级。

查看继承的特殊属性和方法有:

__base__:类的基类

__bases__:类的基类元组

__mro__:显示方法查找顺序,基类的元组。

mro()方法,同__mro__,比如int.mro()

__subclasses__()类的子类列表,int.__subclasses__()。

class Animal():
    x = 123
    def __init__(self,name):
        self._name = name
        
    @property
    def name(self):
        return self._name
    def shout(self):
        print("animal shout")
        
class Cat(Animal):
    x = "cat"
    def shout(self):#override
        print("miao")

class Garfield(Cat):
    pass
class PersiaCat(Cat):
    pass

class Dog(Animal):
    def run(self):
        print("dog run")
        
tom = Cat("tom")
print(tom.name)
print(tom.shout())

dog = Dog("ahuang")
print(dog.name)
print(dog.shout())

gf = Garfield("gf")
gf.shout()
print("gf.x",gf.x)
print("gf",gf.__dict__)

print("gf.mro = {}".format(gf.__class__.__mro__))#祖先列表,继承链,应该注意,类才有这些方法,实例没有。
print("gf.bases = {}".format(gf.__class__.__bases__))

结果为:
tom
miao
None
ahuang
animal shout
None
miao
gf.x cat
gf {_name: gf}
gf.mro = (<class __main__.Garfield>, <class __main__.Cat>, <class __main__.Animal>, <class object>)
gf.bases = (<class __main__.Cat>,)

继承中的访问控制

class Animal:
    __COUNT = 100
    HEIGHT = 0
    
    def __init__(self,age,weight,height):
        self.__COUNT+=1
        self.age = age
        self.__weight = weight
        self.HEIGHT = height
        
    def eat(self):
        print("{} eat ".format(self.__class__.__name__))
        
    def __getweight(self):
        print(self.__weight)
        
        
    @classmethod
    def showcount1(cls):
        print(cls.__COUNT)
        
    @classmethod
    def __showcount2(cls):
        print(cls.__COUNT)
        
    def showcount3(self):
        print(self.__COUNT)
        
class Cat(Animal):
    NAME = "CAT"
    __COUNT = 200
    
    
#c = Cat()__init__函数参数错误
c = Cat(3,5,15)
c.eat()
print(c.HEIGHT)
#print(c.__COUNT)#私有的不可访问
#c.show__weight()#私有的不可访问
c.showcount1()
#c.__showcount2()#私有的不可访问
c.showcount3()
print(c.NAME)

print("{}".format(Animal.__dict__))
print("{}".format(Cat.__dict__))

print(c.__dict__)
print(c.__class__.mro())
        

结果为:
Cat eat 
15
100
101
CAT
{__module__: __main__, _Animal__COUNT: 100, HEIGHT: 0, __init__: <function Animal.__init__ at 0x0000000005A796A8>, eat: <function Animal.eat at 0x0000000005A79730>, _Animal__getweight: <function Animal.__getweight at 0x0000000005A797B8>, showcount1: <classmethod object at 0x0000000005A74E10>, _Animal__showcount2: <classmethod object at 0x0000000005A74748>, showcount3: <function Animal.showcount3 at 0x0000000005A79488>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}
{__module__: __main__, NAME: CAT, _Cat__COUNT: 200, __doc__: None}
{_Animal__COUNT: 101, age: 3, _Animal__weight: 5, HEIGHT: 15}
[<class __main__.Cat>, <class __main__.Animal>, <class object>]

从父类继承,自己没有的,就可以到父类中找。

私有的都是不可访问的,但是本质上依然是改了名称放在这个属性所在类的__dict__中了,知道这个新名称就可以直接找到这个隐藏的变量,但是这是个黑魔法,应该慎用。

class Animal():
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 10
        
    @property
    def name(self):
        return self._name
    def shout(self):
        print("animal shout")
        
class Cat(Animal):
    x = "cat"
    def shout(self):#override
        print("miao")

class Garfield(Cat):
    pass
class PersiaCat(Cat):
    pass
tom = Garfield("tom")
print(tom.name)
print(tom.shout())
print(tom.__dict__)

print(Garfield.__dict__)
print(Cat.__dict__)  
print(Animal.__dict__)

结果为:
tom
miao
None
{_name: tom, _Animal__age: 10}
{__module__: __main__, __doc__: None}
{__module__: __main__, x: cat, shout: <function Cat.shout at 0x03FB7F60>, __doc__: None}
{__module__: __main__, x: 123, __init__: <function Animal.__init__ at 0x03FB7228>, name: <property object at 0x03FD3210>, shout: <function Animal.shout at 0x03FB7E40>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}
class Animal():
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 10
        
    @property
    def name(self):
        return self._name
    def shout(self):
        print("animal shout")
        
class Cat(Animal):
    x = "cat"
    def __init__(self,name):
        Animal.__init__(self,name)#调整顺序,执行结果不同
        self.catname = name#改成self._name会覆盖前面的_name
    def shout(self):#override
        print("miao")

tom = Cat("tom")
print(tom.name)
print(tom.shout())
print(tom.__dict__)

print(Cat.__dict__)  
print(Animal.__dict__)

结果为:
tom
miao
None
{_name: tom, _Animal__age: 10, catname: tom}
{__module__: __main__, x: cat, __init__: <function Cat.__init__ at 0x03FDC108>, shout: <function Cat.shout at 0x03FDC150>, __doc__: None}
{__module__: __main__, x: 123, __init__: <function Animal.__init__ at 0x03FDC030>, name: <property object at 0x03FB9840>, shout: <function Animal.shout at 0x03FDC0C0>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}

 

总结:

继承时,公有的,子类和实例都可以随意访问,私有成员被隐藏,子类和实例不可直接访问,当私有变量所在的类内的方法中可以访问这个私有变量。

Python通过自己一套实现和其他语言一样的面向对象的继承机制。

属性查找顺序

实例的__dict__》类__dict__如果有继承==》父类__dict__

如果搜索这些地方后没有找到就会抛异常,先找到就立即返回了。

方法的重写、覆盖override

class Animal():
    def shout(self):
        print("animal shouts")
        
class Cat(Animal):
    #覆盖了父类方法
    def shout(self):
        print("miao")
        
a = Animal()
a.shout()
c = Cat()
c.shout()


print(a.__dict__)
print(c.__dict__)
print(Animal.__dict__)
print(Cat.__dict__)

结果为:
animal shouts
miao
{}
{}
{__module__: __main__, shout: <function Animal.shout at 0x0000000005A79D90>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}
{__module__: __main__, shout: <function Cat.shout at 0x0000000005A79C80>, __doc__: None}

cat能否覆盖自己的方法?

class Animal():
    def shout(self):
        print("animal shouts")
        
class Cat(Animal):
    #覆盖了父类方法
    def shout(self):
        print("miao")
        
    #覆盖了自身的方法,显式调用了父类的方法
    def shout(self):
        print(super())
        print(super(Cat,self))
        super().shout()
        super(Cat,self).shout()#等价与super()
        self.__class__.__base__.shout(self)#不推荐
        
a = Animal()
a.shout()
c = Cat()
c.shout()


print(a.__dict__)
print(c.__dict__)
print(Animal.__dict__)
print(Cat.__dict__)

结果为:
animal shouts
<super: <class Cat>, <Cat object>>
<super: <class Cat>, <Cat object>>
animal shouts
animal shouts
animal shouts
{}
{}
{__module__: __main__, shout: <function Animal.shout at 0x0000000005A79510>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}
{__module__: __main__, shout: <function Cat.shout at 0x0000000005A69BF8>, __doc__: None}

super()可以访问到父类的属性,具体原理后面再说。

那对于类方法和静态方法呢?

class Animal():
    @classmethod
    def class_method(cls):
        print("class_method_animals")
        
    @staticmethod
    def static_method():
        print("static_method_animals")
        
class Cat(Animal):
    @classmethod
    def class_method(cls):
        print("class_method_cat")
        
    @staticmethod
    def static_method():
        print("static_method_cat")
        
c = Cat()
c.class_method()
c.static_method()

结果为:
class_method_cat
static_method_cat

这些方法都可以覆盖,原理都一样,属性字典的搜索顺序。

class Animal():
    x = 123
    def __init__(self,name):
        self._name = name
        self.__age = 10
        
    @property
    def name(self):
        return self._name
    def shout(self):
        print("animal shout")
        
    @classmethod
    def clsmtd(cls):
        print(cls,cls.__name__)
        
class Cat(Animal):
    x = "cat"
    def __init__(self,name):
        Animal.__init__(self,name)#调整顺序,执行结果不同
        self.catname = name#改成self._name会覆盖前面的_name
    def shout(self):#override
        print("miao")
        
    @classmethod
    def clsmtd(cls):
        print(cls,cls.__name__)
        
class Garfield(Cat):
    pass


tom = Garfield("tom")
print(tom.clsmtd())#注意结果
print(tom.__dict__)

print(Cat.__dict__)  
print(Animal.__dict__)

结果为:
<class __main__.Garfield> Garfield
None
{_name: tom, _Animal__age: 10, catname: tom}
{__module__: __main__, x: cat, __init__: <function Cat.__init__ at 0x03FDC4F8>, shout: <function Cat.shout at 0x03FDC4B0>, clsmtd: <classmethod object at 0x03FCB990>, __doc__: None}
{__module__: __main__, x: 123, __init__: <function Animal.__init__ at 0x03FB76F0>, name: <property object at 0x03FD7AE0>, shout: <function Animal.shout at 0x03FDC588>, clsmtd: <classmethod object at 0x03FCB9D0>, __dict__: <attribute __dict__ of Animal objects>, __weakref__: <attribute __weakref__ of Animal objects>, __doc__: None}

 

继承中的初始化

先看下面这一段代码,有没有问题:

class A:
    def __init__(self,a):
        self.a = a
        
class B(A):
    def __init__(self,b,c):
        self.b = b
        self.c = c
        
    def printv(self):
        print(self.b)
        #print(self.a)#出错吗?会出错。
        
        
f = B(200,300)
print(f.__dict__)
print(f.__class__.__bases__)
f.printv()

结果为:
{b: 200, c: 300}
(<class __main__.A>,)
200

上例代码可知:如果类B定义时声明继承自类A,则在类B中__bases__中可以看到类A。但是这和是否调用类A的构造方法是两回事。

如果B中调用了A的构造方法,就可以拥有父类的属性了,如何理解这句话?观察B的实例f的__dict__中的属性。

class A:
    def __init__(self,a,d = 10):
        self.a = a
        self.__d = d
        
class B(A):
    def __init__(self,b,c):
        A.__init__(self,b+c,b-c)
        self.b = b
        self.c = c
        
    def printv(self):
        print(self.b)
        #print(self.a)#出错吗?
        
        
f = B(200,300)
print(f.__dict__)
print(f.__class__.__bases__)
f.printv()

结果为:
{a: 500, _A__d: -100, b: 200, c: 300}
(<class __main__.A>,)
200

作为好的习惯,如果父类定义了__init__方法,你就该在子类的__init__中调用它。那子类什么时候自动调用父类的__init__方法呢?

示例1

class A:
    def __init__(self):
        self.a1 = "a1"
        self.__a2 = "a2"
        print("A init")
        
class B(A):
    pass

b = B()
print(b.__dict__)


结果为:
A init
{a1: a1, _A__a2: a2}

B实例的初始化会自动调用基类A的__init__方法。

实例2

class A:
    def __init__(self):
        self.a1 = "a1"
        self.__a2 = "a2"
        print("A init")
        
class B(A):
    def __init__(self):
        self.b1 = "b1"
        print("B init")

b = B()
print(b.__dict__)

结果为:
B init
{b1: b1}

B实例的初始化__init__方法不会自动调用父类的初始化__init__方法,需要手动调用。

class A:
    def __init__(self):
        self.a1 = "a1"
        self.__a2 = "a2"
        print("A init")
        
class B(A):
    def __init__(self):
        self.b1 = "b1"
        print("B init")
        A.__init__(self)

b = B()
print(b.__dict__)

结果为:
B init
A init
{b1: b1, a1: a1, _A__a2: a2}

如何正确初始化

class Animal:
    def __init__(self,age):
        print("Animal init")
        self.age = age
        
    def show(self):
        print(self.age)
        
class Cat(Animal):
    def __init__(self,age,weight):
        print("cat init")
        self.age = age+1
        self.weight = weight
        
c = Cat(10,5)
c.show()

结果为:
cat init
11

上例我们前面都分析过,不会调用父类的__init__方法的,这就会导致没有实现继承效果。所以在子类的__init__方法中,应该显示调用父类的__init__方法。

class Animal:
    def __init__(self,age):
        print("Animal init")
        self.age = age
        
    def show(self):
        print(self.age)
        
class Cat(Animal):
    def __init__(self,age,weight):
        #调用父类的__init__方法的顺序决定着show方法的结果
        super().__init__(age)
        print("cat init")
        self.age = age+1
        self.weight = weight
        #super().__init__(age)
        
c = Cat(10,5)
c.show()

结果为:
Animal init
cat init
11

注意,调用父类的__init__方法,出现在不同的位置,可能导致出现不同的结果。那么直接将上例中所有的实例属性改成私有变量呢?

class Animal:
    def __init__(self,age):
        print("Animal init")
        self.__age = age
        
    def show(self):
        print(self.__age)
        
class Cat(Animal):
    def __init__(self,age,weight):
        #调用父类的__init__方法的顺序决定着show方法的结果
        super().__init__(age)
        print("cat init")
        self.__age = age+1
        self.__weight = weight
        #super().__init__(age)
        
c = Cat(10,5)
c.show()

print(c.__dict__)

结果为:
Animal init
cat init
10
{_Animal__age: 10, _Cat__age: 11, _Cat__weight: 5}

上例中打印10,原因看__dict__就知道了。因为父类Animal的show方法中__age会被解释为_Animal__age,因此显示的是10,而不是11。

这样的设计好不好,cat的实例c应该显示自己的属性值更好。

解决的办法:一个原则,自己的私有属性,就该自己的方法读取和修改,不要借助其他类的方法,即便是父类或者派生类的方法。

 

Python类的继承

标签:魔法   派生   通过   python   pytho   隐藏   for   init   原则   

原文地址:https://www.cnblogs.com/xpc51/p/11760352.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!