Customizing Classes with Magic Methods in Python0%

CPython Internals: Memory Management, Garbage Collection, and __slots__

Customizing Classes with Magic Methods in Python

Advanced9 min read•Updated: 2026-10-01

Customizing Classes with Magic Methods

Beyond basic arithmetic and string representations, Python's Data Model enables deep customization of user-defined classes. By implementing container protocols, callable behaviors, and attribute access hooks, you can create objects that behave like custom dictionaries, custom lists, dynamic proxies, or stateful function pipelines.

1. Emulating Containers: Sequence and Mapping Protocols

In Python, an object becomes a collection or container by implementing the Sequence Protocol or Mapping Protocol:

Operation	Dunder Method	Example Syntax
Read element	`__getitem__(self, key)`	`val = container[key]` or `container[start:stop]`
Assign element	`__setitem__(self, key, value)`	`container[key] = value`
Delete element	`__delitem__(self, key)`	`del container[key]`
Membership check	`__contains__(self, item)`	`if item in container:`
Length count	`__len__(self)`	`total = len(container)`

                     Indexing Expression: container[key]
                                     │
                                     ▼
                       Does key represent a slice?
                                     │
                    ┌────────────────┴────────────────┐
                   YES                                NO
                    │                                 │
                    ▼                                 ▼
            key is slice(...)                   key is discrete
        (e.g., [start:stop:step])             (e.g., int, str, tuple)
                    │                                 │
                    └────────────────┬────────────────┘
                                     ▼
                     Invoke: container.__getitem__(key)

Implementing a Typed, Key-Value Memory Store

1from typing import Any, Iterator, Union
2 
3class CaseInsensitiveDictionary:
4    """A dictionary-like container that normalizes string keys to lowercase."""
5 
6    def __init__(self) -> None:
7        self._store: dict[str, Any] = {}
8 
9    def _normalize_key(self, key: Any) -> str:
10        if not isinstance(key, str):
11            raise TypeError(f"Key must be a string, got {type(key).__name__}")
12        return key.lower()
13 
14    def __setitem__(self, key: str, value: Any) -> None:
15        norm_key = self._normalize_key(key)
16        self._store[norm_key] = value
17 
18    def __getitem__(self, key: str) -> Any:
19        norm_key = self._normalize_key(key)
20        return self._store[norm_key]
21 
22    def __delitem__(self, key: str) -> None:
23        norm_key = self._normalize_key(key)
24        del self._store[norm_key]
25 
26    def __contains__(self, key: object) -> bool:
27        if not isinstance(key, str):
28            return False
29        return key.lower() in self._store
30 
31    def __len__(self) -> int:
32        return len(self._store)
33 
34    def __repr__(self) -> str:
35        return f"CaseInsensitiveDictionary({self._store!r})"
36 
37# Testing the custom mapping
38headers = CaseInsensitiveDictionary()
39headers["Content-Type"] = "application/json"
40headers["Authorization"] = "Bearer token_xyz"
41 
42# Access with varied casings
43print(headers["content-type"])       # "application/json"
44print(headers["CONTENT-TYPE"])       # "application/json"
45print("authorization" in headers)    # True
46print(f"Total headers: {len(headers)}")

2. Handling Slices in `getitem`

When an indexing expression includes colons (e.g. obj[1:5:2]), Python constructs a built-in slice object and passes it to __getitem__.

1class RollingWindow:
2    """Demonstrates handling discrete integer indices as well as slice objects."""
3 
4    def __init__(self, data: list[int]) -> None:
5        self._data = list(data)
6 
7    def __getitem__(self, index: Union[int, slice]):
8        if isinstance(index, slice):
9            # slice objects contain .start, .stop, and .step
10            print(f"Intercepted slice: start={index.start}, stop={index.stop}, step={index.step}")
11            return self._data[index]
12        elif isinstance(index, int):
13            return self._data[index]
14        raise TypeError("Indices must be integers or slices.")
15 
16window = RollingWindow([10, 20, 30, 40, 50, 60, 70])
17print("Single item:", window[2])       # 30
18print("Slice item: ", window[1:5:2])   # [20, 40]

