Abstract Base Classes (ABCs) and Protocols in Python0%

Metaclasses and Class Creation Hooks with __init_subclass__

Abstract Base Classes (ABCs) and Protocols in Python

Advanced11 min read•Updated: 2026-10-23

🐍 Abstract Base Classes (abc.ABC) & Protocols

In large-scale enterprise software architectures, enforcing interface contracts is essential. Developers need guarantees that components conform to expected behaviors.

Python provides two complementary architectural mechanisms for interface design:

1
Abstract Base Classes (abc.ABC): Nominal Subtyping (explicit inheritance where subclasses explicitly declare their parent).
2
Protocols (typing.Protocol - PEP 544): Structural Subtyping (static duck typing where an object matches if it possesses the required methods, regardless of its inheritance tree).

🏛️ 1. Abstract Base Classes (`abc.ABC` & `@abstractmethod`)

An Abstract Base Class cannot be instantiated directly. It forces all derived subclasses to implement designated abstract methods:

1from abc import ABC, abstractmethod
2 
3class PaymentGateway(ABC):
4    @abstractmethod
5    def process_payment(self, amount: float) -> str:
6        """Processes payment and returns transaction ID."""
7        pass
8 
9    @abstractmethod
10    def refund(self, transaction_id: str) -> bool:
11        """Issues a refund."""
12        pass
13 
14# ❌ TypeError: Can't instantiate abstract class PaymentGateway without an implementation for abstract methods 'process_payment', 'refund'
15# gateway = PaymentGateway()
16 
17class RazorpayGateway(PaymentGateway):
18    def process_payment(self, amount: float) -> str:
19        return f"RZP_TXN_{int(amount * 100)}"
20 
21    def refund(self, transaction_id: str) -> bool:
22        print(f"Refunding transaction {transaction_id}")
23        return True
24 
25rzp = RazorpayGateway()
26print(rzp.process_payment(4999.0)) # RZP_TXN_499900

🦆 2. Protocols & Structural Subtyping (`typing.Protocol`)

Python's philosophy has always celebrated duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

With typing.Protocol (introduced in PEP 544), you get the compile-time type safety of an interface without requiring explicit class inheritance:

1from typing import Protocol, runtime_checkable
2 
3@runtime_checkable
4class Renderable(Protocol):
5    def render_html(self) -> str:
6        ...
7 
8# Notice: Neither class inherits from Renderable!
9class StudentCard:
10    def __init__(self, name: str):
11        self.name = name
12 
13    def render_html(self) -> str:
14        return f"<div class='card'>Student: {self.name}</div>"
15 
16class CourseBadge:
17    def render_html(self) -> str:
18        return "<span class='badge'>Python Mastery</span>"
19 
20def publish_to_web(component: Renderable):
21    # Static type checkers (mypy) and IDEs guarantee component has render_html()!
22    print("Output:", component.render_html())
23 
24publish_to_web(StudentCard("Aarav"))
25publish_to_web(CourseBadge())
26 
27# @runtime_checkable allows isinstance checks at runtime:
28print(isinstance(StudentCard("Diya"), Renderable)) # True!

⚖️ When to Choose ABC vs Protocol

Feature	Abstract Base Class (`abc.ABC`)	Protocol (`typing.Protocol`)
Typing Model	Nominal (explicit subclassing)	Structural (duck typing)
Code Sharing	Can provide concrete default implementations	Primarily declares interface signatures
Third-Party Types	Cannot retroactively make external classes inherit from your ABC	External classes naturally comply if signatures match
Primary Use Case	Framework class hierarchies (Django models, custom adapters)	Decoupled libraries, microservice contracts, DI

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What happens if a subclass inherits from an ABC but fails to implement an @abstractmethod?

Question 2

Which PEP introduced Protocols and Structural Subtyping into Python?

Question 3

Does a class need to explicitly inherit from a Protocol to satisfy type checkers?

Question 4

What decorator allows isinstance(obj, MyProtocol) to work at runtime?

Question 5

Can an Abstract Base Class contain non-abstract, fully implemented concrete methods?

🚀 What's Next?

In the next lesson, we will explore Metaclasses and Class Creation Hooks with __init_subclass__ (1: Advanced OOP Concepts).

👉 Continue to Next Lesson: Metaclasses and Class Creation Hooks with __init_subclass__ →

Next Lesson

Metaclasses and Class Creation Hooks with __init_subclass__

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Multiple Inheritance	Metaclasses and Class Creation Hooks with __init_subclass__

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

PreviousPrevNext

MSK Institute • Shikohabad

Loading Page Content...

Preparing courses, live labs, and learning resources.सामग्री लोड हो रही है, कृपया प्रतीक्षा करें...

Connecting serverPlease wait...

💻 Practical Labs🚀 Free Demo📜 Verified Certificates

Metaclasses and Class Creation Hooks with __init_subclass__

Abstract Base Classes (ABCs) and Protocols in Python

Advanced11 min read•Updated: 2026-10-23

Study Materials Cheatsheet

🐍 Abstract Base Classes (abc.ABC) & Protocols

In large-scale enterprise software architectures, enforcing interface contracts is essential. Developers need guarantees that components conform to expected behaviors.

Python provides two complementary architectural mechanisms for interface design:

1
Abstract Base Classes (abc.ABC): Nominal Subtyping (explicit inheritance where subclasses explicitly declare their parent).
2
Protocols (typing.Protocol - PEP 544): Structural Subtyping (static duck typing where an object matches if it possesses the required methods, regardless of its inheritance tree).

