why do i need to call the __init__ method of a parent class when initializing new atrributes?

New programmer here, and I'm just wondering why I need to call the __init__ method of a parent class in my subclass, if I'm not touching any of the arguments in the first __init__ method. Isn't the whole point of Method Resolution Order, that the parent class will be called after the subclass in the Method Resolution Order, if a certain method isn't in the subclass.

fx. If I have an instance of a class with the first and last name arguments. but then in a subclass I add an email, and decide to just write an __init__ method for the email, and then print the first name. shouldn't Python after checking the subclass then check the parent class to see if the "first name" attribute is in an __init__ method there, instead of giving me an AttributeError.

The method resolution operator is only relevant to attribute lookup.

class Person:
    def __init__(self, *, first, last, **kwargs):
        super().__init__(**kwargs)
        self.first = first
        self.last = last


class PersonWithEmail:
    def __init__(self, *, email, **kwargs):
        super().__init__(**kwargs)
        self.email = email


p = Person(first="John", last="Doe", email="jdoe@example.com")

When we call Person, we reach a point where we need to call Person.__init__. Since Person.__init__ is defined, we call it, and once it returns, we're done. Only if Person.__init__ is not defined does the MRO come into play, to find an ancestor of Person that does define an __init__ method that we can use.

Inside Person.__init__, we just call the code that's found. No implicit call to any inherited __init__ method is made. super().__init__ finds the next class in the MRO with an __init__ method defined and calls it. Only when all classes in the MRO are using super in overriden methods do we cooperatively ensure that each appropriate method gets called eventually.

If PersonWithEmail does not call super().__init__, then the first and last attribute never get defined, and the instance remains incorrectly initialized. As to whether the decision to not call a parent __init__ automatically was a good one, that's something you can debate. I will, however, point out that doing so would make __init__ special in a way that it otherwise is not. It's a method like any other, and you can choose to completely override a parent's __init__ if you really want to. Also, Python's class system has evolved slightly from its early days, and things you might have done back then aren't things you would want to do now, but changing the rule about no implicit parent calls would be a compatibility-breaking change that was never deemed necessary.