3. Callable Instances: The `call` Method

By implementing __call__(self, *args, **kwargs), an instance can be invoked directly with parentheses obj(), behaving like a function while maintaining persistent internal state.

1class ExponentialBackoff:
2    """Stateful retry delay calculator implementing the __call__ protocol."""
3 
4    def __init__(self, base_delay: float = 1.0, factor: float = 2.0, max_delay: float = 60.0) -> None:
5        self.base_delay = base_delay
6        self.factor = factor
7        self.max_delay = max_delay
8        self.attempts = 0
9 
10    def __call__(self) -> float:
11        """Computes next backoff duration and increments internal attempt counter."""
12        delay = min(self.base_delay * (self.factor ** self.attempts), self.max_delay)
13        self.attempts += 1
14        return delay
15 
16    def reset(self) -> None:
17        self.attempts = 0
18 
19# Using instance as a callable function
20backoff = ExponentialBackoff(base_delay=1.0, factor=2.0)
21 
22print(f"Is backoff callable? {callable(backoff)}")  # True
23print(f"Attempt 1 delay: {backoff():.1f}s")  # 1.0s
24print(f"Attempt 2 delay: {backoff():.1f}s")  # 2.0s
25print(f"Attempt 3 delay: {backoff():.1f}s")  # 4.0s
26print(f"Attempt 4 delay: {backoff():.1f}s")  # 8.0s

4. Attribute Interception: `getattr` vs `getattribute`

Python provides distinct hooks for intercepting attribute access:

                          Attribute Access: obj.attr
                                      │
                                      ▼
                       Always calls __getattribute__
                                      │
                     ┌────────────────┴────────────────┐
                     ▼                                 ▼
              Attribute Found               Attribute NOT Found
           Returns attribute value             (Raises AttributeError)
                                                       │
                                                       ▼
                                              Calls __getattr__
                                              (Fallback handler)

__getattribute__(self, name): Intercepts every single attribute access unconditionally. Modifying this requires extreme caution to avoid infinite recursion.
__getattr__(self, name): The graceful fallback. It is only called if the attribute was NOT found in normal dictionary lookup.

1class DynamicRecordProxy:
2    """Proxies data access dynamically using __getattr__."""
3 
4    def __init__(self, record_data: dict[str, Any]) -> None:
5        # Bypass custom attribute hooks during initialization
6        super().__setattr__("_data", record_data)
7 
8    def __getattr__(self, name: str) -> Any:
9        """Called only when the attribute does not exist on self."""
10        if name in self._data:
11            return self._data[name]
12        raise AttributeError(f"Record has no attribute '{name}'")
13 
14    def __setattr__(self, name: str, value: Any) -> None:
15        """Intercepts attribute assignments to update the inner dictionary."""
16        if name == "_data":
17            super().__setattr__(name, value)
18        else:
19            self._data[name] = value
20 
21record = DynamicRecordProxy({"user": "admin", "role": "root", "active": True})
22 
23# Dynamic property access
24print("User via attribute:", record.user)
25print("Role via attribute:", record.role)
26 
27# Setting new attribute dynamically
28record.cluster = "us-east-1"
29print("Newly assigned dynamic attribute:", record.cluster)

5. Architectural Comparison Summary

Method	Trigger Syntax	Critical Caveat
`__getitem__`	`obj[key]`	Must handle `slice` objects if sequence behavior is expected.
`__setitem__`	`obj[key] = val`	Should validate keys according to container domain rules.
`__contains__`	`item in obj`	Must return a boolean. If omitted, Python falls back to iterating with `__iter__`.
`__call__`	`obj(*args)`	Makes `callable(obj) == True`. Ideal for stateful closures and middleware.
`__getattr__`	`obj.attr`	Fallback only; runs only when normal lookup fails.
`__getattribute__`	`obj.attr`	Always runs. Must use `super().__getattribute__` to avoid infinite recursion.