🏛️ 1. Abstract Base Classes (`abc.ABC` & `@abstractmethod`)

An Abstract Base Class cannot be instantiated directly. It forces all derived subclasses to implement designated abstract methods:

1from abc import ABC, abstractmethod
2 
3class PaymentGateway(ABC):
4    @abstractmethod
5    def process_payment(self, amount: float) -> str:
6        """Processes payment and returns transaction ID."""
7        pass
8 
9    @abstractmethod
10    def refund(self, transaction_id: str) -> bool:
11        """Issues a refund."""
12        pass
13 
14# ❌ TypeError: Can't instantiate abstract class PaymentGateway without an implementation for abstract methods 'process_payment', 'refund'
15# gateway = PaymentGateway()
16 
17class RazorpayGateway(PaymentGateway):
18    def process_payment(self, amount: float) -> str:
19        return f"RZP_TXN_{int(amount * 100)}"
20 
21    def refund(self, transaction_id: str) -> bool:
22        print(f"Refunding transaction {transaction_id}")
23        return True
24 
25rzp = RazorpayGateway()
26print(rzp.process_payment(4999.0)) # RZP_TXN_499900

🦆 2. Protocols & Structural Subtyping (`typing.Protocol`)

Python's philosophy has always celebrated duck typing: "If it walks like a duck and quacks like a duck, it's a duck."

With typing.Protocol (introduced in PEP 544), you get the compile-time type safety of an interface without requiring explicit class inheritance:

1from typing import Protocol, runtime_checkable
2 
3@runtime_checkable
4class Renderable(Protocol):
5    def render_html(self) -> str:
6        ...
7 
8# Notice: Neither class inherits from Renderable!
9class StudentCard:
10    def __init__(self, name: str):
11        self.name = name
12 
13    def render_html(self) -> str:
14        return f"<div class='card'>Student: {self.name}</div>"
15 
16class CourseBadge:
17    def render_html(self) -> str:
18        return "<span class='badge'>Python Mastery</span>"
19 
20def publish_to_web(component: Renderable):
21    # Static type checkers (mypy) and IDEs guarantee component has render_html()!
22    print("Output:", component.render_html())
23 
24publish_to_web(StudentCard("Aarav"))
25publish_to_web(CourseBadge())
26 
27# @runtime_checkable allows isinstance checks at runtime:
28print(isinstance(StudentCard("Diya"), Renderable)) # True!

⚖️ When to Choose ABC vs Protocol

Feature	Abstract Base Class (`abc.ABC`)	Protocol (`typing.Protocol`)
Typing Model	Nominal (explicit subclassing)	Structural (duck typing)
Code Sharing	Can provide concrete default implementations	Primarily declares interface signatures
Third-Party Types	Cannot retroactively make external classes inherit from your ABC	External classes naturally comply if signatures match
Primary Use Case	Framework class hierarchies (Django models, custom adapters)	Decoupled libraries, microservice contracts, DI

Interactive Quiz• Knowledge Check

Practice Quiz

Question 1

What happens if a subclass inherits from an ABC but fails to implement an @abstractmethod?

Question 2

Which PEP introduced Protocols and Structural Subtyping into Python?

Question 3

Does a class need to explicitly inherit from a Protocol to satisfy type checkers?

Question 4

What decorator allows isinstance(obj, MyProtocol) to work at runtime?

Question 5

Can an Abstract Base Class contain non-abstract, fully implemented concrete methods?

🚀 What's Next?

In the next lesson, we will explore Metaclasses and Class Creation Hooks with __init_subclass__ (1: Advanced OOP Concepts).

👉 Continue to Next Lesson: Metaclasses and Class Creation Hooks with __init_subclass__ →

Next Lesson

Metaclasses and Class Creation Hooks with __init_subclass__

Continue learning with hands-on practice, examples, and exercises in the upcoming topic.

Related Lessons

Previous Lesson	Next Lesson
Multiple Inheritance	Metaclasses and Class Creation Hooks with __init_subclass__

Practice Quiz

Test your understanding of this lesson with 5 questions. Each question has one correct answer.

Previous Next

🐍 Abstract Base Classes (abc.ABC) & Protocols

🏛️ 1. Abstract Base Classes (abc.ABC & @abstractmethod)

🦆 2. Protocols & Structural Subtyping (typing.Protocol)

⚖️ When to Choose ABC vs Protocol

Practice Quiz

🚀 What's Next?

Metaclasses and Class Creation Hooks with __init_subclass__

Related Lessons

Practice Quiz

Loading Page Content...

🐍 Abstract Base Classes (abc.ABC) & Protocols

🏛️ 1. Abstract Base Classes (abc.ABC & @abstractmethod)

🦆 2. Protocols & Structural Subtyping (typing.Protocol)

⚖️ When to Choose ABC vs Protocol

Practice Quiz

🚀 What's Next?

Metaclasses and Class Creation Hooks with __init_subclass__

Related Lessons

Practice Quiz

🏛️ 1. Abstract Base Classes (`abc.ABC` & `@abstractmethod`)

🦆 2. Protocols & Structural Subtyping (`typing.Protocol`)

🏛️ 1. Abstract Base Classes (`abc.ABC` & `@abstractmethod`)

🦆 2. Protocols & Structural Subtyping (`typing.Protocol`)