Python super vs Parent Class Call: Key Differences
Understand the difference between using super() and calling a parent class directly in Python, and when each approach is appropriate.

When you need to invoke a method from a parent class in Python, you have two common ways: calling the parent class method directly with the class name, or using super(). The choice matters more than many developers expect, especially once multiple inheritance enters the picture. This article explains how super() and direct parent class calls behave, where they differ, and how to decide which one fits your code.
How super() Works
super() returns a proxy object that delegates method calls according to the instance's method resolution order (MRO). It does not directly reference a specific class; instead, it starts the lookup after the class in which the call appears. For example:
class Base:
def greet(self):
print("Base")
class Child(Base):
def greet(self):
super().greet()
print("Child")When Child().greet() runs, super().greet() finds greet on Base because Base is the next class in Child's MRO. The proxy handles the self argument automatically, so you do not pass it explicitly.
Direct Parent Class Call
A direct call looks like Base.greet(self). It explicitly invokes the method on a specific class, passing the instance manually. The same example becomes:
class Child(Base):
def greet(self):
Base.greet(self)
print("Child")This works in single inheritance and is easy to read. However, it hardcodes the parent class name, and it does not respect the MRO beyond that class.
Single Inheritance: When They Look Equivalent
In a simple single-inheritance hierarchy, both approaches produce the same result. The difference is mostly stylistic. super() is more maintainable because renaming the parent class does not require changing every call. Direct calls are explicit, which some developers prefer for clarity.
There is one subtle difference: super() always follows the MRO, which in single inheritance is simply the parent class. Direct calls skip the MRO and target a specific class. In single inheritance, that is the same class, so behavior is identical.
Multiple Inheritance and Method Resolution Order
Multiple inheritance is where the two approaches diverge significantly. Consider:
class A:
def method(self):
print("A")
class B(A):
def method(self):
print("B")
super().method()
class C(A):
def method(self):
print("C")
super().method()
class D(B, C):
def method(self):
print("D")
super().method()The MRO of D is [D, B, C, A, object]. When D().method() runs, super().method() in B calls C.method(), not A.method(). This is cooperative multiple inheritance. If B used A.method(self) instead, the call would jump straight to A, skipping C entirely. That breaks the cooperative chain and can lead to unexpected behavior or missed initialization.
Common Mistakes and Failure Modes
One frequent mistake is forgetting to pass self in a direct call, which raises a TypeError. Another is using super() with inconsistent method signatures. In cooperative inheritance, all classes in the MRO must accept the same arguments, or you get a TypeError when the proxy passes them along.
Choosing Between super() and Direct Calls
Use super() when you are building a class hierarchy that may be extended, especially with mixins or multiple inheritance. It keeps the code cooperative and avoids hardcoding class names. Use a direct call when you need to invoke a specific parent method regardless of the MRO, for example when you intentionally want to bypass an intermediate class.
There is no performance reason to prefer one over the other; the overhead of super() is negligible. The decision is about maintainability and correctness.
A Practical Example with Mixins
Mixins are a common use case for super(). Suppose you have a logging mixin and a validation mixin, with a base processor at the end of the chain:
class BaseProcessor:
def process(self):
print("Base")
class LoggingMixin:
def process(self):
print("Logging")
super().process()
class ValidationMixin:
def process(self):
print("Validating")
super().process()
class Worker(LoggingMixin, ValidationMixin, BaseProcessor):
def process(self):
print("Working")
super().process()The MRO of Worker is [Worker, LoggingMixin, ValidationMixin, BaseProcessor, object]. Each super().process() call passes control to the next class in the chain until BaseProcessor.process runs. If a mixin hardcoded a call to a specific class instead of using super(), the chain would not advance through the remaining mixins.
Maintainability and Runtime Considerations
super() reduces coupling to specific class names, making refactoring easier. It also ensures that if the MRO changes due to future inheritance changes, the calls still resolve correctly. Direct calls are more brittle because they assume a fixed hierarchy.
Runtime overhead is minimal, so the choice should be driven by code clarity and the need for cooperative behavior. In large codebases, consistent use of super() prevents subtle bugs that are hard to trace.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.