⚠️ Common Advanced Mistakes & Gotchas

1. Implementing `eq` Without `hash`

Defining __eq__ automatically sets __hash__ = None, making your class unhashable (it cannot be stored in sets or used as dictionary keys). If instances are immutable, explicitly implement __hash__.

2. Ignoring Slice Objects in `getitem`

When creating a custom sequence class, obj[1:4] passes a slice object to __getitem__, not an integer. Always check if isinstance(index, slice):.

💻 Try It Yourself: Callable Pipeline Step with call

Scenario

Implement a callable Multiplier class using __call__ that allows instances of the class to be invoked directly like regular functions.

Complete Solution

1class Multiplier:
2    def __init__(self, factor: float):
3        self.factor = factor
4 
5    def __call__(self, value: float) -> float:
6        return value * self.factor
7 
8double = Multiplier(2.0)
9triple = Multiplier(3.0)
10 
11print("Calling double(15):", double(15))
12print("Calling triple(15):", triple(15))
13print("Is double callable?", callable(double))

Expected Output

1Calling double(15): 30.0
2Calling triple(15): 45.0
3Is double callable? True

Interactive Quiz• Knowledge Check

Practice Quiz

1.

Which dunder method is executed when an element is retrieved via square bracket notation value = obj["my_key"]? A. __get__ B. __getattr__ C. __getitem__ D. __access__

Answer: C

Explanation:The subscript indexing operation obj[key] is mapped directly to __getitem__(self, key).

2.

What object type does Python pass as the key argument to __getitem__ when an expression like obj[2:10:2] is executed? A. A tuple containing (2, 10, 2) B. A built-in slice object with start=2, stop=10, step=2 C. A range object range(2, 10, 2) D. A string "2:10:2"

Answer: B

Explanation:Python creates a slice(2, 10, 2) instance and passes it directly to __getitem__ when colon slicing syntax is used.

3.

What built-in function returns True when evaluated on an instance whose class defines the __call__ method? A. isfunction() B. callable() C. hasattr() D. isinstance(obj, FunctionType)

Answer: B

Explanation:The built-in callable(obj) returns True for any object whose class implements the __call__ dunder method.

4.

What is the key difference between __getattr__ and __getattribute__? A. __getattr__ is called on every attribute access, while __getattribute__ is only a fallback. B. __getattribute__ is called unconditionally on every attribute lookup, while __getattr__ is only called if standard attribute resolution fails. C. __getattr__ is private, whereas __getattribute__ is public. D. __getattribute__ is deprecated in Python 3.

Answer: B

Explanation:__getattribute__ intercepts every attribute access unconditionally. __getattr__ is only invoked as a fallback mechanism when the attribute is not found in the object's instance dictionary or class hierarchy.

5.

Inside __getattribute__, how should you safely access attributes on the instance without triggering infinite recursion? A. Directly access self.__dict__[name] B. Call self.name C. Delegate via super().__getattribute__(name) or object.__getattribute__(self, name) D. Call getattr(self, name)

Answer: C

Explanation:Accessing self.__dict__ or calling getattr(self, ...) inside __getattribute__ triggers __getattribute__ again, causing infinite recursion and a RecursionError. One must use super().__getattribute__(name).

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Project: Vector Class with Overloaded Operators (2: Magic Methods & Operator Overloading).

👉 Continue to Next Lesson: Project: Vector Class with Overloaded Operators →

Next Lesson

CPython Internals: Memory Management, Garbage Collection, and slots

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

Related Lessons

Previous Lesson	Next Lesson
Operator Overloading	CPython Internals: Memory Management, Garbage Collection, and __slots__

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

CPython Internals: Memory Management, Garbage Collection, and __slots__

Customizing Classes with Magic Methods in Python

Advanced9 min read•Updated: 2026-10-01

Study Materials Cheatsheet

Customizing Classes with Magic Methods

1. Emulating Containers: Sequence and Mapping Protocols

