Чому IoC / DI не часто зустрічається в Python?

У Java IoC / DI - дуже поширена практика, яка широко використовується у веб-додатках, майже у всіх доступних рамках та Java EE. З іншого боку, є також багато великих веб-додатків Python, але крім Zope (яку я чув, що це дуже жахливо), IoC, здається, не дуже поширений у світі Python. (Назвіть, будь ласка, кілька прикладів, якщо ви вважаєте, що я помиляюся).

Звичайно, є кілька клонів популярних фреймворків Java IoC, доступних для Python, наприклад Springpython . Але жодна з них, здається, не звикла практично. Принаймні, я ніколи не натрапляв на веб-додаток на основі Django або sqlalchemy +, <insert your favorite wsgi toolkit here>який використовує щось подібне.

На мою думку, IoC має розумні переваги і полегшить заміну, наприклад, моделі django-default-user-user, але широке використання класів інтерфейсів та IoC в Python виглядає дещо дивним і не «пітонічним». Але, можливо, хтось має краще пояснення, чому IoC не використовується широко в Python.

Я насправді не думаю, що DI / IoC є такою рідкістю в Python. Однак , рідкість - це рамки / контейнери DI / IoC .

Подумайте: що робить контейнер DI? Це дозволяє вам

1. з'єднайте незалежні компоненти в повну програму ...
2. ... під час виконання.

У нас є назви "проводка разом" і "під час виконання":

1. сценаріїв
2. динамічний

Отже, контейнер DI - це не що інше, як інтерпретатор мови динамічного сценарію. Насправді, дозвольте перефразувати це: типовий контейнер для Java / .NET DI - це не що інше, як хитрий інтерпретатор дійсно поганої динамічної мови сценаріїв із непотворним, іноді на основі XML синтаксисом.

Коли ви програмуєте в Python, чому ви хочете використовувати некрасиву, погану мову сценаріїв, коли у вас є красива, блискуча мова сценаріїв? Насправді, це більш загальне питання: коли ви програмуєте майже будь-якою мовою, чому ви хочете використовувати некрасиву, погану мову сценаріїв, коли у вас є Jython та IronPython?

Отже, підводячи підсумки: практика DI / IoC настільки ж важлива в Python, як і в Java, з точно тих же причин. Однак реалізація DI / IoC вбудована в мову і часто настільки легка, що повністю зникає.

