Python-Specific Design Patterns

Learn about Python-specific design patterns, including context managers and descriptors, to write more efficient and Pythonic code.

Python-Specific Design Patterns

---

5.1 Context Managers

Context managers in Python provide a clean way to manage resources, ensuring proper acquisition and release.

The with Statement

Implementing Custom Context Managers

Explanation of __exit__ parameters: - exc_type: The type of the exception that occurred, or None if no exception occurred. - exc_value: The exception instance, or None if no exception occurred. - traceback: A traceback object, or None if no exception occurred.

Using contextlib

Async Context Managers

5.2 Descriptors

Descriptors provide a way to customize attribute access in Python classes.

Meaningful Descriptor Example

Explanation of __get__ parameters: - obj: The instance that the attribute was accessed through, or None when the attribute is accessed through the class. - objtype: The class that was used to access the attribute. This is set even when called on an instance.

The difference between __get__ and getattr: - __get__ is a method of the descriptor object itself. It’s called when accessing an attribute that is a descriptor. - getattr is a built-in function that retrieves an attribute from an object. Inside __get__, we often use getattr to access the actual stored value.

Advanced Descriptor: Lazy Property

Now, let’s break down how this works step by step:

1. When @LazyProperty is applied to the data method in DataProcessor:
   • An instance of LazyProperty is created, with the data method as its function attribute.
   • This LazyProperty instance replaces the data method in the class dictionary.
2. When we create a DataProcessor instance:
   • No data is loaded yet. The filename is stored, but data is not accessed.
3. The first time processor.data is accessed:
   • Python sees that data is a descriptor (it has a __get__ method) and calls LazyProperty.__get__(processor, DataProcessor).
   • Inside __get__:
     1. It checks if obj (processor) is None. It’s not, so it continues.
     2. It calls self.function(obj), which is equivalent to calling the original data method.
     3. This prints “Loading data…” and reads the file.
     4. The result is stored back into the processor instance using setattr(obj, self.name, value).
     5. The value is returned.
4. The second time processor.data is accessed:
   • Python first looks for an instance attribute named data.
   • It finds one (because we set it in step 3d), so it returns that value directly.
   • The LazyProperty.__get__ method is not called this time.

The key point is that after the first access, the LazyProperty descriptor is effectively replaced by the computed value. This is why the “Loading data…” message only appears once.

These examples demonstrate how context managers and descriptors can be used to create more robust, efficient, and Pythonic code. Context managers excel at resource management, while descriptors offer powerful ways to customize attribute behavior.