似乎人们真的不明白依赖注入和控制反转意味着什么了。

使用控制反转的实践是让类或函数依赖于其他类或函数，但是与其在类或函数代码中创建实例，不如将它们作为参数接收，这样就可以实现松耦合。这有很多好处，如更多的可测试性和实现利斯科夫替换原理。

You see, by working with interfaces and injections, your code gets more maintainable, since you can change the behavior easily, because you won't have to rewrite a single line of code (maybe a line or two on the DI configuration) of your class to change its behavior, since the classes that implement the interface your class is waiting for can vary independently as long as they follow the interface. One of the best strategies to keep code decoupled and easy to maintain is to follow at least the single responsibility, substitution and dependency inversion principles.

What's a DI library good for if you can instantiate an object yourself inside a package and import it to inject it yourself? The chosen answer is right, since java has no procedural sections (code outside of classes), all that goes into boring configuration xml's, hence the need of a class to instantiate and inject dependencies on a lazy load fashion so you don't blow away your performance, while on python you just code the injections in the "procedural" (code outside classes) sections of your code.

我同意@Jorg的观点，在Python中DI/IoC是可能的，更简单，甚至更漂亮。缺少的是支持它的框架，但也有一些例外。举几个我想到的例子:

Django注释允许您将自己的Comment类与自定义逻辑和表单连接起来。(更多信息) Django允许你使用一个自定义Profile对象来附加到你的User模型。这不是完全的IoC，但却是一个很好的方法。就我个人而言，我希望像注释框架那样取代hole User模型。(更多信息)

我的观点是，在大多数Python应用程序中，您不需要它，即使您需要它，许多讨厌Java的人(以及自认为是开发人员的无能的摆弄者)很可能认为它很糟糕，只是因为它在Java中很受欢迎。

An IoC system is actually useful when you have complex networks of objects, where each object may be a dependency for several others and, in turn, be itself a dependant on other objects. In such a case you'll want to define all these objects once and have a mechanism to put them together automatically, based on as many implicit rules as possible. If you also have configuration to be defined in a simple way by the application user/administrator, that's an additional reason to desire an IoC system that can read its components from something like a simple XML file (which would be the configuration).

典型的Python应用程序要简单得多，只有一堆脚本，没有这么复杂的体系结构。就我个人而言，我知道IoC实际上是什么(与那些在这里写下某些答案的人相反)，在我有限的Python经验中，我从来没有觉得需要它(而且我不会在任何地方都使用Spring，当它所提供的优势不足以证明它的开发开销时)。

也就是说，在Python中，IoC方法实际上是有用的，事实上，我在这里读到Django使用了它。

上述相同的推理可以应用于Java世界中的面向方面编程，不同的是，AOP真正有价值的情况的数量甚至更有限。

我并不认为DI/IoC在Python中很少见。然而，不常见的是DI/IoC框架/容器。

想想看:DI容器做什么?它允许你

将独立的组件连接成一个完整的应用程序…… ．.． 在运行时。

我们为“连接在一起”和“在运行时”命名:

脚本 动态

因此，DI容器只是动态脚本语言的解释器。实际上，让我换一种说法:典型的Java/。NET DI容器只是一个蹩脚的解释器，适用于一种非常糟糕的动态脚本语言，语法非常难看，有时是基于xml的。

当您使用Python编程时，为什么要使用一种丑陋、糟糕的脚本语言，而不是拥有一种漂亮、出色的脚本语言呢?实际上，这是一个更普遍的问题:当您使用几乎任何语言进行编程时，当您可以使用Jython和IronPython时，为什么还要使用一种丑陋、糟糕的脚本语言呢?

因此，概括一下:DI/IoC的实践在Python中和在Java中一样重要，原因完全相同。然而，DI/IoC的实现是内置在语言中，并且通常是轻量级的，以至于完全消失了。

(Here's a brief aside for an analogy: in assembly, a subroutine call is a pretty major deal - you have to save your local variables and registers to memory, save your return address somewhere, change the instruction pointer to the subroutine you are calling, arrange for it to somehow jump back into your subroutine when it is finished, put the arguments somewhere where the callee can find them, and so on. IOW: in assembly, "subroutine call" is a Design Pattern, and before there were languages like Fortran which had subroutine calls built in, people were building their own "subroutine frameworks". Would you say that subroutine calls are "uncommon" in Python, just because you don't use subroutine frameworks?)

顺便说一句:关于如何将DI引入逻辑结论的例子，可以看看Gilad Bracha的Newspeak编程语言和他关于这个主题的文章:

被认为有害的构造物 注射 禁止进口(续)

所有基于DI的pytest夹具(来源)

IoC/DI是一个设计概念，但不幸的是，它经常被认为是一个适用于某些语言(或类型系统)的概念。我希望看到依赖注入容器在Python中变得更加流行。有Spring，但它是一个超级框架，似乎是Java概念的直接移植，没有太多考虑“Python方式”。

鉴于Python 3中的注释，我决定尝试一个功能齐全但简单的依赖注入容器:https://github.com/zsims/dic。它基于。net依赖注入容器的一些概念(如果你曾经在那个领域玩过，IMO是很棒的)，但与Python概念发生了变化。