(Ось короткий відбій для аналогії: при складанні виклик підпрограми є досить важливою справою - вам потрібно зберегти локальні змінні та регістри в пам'яті, десь зберегти свою зворотну адресу, змінити вказівник інструкцій на підпрограму, яку ви телефонуєте, домовтеся, щоб якимось чином перескочив назад у вашу підпрограму, коли вона закінчиться, покладіть аргументи кудись, де їх може знайти їх, і т. д. IOW: у зборі «виклик підпрограми» - це шаблон дизайну, і раніше існували такі мови, як У Fortran, в якому були вбудовані виклики підпрограми, люди будували свої власні "рамки підпрограми". Ви б сказали, що виклики підпрограми є "рідкістю" в Python, тільки тому, що ви не використовуєте рамки підпрограми?)

BTW: для прикладу того, як виглядає сприйняття DI до його логічного завершення, подивіться на мову новомовного програмування Гілада Брача та його статті на цю тему:

• Конструктори вважаються шкідливими
• Смертельна ін'єкція
• Заборона на імпорт ( продовження )

Частина його - це те, як працює модульна система в Python. Ви можете отримати свого роду "одиночний" безкоштовно, просто імпортувавши його з модуля. Визначте фактичний екземпляр об'єкта в модулі, і тоді будь-який код клієнта може імпортувати його і фактично отримати робочий, повністю побудований / заселений об'єкт.

Це на відміну від Java, куди ви не імпортуєте фактичні екземпляри об'єктів. Це означає, що вам завжди доведеться інстанціювати їх самостійно (або використовувати якийсь підхід у стилі IoC / DI). Ви можете пом'якшити клопоти з необхідності придумати все самостійно, встановивши статичні фабричні методи (або фактичні фабричні класи), але тоді ви все одно несете ресурси, що фактично створюють нові.

IoC та DI дуже поширені в зрілому коді Python. Вам просто не потрібна основа для реалізації DI завдяки друкуванню качок.

Найкращий приклад - налаштування програми Django за допомогою settings.py:

# 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

Нагадаю ( джерело ):

"Ін'єкційна залежність" - це термін, що становить 25 доларів, для концепції 5 центів. [...] Введення залежності залежить від надання об'єкту змінних його примірників. [...].

Джанго чудово використовує інверсію контролю. Наприклад, сервер бази даних вибирається файлом конфігурації, тоді рамка забезпечує відповідні екземпляри обгортки бази даних для клієнтів бази даних.

Різниця полягає в тому, що Python має першокласні типи. Типи даних, включаючи класи, самі по собі є об'єктами. Якщо ви хочете щось використовувати для певного класу, просто назвіть клас. Наприклад:

if config_dbms_name == 'postgresql':
    import psycopg
    self.database_interface = psycopg
elif config_dbms_name == 'mysql':
    ...

Пізніше код може створити інтерфейс бази даних, написавши:

my_db_connection = self.database_interface()
# Do stuff with database.

Замість заводських функцій котлоагрегатів, які потрібні Java та C ++, Python виконує це одним або двома рядками звичайного коду. Це сила функціонального та імперативного програмування.

Здається, що люди справді не отримують того, що вводить залежність та інверсія управління.

Практика використання інверсії управління полягає в тому, щоб мати класи або функції, які залежать від інших класів або функцій, але замість того, щоб створювати екземпляри, що входять до класу коду функції, краще отримувати його як параметр, тому може бути досягнуто вільне з'єднання. Це має багато переваг, як більш перевіряти і досягти принципу заміни Ліскова.

Розуміючи, працюючи з інтерфейсами та ін'єкціями, ваш код стає більш керованим, оскільки ви можете легко змінити поведінку, оскільки вам не доведеться переписувати один рядок коду (можливо, рядок чи два в конфігурації DI) вашого клас, щоб змінити свою поведінку, оскільки класи, які реалізують інтерфейс, якого очікує ваш клас, можуть змінюватися незалежно, доки вони слідують за інтерфейсом. Однією з найкращих стратегій, щоб тримати код, нерозв'язаний та простий у обслуговуванні, є дотримання принаймні єдиних принципів відповідальності, заміни та інверсії залежності.

Для чого корисна бібліотека DI, якщо ви можете інстанціювати об’єкт самостійно всередині пакета та імпортувати його, щоб ввести його самостійно? Обрана відповідь правильна, оскільки java не має процедурних розділів (код за межами класів), все, що входить у нудну конфігурацію xml, отже, необхідність класу інстанціювати та вводити залежності від ледачого навантаження, щоб не дути ваша ефективність, тоді як на python ви просто кодуєте ін'єкції в "процедурних" (код поза класами) розділах вашого коду

Не використовував Python протягом декількох років, але я б сказав, що це більше стосується того, що мова є динамічно набраною мовою, ніж будь-що інше. На прикладі простого прикладу, в Java, якщо я хотів перевірити, що щось написане для стандартного стандарту, я міг би використати DI і передати будь-яку програму PrintStream, щоб захопити написаний текст і перевірити його. Однак, працюючи в Ruby, я можу динамічно замінити метод 'put' на STDOUT, щоб зробити перевірку, не залишаючи DI повністю поза картиною. Якщо єдиною причиною я створюю абстракцію, є тестування класу, який він використовує (думаю, що операції з файловою системою або годинник на Java), то DI / IoC створює непотрібну складність рішення.

Насправді, досить просто написати достатньо чистий і компактний код за допомогою DI (мені цікаво, чи буде це / залишатися пітонічним , але все одно :)), наприклад, я фактично переглядаю цей спосіб кодування:

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, за замовчуванням.

PS Я також розмістив більший приклад такого наївного підходу при динамічному оцінюванні простої булевої логіки в Python .

IoC / DI - це концепція дизайну, але, на жаль, її часто сприймають як концепцію, яка застосовується до певних мов (або машинописних систем). Я хотів би бачити, щоб контейнери для ін'єкцій залежностей стали набагато популярнішими в Python. Там весна, але це суперкадр і, здається, є прямим портом концепцій Java без особливого розгляду для "Шлях Python".

З огляду на Анотації в Python 3, я вирішив отримати тріщину у повнофункціональному, але простому контейнері для ін'єкцій залежності: https://github.com/zsims/dic . Він заснований на деяких поняттях з контейнера для ін'єкцій залежності .NET (який IMO є фантастичним, якщо ви коли-небудь граєте в цьому просторі), але мутований з концепціями Python.

Я думаю, що через динамічний характер пітона люди часто не бачать потреби в іншому динамічному середовищі. Коли клас успадковує новий об'єкт стилю, ви можете динамічно створювати нову змінну ( https://wiki.python.org/moin/NewClassVsClassicClass ).

тобто в звичайному пітоні:

#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, це може бути те, що ви шукаєте.

тобто в піоку

from libs.service_locator import ServiceLocator

#main.py
ServiceLocator.register(PostgresConnection)

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

Я повертаюсь до відповіді "Йорг W Міттаг": "Реалізація DI / IoC Python настільки легка, що повністю зникає".

