What is dependency injection, and how does it improve testability in Python applications?
Dependency injection: pass collaborators in, don't create them inside
Dependency injection (DI) is a technique where a component receives its dependencies from outside rather than creating them internally. In Python, this often means passing dependencies as arguments to init or to the function that needs them. It improves testability because you can inject fakes or mocks in tests, and it reduces coupling because the component does not depend on a concrete implementation. It also makes dependencies explicit, which improves readability. There are frameworks such as dependency-injector or FastAPI's Depends, but manual DI is often sufficient and more transparent. The trade-off is more wiring code, but this pays off in testability, flexibility, and the ability to swap implementations without changing the component.
- 1
Constructor injection: pass dependencies to init. Most common and explicit.
- 2
Method injection: pass dependencies to the method that needs them. Useful for one-off collaborators.
- 3
Parameter injection: pass simple values or callables as arguments.
- 4
Frameworks: FastAPI's Depends, dependency-injector, or manual wiring in a composition root.
- 5
Trade-off: explicit wiring versus convenience of global imports. DI makes dependencies visible and testable.
- 6
Common mistake: using a service locator or global registry, which hides dependencies and makes testing harder.
- 7
Common mistake: injecting too many dependencies, which indicates a class with too many responsibilities.
- 8
Version note: DI is a pattern, not a library. Python's dynamic nature makes manual DI straightforward.
Scenario Questions
0-2 years experience
- 1Why is it hard to test a class that creates its own database connection internally?
- 2What does it mean to inject a dependency?
2-5 years experience
- 1You need to test a service that sends emails. How do you use DI to avoid sending real emails?
- 2You have a class with many dependencies. How do you decide which to inject and which to create internally?
5-8 years experience
- 1You are building a framework where users can plug in their own implementations. How do you design the DI mechanism?
- 2You want to introduce DI into a legacy codebase. What is a safe incremental approach?
8+ years experience
- 1Design a composition root for a large application that wires all dependencies explicitly without a framework.
- 2Compare manual DI, a DI framework, and a service locator on testability, readability, and coupling in a large Python codebase.
Follow-up Questions
- How does FastAPI's Depends implement dependency injection?
- When is a service locator preferable to explicit DI?