LEARN COMPLETE PYTHON IN 24 HOURS

10. Metaclasses & Advanced OOP

10.1 What are Metaclasses?

In Python, everything is an object — including classes. Just like a class creates instances (objects), a metaclass creates classes.

Normal flow (you already know):

Python

class Person: pass p = Person() # Person is the class (blueprint), p is the instance

Metaclass flow:

• A metaclass is responsible for creating the Person class itself.

• The default metaclass in Python is type.

Python

print(type(Person)) # <class 'type'> print(type(int)) # <class 'type'> print(type(str)) # <class 'type'>

So type is the built-in metaclass that creates almost all classes.

When do you need custom metaclasses?

• You want to automatically add methods/attributes to classes

• Enforce coding standards (e.g., all methods must have docstrings)

• Auto-register classes (used in ORMs like SQLAlchemy, Django models, plugins)

• Change class creation behavior (very rare in everyday code)

10.2 type() as a Metaclass

type can be used in three ways:

1. As a function to check type: type(obj)

2. As a metaclass (default)

3. As a dynamic class factory

Dynamic class creation with type()

Python

# type(name, bases, dict) → creates a class dynamically def speak(self): return f"Hello, I'm {self.name}" Person = type( "Person", # class name (object,), # base classes { "name": "Anshuman", # class attribute "speak": speak, # method "age": 25 # another attribute } ) p = Person() print(p.speak()) # Hello, I'm Anshuman print(p.age) # 25

This is exactly how Python creates classes under the hood when you write class Person: ...

10.3 Creating Custom Metaclasses

To create a custom metaclass, you inherit from type and override special methods (usually new or init).

Most common pattern: Override new

Python

class MetaLogger(type): def new(cls, name, bases, attrs): # Add logging to every method automatically for attr_name, attr_value in attrs.items(): if callable(attr_value) and not attr_name.startswith("_"): def wrapper(*args, **kwargs): print(f"Calling {name}.{attr_name}()") result = attr_value(*args, **kwargs) print(f"{name}.{attr_name}() finished") return result attrs[attr_name] = wrapper return super().__new__(cls, name, bases, attrs) # Use the metaclass class MyService(metaclass=MetaLogger): def process_data(self, data): print(f"Processing: {data}") return len(data) s = MyService() s.process_data("Hello world")

Output:

text

Calling MyService.process_data() Processing: Hello world MyService.process_data() finished

10.4 new vs init

Both are special methods, but they serve different purposes:

MethodCalled onPurposeReturnsMost used in metaclasses?__new__Class creation (before instance)Creates & returns the object/class itselfThe new object/classYes (control class creation)__init__Instance creation (after new)Initializes the object (sets attributes)None (implicit)Rarely in metaclasses

Key difference in metaclasses:

• Override new when you want to modify the class dictionary (methods, attributes) before the class is created.

• Override init when you want to do something with the already-created class (less common).

Example: Enforce docstring on all methods

Python

class RequireDocstringMeta(type): def new(cls, name, bases, attrs): for attr_name, value in attrs.items(): if callable(value) and not attr_name.startswith("_"): if not value.__doc__: raise TypeError(f"Method {name}.{attr_name} must have a docstring!") return super().__new__(cls, name, bases, attrs) class MyClass(metaclass=RequireDocstringMeta): def good_method(self): """This has a docstring.""" pass # def bad_method(self): # This would raise TypeError # pass

10.5 Practical Use Cases (Frameworks, ORMs)

Metaclasses are rarely needed in everyday code — but they power some of the most famous Python libraries.

1. Django Models (ORM) Django uses metaclasses to turn a simple class into a full database model:

Python

class Book(models.Model): # metaclass=ModelBase title = models.CharField(max_length=200) author = models.ForeignKey(Author, on_delete=models.CASCADE)

→ Metaclass automatically adds manager (objects), table name, fields, etc.

2. SQLAlchemy Declarative Base

Python

class Base(DeclarativeBase): pass class User(Base): tablename = "users" id = Column(Integer, primary_key=True)

→ Metaclass inspects attributes and builds the mapping to database tables.

3. Plugin / Registry Systems Auto-register classes:

Python

class PluginRegistryMeta(type): registry = {} def new(cls, name, bases, attrs): new_cls = super().__new__(cls, name, bases, attrs) if name != "PluginBase": cls.registry[name] = new_cls return new_cls class PluginBase(metaclass=PluginRegistryMeta): pass class ImagePlugin(PluginBase): pass class VideoPlugin(PluginBase): pass print(PluginRegistryMeta.registry) # {'ImagePlugin': <class '__main__.ImagePlugin'>, 'VideoPlugin': <class '__main__.VideoPlugin'>}

4. Enforcing Design Patterns

• Singleton pattern via metaclass

• Auto-add logging, timing, validation to methods

• ABC-like enforcement without abc module

Important advice (2026):

• Use metaclasses only when you really need them — they make code harder to understand.

• Prefer decorators, class decorators, or __init_subclass__ (Python 3.6+) for most cases.

• If you're building a framework/library → metaclasses are powerful tools.

• For application code → avoid unless there's no simpler solution.

Mini Project – Auto-Register Commands (CLI style)

Python

class CommandRegistryMeta(type): commands = {} def new(cls, name, bases, attrs): new_cls = super().__new__(cls, name, bases, attrs) if name != "Command": cls.commands[name.lower()] = new_cls return new_cls class Command(metaclass=CommandRegistryMeta): @classmethod def execute(cls): raise NotImplementedError class HelpCommand(Command): @classmethod def execute(cls): print("Available commands:", list(CommandRegistryMeta.commands.keys())) class ClearCommand(Command): @classmethod def execute(cls): print("Screen cleared!") # Simulate CLI command = "help" if command in CommandRegistryMeta.commands: CommandRegistryMeta.commands[command].execute()

This completes the full Metaclasses & Advanced OOP section — now you understand one of Python's most advanced concepts and when (and when not) to use it!

📚 Amazon Book Library

All my books are FREE on Amazon Kindle Unlimited🌍 Exclusive Country-Wise Amazon Book Library – Only Here!

On GlobalCodeMaster.com you’ll find complete, ready-to-use lists of my books with direct Amazon links for every country.

Belong to India, Australia, USA, UK, Canada or any other country? Just click your country’s link and enjoy:

✅ Any eBook FREE on Kindle Unlimited ✅ Or buy at incredibly low prices

400+ fresh books written in 2025-2026 with today’s latest AI, Python, Machine Learning & tech trends – nowhere else will you find this complete country-wise collection on one platform!

Choose your country below and start reading instantly 🚀

BOOK LIBRARY USA 2026 LINK

BOOK LIBRARY INDIA 2026 LINK

BOOK LIBRARY AUSTRALIA 2026 LINK

BOOK LIBRARY CANADA 2026 LINK

BOOK LIBRARY UNITED KINGDOM 2026 LINK

BOOK LIBRARY GERMANY 2026 LINK

BOOK LIBRARY FRANCE 2026 LINK

BOOK LIBRARY ITALY 2026 LINK

BOOK LIBRARY SPAIN 2026 LINK

BOOK LIBRARY NETHERLANDS 2026 LINK

BOOK LIBRARY BRAZIL 2026 LINK

BOOK LIBRARY MEXICO 2026 LINK

BOOK LIBRARY JAPAN 2026 LINK

BOOK LIBRARY POLAND 2026 LINK

BOOK LIBRARY IRELAND 2026 LINK

BOOK LIBRARY SWEDEN 2026 LINK

BOOK LIBRARY BELGIUM 2026 LINK