Щоб створити резервну копію цього твердження, подивіться на приклад відомого Мартіна Фаулера, перенесеного з Java на Python: Python: Design_Patterns: Inversion_of_Control

Як видно з вищенаведеного посилання, "Контейнер" на Python може бути записаний у 8 рядках коду:

class Container:
    def __init__(self, system_data):
        for component_name, component_class, component_args in system_data:
            if type(component_class) == types.ClassType:
                args = [self.__dict__[arg] for arg in component_args]
                self.__dict__[component_name] = component_class(*args)
            else:
                self.__dict__[component_name] = component_class

Мої 2 центи полягають у тому, що у більшості додатків Python він вам не потрібен, і навіть якщо він вам потрібен, є велика ймовірність, що багато ненависників Java (і некомпетентні скрипачі, які вважають розробниками) вважають це як щось погане, лише тому, що воно популярне на Java .

Система IoC насправді корисна, коли у вас є складні мережі об'єктів, де кожен об'єкт може бути залежністю для кількох інших і, у свою чергу, бути самим залежним від інших об'єктів. У такому випадку ви хочете один раз визначити всі ці об'єкти і мати механізм їх автоматичного з’єднання разом на основі якомога більше неявних правил. Якщо ви також маєте конфігурацію, яку слід просто визначити користувачем / адміністратором програми, це додатковий привід бажати системи IoC, яка може читати її компоненти з чогось на зразок простого XML-файлу (яка би була конфігурація).

Типовий додаток Python набагато простіший, просто купа сценаріїв, без такої складної архітектури. Особисто я знаю, що насправді є IoC (всупереч тим, хто писав тут певні відповіді), і я ніколи не відчував потреби в цьому в моєму обмеженому досвіді Python (також я не використовую Весну скрізь, не коли переваги це дає не виправдовувати його розвиток накладних витрат).

Однак, є ситуації з Python, коли підхід IoC насправді корисний, і, власне, я прочитав тут, що Django використовує його.

Це ж міркування вище можна було б застосувати до орієнтованого на аспекти програмування у світі Java, з тією різницею, що кількість випадків, коли AOP дійсно вартує, ще більше обмежена.

світильники для пістетів на основі DI ( джерело )

Я погоджуюся з @Jorg в тому, що DI / IoC можливий, простіший і ще красивіший в Python. Не вистачає рамки, яка її підтримує, але є кілька винятків. Навести кілька прикладів, які мені спадають на думку:

• Зауваження Джанго дозволяють передавати свій власний клас коментарів за допомогою власної логіки та форм. [Більше інформації]

• Django дозволяє використовувати спеціальний об'єкт профілю для приєднання до вашої моделі користувача. Це не зовсім IoC, але це хороший підхід. Особисто я хотів би замінити дірку Модель користувача, як це робиться в рамках коментарів. [Більше інформації]

На мою думку, такі речі, як ін'єкція залежності, - це симптоми жорсткої та надскладної структури. Коли основна частина коду стає занадто вагомою, щоб легко змінюватись, вам виникає необхідність вибирати невеликі її частини, визначати для них інтерфейси, а потім дозволяти людям змінювати поведінку за допомогою об'єктів, що підключаються до цих інтерфейсів. Це все добре і добре, але краще уникати такої складності в першу чергу.

Це також симптом мови, що має статичний тип. Коли єдиним інструментом, яким ви маєте висловити абстракцію, є спадкування, то це майже все, що ви використовуєте всюди. Сказавши це, C ++ досить схожий, але ніколи не сприймав захоплення будівельниками та інтерфейсами скрізь, чим займалися розробники Java. Легко переборщити з мрією бути гнучким та розширюваним ціною написання занадто багато загального коду з малою реальною вигодою . Я думаю, що це культура.

Як правило, я думаю, що люди Python звикли вибирати правильний інструмент для роботи, який є цілісним і простим цілим, а не Єдиним вірним інструментом (із тисячею можливих плагінів), який може робити все, що завгодно, але пропонує здивований масив можливих перестановок конфігурації . Все ще є взаємозамінні частини, де це необхідно, але без необхідності великого формалізму визначення фіксованих інтерфейсів, завдяки гнучкості введення качок та відносній простоті мови.

На відміну від сильної набраної природи на Яві. Поведінка качки Python дозволяє легко наводити об'єкти навколо.

Розробники Java роблять акцент на побудові структури класу та взаємозв'язку між об'єктами, зберігаючи гнучкість. IoC є надзвичайно важливим для досягнення цього.

Розробники Python зосереджуються на виконанні роботи. Вони просто проводять заняття, коли їм це потрібно. Вони навіть не повинні турбуватися про тип класу. Поки вона може стукати, це качка! Ця природа не залишає місця для IoC.