{"id":2660,"date":"2026-10-20T11:14:38","date_gmt":"2026-10-20T11:14:38","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2660"},"modified":"2026-10-22T02:26:18","modified_gmt":"2026-10-22T02:26:18","slug":"python-inheritance-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-oops\/python-inheritance-tutorial\/","title":{"rendered":"Python Inheritance Tutorial"},"content":{"rendered":"

Python Inheritance Tutorial: Types, super() and Examples<\/b><\/strong><\/h1>\n

Imagine you are writing a program for a sports shop. You write a class for sports items with a model, a colour and a cost. Next, you need a class for shoes, which has all of those and a brand as well. Do you copy the first class and add one line? You could, but then every fix must be made twice, and one copy will soon be wrong. Inheritance is the way out.<\/p>\n

Inheritance lets a new class take everything an existing class has, and then add or change only what is different. The existing class is called the parent, and the new one is the child. It is one of the four main ideas of object oriented programming, with encapsulation, polymorphism and abstraction, and you will find it in almost every large Python project.<\/p>\n

In this tutorial, we begin with a tiny working example and then build a real one with a parent, a child and super()<\/code>. We cover all the types of inheritance with tested code, method overriding, the method resolution order, and the mistakes that cause errors. Everything below was run, and the output shown is the real output.<\/p>\n

What is Inheritance in Python?<\/h2>\n

Inheritance is the ability of one class to use the attributes and methods of another class. The class that gives is the parent class, also called the superclass or base class. The class that receives is the child class, also called the subclass or derived class.<\/p>\n

The main benefits are:<\/p>\n

    \n
  • Reuse.<\/strong> Write the common code once, in the parent, and every child gets it.<\/li>\n
  • One place to fix.<\/strong> A bug fixed in the parent is fixed for all children.<\/li>\n
  • Easy to extend.<\/strong> A child can add new methods, or change inherited ones, without touching the parent.<\/li>\n
  • Transitive.<\/strong> If C inherits from B, and B inherits from A, then C also gets everything from A.<\/li>\n<\/ul>\n

    A simple test for good use: the sentence child is a kind of parent should sound right. A dog is a kind of animal, so Dog<\/code> can inherit from Animal<\/code>. Shoes are a kind of sports item, so that works too.<\/p>\n

    How to Create a Child Class<\/h2>\n

    Put the name of the parent in brackets after the name of the child class.<\/p>\n

    \n
    python<\/div>\n
    class ChildClassName(ParentClassName):\r\n    # body of the child class<\/pre>\n<\/div>\n
    Here is the smallest working example. The child class does nothing of its own, and it still can use the parent method:<\/p>\n
    \n
    python<\/div>\n
    class Parent:\r\n    def greet(self):\r\n        print(\"Hello from the parent class\")\r\n\r\nclass Child(Parent):\r\n    pass\r\n\r\nChild().greet()<\/pre>\n
    output<\/div>\n
    Hello from the parent class<\/pre>\n<\/div>\n
    The word pass<\/code> means do nothing, and it is needed because a class cannot be empty. Notice the indentation, which is four spaces. Python stops with an error when it is missing:<\/p>\n
    \n
    python<\/div>\n
    class X:\r\ndef f(self):\r\n    pass<\/pre>\n
    output<\/div>\n
    IndentationError: expected an indented block after class definition on line 1<\/pre>\n<\/div>\n
    Python Inheritance Example: SportsItem and Shoes<\/h2>\n
    Now a real one. The parent class SportsItem<\/code> stores a model, a colour and a cost. Its child Shoes<\/code> adds a brand. Shoes<\/code> does not repeat any of the parent code.<\/p>\n
    \n
    python<\/div>\n
    class SportsItem:\r\n    def __init__(self, model, color, cost):\r\n        self.__model = model\r\n        self.__color = color\r\n        self.__cost = cost\r\n\r\n    def get_model(self):\r\n        return self.__model\r\n\r\n    def get_color(self):\r\n        return self.__color\r\n\r\n    def set_color(self, color):\r\n        self.__color = color\r\n\r\n    def get_cost(self):\r\n        return self.__cost\r\n\r\n    def set_cost(self, cost):\r\n        self.__cost = cost\r\n\r\n\r\nclass Shoes(SportsItem):\r\n    def __init__(self, model, color, cost, brand):\r\n        super().__init__(model, color, cost)\r\n        self.__brand = brand\r\n\r\n    def info(self):\r\n        return (self.get_model() + \" of brand \" + self.__brand + \" in \"\r\n                + self.get_color() + \" color for Rs.\" + str(self.get_cost()))\r\n\r\nsh1 = Shoes(\"Shoes\", \"Black\", 3699, \"Xyz123\")\r\nprint(sh1.info())\r\nprint(sh1.get_model())\r\nsh2 = Shoes(\"Shoes\", \"Black red\", 4599, \"Xyz345\")\r\nprint(sh2.info())\r\nsh2.set_cost(3999)\r\nprint(sh2.info())<\/pre>\n
    output<\/div>\n
    Shoes of brand Xyz123 in Black color for Rs.3699\r\nShoes\r\nShoes of brand Xyz345 in Black red color for Rs.4599\r\nShoes of brand Xyz345 in Black red color for Rs.3999<\/pre>\n<\/div>\n
    Notes on the Code<\/h3>\n
      \n
    • There is one set_color<\/code> and one set_cost<\/code> method.<\/li>\n
    • Method names use lower case with underscores, the usual Python style.<\/li>\n
    • The cost is stored as a number and is turned into text only in the output.<\/li>\n<\/ul>\n
      The Private Name Trap<\/h3>\n
      Look at the double underscore in self.__model<\/code>. Python changes such a name inside the class, so it is hard to reach from outside, and that includes child classes. A child must use the parent methods, such as get_model<\/code>, to read it. Here is what happens when a child tries to read it directly:<\/p>\n
      \n
      python<\/div>\n
      class BadShoes(SportsItem):\r\n    def show(self):\r\n        return self.__model\r\n\r\nBadShoes(\"Shoes\", \"Black\", 3699).show()<\/pre>\n
      output<\/div>\n
      AttributeError: 'BadShoes' object has no attribute '_BadShoes__model'<\/pre>\n<\/div>\n
      If you want a child to read a value directly, use a single underscore, such as self._model<\/code>. It is a signal to other programmers that the value is for internal use, and Python does not rename it.<\/p>\n
      How super() Works in Python<\/h2>\n
      The function super()<\/code> gives you access to the parent class from inside the child. You use it for two main jobs.<\/p>\n
        \n
      • To run the parent constructor.<\/strong> In the Shoes<\/code> class, super().__init__(model, color, cost)<\/code> lets the parent set up the model, colour and cost, so the child only deals with the brand.<\/li>\n
      • To call a parent method that the child has changed.<\/strong> This is shown in the next section.<\/li>\n<\/ul>\n
        If a child writes its own __init__<\/code> and forgets to call the parent one, the parent values are never set. Python does not warn you. The error shows up later, when you use them:<\/p>\n
        \n
        python<\/div>\n
        class ForgetfulShoes(SportsItem):\r\n    def __init__(self, brand):\r\n        self.brand = brand\r\n\r\nForgetfulShoes(\"Xyz\").get_model()<\/pre>\n
        output<\/div>\n
        AttributeError: 'ForgetfulShoes' object has no attribute '_SportsItem__model'<\/pre>\n<\/div>\n
        Method Overriding<\/h2>\n
        A child can write a method with the same name as one in the parent. The child version is used for child objects. This is called overriding. Inside it, super()<\/code> lets you keep the parent behaviour and add to it.<\/p>\n
        \n
        python<\/div>\n
        class Animal:\r\n    def speak(self):\r\n        return \"Some sound\"\r\n\r\nclass Dog(Animal):\r\n    def speak(self):\r\n        return super().speak() + \", then Woof\"\r\n\r\nprint(Animal().speak())\r\nprint(Dog().speak())<\/pre>\n
        output<\/div>\n
        Some sound\r\nSome sound, then Woof<\/pre>\n<\/div>\n
        isinstance and issubclass<\/h3>\n
        Two built in functions check the family tree. The first checks an object, and the second checks a class.<\/p>\n
        \n
        python<\/div>\n
        d = Dog()\r\nprint(isinstance(d, Dog), isinstance(d, Animal), isinstance(Animal(), Dog))\r\nprint(issubclass(Dog, Animal), issubclass(Animal, Dog))<\/pre>\n
        output<\/div>\n
        True True False\r\nTrue False<\/pre>\n<\/div>\n
        A Dog<\/code> object is also an Animal<\/code>, but an Animal<\/code> is not a Dog<\/code>. The relation works in one direction only.<\/p>\n
        Types of Inheritance in Python<\/h2>\n
        Python programmers usually talk about five types.<\/p>\n
        \n\n\n\n\n\n\n\n\n\n
        Types of inheritance in Python<\/caption>\n
        Type<\/th>\nMeaning<\/th>\nExample<\/th>\n<\/tr>\n<\/thead>\n
        Single<\/th>\nOne child, one parent<\/td>\nDog inherits from Animal<\/td>\n<\/tr>\n
        Multilevel<\/th>\nA chain: a grandparent, a parent and a child<\/td>\nC inherits from B, and B from A<\/td>\n<\/tr>\n
        Hierarchical<\/th>\nSeveral children, one parent<\/td>\nSquare and Circle inherit from Shape<\/td>\n<\/tr>\n
        Multiple<\/th>\nOne child, two or more parents<\/td>\nMultiInher inherits from Super1 and Super2<\/td>\n<\/tr>\n
        Hybrid<\/th>\nA mix of the types above<\/td>\nBottom inherits from Left and Right, which both inherit from Base<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
        Single Inheritance<\/h3>\n
        This is the case we have already seen in Child<\/code> and Parent<\/code>, Dog<\/code> and Animal<\/code>, and Shoes<\/code> and SportsItem<\/code>.<\/p>\n
        Multilevel Inheritance<\/h3>\n
        Each class inherits from the one before it. So C<\/code> gets everything from B<\/code> and A<\/code>.<\/p>\n
        \n
        python<\/div>\n
        class A:\r\n    def who(self):\r\n        return \"A\"\r\n\r\nclass B(A):\r\n    pass\r\n\r\nclass C(B):\r\n    pass\r\n\r\nprint(C().who())\r\nprint([k.__name__ for k in C.__mro__])<\/pre>\n
        output<\/div>\n
        A\r\n['C', 'B', 'A', 'object']<\/pre>\n<\/div>\n
        The second line shows the chain Python follows when it looks for a method. We explain it below.<\/p>\n
        Hierarchical Inheritance<\/h3>\n
        Several children share one parent, and each changes the part that is different.<\/p>\n
        \n
        python<\/div>\n
        class Shape:\r\n    def area(self):\r\n        return 0\r\n\r\nclass Square(Shape):\r\n    def __init__(self, s):\r\n        self.s = s\r\n    def area(self):\r\n        return self.s * self.s\r\n\r\nclass Circle(Shape):\r\n    def __init__(self, r):\r\n        self.r = r\r\n    def area(self):\r\n        return round(3.14159 * self.r * self.r, 2)\r\n\r\nfor sh in (Square(4), Circle(3)):\r\n    print(type(sh).__name__, sh.area())<\/pre>\n
        output<\/div>\n
        Square 16\r\nCircle 28.27<\/pre>\n<\/div>\n
        Multiple Inheritance<\/h3>\n
        A child can have more than one parent. List them in brackets, separated by commas. It is not a list, it is a group of names written in the class line.<\/p>\n
        \n
        python<\/div>\n
        class Super1:\r\n    def __init__(self):\r\n        self.test1 = \"Python\"\r\n        print(\"Superclass1\")\r\n\r\nclass Super2:\r\n    def __init__(self):\r\n        self.test2 = \"Tutorials\"\r\n        print(\"Superclass2\")\r\n\r\nclass MultiInher(Super1, Super2):\r\n    def __init__(self):\r\n        Super1.__init__(self)\r\n        Super2.__init__(self)\r\n        print(\"Derived\")\r\n\r\n    def print_vals(self):\r\n        print(self.test1, self.test2)\r\n\r\nobj = MultiInher()\r\nobj.print_vals()<\/pre>\n
        output<\/div>\n
        Superclass1\r\nSuperclass2\r\nDerived\r\nPython Tutorials<\/pre>\n<\/div>\n
        Here the child calls each parent constructor by name. That works for a simple case. For bigger programs, the next section shows the cleaner way.<\/p>\n
        Hybrid Inheritance and the Diamond<\/h3>\n
        Hybrid inheritance mixes the types. The best known shape is the diamond, where two classes inherit from the same base, and a fourth class inherits from both. Python handles it with super()<\/code>, and each class calls the next one in line:<\/p>\n
        \n
        python<\/div>\n
        class Base:\r\n    def hello(self):\r\n        return \"Base\"\r\n\r\nclass Left(Base):\r\n    def hello(self):\r\n        return \"Left then \" + super().hello()\r\n\r\nclass Right(Base):\r\n    def hello(self):\r\n        return \"Right then \" + super().hello()\r\n\r\nclass Bottom(Left, Right):\r\n    def hello(self):\r\n        return \"Bottom then \" + super().hello()\r\n\r\nprint(Bottom().hello())<\/pre>\n
        output<\/div>\n
        Bottom then Left then Right then Base<\/pre>\n<\/div>\n
        Notice that Base<\/code> runs only once, and that Right<\/code> runs even though Left<\/code> does not name it. This is the method resolution order at work.<\/p>\n
        Method Resolution Order (MRO)<\/h2>\n
        When you call a method, Python searches the classes in a fixed order, and uses the first match. That order is the method resolution order. Print it with the __mro__<\/code> attribute:<\/p>\n
        \n
        python<\/div>\n
        print([k.__name__ for k in Bottom.__mro__])<\/pre>\n
        output<\/div>\n
        ['Bottom', 'Left', 'Right', 'Base', 'object']<\/pre>\n<\/div>\n
        Read it from left to right. A child comes before its parents, and the parents appear in the order you wrote them in the brackets. At the end of every chain sits object<\/code>, the base of all classes in Python 3. So, if two parents define the same method, the one written first in the class line wins.<\/p>\n
        Inheritance or Composition?<\/h2>\n
        Inheritance is not always the right tool. Use it when the child really is a kind of the parent. Use composition when one thing has another. A car has an engine, but a car is not an engine, so the car holds an engine object:<\/p>\n
        \n
        python<\/div>\n
        class Engine:\r\n    def start(self):\r\n        return \"Engine started\"\r\n\r\nclass Car:\r\n    def __init__(self):\r\n        self.engine = Engine()\r\n    def start(self):\r\n        return self.engine.start()\r\n\r\nprint(Car().start())<\/pre>\n
        output<\/div>\n
        Engine started<\/pre>\n<\/div>\n
        A good rule for new programmers: if the sentence is a kind of does not sound right, do not use inheritance.<\/p>\n
        Common Inheritance Errors and How to Fix Them<\/h2>\n
        \n\n\n\n\n\n\n\n\n\n\n
        Inheritance errors and fixes<\/caption>\n
        Error<\/th>\nUsual cause<\/th>\nFix<\/th>\n<\/tr>\n<\/thead>\n
        IndentationError: expected an indented block<\/th>\nThe class or method body is not indented<\/td>\nIndent the body by four spaces<\/td>\n<\/tr>\n
        SyntaxError on classabc or defgetModel<\/th>\nA missing space after class or def<\/td>\nWrite class abc and def getModel<\/td>\n<\/tr>\n
        SyntaxError on a curly quote<\/th>\nText copied from a web page or a Word file<\/td>\nType straight quotes in your editor<\/td>\n<\/tr>\n
        AttributeError: object has no attribute _Class__name<\/th>\nA double underscore name used in a child, or the parent init was not called<\/td>\nUse the parent method, or call super().__init__()<\/td>\n<\/tr>\n
        TypeError: missing required positional argument<\/th>\nThe child init does not pass all values to the parent<\/td>\nPass every value that the parent init needs<\/td>\n<\/tr>\n
        TypeError: Cannot create a consistent method resolution order (MRO)<\/th>\nA parent is listed before its own child, such as class C(A, B) when B inherits from A<\/td>\nPut the child first, as in class C(B, A)<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
        Practice Exercises<\/h2>\n
          \n
        1. Create a Vehicle<\/code> class with a name and a speed. Create a Car<\/code> class that inherits from it and adds a number of doors.<\/li>\n
        2. Add a describe<\/code> method to Vehicle<\/code>, then override it in Car<\/code>, and use super()<\/code> to keep the first part of the text.<\/li>\n
        3. Add a Bike<\/code> class as a second child of Vehicle<\/code>, and loop over a Car<\/code> and a Bike<\/code> calling describe<\/code> on each.<\/li>\n
        4. Print the method resolution order of Car<\/code>, and check with isinstance<\/code> that a Car<\/code> object is also a Vehicle<\/code>.<\/li>\n
        5. Build a diamond like the one above, then swap the order of the two parents and see how the output changes.<\/li>\n<\/ol>\n
          Complete Script to Run Yourself<\/h2>\n
          Here is the full script that was used to test every example on this page. It ran on Python 3.13.<\/p>\n
          \n
          python<\/div>\n
          import sys\r\n\r\n# 1. Smallest example\r\nclass Parent:\r\n    def greet(self):\r\n        print(\"Hello from the parent class\")\r\n\r\nclass Child(Parent):\r\n    pass\r\n\r\nChild().greet()\r\n\r\n# 2. Sports example\r\nclass SportsItem:\r\n    def __init__(self, model, color, cost):\r\n        self.__model = model\r\n        self.__color = color\r\n        self.__cost = cost\r\n\r\n    def get_model(self):\r\n        return self.__model\r\n\r\n    def get_color(self):\r\n        return self.__color\r\n\r\n    def set_color(self, color):\r\n        self.__color = color\r\n\r\n    def get_cost(self):\r\n        return self.__cost\r\n\r\n    def set_cost(self, cost):\r\n        self.__cost = cost\r\n\r\n\r\nclass Shoes(SportsItem):\r\n    def __init__(self, model, color, cost, brand):\r\n        super().__init__(model, color, cost)\r\n        self.__brand = brand\r\n\r\n    def info(self):\r\n        return (self.get_model() + \" of brand \" + self.__brand + \" in \"\r\n                + self.get_color() + \" color for Rs.\" + str(self.get_cost()))\r\n\r\n\r\nsh1 = Shoes(\"Shoes\", \"Black\", 3699, \"Xyz123\")\r\nprint(sh1.info())\r\nprint(sh1.get_model())\r\nsh2 = Shoes(\"Shoes\", \"Black red\", 4599, \"Xyz345\")\r\nprint(sh2.info())\r\nsh2.set_cost(3999)\r\nprint(sh2.info())\r\n\r\n# 3. Private name from a child\r\nclass BadShoes(SportsItem):\r\n    def show(self):\r\n        return self.__model\r\n\r\ntry:\r\n    BadShoes(\"Shoes\", \"Black\", 3699).show()\r\nexcept AttributeError as e:\r\n    print(\"AttributeError:\", e)\r\n\r\n# 4. Forgetting super().__init__\r\nclass ForgetfulShoes(SportsItem):\r\n    def __init__(self, brand):\r\n        self.brand = brand\r\n\r\ntry:\r\n    ForgetfulShoes(\"Xyz\").get_model()\r\nexcept AttributeError as e:\r\n    print(\"AttributeError:\", e)\r\n\r\n# 5. Overriding and super()\r\nclass Animal:\r\n    def speak(self):\r\n        return \"Some sound\"\r\n\r\nclass Dog(Animal):\r\n    def speak(self):\r\n        return super().speak() + \", then Woof\"\r\n\r\nprint(Animal().speak())\r\nprint(Dog().speak())\r\n\r\n# 6. isinstance and issubclass\r\nd = Dog()\r\nprint(isinstance(d, Dog), isinstance(d, Animal), isinstance(Animal(), Dog))\r\nprint(issubclass(Dog, Animal), issubclass(Animal, Dog))\r\n\r\n# 7. Types\r\nclass A:\r\n    def who(self):\r\n        return \"A\"\r\n\r\nclass B(A):\r\n    pass\r\n\r\nclass C(B):\r\n    pass\r\n\r\nprint(C().who())\r\nprint([k.__name__ for k in C.__mro__])\r\n\r\nclass Shape:\r\n    def area(self):\r\n        return 0\r\n\r\nclass Square(Shape):\r\n    def __init__(self, s):\r\n        self.s = s\r\n    def area(self):\r\n        return self.s * self.s\r\n\r\nclass Circle(Shape):\r\n    def __init__(self, r):\r\n        self.r = r\r\n    def area(self):\r\n        return round(3.14159 * self.r * self.r, 2)\r\n\r\nfor sh in (Square(4), Circle(3)):\r\n    print(type(sh).__name__, sh.area())\r\n\r\nclass Base:\r\n    def hello(self):\r\n        return \"Base\"\r\n\r\nclass Left(Base):\r\n    def hello(self):\r\n        return \"Left then \" + super().hello()\r\n\r\nclass Right(Base):\r\n    def hello(self):\r\n        return \"Right then \" + super().hello()\r\n\r\nclass Bottom(Left, Right):\r\n    def hello(self):\r\n        return \"Bottom then \" + super().hello()\r\n\r\nprint(Bottom().hello())\r\nprint([k.__name__ for k in Bottom.__mro__])\r\n\r\n# 8. Multiple inheritance\r\nclass Super1:\r\n    def __init__(self):\r\n        self.test1 = \"Python\"\r\n        print(\"Superclass1\")\r\n\r\nclass Super2:\r\n    def __init__(self):\r\n        self.test2 = \"Tutorials\"\r\n        print(\"Superclass2\")\r\n\r\nclass MultiInher(Super1, Super2):\r\n    def __init__(self):\r\n        Super1.__init__(self)\r\n        Super2.__init__(self)\r\n        print(\"Derived\")\r\n\r\n    def print_vals(self):\r\n        print(self.test1, self.test2)\r\n\r\nobj = MultiInher()\r\nobj.print_vals()\r\n\r\n# 9. Composition\r\nclass Engine:\r\n    def start(self):\r\n        return \"Engine started\"\r\n\r\nclass Car:\r\n    def __init__(self):\r\n        self.engine = Engine()\r\n    def start(self):\r\n        return self.engine.start()\r\n\r\nprint(Car().start())\r\n\r\n# 10. Unindented code\r\ntry:\r\n    compile(\"class X:\\ndef f(self):\\n    pass\", \"x\", \"exec\")\r\nexcept IndentationError as e:\r\n    print(\"IndentationError:\", e.msg)\r\n\r\nprint(sys.version_info[:2])<\/pre>\n<\/div>\n