Haven't used Python in several years, but I would say that it has more to do with it being a dynamically typed language than anything else. For a simple example, in Java, if I wanted to test that something wrote to standard out appropriately I could use DI and pass in any PrintStream to capture the text being written and verify it. When I'm working in Ruby, however, I can dynamically replace the 'puts' method on STDOUT to do the verify, leaving DI completely out of the picture. If the only reason I'm creating an abstraction is to test the class that's using it (think File system operations or the clock in Java) then DI/IoC creates unnecessary complexity in the solution.

IoC和DI在成熟的Python代码中非常常见。由于鸭子类型，您不需要框架来实现依赖注入。

最好的例子是如何使用settings.py设置Django应用程序:

# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django_redis.cache.RedisCache',
        'LOCATION': REDIS_URL + '/1',
    },
    'local': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',
        'LOCATION': 'snowflake',
    }
}

Django Rest Framework充分利用了DI:

class FooView(APIView):
    # The "injected" dependencies:
    permission_classes = (IsAuthenticated, )
    throttle_classes = (ScopedRateThrottle, )
    parser_classes = (parsers.FormParser, parsers.JSONParser, parsers.MultiPartParser)
    renderer_classes = (renderers.JSONRenderer,)

    def get(self, request, *args, **kwargs):
        pass

    def post(self, request, *args, **kwargs):
        pass

让我提醒一下(来源):

“依赖注入”是一个5美分概念的25美元术语。[…依赖注入意味着给一个对象它的实例变量。[…]。

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

实际上，使用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中动态计算简单的布尔逻辑。

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

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

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应用程序中，您不需要它，即使您需要它，许多讨厌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真正有价值的情况的数量甚至更有限。