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

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

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.

我认为由于python的动态特性，人们并不经常看到对另一个动态框架的需求。当一个类继承了new-style 'object'时，你可以动态地创建一个新变量(https://wiki.python.org/moin/NewClassVsClassicClass)。

即。 在普通python中:

#application.py
class Application(object):
    def __init__(self):
        pass

#main.py
Application.postgres_connection = PostgresConnection()

#other.py
postgres_connection = Application.postgres_connection
db_data = postgres_connection.fetchone()

不过，看看https://github.com/noodleflake/pyioc，这可能就是你要找的。

即pyioc

from libs.service_locator import ServiceLocator

#main.py
ServiceLocator.register(PostgresConnection)

#other.py
postgres_connection = ServiceLocator.resolve(PostgresConnection)
db_data = postgres_connection.fetchone()

你可以手动使用Python进行依赖注入，但手动方法有其缺点:

大量的样板代码来进行连接。你可以使用Python的动态特性来进行注入，但这样你就失去了IDE的支持(例如，PyCharm中的Ctrl+Space)，并且你会使代码更难理解和调试 没有标准:每个程序员都有自己解决相同问题的方法，这导致了重新发明轮子，理解彼此的代码很快就会成为一种痛苦。依赖注入库为插件提供了简单的框架

要做到这一切，我们需要一个依赖注入框架，例如这个https://python-dependency-injector.ets-labs.org/index.html似乎是Python最成熟的依赖注入框架。

对于较小的应用程序，DI容器是不必要的，对于任何有几百行代码或更多的东西，DI容器是必须的，以保持你的代码可维护性。

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

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

实际上，使用DI编写足够干净和紧凑的代码是相当容易的(我想知道，它会/保持python化吗，但无论如何:))，例如，我实际上更喜欢这种编码方式:

def polite(name_str):
    return "dear " + name_str

def rude(name_str):
    return name_str + ", you, moron"

def greet(name_str, call=polite):
    print "Hello, " + call(name_str) + "!"

_

>>greet("Peter")
Hello, dear Peter!
>>greet("Jack", rude)
Hello, Jack, you, moron!

是的，这可以被看作是参数化函数/类的一种简单形式，但它确实起作用了。所以，也许Python默认包含的电池在这里也足够了。

另外，我还发布了一个更大的例子，说明了这种简单的方法在Python中动态计算简单的布尔逻辑。

IoC容器主要使用**kwarg来“模仿”

class A:
    def __init__(self, **kwargs):
        print(kwargs)

Class B:
    pass

Class C:
    pass

Ainstance = A(b=B, c=C)