In Python, an object becomes a collection or container by implementing the Sequence Protocol or Mapping Protocol:

Operation	Dunder Method	Example Syntax
Read element	`__getitem__(self, key)`	`val = container[key]` or `container[start:stop]`
Assign element	`__setitem__(self, key, value)`	`container[key] = value`
Delete element	`__delitem__(self, key)`	`del container[key]`
Membership check	`__contains__(self, item)`	`if item in container:`
Length count	`__len__(self)`	`total = len(container)`

                     Indexing Expression: container[key]
                                     │
                                     ▼
                       Does key represent a slice?
                                     │
                    ┌────────────────┴────────────────┐
                   YES                                NO
                    │                                 │
                    ▼                                 ▼
            key is slice(...)                   key is discrete
        (e.g., [start:stop:step])             (e.g., int, str, tuple)
                    │                                 │
                    └────────────────┬────────────────┘
                                     ▼
                     Invoke: container.__getitem__(key)

Implementing a Typed, Key-Value Memory Store

1from typing import Any, Iterator, Union
2 
3class CaseInsensitiveDictionary:
4    """A dictionary-like container that normalizes string keys to lowercase."""
5 
6    def __init__(self) -> None:
7        self._store: dict[str, Any] = {}
8 
9    def _normalize_key(self, key: Any) -> str:
10        if not isinstance(key, str):
11            raise TypeError(f"Key must be a string, got {type(key).__name__}")
12        return key.lower()
13 
14    def __setitem__(self, key: str, value: Any) -> None:
15        norm_key = self._normalize_key(key)
16        self._store[norm_key] = value
17 
18    def __getitem__(self, key: str) -> Any:
19        norm_key = self._normalize_key(key)
20        return self._store[norm_key]
21 
22    def __delitem__(self, key: str) -> None:
23        norm_key = self._normalize_key(key)
24        del self._store[norm_key]
25 
26    def __contains__(self, key: object) -> bool:
27        if not isinstance(key, str):
28            return False
29        return key.lower() in self._store
30 
31    def __len__(self) -> int:
32        return len(self._store)
33 
34    def __repr__(self) -> str:
35        return f"CaseInsensitiveDictionary({self._store!r})"
36 
37# Testing the custom mapping
38headers = CaseInsensitiveDictionary()
39headers["Content-Type"] = "application/json"
40headers["Authorization"] = "Bearer token_xyz"
41 
42# Access with varied casings
43print(headers["content-type"])       # "application/json"
44print(headers["CONTENT-TYPE"])       # "application/json"
45print("authorization" in headers)    # True
46print(f"Total headers: {len(headers)}")

2. Handling Slices in `getitem`

When an indexing expression includes colons (e.g. obj[1:5:2]), Python constructs a built-in slice object and passes it to __getitem__.

1class RollingWindow:
2    """Demonstrates handling discrete integer indices as well as slice objects."""
3 
4    def __init__(self, data: list[int]) -> None:
5        self._data = list(data)
6 
7    def __getitem__(self, index: Union[int, slice]):
8        if isinstance(index, slice):
9            # slice objects contain .start, .stop, and .step
10            print(f"Intercepted slice: start={index.start}, stop={index.stop}, step={index.step}")
11            return self._data[index]
12        elif isinstance(index, int):
13            return self._data[index]
14        raise TypeError("Indices must be integers or slices.")
15 
16window = RollingWindow([10, 20, 30, 40, 50, 60, 70])
17print("Single item:", window[2])       # 30
18print("Slice item: ", window[1:5:2])   # [20, 40]

3. Callable Instances: The `call` Method

By implementing __call__(self, *args, **kwargs), an instance can be invoked directly with parentheses obj(), behaving like a function while maintaining persistent internal state.

