A class can be a subclass of a few other classes (inherit from multiple other classes).

To inherit from multiple classes, you can write the names of the classes separated by commas (`,`):

class First:
    first_attribute = "First"

    def first_method(self):
        print("The first_method from the First class")
  
class Second:
    second_attribute = "Second"

    def second_method(self):
        print("The second_method from the Second class")

  
class Child(First, Second):
    pass

instance = Child()
print(instance.first_attribute)
print(instance.second_attribute)
instance.first_method()
instance.second_method()

But the multiple inheritance has an order. The priority of the attributes/methods search is going from left to right:

class First:
    attribute = "First"
    
class Second:
    attribute = "Second"
    
class Child(Second, First):  # Order starts from the `Second`
    pass

instance = Child()
print(instance.attribute)

<details>
  <summary class='CodeD'>Code Description</summary>
  <div class="CodeD-text">
The <code>Child</code> class is defined as a subclass of both <code>Second</code> and <code>First</code> classes. The order of inheritance in the <code>Child</code> class is specified as <code>Second, First</code>.<br>
<br>
When <code>print(instance.attribute)</code> is called, it accesses the <code>attribute</code> attribute from the <code>Child</code> class.<br>
<br>
Since the <code>Child</code> class inherits from both <code>Second</code> and <code>First</code>, the order of inheritance becomes important. In this case, <code>Second</code> is specified first in the inheritance list. Therefore, the attribute lookup starts from the <code>Second</code> class.<br>
<br>
As a result, the output of <code>print(instance.attribute)</code> will be "Second". This means that the <code>attribute</code> attribute of the <code>Second</code> class takes precedence over the same attribute in the <code>First</code> class due to the order of inheritance in the <code>Child</code> class.
  </div> 
</details>

This demonstrates how the order of inheritance affects attribute resolution in cases where the same attribute is defined in multiple parent classes.

How to inherit a class from Parent1 and Parent2?

This course covers Object-Oriented Programming (OOP) in Python, starting with the basics and progressing to advanced concepts. You will implement a User model to gain practical experience and understanding of OOP features. By the end of the course, you will have a strong foundation in OOP and a deeper knowledge of Python's inner workings.

Let's start! The Object-Oriented Programming basic concepts are waiting for you here! In this section, you will get acquainted with the most important concepts for understanding Object-Oriented Programming.

Inheritance - the first of the OOP principles. The entities can be inherited from other ones. You learn how it works in code here.

Inheritance - the second of the OOP principles. The attributes and methods can be closed inside the class and used by the class only. Here you learn how to code with different access modifiers.

Polymorphism and abstraction are the third and fourth of the OOP principles. These principles are not easy to understand. Here you will get to know them in the simplest ways.

The magic methods make sandbox from Python. It's a unique Python tool you can't see in other languages. Here you learn how to use these methods and about the flexibility that they bring to Python.

Multiple Inheritance