python-design-patterns

Python design patterns like Composition over Inheritance and Dependency Injection help improve maintainability by separating concerns and reducing code complexity. Use this Skill to identify which pattern best resolves your specific refactoring bottleneck.

The best way to structure Python classes handling multiple responsibilities is to apply the Single Responsibility Principle and split them into separate components. This decouples distinct operations like HTTP requests and database logic, ensuring each class has only one reason to change.

You should use composition over inheritance in Python software architecture when you need to build flexible, maintainable components without creating rigid class hierarchies. This approach allows dynamic dependency injection, significantly improving code testability and reducing structural coupling.

Dependency injection works for writing scalable Python code by decoupling object creation from its usage, allowing external dependencies to be injected dynamically. This design pattern enhances testability and ensures components remain modular, maintainable, and highly independent.

To evaluate abstraction appropriateness when refactoring a Python module, apply the KISS principle to avoid over-engineering. This Skill guides you in assessing software architecture decisions to maintain a strict balance between necessary flexibility and unnecessary structural complexity.