python类继承

python
python中的类继承

当我们遇到有些情况是这样子的，有些对象既有相同的属性，又有不同的属性，这个时候没必要去吧在每个对象中把所有的属性都实现一边
而是说，先定义一个父类，然后子类继承父类的方法属性，如果有些属性特殊，可以重写，在python中经典类和新式类继承是不一样的
现在一般用新式类的继承方法也就是super(),super其实也是类，源码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
class super(object):
    """
    super() -> same as super(__class__, <first argument>)
    super(type) -> unbound super object
    super(type, obj) -> bound super object; requires isinstance(obj, type)
    super(type, type2) -> bound super object; requires issubclass(type2, type)
    Typical use to call a cooperative superclass method:
    class C(B):
        def meth(self, arg):
            super().meth(arg)
    This works for class methods too:
    class C(B):
        @classmethod
        def cmeth(cls, arg):
            super().cmeth(arg)
    """
    def __getattribute__(self, name): # real signature unknown; restored from __doc__
        """ x.__getattribute__('name') <==> x.name """
        pass

    def __get__(self, obj, type=None): # real signature unknown; restored from __doc__
        """ descr.__get__(obj[, type]) -> value """
        pass

    def __init__(self, type1=None, type2=None): # known special case of super.__init__
        """
        super() -> same as super(__class__, <first argument>)
        super(type) -> unbound super object
        super(type, obj) -> bound super object; requires isinstance(obj, type)
        super(type, type2) -> bound super object; requires issubclass(type2, type)
        Typical use to call a cooperative superclass method:
        class C(B):
            def meth(self, arg):
                super().meth(arg)
        This works for class methods too:
        class C(B):
            @classmethod
            def cmeth(cls, arg):
                super().cmeth(arg)
        
        # (copied from class doc)
        """
        pass

    @staticmethod # known case of __new__
    def __new__(S, *more): # real signature unknown; restored from __doc__
        """ T.__new__(S, ...) -> a new object with type S, a subtype of T """
        pass

    def __repr__(self): # real signature unknown; restored from __doc__
        """ x.__repr__() <==> repr(x) """
        pass

    __self_class__ = property(lambda self: type(object))
    """the type of the instance invoking super(); may be None

    :type: type
    """

    __self__ = property(lambda self: type(object))
    """the instance invoking super(); may be None

    :type: type
    """

    __thisclass__ = property(lambda self: type(object))
    """the class invoking super()

    :type: type
    """

下面看一个例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Food(object):
    """
    定义一个食物的父类
    """
    food_number = 0
    def __init__(self,name,price):
        """
        构造函数
        :param name:  食物名称
        :param price: 食物价格
        :return:
        """
        self.name = name
        self.price = price
        self.enroll()

    def enroll(self):
        Food.food_number +=1
        print("第[%s]个食物: [%s] 入库了!" % (self.food_number,self.name))

class meat(Food):
    def __init__(self,name,price,from_who):
        super(meat,self).__init__(name,price) # 新式类的写法，继承父类的name和price 
        self.from_who = from_who

    def tell_from(self):
        """
        肉来自哪里
        :return:
        """
        print("我是[%s],来自[%s]!" % (self.name,self.from_who))

class fruit(Food):
    def __init__(self,name,price,taste):
        Food.__init__(self,name,price) #经典类的写法 继承Food的name,price
        self.taste = taste

    def tell_taste(self):
        print("我是水果:[%s],我是[%s]的"% (self.name,self.taste))
        
if __name__ == '__main__' :
    beaf = meat("牛肉","100元","公牛")
    apple = fruit("苹果","10元","甜")
    beaf.tell_from()
    apple.tell_taste()
    print(Food.food_number)

输出:

1
2
3
4
5
第[1]个食物: [牛肉] 入库了!
第[2]个食物: [苹果] 入库了!
我是[牛肉],来自[公牛]!
我是水果:[苹果],我是[甜]的
2

文章目录
  1. 1. python中的类继承