1class ExponentialBackoff:
2    """Stateful retry delay calculator implementing the __call__ protocol."""
3 
4    def __init__(self, base_delay: float = 1.0, factor: float = 2.0, max_delay: float = 60.0) -> None:
5        self.base_delay = base_delay
6        self.factor = factor
7        self.max_delay = max_delay
8        self.attempts = 0
9 
10    def __call__(self) -> float:
11        """Computes next backoff duration and increments internal attempt counter."""
12        delay = min(self.base_delay * (self.factor ** self.attempts), self.max_delay)
13        self.attempts += 1
14        return delay
15 
16    def reset(self) -> None:
17        self.attempts = 0
18 
19# Using instance as a callable function
20backoff = ExponentialBackoff(base_delay=1.0, factor=2.0)
21 
22print(f"Is backoff callable? {callable(backoff)}")  # True
23print(f"Attempt 1 delay: {backoff():.1f}s")  # 1.0s
24print(f"Attempt 2 delay: {backoff():.1f}s")  # 2.0s
25print(f"Attempt 3 delay: {backoff():.1f}s")  # 4.0s
26print(f"Attempt 4 delay: {backoff():.1f}s")  # 8.0s

4. Attribute Interception: `getattr` vs `getattribute`

Python provides distinct hooks for intercepting attribute access:

                          Attribute Access: obj.attr
                                      │
                                      ▼
                       Always calls __getattribute__
                                      │
                     ┌────────────────┴────────────────┐
                     ▼                                 ▼
              Attribute Found               Attribute NOT Found
           Returns attribute value             (Raises AttributeError)
                                                       │
                                                       ▼
                                              Calls __getattr__
                                              (Fallback handler)

__getattribute__(self, name): Intercepts every single attribute access unconditionally. Modifying this requires extreme caution to avoid infinite recursion.
__getattr__(self, name): The graceful fallback. It is only called if the attribute was NOT found in normal dictionary lookup.

1class DynamicRecordProxy:
2    """Proxies data access dynamically using __getattr__."""
3 
4    def __init__(self, record_data: dict[str, Any]) -> None:
5        # Bypass custom attribute hooks during initialization
6        super().__setattr__("_data", record_data)
7 
8    def __getattr__(self, name: str) -> Any:
9        """Called only when the attribute does not exist on self."""
10        if name in self._data:
11            return self._data[name]
12        raise AttributeError(f"Record has no attribute '{name}'")
13 
14    def __setattr__(self, name: str, value: Any) -> None:
15        """Intercepts attribute assignments to update the inner dictionary."""
16        if name == "_data":
17            super().__setattr__(name, value)
18        else:
19            self._data[name] = value
20 
21record = DynamicRecordProxy({"user": "admin", "role": "root", "active": True})
22 
23# Dynamic property access
24print("User via attribute:", record.user)
25print("Role via attribute:", record.role)
26 
27# Setting new attribute dynamically
28record.cluster = "us-east-1"
29print("Newly assigned dynamic attribute:", record.cluster)

5. Architectural Comparison Summary

Method	Trigger Syntax	Critical Caveat
`__getitem__`	`obj[key]`	Must handle `slice` objects if sequence behavior is expected.
`__setitem__`	`obj[key] = val`	Should validate keys according to container domain rules.
`__contains__`	`item in obj`	Must return a boolean. If omitted, Python falls back to iterating with `__iter__`.
`__call__`	`obj(*args)`	Makes `callable(obj) == True`. Ideal for stateful closures and middleware.
`__getattr__`	`obj.attr`	Fallback only; runs only when normal lookup fails.
`__getattribute__`	`obj.attr`	Always runs. Must use `super().__getattribute__` to avoid infinite recursion.

⚠️ Common Advanced Mistakes & Gotchas

1. Implementing `eq` Without `hash`

2. Ignoring Slice Objects in `getitem`

When creating a custom sequence class, obj[1:4] passes a slice object to __getitem__, not an integer. Always check if isinstance(index, slice):.

💻 Try It Yourself: Callable Pipeline Step with call

Scenario

Implement a callable Multiplier class using __call__ that allows instances of the class to be invoked directly like regular functions.

Complete Solution

