la façon dont nous faisons l'injection de dépendances dans notre projet est en utilisant le injecter lib. Découvrez documentation. Je recommande fortement de l'utiliser pour DI. Cela n'a aucun sens avec une seule fonction, mais commence à avoir beaucoup de sens quand vous devez gérer plusieurs sources de données, etc.

en suivant votre exemple, cela pourrait être quelque chose de similaire à:

# framework.py
class FrameworkClass():
    def __init__(self, func):
        self.func = func

    def do_the_job(self):
        # some stuff
        self.func()

Votre fonction personnalisée:

# my_stuff.py
def my_func():
    print('aww yiss')

quelque part dans l'application vous souhaitez créer un fichier d'amorçage, qui conserve la trace de toutes les dépendances définies:

# bootstrap.py
import inject
from .my_stuff import my_func

def configure_injection(binder):
    binder.bind(FrameworkClass, FrameworkClass(my_func))

inject.configure(configure_injection)

Et puis vous pouvez consommer le code de cette façon:

# some_module.py (has to be loaded with bootstrap.py already loaded somewhere in your app)
import inject
from .framework import FrameworkClass

framework_instance = inject.instance(FrameworkClass)
framework_instance.do_the_job()

j'ai bien peur que ce soit aussi pythonique qu'il peut l'être (le module a certains Python swegness comme décorateurs à injecter par paramètre etc - vérifier les docs), car python n'a pas de trucs fantaisistes comme des interfaces ou des suggestions de type.

répondez à votre question directement serait très dur. Je pense la vraie question Est: python a-t-il un support natif pour DI? Et la réponse est malheureusement non.

Il y a quelque temps, j'ai écrit des microframes d'injection de dépendances avec l'ambition de les rendre Pythoniques - Injecteur De Dépendance. Voilà à quoi ressemble votre code en cas d'utilisation:

"""Example of dependency injection in Python."""

import logging
import sqlite3

import boto.s3.connection

import example.main
import example.services

import dependency_injector.containers as containers
import dependency_injector.providers as providers


class Platform(containers.DeclarativeContainer):
    """IoC container of platform service providers."""

    logger = providers.Singleton(logging.Logger, name='example')

    database = providers.Singleton(sqlite3.connect, ':memory:')

    s3 = providers.Singleton(boto.s3.connection.S3Connection,
                             aws_access_key_id='KEY',
                             aws_secret_access_key='SECRET')


class Services(containers.DeclarativeContainer):
    """IoC container of business service providers."""

    users = providers.Factory(example.services.UsersService,
                              logger=Platform.logger,
                              db=Platform.database)

    auth = providers.Factory(example.services.AuthService,
                             logger=Platform.logger,
                             db=Platform.database,
                             token_ttl=3600)

    photos = providers.Factory(example.services.PhotosService,
                               logger=Platform.logger,
                               db=Platform.database,
                               s3=Platform.s3)


class Application(containers.DeclarativeContainer):
    """IoC container of application component providers."""

    main = providers.Callable(example.main.main,
                              users_service=Services.users,
                              auth_service=Services.auth,
                              photos_service=Services.photos)

Voici un lien vers une description plus complète de cet exemple - http://python-dependency-injector.ets-labs.org/examples/services_miniapp.html

j'Espère que ça peut aider un peu. Pour plus d'informations, veuillez visiter:

• GitHub https://github.com/ets-labs/python-dependency-injector
• Docs http://python-dependency-injector.ets-labs.org/

je pense que DI et peut-être AOP ne sont pas généralement considérés comme Pythonic en raison des préférences typiques des développeurs Python, plutôt que des fonctionnalités de langage.

en fait, vous pouvez implémenter a base DI-cadre dans <100 lignes, en utilisant des métaclasses et des décorateurs de classe.

pour une solution moins invasive, ces constructions peuvent être utilisées pour intégrer des implémentations personnalisées dans un cadre générique.

en raison de L'implémentation de Python OOP, le CIO et l'injection de dépendances ne sont pas des pratiques courantes dans le monde de Python. Néanmoins l'approche semblait prometteuse même pour Python.

• pour utiliser des dépendances comme arguments, même si c'est une classe définie dans la même base de code, c'est une approche dramatiquement non-pythonique. Python est un langage OOP avec un beau et élégant modèle OOP, donc l'ignorer n'est pas une bonne idée.
• définir des classes pleines de méthodes abstraites juste pour imiter le type d'interface est bizarre aussi.
• D'énormes solutions de rechange sont trop peu élégantes pour être utilisées.
• Je n'aime pas non plus utiliser les bibliothèques quand tout ce dont j'ai besoin est un petit modèle.

Donc mon solution est:

# Framework internal
def MetaIoC(name, bases, namespace):
    cls = type("IoC{}".format(name), tuple(), namespace)
    return type(name, bases + (cls,), {})


# Entities level                                        
class Entity:
    def _lower_level_meth(self):
        raise NotImplementedError

    @property
    def entity_prop(self):
        return super(Entity, self)._lower_level_meth()


# Adapters level
class ImplementedEntity(Entity, metaclass=MetaIoC):          
    __private = 'private attribute value'                    

    def __init__(self, pub_attr):                            
        self.pub_attr = pub_attr                             

    def _lower_level_meth(self):                             
        print('{}\n{}'.format(self.pub_attr, self.__private))


# Infrastructure level                                       
if __name__ == '__main__':                                   
    ENTITY = ImplementedEntity('public attribute value')     
    ENTITY.entity_prop