Python Interfaces (Complete Guide for Beginners)

In Python, interfaces are not a built-in keyword like Java or C#, but the concept still exists and is very important in Object-Oriented Programming (OOP).

Python implements interfaces using abstract base classes (ABCs).

---

🔹 What is an Interface in Python?

An interface is:

A blueprint that defines a set of methods that a class must implement, without providing implementation details.

In simple words:

• It tells what to do
• It does NOT tell how to do it

---

🔹 Why Use Interfaces?

Interfaces help you:

• ✔ Define common structure for multiple classes
• ✔ Enforce rules for child classes
• ✔ Achieve clean and scalable code
• ✔ Support polymorphism
• ✔ Improve maintainability in large projects

---

🔹 Interfaces in Python (Concept)

Unlike Java, Python does NOT have a direct interface keyword.

Instead, we use:

from abc import ABC, abstractmethod

👉 Abstract classes act as interfaces when they contain only abstract methods.

---

🔹 How to Create an Interface in Python

Basic structure:

from abc import ABC, abstractmethod

class InterfaceName(ABC):

    @abstractmethod
    def method1(self):
        pass

    @abstractmethod
    def method2(self):
        pass

---

🔹 Example of Interface in Python

Step 1: Define Interface

from abc import ABC, abstractmethod

class Payment(ABC):

    @abstractmethod
    def pay(self, amount):
        pass

---

Step 2: Implement Interface in Classes

class CreditCard(Payment):
    def pay(self, amount):
        return f"Paid {amount} using Credit Card"

class PayPal(Payment):
    def pay(self, amount):
        return f"Paid {amount} using PayPal"

---

Step 3: Use the Interface

p1 = CreditCard()
p2 = PayPal()

print(p1.pay(100))
print(p2.pay(200))

Output:

Paid 100 using Credit Card
Paid 200 using PayPal

---

🔹 Real-Life Example of Interface

Think about a remote control system 🎮

All devices follow the same interface:

• Power ON
• Power OFF
• Volume control

But each device works differently internally.

---

Interface Example:

from abc import ABC, abstractmethod

class Device(ABC):

    @abstractmethod
    def power_on(self):
        pass

    @abstractmethod
    def power_off(self):
        pass

---

TV Implementation:

class TV(Device):
    def power_on(self):
        return "TV is ON"

    def power_off(self):
        return "TV is OFF"

---

AC Implementation:

class AC(Device):
    def power_on(self):
        return "AC is ON"

    def power_off(self):
        return "AC is OFF"

---

Usage:

tv = TV()
ac = AC()

print(tv.power_on())
print(ac.power_off())

---

🔹 Interface vs Abstract Class

Feature	Interface	Abstract Class
Methods	Only abstract methods	Can have both abstract and normal methods
Data	No state (usually)	Can have variables
Purpose	Define rules	Provide partial implementation
Flexibility	High	Medium

---

🔹 Key Features of Interfaces in Python

• ✔ Achieved using ABC module
• ✔ Contains only method definitions
• ✔ Cannot be instantiated
• ✔ Forces child classes to implement methods

---

🔹 Multiple Interfaces in Python

Python supports multiple inheritance, so a class can implement multiple interfaces.

class Flyable(ABC):
    @abstractmethod
    def fly(self):
        pass


class Swimmable(ABC):
    @abstractmethod
    def swim(self):
        pass

---

Implement both interfaces:

class Duck(Flyable, Swimmable):

    def fly(self):
        return "Duck can fly"

    def swim(self):
        return "Duck can swim"

---

Usage:

d = Duck()
print(d.fly())
print(d.swim())

---

🔹 Benefits of Interfaces

✅ 1. Standard structure

All classes follow the same rules.

✅ 2. Loose coupling

Code becomes independent and flexible.

✅ 3. Easy maintenance

Changes in one class don’t affect others.

✅ 4. Better scalability

Easy to add new implementations.

---

🔹 Common Mistakes

❌ Forgetting to implement all methods:

class Car(Device):
    pass  # Error

❌ Trying to instantiate interface:

obj = Payment()  # ❌ Not allowed

---

🚀 Conclusion

Python interfaces help you define clean architecture and structured code design.

Even though Python does not have a built-in interface keyword, you can achieve the same behavior using:

• Abstract Base Classes (ABC)
• Abstract methods

Interfaces are widely used in:

• Payment systems
• API design
• Large-scale software architecture
• Plugin-based systems