精华内容
下载资源
问答
  • python 类继承

    千次阅读 多人点赞 2018-07-19 19:04:13
    一个类继承另一个时,会自动获得另一个的所有属性和方法,被继承称之为父类,新称为子类。子类拥有父类所有的属性和方法,并且可以定义自己的属性和方法。 首先我们定义一个表示动物的父类: class ...

    一个类继承另一个类时,会自动获得另一个类的所有属性和方法,被继承的类称之为父类,新类称为子类。子类拥有父类所有的属性和方法,并且可以定义自己的属性和方法。

    首先我们定义一个表示动物的父类:

    class Animal:
        def __init__(self, animal_name, animal_type='animal'):
            self.animal_type = animal_type
            self.animal_name = animal_name
    
        def eat(self):
            print(self.animal_name + ':eat')
    
        def walk(self):
            print(self.animal_name + ':walk')
    
        def run(self):
            print(self.animal_name + ':run')
    

    我们生成一个Animal实例并且输出它的所有属性和方法:

    animal = Animal('动物','eat-animal')
    print(animal.animal_name)
    print(animal.animal_type)
    animal.eat()
    animal.walk()
    animal.run()

    运行结果:

    动物
    eat-animal
    动物:eat
    动物:walk
    动物:run

    好的,大家可以看到我们的类实例是正常的,没有任何问题。那么接下来我们就要,通过继承来创建我们的新类了。这里我们创建一个Birds类吧。

    语法:

    class Birds(Animal):
        def __init__(self,animal_name,animal_type='birds'):
            super().__init__(animal_name,animal_type)

    在python2.7中大家可能会遇到这要的写法:

    class Birds(Animal):
        def __init__(self,animal_name,animal_type='birds'):
            super(Birds,self).__init__(animal_name,animal_type)

    这和上面的区别在于super这个特殊函数必须接收两个参数,第一个是子类名,第二个是对象self。

    在创建子类的时候,首先我们的确保在当前文件中,你已经定义好了父类,而且父类定义的必须在子类前面。

    定义子类的时候,必须在括号内指定父类的名称。init 函数接收创建实例的所需参数,注意一点:这里必须包括父类init 函数的参数。你也可以添加你自己的参数:

      def __init__(self,animal_name,animal_type='birds',birds_age=10):

    这里必须调用父类的 init 函数,这样才能让子类拥有父类的所有属性。

    然后我们试着输出我们的子类:

    bird = Birds('百灵鸟')
    print(bird.animal_name)
    print(bird.animal_type)
    print(bird.birds_age)
    bird.eat()
    bird.walk()
    bird.run()

    运行结果:

    百灵鸟
    birds
    10
    百灵鸟:eat
    百灵鸟:walk
    百灵鸟:run

    我们继承父类,不会只想像上面一样这样的简单使用吧,我们当然希望能在我们的子类中增加我们需要的属性和方法。

    还是拿上面的例子来说,我们给Birds类增加一个标识有几只腿的属性和一个飞的方法。

    class Birds(Animal):
        def __init__(self,animal_name,animal_type='birds'):
            super().__init__(animal_name,animal_type)
            self.leg_count = 2
    
        def fly(self):
            print(self.animal_name + ':fly')
            print('此鸟有'+ str(self.leg_count) +'只腿')

    添加属性和方法和我们前面讲过的一样,没什么需要注意的。我们调用以下fly方法,看下能否正常输出:

    bird = Birds('百灵鸟')
    print(bird.leg_count)
    bird.fly()

    输出:

    2
    百灵鸟:fly
    此鸟有2只腿
    

    在子类中,父类的方法有可能不符合我们的期望,此时,我们需要重写父类的方法,来实现子类特性。拿Birds来说,我们希望它可以在eat方法中增加一行输出,比如我是一只吃素的鸟,显然,我们要重写eat方法:

     def eat(self):
            super().eat()
            print("我是一只吃素的鸟")
    

    然后调用一下eat方法:

    bird.eat()

    输出:

    百灵鸟:eat
    我是一只吃素的鸟

    这里大家可能看到我调用了父类的eat方法,这里我只是增加一行输出,父类的输出我们还是需要的,所以会调用。如果子类的方法和父类的逻辑不同,千万不要在调用父类的方法,自己重新实现就好。

    最后我们在来聊一下类的嵌套使用,这里的嵌套值得是将一个类作为另一个类的属性。

    让我们看下语法示例:

    class Food:
        def __init__(self):
            self.favorite_food = 'banana'
    
    
    class Person:
        def __init__(self):
            self.food = Food()
    
        def show_favorite(self):
            print("My favorite food is :" + self.food.favorite_food.title())
    
    
    person = Person();
    person.show_favorite()
    

    例子如上,很简单,首先我们定义好food类,然后将food类作为person类的属性,使用和普通的属性没有区别,只不过这个属性还可以调用自身的方法。

    输出:

    My favorite food is :Banana
    
    展开全文
  • 主要介绍了python类继承用法,实例分析了Python类的定义与类继承的实现技巧,需要的朋友可以参考下
  • 主要介绍了python类继承和多态原理解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 主要介绍了python类继承与子类实例初始化用法,实例分析了Python类的使用技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • Python类继承及super()函数

    万次阅读 多人点赞 2019-06-27 19:57:36
    文章目录Python中单类继承普通方法继承初始化函数继承Python中多类继承 Python中单类继承 Python是一门面向对象的编程语言,支持类继承。新的称为子类(Subclass),被继承称为父类、基类或者超类。子类继承...

    Python中单类继承

    Python是一门面向对象的编程语言,支持类继承。新的类称为子类(Subclass),被继承的类称为父类、基类或者超类。子类继承父类后,就拥有父类的所有特性。类继承的简单例子:

    普通类方法继承

    class Fruit():
        def color(self):
            print("colorful")
    
    class Apple(Fruit):
        pass
    
    class Orange(Fruit):
        pass
    
    apple = Apple()
    orange = Orange()
    apple.color()
    orange.color()
    
    # 输出
    # colorful
    # colorful
    

    这里Fruit为父类,AppleOrange为子类,子类继承了父类的特性,因此AppleOrange也拥有Color方法。
    子类除了可以继承父类的方法,还可以覆盖父类的方法:

    class Fruit():
        def color(self):
            print("colorful")
    
    class Apple(Fruit):
        def color(self):
            print("red")
    
    class Orange(Fruit):
        def color(self):
            print("orange")
    
    apple = Apple()
    orange = Orange()
    apple.color()
    orange.color()
    
    # 输出
    # red
    # orange
    

    子类可以在继承父类方法的同时,对方法进行重构。这样一来,子类的方法既包含父类方法的特性,同时也包含子类自己的特性:

    class Fruit():
        def color(self):
            print("Fruits are colorful")
    
    class Apple(Fruit):
        def color(self):
            super().color()
            print("Apple is red")
    
    class Orange(Fruit):
        def color(self):
            super().color()
            print("Orange is orange")
    
    apple = Apple()
    orange = Orange()
    apple.color()
    orange.color()
    
    # 输出
    # Fruits are colorful
    # Apple is red
    # Fruits are colorful
    # Orange is orange
    

    初始化函数继承

    如果我们需要给类传入参数,需要使用初始化函数。如果所有子类中部分参数是相同的,那么可以在父类的初始化函数中定义这些参数,然后子类继承父类的初始化函数,这样所有子类就可共享这些参数,而不需要在每个子类中单独定义。初始化函数的继承:

    class Fruit():
        def __init__(self, color, shape):
            self.color = color
            self.shape = shape
    
    class Apple(Fruit):
        def __init__(self, color, shape, taste):
            Fruit.__init__(self, color, shape) # 等价于super().__init__(color, shape)
            self.taste = taste
        
        def feature(self):
            print("Apple's color is {}, shape is {} and taste {}".format(
                self.color, self.shape, self.taste))
    
    class Orange(Fruit):
        def __init__(self, color, shape, taste):
            Fruit.__init__(self, color, shape)
            self.taste = taste
        
        def feature(self):
            print("Orange's color is {}, shape is {} and taste {}".format(
                self.color, self.shape, self.taste))
    
    apple = Apple("red", "square", "sour")
    orange = Orange("orange", "round", "sweet")
    apple.feature()
    orange.feature()
    
    # 输出
    # Apple's color is red, shape is square and taste sour
    # Orange's color is orange, shape is round and taste sweet
    

    Python中多类继承

    在单类继承中,super()函数用于指向要继承的父类,且不需要显式的写出父类名称。但是在多类继承中,会涉及到查找顺序(MRO)、钻石继承等问题。MRO 是类的方法解析顺序表, 也就是继承父类方法时的顺序表。钻石继承:

        A
       / \
      B   C
       \ /
        D
    

    如图所示,A是父类,B和C继承A,D继承B和C。下面举例说明钻石继承的继承顺序:

    class Plant():
        def __init__(self):
            print("Enter plant")
            print("Leave plant")
    
    class Fruit(Plant):
        def __init__(self):
            print("Enter Fruit")
            super().__init__()
            print("Leave Fruit")
    
    class Vegetable(Plant):
        def __init__(self):
            print("Enter vegetable")
            super().__init__()
            print("Leave vegetable")
    
    class Tomato(Fruit, Vegetable):
        def __init__(self):
            print("Enter Tomato")
            super().__init__()
            print("Leave Tomato")
    
    tomato = Tomato()
    print(Tomato.__mro__)
    
    
    # 输出
    # Enter Tomato
    # Enter Fruit
    # Enter vegetable
    # Enter plant
    # Leave plant
    # Leave vegetable
    # Leave Fruit
    # Leave Tomato
    # (<class '__main__.Tomato'>, <class '__main__.Fruit'>, <class '__main__.Vegetable'>, <class '__main__.Plant'>, <class 'object'>)
    
    展开全文
  • python类继承和组合

    千次阅读 2020-08-06 11:13:57
    继承 继承语法为class 派生类名(基类名):基类名写作括号里,基类是在子类定义的时候在元组之中指明的。即括子类定义时的括号为一个元组,里面为基类的类名。 class A(): pass class B(A):#B类继承A pass ...

    类的继承

    继承语法为class 派生类名(基类名):基类名写作括号里,基类是在子类定义的时候在元组之中指明的。即括子类定义时的括号为一个元组,里面为基类的类名。

    class A():
        pass
    
    class B(A):#B类继承A类
        pass
    
    示例

    子类调用基类的方法需要用BaseClassName.F(self)的格式,调用本类的方法的格式为self.F(self)的格式。

    class A():
        def print1(self):
            print('a... ...')
    
        def print2(self):
            print('aa... ...')
    
    
    class B(A):
        def print1(self):
            print('b... ...')
    
        def print2(self):
            print('bb... ...')
    
        def print3(self):
            self.print1()  # 调用类中的方法
            A.print1(self)  # 调用基类的方法
    
    b = B()
    b.print3()
    
    示例

    子类可以继承基类的所有公有变量和方法,但是不能继承私有变量和方法。

    class A():
        name = 'abc'
        __score = 100
    
    class B(A):
        def print1(self):
            print(self.name)
            # print(self.score)  # 基类的私有成员不会被继承
    
    b = B()
    b.print1()
    
    示例

    可以在括号中选择继承多个基类,以逗号隔开,这种继承被称为多重继承

    class A():
        namea = 'a'
    
    class B():
        nameb = 'b'
    
    class C(A, B):
        pass
    
    c = C()
    print(c.namea, c.nameb)
    
    示例

    如果子类和基类都有__init__()构造方法,构造方法会被重写,在子类中调用基类方法遵循上面的子类调用基类的函数原则,格式为BaseClassName.F(self)。也可以用super.__init__()按照MRO的解析顺序调用基类的构造方法(不过我还没懂MRO)。

    class A():
        def __init__(self):
            print('a... ...')
    
    class B():
        def __init__(self):
            print('b... ...')
    
    class C(A, B):
        def __init__(self):
            A.__init__(self)  # 用BaseClassName.F(self)的形式调用基类的构造方法
            B.__init__(self)
            print('c... ...')
    
    c = C()
    
    示例

    类的组合

    类的继承主要解决的是纵向关系的类,例如交通工具类和高铁、飞机类。类的组合解决的则是横向关系,例如学校和学生、老师。

    class Student():
        def __init__(self, num):
            self.num = num
    
    class Teacher():
        def __init__(self, num):
            self.num = num
    
    class School():
        def __init__(self, num1, num2):
            self.student = Student(num1)
            self.teacher = Teacher(num2)
    
    school = School(100, 10)
    print(school.student.num, school.teacher.num)
    
    示例

    参考资料

    1. python:继承、组合
    展开全文
  • Python类继承问题

    千次阅读 2019-06-21 14:05:49
    super(D, self).a() # 会自左向右先调用D以后的(A)中的a方法 super(A, self).a() # 会自左向右先调用A以后的(B)中的a方法 super(B, self).a() # 会自左向右先调用B以后的(C)中的a方法 D().b()  
    class A(object):
        def a(self):
            self.b()
        def b(self):
            print('A---b')
    class B(A):
        def b(self):
            print('B---b')
        def c(self):
            super(B, self).a()
    B().c()   # B---b
    # 结论1:子类重写父类的b方法,并且这个父类的b方法在父类的方法a中被调用,
    # 则当子类调用父类的a方法时,a中会调用子类中被重写的b方法,而不会调父类的原始b方法。
    
    class A(object):
        def a(self):
            print('--------A--------')
    class B(object):
        def a(self):
            print('--------B--------')
    class C(object):
        def a(self):
            print('--------C--------')
    class D(A,B,C):
        def b(self):
            super(D, self).a() # 会自左向右先调用D以后的类(A)中的a方法
            super(A, self).a()  # 会自左向右先调用A以后的类(B)中的a方法
            super(B, self).a()  # 会自左向右先调用B以后的类(C)中的a方法
    D().b()
    

     

    展开全文
  • Python类继承简单实现

    万次阅读 2010-10-27 17:04:00
    代码: #! /usr/bin/python # Filename: inherit.py # Author: yanggang class SchoolMember: def __init__(self,name,age): self.name = name self.age = age print 'init SchoolMember

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 225,681
精华内容 90,272
关键字:

python类的继承

python 订阅