1class Multiplier:
2    def __init__(self, factor: float):
3        self.factor = factor
4 
5    def __call__(self, value: float) -> float:
6        return value * self.factor
7 
8double = Multiplier(2.0)
9triple = Multiplier(3.0)
10 
11print("Calling double(15):", double(15))
12print("Calling triple(15):", triple(15))
13print("Is double callable?", callable(double))

Expected Output

1Calling double(15): 30.0
2Calling triple(15): 45.0
3Is double callable? True

Interactive Quiz• Knowledge Check

Practice Quiz

1.

Which dunder method is executed when an element is retrieved via square bracket notation value = obj["my_key"]? A. __get__ B. __getattr__ C. __getitem__ D. __access__

Answer: C

Explanation:The subscript indexing operation obj[key] is mapped directly to __getitem__(self, key).

2.

Answer: B

Explanation:Python creates a slice(2, 10, 2) instance and passes it directly to __getitem__ when colon slicing syntax is used.

3.

What built-in function returns True when evaluated on an instance whose class defines the __call__ method? A. isfunction() B. callable() C. hasattr() D. isinstance(obj, FunctionType)

Answer: B

Explanation:The built-in callable(obj) returns True for any object whose class implements the __call__ dunder method.

4.

Answer: B

5.

Answer: C

🚀 What's Next?

In the next lesson, we will continue your advanced Python journey with Project: Vector Class with Overloaded Operators (2: Magic Methods & Operator Overloading).

👉 Continue to Next Lesson: Project: Vector Class with Overloaded Operators →

Next Lesson

CPython Internals: Memory Management, Garbage Collection, and slots

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

Related Lessons

Previous Lesson	Next Lesson
Operator Overloading	CPython Internals: Memory Management, Garbage Collection, and __slots__

Practice Quiz

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

Previous Next

Customizing Classes with Magic Methods

1. Emulating Containers: Sequence and Mapping Protocols

Implementing a Typed, Key-Value Memory Store

2. Handling Slices in __getitem__

3. Callable Instances: The __call__ Method

4. Attribute Interception: __getattr__ vs __getattribute__

5. Architectural Comparison Summary

⚠️ Common Advanced Mistakes & Gotchas

1. Implementing __eq__ Without __hash__

2. Ignoring Slice Objects in __getitem__

💻 Try It Yourself: Callable Pipeline Step with __call__

Scenario

Complete Solution

Expected Output

Practice Quiz

1.

2.

3.

4.

5.

🚀 What's Next?

CPython Internals: Memory Management, Garbage Collection, and __slots__

Related Lessons

Practice Quiz

Loading Page Content...

Customizing Classes with Magic Methods

1. Emulating Containers: Sequence and Mapping Protocols

Implementing a Typed, Key-Value Memory Store

2. Handling Slices in __getitem__

3. Callable Instances: The __call__ Method

4. Attribute Interception: __getattr__ vs __getattribute__

5. Architectural Comparison Summary

⚠️ Common Advanced Mistakes & Gotchas

1. Implementing __eq__ Without __hash__

2. Ignoring Slice Objects in __getitem__

💻 Try It Yourself: Callable Pipeline Step with __call__

Scenario

Complete Solution

Expected Output

Practice Quiz

1.

2.

3.

4.

5.

🚀 What's Next?

CPython Internals: Memory Management, Garbage Collection, and __slots__

Related Lessons

Practice Quiz

2. Handling Slices in `getitem`

3. Callable Instances: The `call` Method

4. Attribute Interception: `getattr` vs `getattribute`

1. Implementing `eq` Without `hash`

2. Ignoring Slice Objects in `getitem`

💻 Try It Yourself: Callable Pipeline Step with call

CPython Internals: Memory Management, Garbage Collection, and slots

2. Handling Slices in `getitem`

3. Callable Instances: The `call` Method

4. Attribute Interception: `getattr` vs `getattribute`

1. Implementing `eq` Without `hash`

2. Ignoring Slice Objects in `getitem`

💻 Try It Yourself: Callable Pipeline Step with call

CPython Internals: Memory Management, Garbage Collection, and slots