Top 100 Questions

Топ-100 найпопулярніших питань⚑

1. Що таке GIL? Які проблеми в нього є?⚑

🔥 96/100 · python/gil_threads_processes.md

Summary

GIL - Global Interpreter Lock - Глобальний блок інтерпретатора - це механізм, який регулює виконання потоків у межах інтерпретатора CPython, запобігаючи одночасному виконанню кількох потоків Python-коду. Він забезпечує безпеку доступу до пам’яті під час виконання інтерпретатора, але водночас створює значні обмеження для паралельного виконання обчислювальних задач. GIL — це не просто обмеження. Він є компромісом між продуктивністю, безпекою пам’яті та простотою реалізації інтерпретатора.

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

GIL — це блокування, яке має бути захоплено перед будь-яким доступом до Python (не так важливо, чи це виконується Python-код або виклики Python C API).

GIL необхідний для забезпечення безпеки пам’яті в Python та потокобезпечності загалом. Без GIL довелося б додатково синхронізувати доступ до кожного об’єкта у пам’яті, що суттєво ускладнило б код і зменшило б продуктивність однопоточних програм. Тому GIL також покращує продуктивність у сценаріях, де код виконується в одному потоці. Для однопоточних задач відсутність накладних витрат на синхронізацію робить виконання швидшим. Це особливо корисно для багатьох класичних сценаріїв використання Python, таких як обробка скриптів, автоматизація або створення вебсервісів.

Також GIL робить розробку розширень на C набагато простішою. Багато бібліотек на C розраховують на те, що GIL захищає доступ до об’єктів Python. Це дозволяє бібліотекам уникати ручної синхронізації та працювати з об’єктами Python у безпечному середовищі.

Принцип роботи простий. Потоки утримують GIL, поки вони виконуються. Однак, вони звільняють його при блокуванні для операцій введення-виведення. Кожного разу, коли поток змушений чекати, інші готові до виконання потоки отримують шанс запуститися.

PyObject*
_PyEval_EvalFrameDefault(PyThreadState *tstate, PyFrameObject *f, int throwflag)
{
    // local variable declarations, etc.
    // evaluation loop
    for (;;) {
        // eval_breaker signals whether bytecode execution must pause, e.g. another thread requested the GIL
        if (_Py_atomic_load_relaxed(eval_breaker)) {
            // eval_frame_handle_pending() pauses bytecode execution, releases the GIL, then waits for it again
            if (eval_frame_handle_pending(tstate) != 0) {
                goto error;
            }
        }

        NEXTOPARG(); // fetch the next bytecode instruction

        switch (opcode) {
            case TARGET(NOP) {
                FAST_DISPATCH(); // next iteration
            }
            case TARGET(LOAD_FAST) {
                FAST_DISPATCH(); // next iteration
            }
            // 117 more case blocks covering every possible opcode
        }
        // error handling
    }
    // cleanup
}

Функція __PyEval_EvalFrameDefault_ відповідає за обробку байт-коду і виконання його інструкцій.

Коли потік починає роботу, він захоплює GIL. Через певний час планувальник процесів вирішує, що поточний потік виконав достатньо роботи і передає управління наступному потоку. Потік №2 бачить, що GIL захоплений, тому він не продовжує роботу, а сам себе переводить у сплячий режим, уступаючи процесор потоку №1.

Але потік не може утримувати GIL нескінченно. До версії Python 3.2 GIL перемикався кожні 100 тіків (байткод-інструкцій Python, sys.setcheckinterval). У пізніших версіях GIL може бути утримано потоком не більше 5 мс. Значення цього інтервалу можна змінити за допомогою функції sys.setswitchinterval(). GIL також звільняється, якщо потік здійснює системний виклик, працює з диском або мережею.

import threading
import time

def run_io_task(name: str):
    print(f'{name} started I/O operation')
    time.sleep(2)
    print(f'{name} finished I/O operation')

threads = [threading.Thread(target=run_io_task, args=(f'Thread-{i}',)) for i in range(4)]

for t in threads:
    t.start()

for t in threads:
    t.join()

Кожен потік викликає time.sleep(2) інструкцію, яка звільняє GIL. Поки один потік чекає завершення sleep, інші потоки можуть виконуватися. У результаті всі потоки працюють ефективно, і програма виконується швидше (приблизно 2 секунди), ніж при послідовному виконанні (приблизно 8 секунд).

На глибокому рівні механізм роботи GIL реалізовано через примітиви синхронізації операційної системи. У CPython це зазвичай м’ютекси для блокування та семафори для сигналізації між потоками. У сучасних версіях Python (починаючи з Python 3.2) GIL реалізовано через м’ютекс і умови (pthreads condition variables) для підвищення продуктивності.

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

Проблема полягає в тому, що через GIL далеко не всі завдання можуть бути вирішені у потоках. Навпаки, їх використання часто знижує продуктивність програми (у випадку CPU-bound завдань). Використання потоків вимагає контролю доступу до загальних ресурсів, таких як словники, файли, підключення до бази даних.

• GIL спрощує інтеграцію незахищених від багатопотоковості (non thread safe) бібліотек на C. Завдяки GIL у нас є так багато швидких модулів та зв'язків майже до всього.
• Бібліотекам на C доступний механізм керування GIL. Наприклад, NumPy звільняє його під час тривалих операцій.

На практиці, GIL у Python робить непотрібною ідею використання потоків для паралелізму в обчислювальних задачах. Вони будуть працювати послідовно навіть на багатопроцесорній системі. У випадку CPU-bound задач програма не прискориться, а тільки сповільниться, оскільки тепер потокам доведеться поділити процесорний час навпіл. При цьому операції I/O GIL не сповільнює, оскільки перед системним викликом потік звільняє GIL.

GIL - це деталь реалізації, а не частина специфікації мови. Він є не тільки в CPython, а й у PyPy; натомість Jython та IronPython GIL не мають (покладаються на потоки хостової платформи - JVM та .NET відповідно).

Способи обходу GIL

Кілька стандартних шляхів отримати справжню паралельність попри GIL у CPython:

• Багатопроцесність. multiprocessing, concurrent.futures.ProcessPoolExecutor. Кожен процес має власний інтерпретатор і власний GIL, тому Python-код виконується паралельно на різних ядрах. Накладні витрати - порядку мегабайт пам'яті на процес і необхідність IPC замість прямих посилань на об'єкти.
• GIL відпускається на IO-блокуючих syscall'ах (recv, read, accept, time.sleep). Поки потік чекає у ядрі, інші потоки виконують байт-код. Тому потоки залишаються корисними для IO-bound задач: 100 потоків, що чекають на сокетах, не блокують одне одного.
• C-розширення, що явно звільняють GIL. Бібліотеки на C/C++/Rust, які виконують довгі обчислення, можуть звільнити GIL через макрос Py_BEGIN_ALLOW_THREADS на час чистого C-коду. NumPy, scipy, lxml, hashlib (для великих блоків), pandas (частково) роблять це. У результаті CPU-bound операція в NumPy через кілька потоків справді розпаралелюється.
• Sub-interpreters (PEP 684, PEP 734). Кілька ізольованих інтерпретаторів у межах одного процесу, кожен з власним GIL. Доступне з Python 3.12 на рівні C API (PEP 684 - per-interpreter GIL); з Python 3.14 додано stdlib-модуль concurrent.interpreters (PEP 734) з Python-API. Об'єкти не діляться між інтерпретаторами напряму; обмін - через канали / pickle. Накладні витрати менші за multiprocessing (без окремих процесів), але вища складність моделі ізоляції.
• No-GIL CPython (PEP 703). Експериментальна збірка CPython без GIL (--disable-gil), доступна з 3.13 як опція. Дає справжню паралельність потоків без зміни моделі програмування, ціною накладних витрат на atomic-операції з лічильниками посилань і складнішої сумісності з C-розширеннями. Поки що "free-threaded" режим - офіційно підтримувана експериментальна функція, не дефолт; для продакшну орієнтуватися на ноти релізу конкретної версії.

Links

• GIL у Python. Ключ до стабільності чи ворог продуктивності - dou.ua
• GlobalInterpreterLock
• Как устроен GIL в Python
• Embracing the Global Interpreter Lock (GIL) - David Beazley

2. Наслідування⚑

🔥 94/100 · computer_science/oop.md

Summary

Наслідування - це один з ключових принципів ООП, який дозволяє створювати новий клас на основі вже існуючого класу (батьківського класу). Наслідування дозволяє використовувати властивості та методи батьківського класу в новому класі, що допомагає уникнути повторення коду та забезпечити використання вже існуючого функціоналу. Дочірній клас містить всі атрибути батьківського класу, при цьому деякі з них можуть бути перевизначені в дочірньому. Cтворення підкласу має супроводжуватися ідеєю спеціалізації - відношенням is-a (є).

У Python, наслідування здійснюється за допомогою вказання батьківського класу у визначенні нового класу в дужках після імені класу:

class ParentClass:
    def parent_method(self):
        print("This is a method from the parent class")

class ChildClass(ParentClass):
    def child_method(self):
        print("This is a method from the child class")

У цьому прикладі ChildClass наслідує всі властивості та методи з ParentClass. Це означає, що ChildClass буде мати доступ до методу parent_method, а також може мати свої власні методи, наприклад, child_method.

При наслідуванні, клас, який успадковує властивості, називається підкласом або дочірнім класом, а клас, від якого успадковуються властивості, називається батьківським класом або суперкласом.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

dog = Dog("Buddy")
cat = Cat("Whiskers")

print(dog.name)  # Output: Buddy
print(dog.speak())  # Output: Woof!

print(cat.name)  # Output: Whiskers
print(cat.speak())  # Output: Meow!

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

Ми можемо отримати доступ до методів класу-предку або по прямому зверненню, або з допомогою функції super().

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

Хоча завжди повинні дбати про повторне використання коду, не варто змушувати дизайн використовувати успадкування для повторного використання коду лише тому, що отримуємо методи від батьківського класу безкоштовно. Правильний спосіб повторного використання коду полягає в тому, щоб мати дуже зчеплені (highly cohesive) об’єкти, які можна легко компонувати та працювати в багатьох контекстах.

3. Генератор vs Ітератор⚑

🔥 85/100 · python/iterator_and_generator.md

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

Links

• Генераторы-итераторы Python
• Итерируемый объект, итератор и генератор
• https://pavel-karateev.gitbook.io/intermediate-python/struktury-dannykh/generators

4. Що таке декоратори. Навіщо вони потрібні⚑

🔥 76/100 · python/decorators.md

Summary

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

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

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

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

Декоратор використовує механізм замикання.

Приклад декоратора в Python, який друкує повідомлення перед виконанням функції.

def decorator(func):  
    def wrapper(*args, **kwargs):  
        print("Some logic before original func")  
        return func(*args, **kwargs)  
    return wrapper  

@decorator  
def my_function():  
    print("Original function")

print(my_function.__name__)  # wrapper # NOTE: because we didn't use wraps
print(my_function.__closure__[0])  # <cell at 0x10...: function object at 0x108e25170>
print(my_function.__closure__[0].cell_contents.__name__)  # my_function

Декоратор як патерн (GoF) проти декоратора Python

Суть патерну Декоратор: маючи об'єкт і потребу виконувати додаткову роботу, його не змінюють, а створюють обгортку, що (1) сумісна з вихідним об'єктом за інтерфейсом і (2) за потреби делегує йому роботу. Такий декоратор добре лягає на DI та фабрики: змінюють код створення об'єкта, а не код, що його використовує. Типовий приклад - кешування запитів до зовнішньої системи.

Декоратор Python через @ виконує схожу роль, але з відмінностями:

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

Часто декоратори Python використовують інакше, ніж патерн: змінюють API об'єкта (@staticmethod, @property), виконують реєстрацію (@app.route("/")) або взагалі замінюють тіло об'єкта (@dataclass).

Типові помилки:

• Простий перенос виклику з тіла функції в декоратор - декоратору доводиться працювати з функціями різних сигнатур, а виклик логіки втрачає гнучкість вибору моменту.
• Недостатньо універсальні декоратори, що покладаються на конкретну сигнатуру чи очікують параметр із певним ім'ям.
• Глобальні реєстри об'єктів - можуть давати ефекти глобальних змінних (стан, імпорти заради побічного ефекту).
• Примусове застосування опціональної функціональності - наприклад, кеш, прибитий декоратором, заважає налаштувати TTL чи замінити реалізацію та ускладнює тестування. Тут краще DI плюс патерн Декоратор.

Links

• Понимаем декораторы в Python'e, шаг за шагом. Шаг 1
• Понимаем декораторы в Python'e, шаг за шагом. Шаг 2

5. Яка різниця між змінними і незмінними типами даних в Python?⚑

🔥 73/100 · python/data_types.md

В Python є два основні типи даних за їхньою здатністю до зміни: змінні (mutable) та незмінні (immutable).

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

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

x = 10  # Immutable type
print(id(x))  # Shows memory address - 4392920520

x = 20  # Creates a new object
print(id(x))  # Address will change - 4392920840

y = [1, 2, 3]  # Mutable type
print(id(y))  # Memory address - 4418755008

y.append(4)  # Modifies the existing object
print(id(y))  # Address remains the same - 4418755008

У Python, всі об'єкти зберігаються в купі (heap). Це справедливо і для змінних, і для незмінних типів даних. Купа забезпечує динамічне виділення пам'яті, що дозволяє створювати нові об'єкти за потреби.

Namespace, або простір імен, створюється у стеку. Коли викликається функцію або імпортується модуль, стек використовується для зберігання контексту виконання, включаючи локальні змінні і простори імен. Об'єкти, на які посилається цей простір імен, залишаються у купі.

Тобто коли імпортується модуль, інтерпретатор Python зберігає змінні та об'єкти модуля в купі, а простір імен модуля використовується для доступу до цих змінних та об'єктів у програмі - купа зберігає дані, а стек - виклики функцій і контексти.

6. Масив⚑

🔥 68/100 · computer_science/data_structures.md

Summary

Масив - структура даних, що зберігає елементи в суміжній ділянці пам'яті й адресує їх за індексом через арифметику зсуву (base + i * розмір_елемента), звідки доступ за індексом O(1), а вставка/видалення в середині O(n) через зсув решти.

Доступ за індексом сталого часу випливає саме зі суміжного розміщення: адресу елемента обчислюють як base + i * розмір_елемента, без обходу. Пошук довільного значення в невпорядкованому масиві - O(n) (лінійний перебір); якщо масив відсортований, застосовний бінарний пошук за O(log n) - але саме за передумови впорядкованості, не безумовно. Вставка й видалення в довільній позиції - O(n), бо решту елементів доводиться зсувати; у кінці (для динамічного масиву) - амортизовано O(1).

За розміром розрізняють статичні масиви (фіксований розмір, заданий при оголошенні) і динамічні (з резервом ємності: при вичерпанні вміст копіюється в більший буфер). Багатовимірні масиви адресують елемент кількома індексами (двовимірний - як сітка з індексами x та y).

Ефективність операцій (О велике)

• доступ за індексом - O(1)
• пошук (невпорядкований) - O(n)
• пошук (відсортований, бінарний) - O(log n)
• вставка/видалення в середині - O(n)
• вставка/видалення в кінці (динамічний масив) - амортизовано O(1)

7. Як працює хеш-таблиця⚑

🔥 66/100 · python/set_and_dict.md

Хеш-таблиця - це розріджений масив (масив, в якому є незаповнені позиції). У стандартних англомовних підручниках комірки хеш-таблиці називаються "bucket". Хеш-значення - це числове значення, яке обчислюється для кожного ключа з метою швидкого доступу до відповідного значення у словнику. У хеш-таблиці dict кожному елементу відповідає комірка, що містить два поля: посилання на ключ і посилання на значення елемента. Оскільки розмір усіх комірок однаковий, доступ до окремої комірки відбувається за зміщенням.

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

Для розміщення елемента в хеш-таблицю потрібно спочатку обчислити хеш-значення ключа елемента. Це робить вбудована функція hash().

Для вибірки значення за допомогою виразу my_dict[search_key] Python звертається до функції hash(search_key), щоб отримати хеш-значення search_key, і використовує кілька молодших бітів отриманого числа як зміщення комірки відносно початку хеш-таблиці (скільки саме бітів залежить від поточного розміру таблиці). Якщо знайдена комірка порожня, виникає виключення KeyError. В іншому випадку в знайденій комірці є якийсь елемент - пара ключ:значення - і тоді Python перевіряє, чи справді search_key == found_key. Якщо так, елемент знайдено і повертається found_value. Якщо search_key і found_key не збігаються, відбувається колізія хешування. Для вирішення колізії алгоритм бере різні біти хеш-значення, виконує над ними певні дії і використовує результат як зміщення іншої комірки.

Links

• https://web.archive.org/web/20240712214159/https://gorinenko.ru/blog/cpython-types/#a13

8. Для яких завдань варто використовувати потоки, для яких - процеси, а для яких - асинхронність?⚑

🔥 65/100 · python/gil_threads_processes.md

Summary

• CPU-залежна задача => Multi Processing
• I/O-залежна, швидкий I/O => Multi Threading
• I/O-залежна, повільний I/O => Asyncio (робота з вебсокетами)

Наприклад треба написати HTTP або WebSocket сервер, який обробляє кожне з'єднання в окремому потоці.

Можна створити 100, а можливо, навіть 500 потоків, щоб обробити необхідну кількість одночасних з'єднань. Для коротких запитів це може працювати і дозволити витримувати навантаження 5000 RPS на найбільш доступному DO інстансі за п'ять доларів - це досить непогано. Якщо менше, то можливо вам не потрібні жодні AsyncIO/Tornado/Twisted.

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

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

Перемикання контексту - взагалі витратна для процесора операція, яка потребує скидання регістрів, кешу та таблиці відображення сторінок пам'яті. Чим більше потоків запущено, тим більше процесор робить марні перемикання на потоки, що заблоковані GIL, перед тим, як дістатися до того самого, який утримує цей GIL. Не дуже ефективно.

Є також співпрограми - те, що пропонує AsyncIO і Tornado. Їх також називають корутинами або просто потоками на рівні користувача, які використовувалася ще в часи, коли були операційні системи без підтримки багатозадачності.

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

Як і у випадку з потоками, асинхронні фреймворки використовуються для I/O-bound задач - таких як мережеві виклики, взаємодія з базами даних, робота з файлами. Для CPU-bound задач, які вимагають багато обчислень, такий підхід може бути неефективним, оскільки співпрограми теж працюють в одному потоці через GIL.

Ще одна найважливіша особливість корутину полягає в тому, що вони легкі. Вони "легші" за потоки. Тобто швидше запускаються і використовують менше пам'яті. По суті, корутини – це особливий різновид функцій, а от потоки представлені Python-об'єктами та пов'язані з потоками в операційній системі, з якими ці об'єкти мають взаємодіяти. Перемикання між потоками відбувається тоді, коли заманеться операційній системі. У випадку з asyncio - перемикання може відбутись на await, що дає більше контролю над програмою.

В Python-програмі можуть міститись тисячі потоків. А якщо говорити про корутини, то їх уже можуть бути десятки або сотні тисячі, і всі вони будуть розміщені в одному потоці.

Якщо задача потребує інтенсивних обчислень (CPU-bound), то потрібно використовувати процеси або оптимізації. Бібліотеки NumPy, Pandas вміють відпускати GIL. Також можна переписати критичні частини коду з допомогою Cyton, Numba, Clang. Оптимальна кількість процесів зазвичай дорівнює або трохи менша кількості ядер процесора. Рекомендується залишати хоча б одне ядро вільним, наприклад, запускати cpu_count() - 1 процесів, або експериментально визначати оптимальну кількість.

Links

• Асинхронний Python: види конкурентності - DevZone.ua
• Швидко та недорого покращуємо перфоманс невеликого Python-проєкту
• Розділяй і володарюй. Як працюють процеси в Python - dou.ua

9. Контекстний менеджер (Context manager)⚑

🔥 64/100 · python/namespace_and_context_manager.md

У Python є оператор with. Код всередині нього виконується з особливістю: перед та після нього гарантовано спрацьовують події входу до блоку with та виходу з нього (навіть у випадку коли з'являється виняток). Об'єкт, який визначає цю логіку, називається контекстним менеджером (context manager).

Події входу і виходу з блоку визначені методами __enter__ і __exit__. Перший спрацьовує в той момент, коли виконання програми переходить всередину with. Метод може повернути значення, яке буде доступне вкладеному коду всередині блоку with.

__exit__ спрацьовує при виході з блоку, включаючи випадок виникнення виключення. У цьому випадку в метод буде передано трійку значень (exc_class, exc_instance, traceback).

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

Слід намагатися виходити з контекстного менеджера якомога швидше, щоб звільнити контекст та ресурси.

with open('file.txt') as f:
    data = f.read()
process_data(data)

Приклад реалізації власного контекстного менеджера на основі класу

class MyOpen:
    def __init__(self, filename):
        self.filename = filename
    def __enter__(self):
        self.file = open(self.filename)
        return self.file
    def __exit__(self, exc_type, exception, traceback):
        self.file.close()

>>> with open('test.txt', 'w') as file:
...     file.write('Hello World!')

Приклад реалізації власного контекстного менеджера з використанням вбудованої бібліотеки contextlib:

from contextlib import contextmanager

@contextmanager
def printable():
    print('enter')
    try:
        yield
    finally:
        print('exit')

Контекстні менеджери також можна використовувати для тимчасової заміни параметрів, змінних середовища, транзакцій БД.

Перевага with над try/finally. Поширена помилка - відкривати ресурс усередині try і звільняти його у finally: якщо саме захоплення ресурсу завершується винятком (файл не відкрився, блокування не взялося), finally спробує звільнити те, що не було захоплене. Тому ресурс захоплюють до try, а краще - делегують це менеджеру контексту: with викликає __exit__ лише після успішного __enter__, тож звільнення не доводиться дублювати в кожному finally.

Асинхронний контекстний менеджер. Для ресурсів, вхід/вихід яких є awaitable (мережеве з'єднання, пул БД, сесія aiohttp), використовують async with. Менеджер реалізує __aenter__ / __aexit__ (обидва - корутини) або функцію огортають у @asynccontextmanager з contextlib.

from contextlib import asynccontextmanager

class AsyncResource:
    async def __aenter__(self):
        await self.connect()
        return self
    async def __aexit__(self, exc_type, exc, tb):
        await self.close()

@asynccontextmanager
async def resource():
    conn = await connect()
    try:
        yield conn
    finally:
        await conn.close()

async with resource() as conn:   # works only inside an async function
    ...

10. Що таке event loop (цикл подій) в asyncio і як він працює?⚑

🔥 60/100 · python/async.md

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

Event Loop - це механізм, який дозволяє координувати виконання асинхронних операцій у Python. Він дозволяє програмі взаємодіяти з багатьма завданнями, такими як ввід-вивід, мережеві запити, без блокування основного потоку виконання.

Event Loop - це як певний безкінечний цикл, який дозволяє розпізнати, чи настала певна подія операційної системи (наприклад, запис даних до сокету).

Event Loop працює на принципі опитування: він постійно перевіряє список подій та завдань, які очікують виконання, і обробляє їх послідовно. Коли подія стає доступною для обробки (наприклад, завершення мережевого запиту), Event Loop викликає відповідну функцію-зворотний виклик, яку визначили, для обробки результату.

Під капотом, Event Loop в asyncio працює на подібних принципах, як в традиційних механізмах вводу-виводу як Select, Poll та Epoll. Він встановлює "наглядачі" на різні асинхронні операції та очікує їхньої готовності.

З допомогою Select формується список файлових дескрипторів, за якими планується спостерігати. У клієнтському коді доведеться перевіряти всі передані дескриптори на наявність подій (і їх кількість обмежена 1024), що робить його повільним та незручним.

У випадку Poll та Epoll, Event Loop використовує більш ефективні механізми опитування, дозволяючи ефективно взаємодіяти з більшим числом подій.

uvloop як альтернатива стандартному loop

uvloop - реалізація event loop'а на C поверх libuv (тієї ж бібліотеки, що лежить в основі Node.js). Drop-in заміна стандартного asyncio loop'а:

import asyncio, uvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
asyncio.run(main())

За бенчмарками авторів uvloop (вимірювання на HTTP- і echo-сервері), пропускна здатність зростає у кілька разів порівняно зі стандартним asyncio loop'ом за рахунок реалізації на C і оптимізованої роботи з epoll/kqueue. Фактичний виграш залежить від характеру навантаження - на CPU-bound коді або частих переходах user/kernel ефект менший. Семантика для прикладного коду не змінюється: ті ж async def, await, Task, gather.

Обмеження: не підтримує Windows нативно (libuv підтримує, але прив'язки uvloop - ні; для Windows у asyncio з 3.8 за замовчуванням використовується ProactorEventLoop поверх IOCP, і uvloop там не потрібен). Тому в більшості продакшн-сценаріїв uvloop ставлять на Linux-серверах, тоді як локальна розробка на macOS/Windows може використовувати стандартний loop.

11. Що таке магічні методи та для чого вони потрібні⚑

🔥 60/100 · python/class_and_object.md

Summary

Магічні методи (дандр методи, Magic methods, dundr methods) - це методи, імена яких починаються і закінчуються подвійним підкресленням. Магічні тому, що майже ніколи не викликаються явно. Їх викликають вбудовані функції або синтаксичні конструкції. Ці методи дозволяють налаштовувати поведінку об’єктів класу при взаємодії з іншими об’єктами або при виконанні певних операцій. Тобто вони дозволяють класам мати або перевизначити певну поведінку при виконанні різних операцій.

Наприклад, функція len() викликає метод __len__() переданого об'єкта. Метод __add__(self, other) автоматично викликається при використанні оператора + для додавання.

Найвживаніші магічні методи

• __init__ - конструктор класу. Приймає екземпляр класу.
• __new__ - приймає не instance, а об'єкт класу. Ініт вже приймає інстанс. Створює даний об'єкт, після цього на нього може відбуватись ініціалізація
• __class__ - визначає клас або тип, екземпляром якого являється об'єкт. Клас і тип - різні назви одного і того ж - type(x) == x.__class__
• __name__ - імя класу
• __str__, __repr__ - повертають рядкове представлення обєкту. repr - для девелопера, str - для прінта
• __getattr__ - використовується для обробки доступу до атрибутів, що не існують в об'єкті при доступі за допомогою точкової нотації obj.<attribute>
• __setattr__, __delattr__ - викликаються при будь-якому присвоєнні (obj.attr = ...) чи видаленні (del obj.attr) атрибута, незалежно від того, чи він уже існує (на відміну від __getattr__, який спрацьовує лише для відсутнього атрибута)
• __getattribute__ - викликається при спробі отримати значення атрибуту. Якщо цей метод перевизначений, стандартний механізм пошуку значень атрибутів не буде задіяний.
• __dict__ - сховище атрибутів, визначених користувачем. Пошук в ньому проводиться під час виконання і при пошуку враховується __dict__ класу обєкту і базових класів.
• __bases__ - список прямих батьків
• __iter__ - повертає ітератор
• __eq__ - перевірка на рівність з іншим об'єктом
• __add__ - додавання до іншого об'єкта
• __call__ - дозволяє екземпляру класу поводитися як функція. Це означає, що об’єкт класу можна викликати як функцію з допомогою дужок
• __getitem__ - метод, який викликається, коли викликається при доступі за допомогою квадратних дужок myobject[key], передаючи ключ або індекс (значення в квадратних дужках) як параметр. По послідовностях (списки, кортежі, рядки) можна ітеруватись, оскільки вони, реалізовуюсть метод __getitem__ і __len__
• __len__ - повертає довжину послідовності
• __enter__, __exit__ - потрібні для реалізації менеджера контексту

Найкращий спосіб правильно реалізувати ці методи (і перевірити набір методів, які потрібно реалізувати разом) — імплементувати базовий абстрактний клас, визначений в модулі collections.abc (https://docs.python.org/3/library/collections.abc.html#collections-abstract-base-classes). Ці інтерфейси надають методи, які потрібно реалізувати, а також подбають про правильне створення типу (коли функція isinstance() викликається для об’єкта).

12. Які популярні типи індексів існують?⚑

🔥 59/100 · infrastructure/database.md

• B-дерево (B-Tree) індекс: Це один з найпоширеніших типів індексів. B-дерева використовуються для оптимізації пошуку даних у впорядкованих полях, таких як числа та рядки. Вони дозволяють виконувати операції порівняння (менше, більше, дорівнює) дуже швидко.
• Хеш-індекс: Хеш-індекси використовують хеш-функції для швидкого пошуку даних. Вони підходять для запитів з точним збігом значень. Однак, вони не так ефективні для діапазонних запитів або запитів, які використовують оператори порівняння.
• GIN (Generalized Inverted Index) індекс: Цей тип індексу використовується для повнотекстового пошуку та інших варіантів пошуку, які вимагають обробки великої кількості слів або термінів.
• GiST (Generalized Search Tree) індекс: GiST індекси призначені для роботи зі складними даними, такими як географічні дані, діапазони дат та інші. Це збалансоване дерево пошуку, точно так само, як і розглянуте раніше B-дерево. Але B-дерево застосовне лише до тих типів даних, для яких має сенс операція порівняння та є можливість упорядкування. Проте PostgreSQL дозволяє зберігати і такі дані, для яких операція упорядкування не має сенсу, наприклад, геодані та геометричні об'єкти.
• SP-GiST (Space-Partitioned Generalized Search Tree) індекс: Цей тип індексу використовується для роздільних даних, які можна розбити на області. Наприклад, для географічних даних це можуть бути координати на карті. SP-GiST схожий із GiST, але він дозволяє створювати незбалансовані дерева. Такі дерева можуть бути корисними при розбитті множини на об'єкти які не перетинаються. Літери SP означають space partitioning.

Підрядковий і повнотекстовий пошук. B-дерево обслуговує точні та діапазонні порівняння, але не пошук по підрядку (LIKE '%abc%') - воно впорядковане за повним значенням. Для ILIKE/підрядка ставлять GIN з розширенням pg_trgm (триграмним). Повнотекстовий пошук (to_tsvector) через GIN вимагає коректної мовної конфігурації: дефолтний english не зведе словоформи кирилиці, тож для україно-/російськомовного тексту задають відповідну конфігурацію.

Links

• https://tproger.ru/articles/indeksy-v-postgresql/

13. Що може бути ключем словника? Що не може?⚑

🔥 59/100 · python/set_and_dict.md

Ключем словника може бути будь-який хешований незмінний об'єкт: число, рядок, datetime, функція або навіть модуль. Такі об'єкти мають метод __hash__(), який однозначно відповідає об'єкту деяким числом. За цим числом словник шукає значення для ключа. А також метод __eq__() - для порівняння ключів на рівність, а не за адресами пам'яті. Це означає, що, навіть якщо два об'єкти мають різні адреси пам'яті, вони вважатимуться рівними, якщо __eq__() повертає True.

Списки, словники, множини є змінними і не мають методу хешування. При спробі вставити їх у словник виникне помилка.

Об'єкти, які є екземплярами класів, визначених користувачем, є хешованими за замовчуванням і їхнє хеш-значення базується на їхньому id(). Тобто усі будуть не рівними. Навіть якщо перевизначити метод __hash__, наступний словник поверне 2 ключі (потрібно перевизначити метод __eq__, щоб він повертав True)

class C:  
    def __hash__(self):  
        return 42 

c, d = C(), C()  
x= {c: 'c', d: 'd'}  
print(list(x.keys()))  # [<__main__.C object at 0x101656300>, <__main__.C object at 0x101655d30>]

Хеш кортежу обчислюється рекурсивно по всім його елементам. Таким чином, кортеж (1, (True, (42, ('hello', )))) складається лише з незмінних елементів, тому може бути ключем. Однак кортеж (1, (True, (42, ({'hello': 'world'},)))) не може бути ключем, оскільки в ньому є змінний словник.

14. Композиція проти Наслідування (Composition vs Inheritance)⚑

🔥 57/100 · computer_science/oop.md

Summary

• Агрегація та композиція - це відношення has-a (має) між об'єктами, де один клас містить посилання на інший клас.
• Наслідування - це відношення is-a (є), коли один клас є різновидом іншого. Наслідуваний клас отримує всі методи та властивості батьківського класу.
• В загальному випадку, слід віддавати перевагу композиції перед наслідуванням, бо вона дає більше гнучкості.

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

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

Переваги

• Допомагає уникнути class explosion problem - успадкування може привести до величезної ієрархічної структури класів, яку важко зрозуміти та підтримувати. А також може збільшити ризик конфліктів імен методів та змінних.
• Гнучкість та мінімізація залежностей. При композиції відношення між двома класами вважаються слабко зв'язаними. Це означає, що зміни в класі компонента рідко впливають на клас композиту, і зміни в класі композиту ніколи не впливають на клас компонента. Це забезпечує кращу адаптивність до змін і дозволяє додаткам вводити нові вимоги, не впливаючи на існуючий код.
• Полегшує тестування - тестувати окремі компоненти легше, оскільки вони є менш залежними одне від одного.

Наслідування (is-a) - Dog — це Animal, тобто собака є твариною.

class Animal:
    def make_sound(self):
        print("Some generic sound")

class Dog(Animal):
    def make_sound(self):
        print("Woof!")

dog = Dog()
dog.make_sound()  # Woof!

Агрегація (has-a - слабкий зв'язок) - Company має Employees, але якщо компанія закриється, співробітники можуть працювати в іншому місці.

class Employee:
    def __init__(self, name):
        self.name = name

    def work(self):
        print(f"{self.name} is working.")

class Company:
    def __init__(self, name, employees):
        self.name = name
        self.employees = employees

    def show_employees(self):
        for emp in self.employees:
            print(f"Employee: {emp.name}")

emp1 = Employee("Alice")
emp2 = Employee("Bob")
company = Company("TechCorp", [emp1, emp2])

company.show_employees()

del company
print(emp1.name)  # Alice still exists

Композиція (has-a - сильний зв'язок) - House має Rooms, але кімнати не можуть існувати без будинку.

class Room:
    def __init__(self, name):
        self.name = name

class House:
    def __init__(self):
        self.rooms = [Room("Kitchen"), Room("Bedroom")]  # Rooms are created in the house

    def show_rooms(self):
        for room in self.rooms:
            print(f"Room: {room.name}")

house = House()
house.show_rooms()

del house  # We delete the house - the rooms also disappear
print(house.rooms)  # Error because house no longer exists

15. Хеш-таблиця⚑

🔥 53/100 · computer_science/data_structures.md

Summary

Хеш-таблиця (Hash Table) — це структура даних, яка використовується для зберігання пар "ключ-значення" і забезпечує ефективний доступ до даних. Основною особливістю хеш-таблиці є використання хеш-функції для перетворення ключа в індекс масиву, де зберігається відповідне значення. Це дозволяє здійснювати пошук, вставку і видалення елементів з високою швидкістю.

Хеш-таблиці забезпечують складність вставки, видалення та доступ до елементів з постійним часом (O(1)).

Хеш-функція перетворює ключ у індекс масиву, за яким зберігається відповідне значення. При цьому можуть виникати колізії. Вони виникають, коли хеш-функція дає однаковий індекс для різних ключів. Існують різні методи вирішення колізій, такі як ланцюгове з'єднання (chaining) і відкрита адресація (open addressing).

Переваги хеш-таблиць

• Швидкість: Операції вставки, пошуку і видалення зазвичай виконуються за O(1) час (в середньому випадку).
• Гнучкість: Можуть зберігати будь-які типи даних як ключі та значення.

Ефективність (О велике)

• Індексування- O(1)
• Пошук - O(1)
• Вставка - O(1)

class HashTable:
    def __init__(self, size):
        self.size = size
        self.table = [[] for _ in range(size)]

    def hash_function(self, key):
        return hash(key) % self.size  # size of hash table

    def insert(self, key, value):
        index = self.hash_function(key)
        for pair in self.table[index]:
            if pair[0] == key:
                pair[1] = value
                return
        self.table[index].append([key, value])

    def search(self, key):
        index = self.hash_function(key)
        for pair in self.table[index]:
            if pair[0] == key:
                return pair[1]
        return None

    def delete(self, key):
        index = self.hash_function(key)
        for i, pair in enumerate(self.table[index]):
            if pair[0] == key:
                del self.table[index][i]
                return

hash_table = HashTable(10)
hash_table.insert("apple", 1)
hash_table.insert("banana", 2)
print(hash_table.search("apple"))  # Output: 1
hash_table.delete("apple")
print(hash_table.search("apple"))  # Output: None

16. Що таке транзакція? Що таке ACID?⚑

🔥 53/100 · infrastructure/database.md

Транзакція - це послідовність дій, які виконуються в базі даних або іншій системі з метою забезпечення консистентності даних та виконання операцій атомарно (тобто вони повинні бути виконані цілісно або не виконуватися взагалі - все або нічого). Іншими словами, транзакція - це група дій, які мають бути виконані як єдине ціле. Транзакція є робочою одиницею роботи з базою даних (БД).

Транзакція - це внесення змін у БД. Наприклад, якщо ми створюємо, змінюємо або видаляємо запис, то ми виконуємо транзакцію. Дуже важливо контролювати транзакції для гарантування цілісності. Крім того, транзакції дозволяють відновлювати базу даних до попереднього стану в разі виникнення помилки або аварії.

Тобто транзакція — це набір SQL-команд, які об'єднані в один фізичний і логічний блок і вважаються, згідно з ACID, найменшим неподільним об'єктом.

Основні концепції (властивості) транзакції описуються абревіатурою ACID

• Atomicity - Атомарність
• Consistency - Узгодженість
• Isolation - Ізоляція
• Durability - Довговічність

Атомарність (Atomicity)

Атомарність гарантує, що транзакція або виконується повністю або зовсім не виконується. Якщо одна з операцій у послідовності не буде виконана, то вся транзакція буде відмінена. Тут вводиться поняття "відкату" (rollback). Тобто всередині послідовності відбуватимуться певні зміни, але в результаті всі вони будуть скасовані ("відкочені"), і в результаті користувач не побачить жодних змін, тобто зміни повертаються до стану, який був на початку запуску транзакції. У випадку вкладених транзакцій, rollback відбувається до найближчого SAVEPOINT.

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

Узгодженість (Consistency)

Узгодженість означає, що будь-яка завершена транзакція (транзакція, яка досягла завершення транзакції - end of transaction) фіксує лише допустимі результати. Система має перебувати в узгодженому, несуперечливому стані до початку дії транзакції і по її завершенню - не має бути порушення FK, PK, Unique key та інших обмежень даних. При цьому вона може перебувати в неузгодженому стані протягом виконання транзакції, проте ця неузгодженість не буде видимою за межами транзакції завдяки іншим властивостям - атомарності та ізольованості.

Наприклад, при переведенні коштів з рахунку на рахунок, кошти можна спочатку зняти з першого рахунку, після чого нараховувати на другий. Відповідно, після зняття коштів, але до їх нарахування система перебуває в неузгодженому стані: коштів немає на жодному з рахунків. Але після завершення транзакції повна сума перебуватиме на другому (або першому у випадку скасування транзакції) рахунку.

Ізоляція (Isolation)

Кожна транзакція повинна бути ізольована від інших, тобто її результат не повинен залежати від виконання інших паралельних транзакцій та не повинна впливати одна на одну. На практиці, ізоляції важко досягнути, тому тут вводиться поняття "рівні ізоляції" (транзакція ізолюється не повністю).

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

Довговічність (Durability)

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

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

Links

• Використання транзакцій в реляційних базах даних: забезпечення надійності та цілісності

17. Що таке MRO⚑

🔥 50/100 · python/class_and_object.md

Summary

MRO (Method Resolution Order) - порядок вирішення методу. Це алгоритм пошуку методу в разі, якщо у класу є два або більше батьків.

При успадкуванні класів нового стилю застосовується правило MRO (порядок вирішення методів), тобто лінійний обхід дерева класів, при цьому вкладений елемент успадкування стає доступним у атрибуті __mro__ даного класу. Такий алгоритм називається C3-лініаризація. Наслідування за правилом MRO здійснюється приблизно за наступним порядком.

1. Перерахування всіх класів, успадкованих екземпляром, за правилом пошуку DFLR для класичних класів, причому клас включається в результат пошуку стільки разів, скільки він зустрічається при обході.
2. Перегляд у отриманому списку дублікатів класів, з яких видаляються всі, крім останнього (останнього справа) дубліката в списку.

Обхід у глибину та зліва направо - DFLR

1. Спочатку екземпляр
2. Потім його клас
3. Далі всі суперкласи його класу з обходом спочатку у глибину, а потім зліва направо
4. Використовується перше знайдене входження.

Упорядкування за правилом MRO застосовується при успадкуванні та виклику вбудованої функції super(), яка завжди викликає наступний клас за правилом MRO (відносно точки виклику).

Приклад успадкування в не-ромбовидних ієрархічних деревах

class D:          attr = 3      #  D:3   E:2
class B(D):       pass          #   |     |
class E:          attr = 2      #   B    C:1
class C(E):       attr = 1      #    \   /
class A(B, C):    pass          #      A
X = A()                         #      |
print(X.attr)                   #      X

>>> DFLR = [X, A, B, D, C, E]
>>> MRO = [X, A, B, D, C, E, object]
>>> Outputs string "3"

Приклад успадкування в ромбовидних ієрархічних деревах

class D:          attr = 3      #     D:3   
class B(D):       pass          #    /   \
class C(D):       attr = 1      #   B   C:1
class A(B, C):    pass          #    \   /
X = A()                         #      A
print(X.attr)                   #      |
...                             #      X

>>> DFLR = [X, A, B, D, C, D]
>>> MRO = [X, A, B, C, D, object] (keeps only the last duplicate D)
>>> Outputs string "1"

18. Поліморфізм⚑

🔥 48/100 · computer_science/oop.md

Summary

Поліморфізм - це один з ключових принципів ООП, який дозволяє об'єктам з різних класів використовувати один і той же інтерфейс, але мати різну реалізацію цього інтерфейсу. Іншими словами, це різна поведінка одного і того ж методу в різних класах. Тобто - один інтерфейс, але різна поведінка і різна реалізація.

Наприклад ми можемо додати два числа, і можемо додати два рядки. При цьому отримаємо різний результат - так як числа і рядки являються різними класами. Це реалізується з допомогою __add__ - "магічний методів" в Python, який використовується для перевантаження оператора додавання +. Він дозволяє задати спеціальну реалізацію операції додавання для об'єктів певного класу.

__add__ для int

class MyInt:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return self.value + other

num1 = MyInt(5)
num2 = 10

result = num1 + num2
print(result)  # Output: 15

__add__ для str

class MyString:
    def __init__(self, value):
        self.value = value

    def __add__(self, other):
        return f"{self.value}{other}"

str1 = MyString("Hello, ")
str2 = "world!"

result = str1 + str2
print(result)  # Output: Hello, world!

Види поліморфізму

• Підтиповий (subtype). Поліморфна поведінка через успадкування: об'єкт дочірнього класу можна підставити там, де очікується батьківський, поки дочірній не ламає його інтерфейс. Прямо пов'язаний з принципом підстановки Лісков (LSP).
• Параметричний (parametric). Тип не важливий - важливо, щоб об'єкт реалізовував потрібну поведінку. У Python це качина типізація (а також узагальнення через TypeVar/ generics): функція приймає будь-що, у чого є очікуваний метод.
• Ad-hoc (перевантаження). Одна операція з різними реалізаціями для різних типів. Перевантаження операторів через dunder-методи (__add__ вище) - саме цей вид. Окремих функцій, перевантажених за сигнатурою (як у C++), Python не має; найближче в рантаймі - functools.singledispatch, що обирає реалізацію за типом першого аргументу:

from functools import singledispatch

@singledispatch
def to_log(value) -> str:
    return f"raw: {value}"

@to_log.register
def _(value: int) -> str:
    return f"int: {value}"

@to_log.register
def _(value: list) -> str:
    return f"list of {len(value)}"

to_log(42)        # "int: 42"
to_log([1, 2])    # "list of 2"

typing.overload, на відміну від singledispatch, впливає лише на перевірку типів і не дає диспетчеризації під час виконання.

19. Що таке рівні ізоляції транзакцій. Які вони бувають⚑

🔥 47/100 · infrastructure/database.md

Ізоляція у сенсі ACID означає, що конкурентно виконувані транзакції ізольовані одна від одної - вони не можуть заважати одна одній. Класичні підручники з баз даних розуміють під ізоляцією серіалізованість (serializability). Тобто кожна транзакція виконується так, наче вона єдина в усій базі. БД гарантує, що результат фіксації транзакцій такий самий, як якщо б вони виконувались послідовно (по одній за раз), хоча насправді вони можуть виконуватись конкурентно.

При паралельному виконанні транзакцій можливі такі проблеми

• втрачене оновлення (lost update) - при одночасній зміні одного блоку даних різними транзакціями, одна із змін втрачається. Наприклад, T1 i T2 працюють над записом з полем foo = 10, T1 додає до поля 5 а T2 додає 15. У результаті ми очікуємо, що буде 30, але транзакція T1 не знає нічого про T2 і навпаки. Вони працюють із полем foo, яке знаходиться в їхній пам'яті, а не з реальним значенням, що міститься в базі, тому зміни T1 або T2 будуть втрачені.
• "брудне" читання (dirty read) - читання даних, які додані чи змінені транзакцією, яка потім не підтвердиться (відкотиться). Наприклад, T1 i T2 працюють над записом із полем foo=10, T1 додає 5, а T2 додає 15. У цьому випадку, якщо одна транзакція змінила поле, інша побачить це та буде працювати з новим полем. Але якщо одна з транзакцій не виконається після того, як інша завершить своє виконання, дані не будуть повернуті в попередній стан. Тобто якщо T1 завершить свою роботу раніше Т2, в полі foo буде 30, а не 25.
• неповторюване читання (non-repeatable read) - транзакція читає один і той самий запис в рамках однієї транзакції, але отримує різні значення. Наприклад, T1 читає запис, через деякий час T2 закінчує оновлення полів цього запису і при повторному читанні T1 отримує інший результат значень полів.
• фантомне читання (phantom reads) - схожа до non-repeatable read, але одна транзакція в ході свого виконання декілька разів вибирає множину рядків за одними і тими ж критеріями. Інша транзакція в інтервалах між цими вибірками додає чи видаляє рядки чи змінює стовпці деяких рядків, що використовується в критеріях вибірки першої транзакції, і успішно закінчується. В результаті отримаємо, що одні і ті ж вибірки в першій транзакції дають різні множини рядків, містять більше/менше записів відносно попередньої операції.

Рівень ізольованості транзакцій — значення, що задає рівень, при якому в транзакції дозволяються неузгоджені дані, тобто ступінь ізольованості однієї транзакції від іншої. Більш високий рівень ізольованості підвищує точність даних, але при цьому може знижуватись кількість транзакцій, що виконуються паралельно. З іншого боку, більш низький рівень ізольованості дозволяє виконувати більше паралельних транзакцій, але знижує точність даних. Тобто при найменшому рівні ізоляції ми отримуємо найбільший перформанс і навпаки.

У стандарті SQL описується чотири рівні ізоляції транзакцій

• Read uncommited (Читання незафіксованих даних)
• Read committed (Читання зафіксованих даних)
• Repeatable read (Повторюване читання)
• Serializable (Серіалізований)

Читання незафіксованих даних (Read Uncommitted)

Найнижчий рівень ізоляції. Транзакція може читати дані, які ще не були зафіксовані іншою транзакцією. Це може призводити до "брудного читання" (dirty reads), коли транзакція працює з даними, які можуть бути відкочені.

Читання зафіксованих даних (Read Committed)

Транзакція бачить лише ті зміни, які вже зафіксовані іншими транзакціями. Це запобігає "брудному читанню", але не вирішує проблему "неповторюваного читання" (non-repeatable reads), коли один і той самий запит повертає різні результати в межах однієї транзакції.

У загальному використанні без FOR UPDATE/SHARE операції працюють зі snapshot-даними, ніякі блокування полів для читання (shared lock) не застосовуються.

Реалізація завершеного читання може ґрунтуватися на одному з двох підходів: блокуванні або версійності.

• Блокування даних, що читаються та змінюються.
  • Полягає в тому, що записуюча транзакція блокує змінні дані для читаючих транзакцій, що працюють на рівні read committed або вищому, до свого завершення, перешкоджаючи таким чином "брудному" читанню, а дані, що зчитуються, які блокуються транзакцією, звільняються одразу після завершення операції SELECT (отже ситуація "неповторного читання" може виникати на даному рівні ізоляції).
• Збереження декількох версій рядків, що змінюються паралельно.
  • При кожній зміні рядка СУБД створює нову версію цього рядка, з якої продовжує працювати транзакція, що змінила дані, в той час як будь-якій іншій "читає" транзакції повертається остання зафіксована версія. Перевага такого підходу в тому, що він забезпечує більшу швидкість, оскільки запобігає блокуванню. Однак він вимагає, порівняно з першим, значно більшої витрати оперативної пам'яті, яка витрачається на зберігання версій рядків.

Повторюване читання (Repeatable Read)

Забезпечує, що дані, прочитані транзакцією, залишаються незмінними до її завершення. Вирішує проблему "неповторюваного читання", але не запобігає "фантомному читанню" (phantom reads), коли нові рядки додаються іншими транзакціями і впливають на результати.

Тобто транзакція весь час буде працювати тільки з однією копією snapshot-а, але власні зміни будуть видимі для всіх операцій всередині транзакції.

Транзакція на цьому рівні ізоляції не може використовувати exclusive lock для полів, що були модифіковані іншою транзакцією, або змінювати модифіковані поля. Якщо ж транзакція спробує це зробити, вона отримає помилку серіалізації. Усі зміни повинні відкотитись, і потрібно спробувати провести транзакцію знову.

Серіалізований (Serializable)

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

Однакова назва ≠ однакова поведінка

Стандарт SQL описує чотири рівні, але кожна СУБД реалізує їх по-своєму. Часта пастка - припускати, що REPEATABLE READ у PostgreSQL і MySQL InnoDB означають одне і те ж.

PostgreSQL (docs: Transaction Isolation):

• Default - Read Committed.
• Read Uncommitted приймається синтаксично, але поводиться як Read Committed: "PostgreSQL's Read Uncommitted mode behaves like Read Committed. This is because it is the only sensible way to map the standard isolation levels to PostgreSQL's multiversion concurrency control architecture". Фактично реалізовано три рівні з чотирьох.
• Repeatable Read реалізовано як Snapshot Isolation: "implemented using a technique known in academic database literature and in some other database products as Snapshot Isolation".
• Serializable з версії 9.1 - Serializable Snapshot Isolation (SSI): "implemented using a technique known in academic database literature as Serializable Snapshot Isolation, which builds on Snapshot Isolation by adding checks for serialization anomalies". До 9.1 Serializable поводився як Repeatable Read.

MySQL InnoDB (docs: InnoDB Transaction Isolation Levels):

• Default - Repeatable Read (не Read Committed, як у Postgres).
• Plain (non-locking) SELECT використовує consistent snapshot, не бере блокувань.
• Для locking reads (SELECT ... FOR UPDATE, FOR SHARE), UPDATE, DELETE з range-умовою InnoDB бере gap locks і next-key locks: "InnoDB locks the index range scanned, using gap locks or next-key locks to block insertions by other sessions into the gaps covered by the range". Це може заблокувати insert у "сусідній" діапазон.
• Виняток: для unique index з unique search condition блокується лише знайдений запис, без gap.

SQL Server (docs: SET TRANSACTION ISOLATION LEVEL):

• Default - Read Committed (у on-prem; Azure SQL Database має READ_COMMITTED_SNAPSHOT ON за замовчуванням).
• Поведінка Read Committed залежить від READ_COMMITTED_SNAPSHOT: з OFF - locks-based, з ON - row versioning, читання не блокують записи.
• Окремий рівень SNAPSHOT (потребує ALLOW_SNAPSHOT_ISOLATION ON) - як Postgres Repeatable Read. Це п'ятий рівень, окремий від Repeatable Read.
• Serializable - класична range-lock-based реалізація, не SSI.

Oracle (docs: Data Concurrency and Consistency):

• Default - Read Committed. Реалізовано через undo segments і snapshot read consistency.
• Oracle підтримує лише два рівні з чотирьох стандартних: Read Committed і Serializable (плюс Read-Only як власне розширення). Read Uncommitted і Repeatable Read як окремі рівні відсутні.
• Dirty reads неможливі ні на якому рівні: "Oracle Database never permits a dirty read".
• Serializable дає transaction-scope snapshot - те, що в інших БД називали б Repeatable Read; справжня serial-order serializability за чистим визначенням Berenson 1995 - частковий випадок.

Базове правило: перед написанням коду, який покладається на конкретний рівень ізоляції, дивитися документацію конкретної версії конкретної бази, не тільки на назву.

Links

• Реалізація рівнів ізоляцій у базах даних - dou.ua
• PostgreSQL: Transaction Isolation
• MySQL InnoDB: Transaction Isolation Levels
• SQL Server: SET TRANSACTION ISOLATION LEVEL
• Oracle: Data Concurrency and Consistency

20. Що таке MQ⚑

🔥 47/100 · infrastructure/mq.md

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

Десять причин, чому черги повідомлень є життєво важливим компонентом для будь-якої архітектури чи додатка

• Слабке зв'язування — черги повідомлень створюють неявні інтерфейси обміну даними, які дозволяють процесам бути незалежними одне від одного, тобто ви просто визначаєте формат повідомлень, відправлених від одного процесу іншому.
• Надмірність — черги дозволяють уникнути випадків неефективного використання ресурсів процесу (наприклад, пам'яті) внаслідок зберігання невикористаної (надмірної) інформації.
• Масштабованість — черги повідомлень дозволяють розподілити процеси обробки інформації. Таким чином, вони дозволяють легко збільшувати швидкість, з якою повідомлення додаються в чергу та обробляються.
• Еластичність та можливість витримувати пікові навантаження — черги повідомлень можуть виконувати роль свого роду буфера для накопичення даних в разі пікового навантаження, згладжуючи таким чином навантаження на систему обробки інформації та запобігаючи її відмові.
• Стійкість до відмов — черги повідомлень дозволяють розділити процеси один від одного, так що якщо процес, який обробляє повідомлення з черги, падає, повідомлення можуть бути додані в чергу для обробки пізніше, коли система відновиться.
• Гарантована доставка — використання черг повідомлень гарантує, що повідомлення буде доставлено та оброблено в будь-якому випадку (поки є принаймні один обробник).
• Гарантований порядок доставки — більшість систем черг повідомлень здатні забезпечити гарантії того, що дані будуть оброблятися у певному порядку (найчастіше у порядку їх надходження).
• Буферизація — черги повідомлень дозволяють відправляти та отримувати повідомлення, при цьому працюючи з максимальною ефективністю, надаючи буферний шар — процес запису в чергу може відбуватися настільки швидко, наскільки це може робити черга повідомлень, а не обробник повідомлення.
• Розуміння потоків даних — черги повідомлень дозволяють виявляти вузькі місця в потоках даних додатка, легко можна визначити, яка з черг заповнюється, яка не використовується, і визначити, що необхідно робити — додавати нових обробників повідомлень або оптимізувати поточну архітектуру.
• Асинхронний зв'язок — черги повідомлень надають можливість асинхронної обробки даних, що дозволяє помістити повідомлення в чергу без обробки, дозволяючи системі обробити повідомлення пізніше, коли з'явиться можливість.
• Винесення довгих задач із циклу запит-відповідь — частина роботи є одночасно тривалою і CPU-bound (наприклад, обробка великого файлу, що триває години). Її не можна виконати в межах HTTP-запиту (клієнт/проксі відваляться по таймауту), не рятує й async (event loop блокується на CPU-роботі), ані просте додавання інстансів застосунку за балансувальником. Рішення — покласти задачу в чергу і виконати її фоновим воркером, лишивши в основному застосунку лише швидкі операції.

21. Asyncio⚑

🔥 47/100 · python/async.md

Asyncio – модуль асинхронного програмування, який був представлений в Python 3.4. Він призначений для використання співпрограм і future для спрощення написання асинхронного коду і робить його майже таким самим читаним, як синхронний код, через відсутності callback-ів.

Asyncio надає цикл подій та ще деякі інші функції. Цикл подій реагує на різні I/O-події та перемикається на завдання, що можуть виконуватися і призупиняє ті, що чекають на I/O. Тобто ми не витрачаємо час на завдання, що ще не готові виконуватися.

Asyncio використовує різні конструкції: event loop, співпрограми та future.

• event loop управляє і контролює виконання різних завдань. Він реєструє їх і обробляє розподіл потоку управління між ними.
• Співпрограми – це спеціальні функції, робота яких схожа з роботою генераторів в Python, за допомогою await вони повертають потік управління назад в event loop. Запуск співпрограми повинен бути запланований в event loop. Заплановані співпрограми будуть обгорнуті в Завдання, що є типом Future.
• Future - це об'єкти, які представляють результат, що буде доступний у майбутньому. Вони як порожнє місце, яке ще не має значення, але обіцяє його надати. Найкраще порівняння — футура = обіцянка. Коли результат стає доступним (наприклад, прийшла відповідь з мережі), футура позначається як завершена і викликає колбек — саме той, який був зареєстрований, щоб продовжити виконання корутини. Тобто future показує результат задачі, яка може або не може бути виконана. Результатом може бути exception. Коли огортаємо співпрограму в Future - отримуємо об’єкт Task.
• Завдання (asyncio.Tasks) - це обгортки над корутинами, які запускаються у фоновому режимі й одразу передаються під контроль циклу подій. На відміну від звичайної корутини, яка просто "готова" до виконання, задача може почати працювати відразу після створення. Вона стежить за перебігом виконання, зберігає результат або помилку, і дозволяє іншим частинам коду дізнатись, чим усе завершилось. Тобто вона огортає корутини, аби їх виконання могло незалежно плануватись циклом подій, коли йому передається управління (зазвичай за допомогою await). Створити завдання можна за допомогою asyncio.create_task(). У Python Task — це підклас Future, тобто кожна таска по суті є футурою, але з додатковою логікою виконання корутин.

Спрощено схема роботи виглядає наступним чином: У нас є цикл подій (event loop) та асинхронні функції, I/O-операції. Ми передаємо свої функції до циклу подій, щоб він запустив їх. Цикл подій повертає нам об'єкт Future. Можна сказати, що це обіцянка, що ми отримаємо якісь дані в майбутньому. Ми зберігаємо його і час від часу перевіряємо чи не має наш Future результату виконання. І якщо так, то використовуємо ці дані для подальшої обробки.

Щоб зупиняти та відновлювати завдання asyncio використовує генератори та співпрограми (generators and coroutines). У разі, якщо в черзі очікування є завдання, то контекст буде перемикнуто, в іншому випадку – ні.

Визначення корутини починається з async, а її виклик - з await. asyncio.run(coroutine) є основною точкою входу для асинхронних програм.

Функції wait(), gather() і as_completed() запускають кілька корутин одночасно. Модуль asyncio також надає власні класи Queue, Event, Lock і Semaphore.

Asyncio на прикладі

import asyncio
import datetime
import random

async def my_sleep_func():
    await asyncio.sleep(random.randint(0, 5))

async def display_date(num, loop):
    end_time = loop.time() + 50.0
    while True:
        print("Loop: {} Time: {}".format(num, datetime.datetime.now()))
        if (loop.time() + 1.0) >= end_time:
            break
        await my_sleep_func()

loop = asyncio.get_event_loop()

asyncio.ensure_future(display_date(1, loop))
asyncio.ensure_future(display_date(2, loop))

loop.run_forever()

• Асинхронна функція display_date приймає число-індентифікатор та цикл подій.
• Функція має безкінечний цикл, що переривається через 50 секунд. Але поки 50 секунд не минуло, вона друкує час і засинає на випадкову кількість секунд. Ключове слово await вказує, що під час виконання функції, що стоїть після нього, можна перемкнутися на іншу асинхронну функцію (співпрограму).
• Функції додаються до циклу подій за допомогою функції ensure_future.
• Запускається цикл подій.

Links

• https://habr.com/ru/companies/wunderfund/articles/716740/

22. Дерево⚑

🔥 46/100 · computer_science/data_structures.md

Особлива різновидність графа, в якому немає ребер, які вказують у зворотньому напрямку. Іноді дерева називають ациклічними графами.

23. Що таке SOLID⚑

🔥 45/100 · computer_science/solid.md

Summary

П'ять принципів ООП-дизайну (SRP, OCP, LSP, ISP, DIP) для систем, що довго розширюються й підтримуються; інструмент проти зайвої складності, а не самоціль.

SOLID - акронім із перших літер п'яти принципів ООП-дизайну. Самі принципи сформулював Роберт Мартін (статті в C++ Report у 1990-х, есе "Design Principles and Design Patterns" 2000 р.), а сам акронім запропонував Майкл Фезерс близько 2004 р.

Принципи SOLID використовуються для дизайну і розробки таких програмних систем, які зможуть тривалий час розширятись, розвиватись і підтримуватись.

S: Single Responsibility Principle (Принцип єдиної відповідальності). Кожен клас повинен мати лише одну відповідальність, вирішувати тільки одне завдання. Або ж кожен клас повинен мати лише одну причину для змін.

O: Open-Closed Principle (Принцип відкритості-закритості). Код має бути відкритим до розширення (тобто до додавання нового функціоналу) та закритим до змін (все, що вже написано, не повинно змінюватися).

L: Liskov Substitution Principle (Принцип підстановки Барбари Лісков). Об'єкти в програмі можуть бути заміненими їх нащадками без зміни коду програми. Клас-нащадок повинен доповнювати, а не змінювати базовий.

I: Interface Segregation Principle (Принцип розділення інтерфейсу). Багато спеціалізованих інтерфейсів краще за один універсальний. Клієнти не повинні залежати від інтерфейсів, які вони не використовують.

D: Dependency Inversion Principle (Принцип інверсії залежностей). Об'єктом залежності повинна бути абстракція, а не щось конкретне.

• Модулі верхніх рівнів не повинні залежати від модулів нижніх рівнів. Обидва типи модулів повинні залежати від абстракцій.
• Абстракції не повинні залежати від деталей. Деталі повинні залежати від абстракцій.

SOLID - компас, а не самоціль. Класичні приклади прийшли зі строго типізованих мов (Java, C#), де частину рішень диктував компілятор. Python дає й легші засоби для тих самих цілей - функції першого класу, dataclass-и, typing.Protocol, - тож нижче для кожного принципу, крім класичного формулювання, показано і ці варіанти (єдиного "правильного" стилю немає). Сліпе ж слідування SOLID шкодить:

• Over-engineering простих скриптів - крон-парсер на 200 рядків не потребує абстрактних фабрик і протоколів.
• Ігнорування вбудованих структур - клас UserDataCollection там, де вистачає dict чи list.
• Порушення YAGNI - абстракція "на випадок, якщо колись перейдемо з Postgres на Mongo", яку найімовірніше доведеться роками підтримувати мертвою, бо перехід так і не настане.

Links

• SOLID в Python без воды - Habr

24. Що таке збирач сміття (garbage collector)?⚑

🔥 45/100 · python/interpreter.md

Збирач сміття (generational garbage collector або GC) - це механізм, створений для виявлення та видалення циклічних посилань. gc є вбудованим модулем в Python і може бути вимкнений або запущений вручну (або не запущений) за потреби.

На відміну від інших популярних мов програмування, Python не повністю звільняє всю пам'ять назад до операційної системи, як тільки він видаляє якийсь об'єкт. Замість цього, він використовує додатковий менеджер пам'яті для малих об'єктів (розміром менше 512 байтів). Для роботи з такими об'єктами він виділяє великі блоки пам'яті, в яких надалі будуть зберігатися багато малих об'єктів.

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

Таким чином, якщо довгоживучий процес Python з часом починає споживати більше пам'яті, це зовсім не означає, що в коді є проблема з витоком пам'яті.

Стандартний інтерпретатор Python (CPython) використовує два алгоритми збирання сміття: підрахунок посилань (reference counting) та збирач сміття (generational garbage collector або GC), більш відомий як стандартний модуль gc в Python.

Алгоритм підрахунку посилань дуже простий і ефективний, але він має один великий недолік. Він не може виявити циклічні посилання. Саме тому в Python існує додатковий збирач, який називається GC і відстежує об'єкти з потенційними циклічними посиланнями. Коли об’єкти посилаються один на одного, утворюючи цикли (A посилається на В, В посилається на С, С посилається на А). У таких випадках, навіть якщо всі зовнішні посилання на ці об’єкти видалені, їхні лічильники посилань не стають нульовими, і пам’ять не звільняється.

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

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

У кожному поколінні є спеціальний лічильник і поріг спрацювання, які визначають початок процесу збирання сміття. Кожен лічильник зберігає кількість алокацій мінус кількість deallocations (звільнень) у даному поколінні. Як тільки в Python створюється який-небудь контейнерний об'єкт, він перевіряє ці лічильники. Якщо умови спрацьовують, починається процес збирання сміття.

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

Стандартні пороги спрацювання для поколінь встановлені на значення 700, 10 і 10 відповідно, але завжди можна змінити їх за допомогою функцій gc.get_threshold та gc.set_threshold.

import gc
print(gc.get_threshold()) # (700, 10, 10)
gc.set_threshold(500, 10, 10)
print(gc.get_threshold()) # (500, 10, 10)

GC-паузи і латентність. Запуск збирача - синхронна пауза в тому ж потоці, тож на гарячому шляху він дає сплески latency (p99 помітно вищий за p50). Інструменти тюнінгу для сервісів із жорстким таймаутом: підняти пороги (gc.set_threshold), щоб GC спрацьовував рідше; gc.freeze() - позначити вже наявні довгоживучі об'єкти (завантажені на старті конфіги, кеші) як "заморожені", щоб GC більше їх не сканував - так скорочують роботу кожного проходу; у крайньому разі gc.disable() для критичної ділянки з ручним gc.collect() у спокійний момент. Засіб діагностики такого спайку - трасування (OpenTelemetry/Jaeger), де GC-пауза видно як "дірку" між спанами.

Слабкі посилання (weakref)

Звичайне посилання інкрементує лічильник refcount і не дає об'єкту звільнитися. Модуль weakref створює посилання, яке не збільшує лічильник: щойно зникають усі звичайні посилання, об'єкт знищується, а слабке посилання починає повертати None. Це дозволяє розривати цикли, не покладаючись на періодичний GC - наприклад, дочірній об'єкт тримає слабке посилання на батька, тому взаємний цикл не утворюється взагалі. Типове застосування - кеші (WeakValueDictionary), спостерігачі та зворотні посилання, які не повинні утримувати об'єкт у пам'яті.

Links

• Всё, что нужно знать о сборщике мусора в Python
• CPython Garbage Collection: The Internal Mechanics and Algorithms

25. Інкапсуляція⚑

🔥 44/100 · computer_science/oop.md

Summary

Інкапсуляція - це один з основних принципів об'єктно-орієнтованого програмування (ООП), що дозволяє об'єднати дані та функції в один об'єкт і приховати їх внутрішню реалізацію від зовнішнього світу. Інкапсуляція - приховання реалізації, працюємо з API.

Тобто, інкапсуляція - це обмеження доступу до компонентів об'єкту (методів і змінних). Інкапсуляція робить деякі з компонентів доступними тільки з середини класу.

Інкапсуляція в Python працює тільки на рівні домовленості між програмістами про те, які атрибути являються загальнодоступними, а які - внутрішніми. У Python, інкапсуляцію зазвичай забезпечують за допомогою модифікаторів доступу, таких як public, private та protected.

• public - це найбільш видимий рівень доступу, коли змінні і методи можуть бути доступними ззовні класу і за його межами без обмежень.
• protected - змінні та методи, які починаються з одного символу підкреслення (наприклад, _protected_var), вважаються захищеними: за домовленістю їх не використовують ззовні класу, хоча технічно доступ можливий. Зазвичай застосовують для внутрішньої реалізації та в успадкуванні.
• private - змінні та методи, які починаються з подвійного символу підкреслення (наприклад, __private_var), вважаються приватними: інтерпретатор застосовує name mangling (__x → _ClassName__x), тож ззовні класу за початковим іменем вони недоступні.

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

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # private (name mangling)

    def deposit(self, amount):
        self.__balance += amount

    def withdraw(self, amount):
        if amount <= self.__balance:
            self.__balance -= amount
        else:
            print("Insufficient funds!")

    def get_balance(self):
        return self.__balance

account = BankAccount(1000)

account.deposit(500)  # use public methods to interact with account
account.withdraw(200)
print(account.get_balance())  # 1300

print(account.__balance)  # AttributeError: 'BankAccount' object has no attribute '__balance'

26. Оператор та види JOIN⚑

🔥 44/100 · infrastructure/sql.md

Оператор JOIN в SQL використовується для об'єднання даних з двох або більше таблиць на основі визначених умов. JOIN дозволяє комбінувати дані з різних таблиць в один результат.

Умова з'єднання вказується в реченні ON. Ця умова визначає, які рядки двох вихідних таблиць вважаються "відповідними" один одному.

Слова INNER та OUTER не є обов'язковими у всіх формах. За замовчуванням передбачається INNER(внутрішнє з'єднання), а при вказанні LEFT, RIGHT і FULL - зовнішнє з'єднання.

Види джойнів

• JOIN (INNER JOIN)
• LEFT JOIN (LEFT OUTER JOIN)
• RIGHT JOIN (RIGHT OUTER JOIN)
• FULL JOIN (FULL OUTER JOIN)

• CROSS JOIN

• INNER JOIN - Повертає ті рядки, які мають відповідні значення в обох таблицях.

SELECT Orders.order_id, Customers.customer_name
FROM Orders
JOIN Customers ON Orders.customer_id = Customers.customer_id;

• LEFT OUTER JOIN - Повертає всі рядки з лівої (першої) таблиці та відповідні значення з правої (другої) таблиці. Якщо відповідних значень немає, повертається NULL.

SELECT Customers.customer_name, Orders.order_id
FROM Customers
LEFT JOIN Orders ON Customers.customer_id = Orders.customer_id;

• RIGHT OUTER JOIN - Повертає всі рядки з правої (другої) таблиці та відповідні значення з лівої (першої) таблиці. Якщо відповідних значень немає, повертається NULL. Це з'єднання є протилежним до лівого (LEFT JOIN).

SELECT Customers.customer_name, Orders.order_id 
FROM Customers 
RIGHT JOIN Orders ON Customers.customer_id = Orders.customer_id;

• FULL OUTER JOIN - Повертає всі рядки з обох таблиць, і якщо відповідних значень немає, повертається NULL. Фактично це одночасний LEFT та RIGHT JOIN.

SELECT Customers.customer_name, Orders.order_id 
FROM Customers 
FULL JOIN Orders ON Customers.customer_id = Orders.customer_id;

• CROSS JOIN - Повертає декартовий добуток (комбінацію) всіх рядків із першої таблиці та всіх рядків із другої таблиці.

SELECT Customers.customer_name, Products.product_name 
FROM Customers 
CROSS JOIN Products;

Скільки рядків поверне JOIN. Поширене питання на співбесіді: для таблиць розмірів X і Y оцінити межі кількості рядків результату.

• INNER JOIN: від 0 (жодного збігу за умовою ON) до X·Y (усі значення ключових стовпців однакові з обох боків - тоді з'єднання вироджується в декартів добуток).
• LEFT JOIN: від X (рядки лівої таблиці зберігаються завжди; за відсутності збігу праві стовпці = NULL) до X·Y (той самий вироджений випадок з повним перетином).
• CROSS JOIN: завжди рівно X·Y - декартів добуток без умови.

Латеральний JOIN, (LATERAL JOIN) дозволяє використовувати результати попереднього запиту як джерело даних для подальших операцій JOIN, що дозволяє створювати більш складні і гнучкі запити.

Основна властивість латерального JOIN полягає в тому, що він дозволяє включати підзапити, які "бачать" дані з рядків, отриманих від зовнішніх таблиць. Це дозволяє використовувати значення з поточного рядка як параметр для підзапиту, що в свою чергу дозволяє гнучко маніпулювати даними.

SELECT e.employee_name, t.task_name
FROM employees e
LEFT JOIN LATERAL (
    SELECT task_name
    FROM tasks
    WHERE tasks.employee_id = e.employee_id
    LIMIT 5 -- Limit the number of tasks per employee, for example
) t ON true;

27. Які механізми використовує Python для очищення пам'яті?⚑

🔥 44/100 · python/interpreter.md

Python має 2 основні механізми для очищення пам'яті

• Підрахунок посилань (Reference Counting). Python відстежує кількість активних посилань на об'єкт. Коли лічильник посилань об'єкта зменшується до нуля (тобто на об'єкт більше ніхто не посилається), пам'ять, зайнята цим об'єктом, автоматично звільняється.
• Збирання сміття (Garbage Collection). Для об'єктів, що можуть утворювати циклічні посилання, Python використовує garbage collector, який автоматично видаляє такі об'єкти. Це важливо для структур даних, які можуть мати взаємні посилання, що не дозволяють зменшити лічильник посилань до нуля.

У Python алгоритм підрахунку посилань є фундаментальним і не може бути вимкнений, тоді як GC є необов'язковим і може бути вимкнений.

• Модуль gc надає програмістам інструменти для управління процесом збирання сміття, включаючи можливість примусового запуску gc.collect() для звільнення пам'яті або зміни налаштувань частоти запуску garbage collection. Модуль також дозволяє тимчасово вимкнути автоматичне збирання сміття, якщо є необхідність у мануальному контролі.

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

28. Що таке бази даних і для чого вони потрібні?⚑

🔥 41/100 · infrastructure/database.md

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

Під базою даних зазвичай розуміють систему керування базами даних. Але варто розрізняти базу даних — сховище даних, та СКБД — засоби для роботи з базою даних.

Бази даних служать для

• Збереження різноманітних даних, які можуть бути структурованими.
• Організації даних у логічних структурах, таких як таблиці, колекції ключ-значення.
• Забезпечення швидкого доступу до даних через індекси та оптимізовані запити.
• Забезпечення безпеки даних шляхом управління правами доступу.
• Можливості спільної роботи над даними багатьох користувачів.
• Виконання аналітичних завдань та генерація звітів.

29. Що таке серіалізація⚑

🔥 41/100 · python/files_and_io.md

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

30. Наведіть приклади РБД та NoSQL БД⚑

🔥 40/100 · infrastructure/database.md

Приклади реляційних баз даних (РБД)

• MySQL
• PostgreSQL
• Microsoft SQL Server
• Oracle Database
• SQLite

Приклади баз даних типу NoSQL

• MongoDB
  • Орієнтована на документи NoSQL база даних, яка зберігає дані у вигляді документів (наприклад, JSON) з гнучкою схемою.
  • MongoDB легко масштабується горизонтально та підтримує індексування даних, що забезпечує швидкий доступ до них.
  • Для зберігання інформації використовується тип даних BSON (Binary JSON). BSON – це бінарний формат для представлення JSON-подібних документів. BSON забезпечує більш ефективне зберігання даних, ніж JSON.
• Cassandra
  • Ключ-значення база даних, яка підходить для великих обсягів даних та горизонтального масштабування.
• Redis (REmote DIctionary Server)
  • Швидка база даних типу ключ-значення, яка використовується для кешування та зберігання швидкозмінних даних.
  • Redis швидко обробляє дані завдяки тому, що всі дані зберігаються у пам'яті.

31. Що таке async/await, навіщо вони потрібні і як їх використовувати⚑

🔥 39/100 · python/async.md

Ключове слово async використовується перед def, щоб показати, що функція є асинхронною (корутиною). Тобто, якщо визначити функцію async def f(): ... та викликатиме її як f() — повернеться корутина. Прийшла на зміну декоратору @asyncio.coroutine в Python 3.5+.

Ключове слово await вказує, що очікується завершення співпрограми. await може бути використане лише в співпрограмі. awaitable — все, що підтримує await, тобто корутини, asyncio.Futures, asyncio.Tasks, об'єкти з методом __await__. await прийшов на зміну yield from в Python 3.5+.

import asyncio
import aiohttp

urls = ['https://www.google.com', 'https://www.python.org']

async def call_url(session, url):
    print(f'Run {url}')
    async with session.get(url) as response:
        data = await response.text()
        print(f'{url}: {len(data)} bytes')
        return data

async def main(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [call_url(session, url) for url in urls]
        results = await asyncio.gather(*tasks)
        return results

asyncio.run(main(urls))  # Run the event loop

Програма містить асинхронний метод. Під час виконання він повертає співпрограму, яка потім перебуває у стані очікування.

async/await необхідні для того, щоб не блокувати виконання потоку під час очікування асинхронної події. Конструкція async/await фактично перетворює функцію на корутину (співпрограму): вона призупиняє своє виконання під час await, очікує асинхронної події та продовжує роботу.

Історична еволюція корутин у Python

Перехід від генератор-базованих корутин до нативного синтаксису відбувся не за один крок:

• Python 3.4 - модуль asyncio додано до стандартної бібліотеки. Корутини визначалися як генератори, обгорнуті декоратором @asyncio.coroutine; передача керування - через yield from.
• Python 3.5 (PEP 492) - додано нативний синтаксис async def / await, окремий від генераторів. await - заміна для yield from, але семантично прив'язана до корутин, а не до загального протоколу ітерації.
• Python 3.8 - декоратор @asyncio.coroutine оголошено застарілим (deprecated) з нотаткою "will be removed in version 3.10".
• Python 3.11 - @asyncio.coroutine остаточно видалено (whatsnew 3.11: "Removed the @asyncio.coroutine decorator enabling legacy generator-based coroutines to be compatible with async/await code").

Нативні корутини (async def) існують із Python 3.5 і весь цей час були окремою сутністю від генераторів на рівні API. У 3.11 видалили саме legacy-варіант із декоратором @asyncio.coroutine, а не нативну реалізацію. Внутрішні CPython-механізми (паузи, збереження стану кадру) історично спільні з генераторами, проте з точки зору API async def ніколи не була generator-based.

32. Партиціювання та шардування⚑

🔥 38/100 · infrastructure/database.md

Партиціювання та шардування - це техніки, які дозволяють розбити велику базу даних на менші частини, щоб забезпечити більшу масштабованість та продуктивність.

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

Партиціювання включає в себе наступні кроки

• Визначення критеріїв партиціювання: це може бути дата, час, ідентифікатор або будь-який інший атрибут, що дозволяє логічно розділити дані.
• Створення партицій: кожна партиція створюється відповідно до визначених критеріїв.
• Розподіл даних: дані переносяться в відповідні партиції.

Шардування (Sharding) - це процес розділення таблиці на менші фрагменти - шарди, які можуть бути збережені на різних серверах. Однак, на відміну від партиціювання, шардування зазвичай використовується для розділення даних на різних серверах у різних локаціях. Це дозволяє збільшити доступність та надійність бази даних, оскільки в разі відмови одного сервера, інші сервери можуть продовжувати працювати.

Шардування буває вертикальне і горизонтальне

• Горизонтальне шардування відбувається, коли рядки даних розподіляються між різними базами даних (шардами). Кожен шард містить унікальний набір рядків. Наприклад, один шард може містити дані про користувачів з іменами, що починаються на літери A-M, а інший шард - про користувачів з іменами на N-Z.
• Вертикальне шардування відбувається, коли стовпці даних розподіляються між різними базами даних. Кожен шард містить унікальний набір стовпців. Наприклад, один шард може містити контактну інформацію користувача, а інший - інформацію про замовлення цього користувача.

Проблема гарячого ключа (hot key / celebrity problem). Якщо ключ шардування дає нерівномірний розподіл навантаження, один шард перевантажується, тоді як інші простоюють. Класичний приклад - "знаменитості" в соцмережі: шардування за user_id рівномірно розкидає самих користувачів, але запити на читання стрічки кількох акаунтів-мільйонників б'ють в один шард. Ключ обирають за патерном доступу, а не лише за рівномірністю самих рядків; для гарячих сутностей застосовують окреме кешування, реплікацію читань або додаткове розбиття гарячого ключа.

33. В чому відмінність потоків від процесів⚑

🔥 38/100 · python/gil_threads_processes.md

Потоки історично з'явились пізніше процесів, і в Linux вони реалізовані однією і тією ж структурою даних, відомою як "таск" (Task). Для ядра Лінуксу немає різниці між потоком і процесом - потоки та процеси розглядаються як завдання (tasks). Тобто для створення того та іншого використовується єдина структура даних, де відмінність тільки в тому, що у треда буде встановлений TID, та декілька інших полей, які залежать від аргументів переданих до fork/clone викликів. CFS (Completely Fair Scheduler) та новий EEVDF (Earliest Eligible Virtual Deadline First) — планувальники, які використовуються для керування розподілом процесорного часу між завданнями в операційній системі - сприймають процеси та треди просто як "таски", тобто як абстракції завдань, тобто одиниці роботи, що потребують часу процесора. Вони не розрізняють тип цих завдань, а лише розподіляють час між ними залежно від заданих правил і алгоритмів.

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

Створення та знищення процесів може бути важким процесом, оскільки вони вимагають виділення окремих ресурсів. IPC (Inter-Process Communication) — це механізм, який дозволяє процесам взаємодіяти між собою, обмінюватися даними та координувати виконання.

Таким чином потоки є легшими, між ними швидше перемикається контекст.

Links

• Що таке потоки та процеси в Python - Foxminded.ua
• https://habr.com/ru/articles/40227/

34. Що таке ООП? Яка відмінність від процедурного?⚑

🔥 37/100 · computer_science/oop.md

Об'єктно-орієнтоване програмування (ООП) - це парадигма програмування, яка базується на концепції "об'єктів". Основними принципами ООП є ідея поділу програми на об'єкти, які взаємодіють один з одним, та спрощення розробки та обслуговування програм завдяки модульності і розподіленій відповідальності. ООП корисний тоді, коли у об'єктів є стан.

Кожен об'єкт групує заданий набір інформації (властивостей) та дій (методів), які може виконувати цей об'єкт.

Основні поняття ООП включають

• Класи і об'єкти (Classes and Objects): Клас - це шаблон або опис об'єкта, який визначає його властивості та методи. Об'єкт - це конкретний екземпляр класу, який може мати свої унікальні значення властивостей.
• Інкапсуляція (Encapsulation): Інкапсуляція визначає, що властивості та методи об'єкта повинні бути збережені разом та захищені від зовнішнього доступу. Це допомагає управляти доступом до даних і методів.
• Наслідування (Inheritance): Наслідування дозволяє створювати новий клас на основі існуючого класу, наслідуючи його властивості та методи. Це спрощує створення нових класів та перевикористання коду.
• Поліморфізм (Polymorphism): Поліморфізм дозволяє об'єктам різних класів використовувати однаковий інтерфейс для виконання різних операцій. Це спрощує роботу з різнорідними об'єктами.

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

35. Master-Slave⚑

🔥 37/100 · infrastructure/database.md

Архітектура Master-Slave (тепер часто називається Primary-Replica, щоб уникнути застарілих термінів) використовується для горизонтального масштабування баз даних і забезпечення високої доступності. У цій моделі одна база даних виступає як Master, а інші як Slave. Використовується для підвищення продуктивності, коли операції читання значно переважають операції запису, або для забезпечення резервування даних. Ця архітектура є популярною для додатків із високими вимогами до масштабованості з великою кількістю запитів на читання.

Master (Primary) - основна база даних, яка приймає всі операції запису. Зміни, внесені до Master, реплікуються (передаються) до всіх Slave.

Slave (Replica) - це одна або більше копій Master, які синхронізуються через реплікацію. Slave обслуговують лише операції читання, що дозволяє розподілити навантаження на систему.

Реплікація може бути синхронною (запис на Master завершується тільки після оновлення Slave) або асинхронною (Master завершує операцію запису, не чекаючи синхронізації з Slave).

Переваги

• Розвантаження Master - операції читання перенаправляються на Slave, що зменшує навантаження на Master.
• Масштабованість - легко додати нові Slave для обробки більшого обсягу запитів на читання.
• Резервування даних - у разі відмови Master, один із Slave може бути підвищений до Master.

Недоліки

• Затримка реплікації - у разі асинхронної реплікації можуть виникати затримки, що призводять до читання застарілих даних зі Slave.
• Складність управління - підтримка синхронізації між Master і Slave потребує додаткових ресурсів і інструментів.
• Відсутність автоматичного переходу на новий Master - у разі відмови Master зазвичай потрібне ручне втручання для призначення нового Master.

36. EXPLAIN та EXPLAIN ANALYZE⚑

🔥 37/100 · infrastructure/sql.md

EXPLAIN - це команда, яка надає інформацію про план виконання запиту. Вона показує, як база даних планує виконати запит, включаючи індекси, порядок виконання операцій та очікувані витрати, що допомагає в оптимізації запитів. Сам запит у разі не виконується.

EXPLAIN ANALYZE виконує пояснюваний вираз, навіть якщо це insert, update або delete.

Приклад використання команди EXPLAIN

EXPLAIN SELECT * FROM employees WHERE age > 30;

Seq Scan on employees (cost=0.00..12.50 rows=3 width=100)
 Filter: (age > 30)

База даних буде виконувати послідовне сканування (Seq Scan) таблиці employees і застосовувати фільтр age > 30. Поле cost показує передбачувані витрати виконання операції термінах часу і ресурсів.

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

Використання EXPLAIN особливо корисне при роботі зі складними запитами або великими обсягами даних, оскільки дозволяє заздалегідь зрозуміти, як виконуватиметься запит, і які оптимізації можуть знадобитися.

37. Чи можливе множинне наслідування⚑

🔥 37/100 · python/class_and_object.md

Так, в класах в Python можна вказати більше одного батька для похідного класу. На відміну від, наприклад, Java.

38. Чому використання змінних об'єктів як параметрів за замовчуванням погана практика⚑

🔥 37/100 · python/functions.md

Функція створюється один раз під час завантаження модуля. Іменовані параметри і їх значення за замовчуванням також створюються один раз і зберігаються в одному з полів об'єкта-функції (__defaults__). Це стосується списків, множин і словників.

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

def foo(bar=[]):
    bar.append(1)
    return bar

foo()
>>> [1]
foo()
[1, 1]
foo()
>>> [1, 1, 1]
foo.__defaults__
>>> ([1, 1, 1],)

Хорошим тоном вважається вказувати для параметра пусте незмінне значення, наприклад 0, None, '', False. В тілі функції перевіряти на False/None і створювати нову колекцію:

def foo(bar=None):
    if bar is None:
        bar = []
    bar.append(1)
    return bar
foo()
>>> [1]
foo()
>>> [1]
foo()
>>> [1]
foo.__defaults__
>>> (None,)

39. S - Single Responsibility Principle⚑

🔥 36/100 · computer_science/solid.md

Summary

У модуля - одна причина для зміни: він відповідає перед одним актором (групою стейкхолдерів), а те, що змінюється з різних причин, розносять окремо.

S - Single Responsibility Principle - SRP - Принцип єдиної відповідальность Кожен клас повинен мати лише одну відповідальність, вирішувати тільки одне завдання. Це означає, що клас має бути створений для виконання лише однієї задачі, яку він повинен повністю інкапсулювати. Отже, всі сервіси цього класу мають бути підпорядковані її виконанню. Результатом слідування цій концепції є наявність лише однієї причини для зміни класу.

Уточнення Мартіна. Формулювання "одна причина для зміни" Мартін згодом визнав таким, що часто розуміють хибно - нібито "клас має робити одну дію". Точніше: модуль має бути відповідальним перед одним актором (групою/роллю стейкхолдерів, яка ініціює зміни). Тобто збирають разом те, що змінюється з одних причин, і розділяють те, що змінюється з різних. SRP - не про "один метод", а про один напрям змін.

Переваги та недоліки

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

Реалізація - розділити більші класи на менші. Наприклад - є клас, який створює звіт і друкує звіт. Такий клас може змінитись через 2 причини - може змінитись сам звіт або формат друку. Тому цей клас треба розділити на 2 нових.

Антипатерном до цього принципу є Божественний клас (God object) - коли один виконує дуже багато всього. І тоді з'являється ефект сніжного кому - зміна в одному місці викликає зміну в багатьох. Це також порушує GRASP-принципи High Cohesion і Low Coupling: незв'язані обов'язки зібрані в одному класі, від якого до того ж залежить багато коду.

SRP та ідея повторного використання коду тісно пов’язані з ідеєю зчеплення (cohesion) в розробці програмного забезпечення. Потрібно прагнути досягти того, щоб класи були розроблені таким чином, щоб більшість їхніх властивостей і атрибутів використовувалися їхніми методами більшу частину часу. Та повинні мати мінімальний рівень відповідальності: виконувати одну задачу, лише одну, і виконувати її добре. Коли це трапляється, ми знаємо, що це пов'язані концепції, і тому має сенс об'єднати їх під одну абстракцію. Чим менші за розміром компоненти, тим вони більш універсальні, і тим легше їх застосувати в іншому контексті без перенесення зайвої поведінки, що спричиняє зв'язування (coupling) та залежності, які роблять програмне забезпечення негнучким.

Функціями чи класами. SRP не диктує форму: розділити відповідальності можна і на функції + dataclass-и + модулі, і на класи - єдиного стандарту немає. Якщо дія не має стану, функція уникає одно-метод-класу; якщо є стан, конфігурація чи поліморфізм - доречніший клас. Приклад розділення функціями:

from dataclasses import dataclass

@dataclass
class ReportData:
    user_id: int
    total_sales: float

def fetch_user_sales(db, user_id: int) -> list[dict]:             # db.py - data layer
    return db.execute(...)

def build_report(user_id: int, sales: list[dict]) -> ReportData:  # analytics.py - logic
    return ReportData(user_id, sum(s["price"] for s in sales))

def save_report_csv(report: ReportData, path: str) -> None:       # export.py - I/O
    ...

Щоб додати експорт у JSON, пишуть нову функцію save_report_json, не чіпаючи розрахунки чи запити до БД. Тестувати теж легше - у функцію розрахунку передають мок-список, не піднімаючи тестову базу.

Links

• https://www.pythontutorial.net/python-oop/python-single-responsibility-principle/
• Все, що ви хотіли знати про принципи SOLID. Частина перша: SRP - dou.ua

40. Які готові реалізації MQ ви знаєте⚑

🔥 36/100 · infrastructure/mq.md

• RabbitMQ: Це відкрите програмне забезпечення, яке реалізує стандартизований протокол AMQP (Advanced Message Queuing Protocol). Він дозволяє надійно та масштабовано обмінюватися повідомленнями між різними системами та компонентами додатків.
• Apache Kafka: Це розподілена платформа для потокової обробки та зберігання даних. Він спроектований для обробки великої кількості подій (повідомлень) та забезпечує гарантовану доставку та зберігання цих подій.
• Redis: Redis може бути використаний як MQ за допомогою свого механізму публікації-підписки (pub-sub) та черги повідомлень (list). Він швидкий та легкий у використанні.
• Apache ActiveMQ: Це ще одна реалізація протоколу AMQP. Він надає різноманітні можливості обробки повідомлень, включаючи публікацію-підписку, черги повідомлень та багато іншого.
• ZeroMQ (0MQ): Це бібліотека для передачі повідомлень між процесами через різні протоколи. Вона дозволяє вам побудувати власні механізми обміну повідомленнями, а також підходить для складних топологій зв'язку.
• Apache RocketMQ: Це система повідомлень, яка забезпечує надійну та масштабовану передачу повідомлень між різними компонентами додатків.

Links

• Message middleware deployment and comparison: rabbitMQ, activeMQ, zeroMQ, rocketMQ, Kafka, redis
• RabbitMQ против Kafka: два разных подхода к обмену сообщениями
• Kafka VS RabbitMQ
• Выбор MQ для высоконагруженного проекта

41. Метакласи⚑

🔥 36/100 · python/metaclass.md

Summary

Метаклас - клас, який створює класи і визначає поведінку класів. Вони дозволяють контролювати процес створення класу, модифікувати його атрибути, методи та поведінку.

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

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

У Python 3 метаклас задається ключовим аргументом metaclass= у заголовку класу (class MyClass(metaclass=Registry): ...). Атрибут __metaclass__ - застарілий механізм Python 2; у Python 3 він ігнорується.

Створення класу з автоматичною реєстрацією у системі

class Registry(type):
    def __init__(cls, name, bases, attrs):
        super().__init__(name, bases, attrs)
        register(cls)

class MyClass(metaclass=Registry):
    pass

Links

• Метаклассы в Python: что это такое и с чем его едят
• Метаклассы в Python

42. Django ORM⚑

🔥 36/100 · python_framework/django.md

Django ORM (Object-Relational Mapping) — це компонент Django, який дозволяє взаємодіяти з базою даних, використовуючи об'єктно-орієнтовані моделі, замість написання сирих SQL-запитів. Він автоматично перетворює Python-код у SQL-запити, роблячи роботу з базами даних зручнішою і більш безпечною.

Основні переваги Django ORM

• Автоматизація створення таблиць і запитів.
• Захист від SQL-ін'єкцій.
• Зручний синтаксис для роботи з базою даних.
• Можливість гнучкої побудови складних запитів.
• Підтримка різних типів баз даних: PostgreSQL, MySQL, SQLite, Oracle тощо.

Основні компоненти Django ORM

• Моделі (Models)
  • Моделі є основою ORM і визначають структуру таблиць у базі даних.
  • Кожна модель в Django — це Python-клас, який успадковує models.Model.
  • Поля класу відповідають стовпцям таблиці бази даних.

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)
    created_at = models.DateTimeField(auto_now_add=True)

• Поля (Fields)

  • Кожне поле моделі (CharField, IntegerField, DateTimeField, тощо) визначає тип даних у відповідному стовпці бази даних.
  • Можна додавати валідатори, налаштовувати значення за замовчуванням, встановлювати унікальність та інші параметри.

• Менеджер об’єктів (QuerySet API)

  • objects — це менеджер, за допомогою якого виконується доступ до записів у таблиці.
  • За допомогою менеджера можна створювати, читати, оновлювати та видаляти дані.

Product.objects.create(name="Laptop", price=1200.00)  # Create object
products = Product.objects.all()  # Getting all records
laptops = Product.objects.filter(name__icontains="laptop")  # Filtering

• Фільтри (Filters)

  • Django ORM надає різноманітні методи для створення запитів: filter(), exclude(), get().
  • Використовуються спеціальні ключі (наприклад, __icontains, __gte), які визначають умови.

• Відношення (Relationships)

  • Django підтримує зв'язки між моделями: ForeignKey, OneToOneField, ManyToManyField.
  • Це дозволяє створювати зв’язки між таблицями в базі даних.

class Category(models.Model):
    name = models.CharField(max_length=100)

class Product(models.Model):
    name = models.CharField(max_length=100)
    category = models.ForeignKey(Category, on_delete=models.CASCADE)

• Міграції (Migrations)
  • Міграції — це механізм, що дозволяє перетворювати зміни у моделях на SQL-команди для синхронізації структури бази даних.
  • Генерація та застосування міграцій

python manage.py makemigrations
python manage.py migrate

• Сигнали (Signals)
  • Django дозволяє виконувати дії перед або після певних подій у моделях (наприклад, збереження, видалення записів).
  • Наприклад, pre_save або post_delete.

from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=Product)
def notify_new_product(sender, instance, created, **kwargs):
    if created:
        print(f"New product added: {instance.name}")

• Транзакції (Transactions)
  • Django ORM підтримує атомарні операції через transaction.atomic(), що дозволяє виконувати кілька операцій як одну.

from django.db import transaction

with transaction.atomic():
    category = Category.objects.create(name="Electronics")
    Product.objects.create(name="Smartphone", category=category)

• Raw SQL
  • Якщо потрібно виконати нестандартний SQL-запит, ORM дозволяє це зробити через метод raw(), через RawSQL-вираз для вбудування шматка у звичайний ORM-запит, або через connection.cursor() для повністю довільного SQL.

products = Product.objects.raw("SELECT * FROM app_product WHERE price > %s", [1000])

Manager.raw(sql, params) повертає RawQuerySet - lazy, як звичайний QuerySet. Параметри обов'язково передавати через placeholder (%s для більшості бекендів, ? для SQLite) - ніколи не інтерполювати через f-string чи %-формат, інакше відкривається SQL injection.

# Safe: parameterized
Product.objects.raw("SELECT * FROM app_product WHERE name = %s", [user_input])

# UNSAFE: never do this
Product.objects.raw(f"SELECT * FROM app_product WHERE name = '{user_input}'")

raw() мапить колонки на атрибути моделі за іменами; колонки без відповідного поля можна додати як RawQuerySet[i].extra_attr. Якщо моделі не існує - тоді connection.cursor() з cursor.execute(sql, params) повертає dict/tuple-рядки:

from django.db import connection

with connection.cursor() as cursor:
    cursor.execute("SELECT id, name FROM app_product WHERE price > %s", [1000])
    rows = cursor.fetchall()        # List of tuples

Для вбудування невеликого SQL-фрагмента у звичайний ORM-запит - RawSQL-вираз:

from django.db.models.expressions import RawSQL

products = Product.objects.annotate(
    discount=RawSQL("price * %s", [0.1]),     # Inline SQL fragment in annotate
)

43. Що таке функція у Python⚑

🔥 35/100 · python/functions.md

Summary

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

Тіло функції - це блок коду, який виконується при виклику функції. Він може містити різні операції та вказівки. Функція може повертати значення за допомогою ключового слова return. Це значення може бути використане у коді, який викликав функцію.

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

Параметри завжди передаються однаково - присвоєнням імені тому самому об'єкту (call by object reference); копій при виклику не створюється. Різниця лише в наслідках:

• незмінний об'єкт (int, str, tuple) неможливо змінити на місці, тож зміни всередині функції його не зачіпають - виглядає як "по значенню"
• змінний об'єкт (list, dict) можна змінити на місці, і ці зміни видно в коді, що викликав функцію - виглядає як "по посиланню"

def greet(name):
    return "Hello, " + name

message = greet("Alice")
print(message)  # Hello, Alice

В Python функція - це об'єкт. Все що є за межами функцій і класів - глобальні змінні.

44. Методи HTTP⚑

🔥 35/100 · web_development/http.md

Методи HTTP поділяються на кілька основних груп, включаючи ідемпотентні та неідемпотентні методи.

Ідемпотентність — це властивість операцій, яка означає, що багаторазове виконання однієї і тієї ж операції призведе до того самого результату, що і перше її виконання. Незалежно від того, скільки разів операція буде викликана, результат залишатиметься незмінним.

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

Ідемпотентні методи HTTP

• GET - використовується для отримання інформації з сервера та не має побічних ефектів на дані на сервері.
• HEAD - подібний до GET, але повертає тільки заголовки без тіла відповіді.
• OPTIONS - використовується для запиту інформації про можливості сервера або ресурсу. Він дозволяє клієнту дізнатися, які HTTP-методи, заголовки та інші можливості підтримуються сервером для конкретного ресурсу без виконання реального запиту, що зменшує навантаження на сервер.
• PUT- використовується для зміни або оновлення існуючих ресурсів на сервері.
• DELETE - використовується для видалення ресурсів на сервері. Повторні виклики DELETE для того ж ресурсу не мають ефекту.

Неідемпотентні методи HTTP

• POST - використовується для відправки даних на сервер для створення нового ресурсу або виконання операцій, які можуть призвести до зміни стану сервера кожного разу, коли він викликається. POST не є ідемпотентним, оскільки два однакових POST-запити можуть мати різні наслідки.
• PATCH - використовується для зміни або оновлення частини ресурсу на сервері, але не завжди є ідемпотентним. Результат може залежати від попереднього стану ресурсу.

45. Що таке REST?⚑

🔥 35/100 · web_development/rest_soap.md

Summary

REST (Representational State Transfer, "передача стану представлення") - це архітектурний стиль для розподілених систем. Іншими словами - це набір правил того, як програмісту організувати написання коду серверної програми, щоб усі системи легко обмінювалися даними і програму можна було масштабувати. Під REST часто розуміють так звані HTTP REST API. Зазвичай це веб-додаток з набором URL-адрес - кінцевих точок. URL-адреси приймають та повертають дані у форматі JSON. REST є альтернативою RPC.

REST не накладає правил на реалізацію на низькому рівні, а лише надає високорівневі рекомендації та залишає вам волю для власної реалізації.

Основні поняття REST

• Ресурс - будь-який об’єкт або дані, з якими взаємодіє клієнт через сервер. Ресурс може бути будь-чим: користувач, файл, замовлення, продукт тощо. У REST API ресурси ідентифікуються через унікальні URL-адреси (Uniform Resource Locator), тобто посилання.
• Посилання - URL (уніфікований локатор ресурсу) є унікальним ідентифікатором ресурсу в REST API. Він слугує як шлях до конкретного ресурсу або його колекції. URL має бути інтуїтивно зрозумілим і відображати структуру та ієрархію ресурсів.
  • /users — колекція всіх користувачів
  • /users/123 — конкретний користувач із ідентифікатором 123
• Версіонування - можливість підтримки кількох версій сервісу для різних клієнтів або застосунків. Можливі варіанти версіонування
  • версія у URL - GET /v1/users, GET /v2/users
  • версія у заголовках - Accept: application/vnd.myapi.v1+json
  • версія у параметрах запиту - GET /users?version=1
• HATEOAS (Hypermedia as the Engine of Application State) — використання гіпермедіа для управління станом застосунку. Гіпермедіа тут означає використання гіперпосилань у відповідях API для надання клієнту можливості переходити між різними станами або ресурсами системи.

REST API будується на кількох ключових принципах. Якщо ці принципи дотримані, інтерфейс сервісу можу називатися RESTful.

Основні принципи REST

• Stateless -Відсутність стану - кожен HTTP-запит відбувається в повній ізоляції
• Client-Server - Клієнт-сервер - автономність клієнта і сервера та їх взаємодія
• Uniform Interface - Однорідний інтерфейс - підтримка однорідного інтерфейсу
• Cacheable - Кешування - підтримка кешування
• Layered System - Шари абстракції - поділ на шари
• Code on Demand - Код на запит - необов’язкове обмеження, що дозволяє завантажувати код клієнта

Операції визначаються HTTP-методами, тому не варто використовувати дієслова в URL. Метод запиту HTTP визначає тип операції

• GET - отримати об'єкт або список об'єктів
• POST - створити об'єкт
• PUT - оновити існуючий об'єкт
• PATCH - частково оновити існуючий об'єкт
• DELETE - видалити об'єкт
• HEAD - отримати метадані об'єкта

REST-архітектура активно використовує можливості протоколу HTTP, щоб уникнути власних рішень. Наприклад, параметри кешування передаються стандартними заголовками Cache, If-Modified-Since, ETag. Аутентифікація здійснюється за допомогою заголовка Authentication.

Links

• Повний огляд REST: нюанси, поради, приклади

46. Абстракція⚑

🔥 34/100 · computer_science/oop.md

Summary

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

У ООП, абстракція зазвичай досягається за допомогою створення абстрактних класів або інтерфейсів, які описують специфікацію поведінки об'єктів, але не надають конкретної реалізації. Абстрактні класи містять абстрактні методи, які мають бути перевизначені в дочірніх класах. Інтерфейси, у свою чергу, описують набір методів, які мають бути реалізовані в класах, які їх імплементують.

Простим прикладом абстракції може бути клас Shape, який представляє геометричну фігуру. Абстрактний клас містить абстрактний метод area, який об'явлений, але не має реалізації:

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

Дочірні класи, наприклад, Circle та Rectangle, успадковують Shape і повинні перевизначити метод area згідно своїх потреб:

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14 * self.radius * self.radius

class Rectangle(Shape):
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

За допомогою абстракції, ми можемо робити узагальнені операції над об'єктами типу Shape, не знаючи конкретних деталей реалізації. Наприклад:

def print_area(shape):
    print(f"The area of the shape is: {shape.area()}")

circle = Circle(5)
rectangle = Rectangle(4, 6)

print_area(circle)  # Output: The area of the shape is: 78.5
print_area(rectangle)  # Output: The area of the shape is: 24

47. Методи. @staticmethod, @classmethod⚑

🔥 34/100 · python/class_and_object.md

Метод - це функція, яка викликається від інстансу класу. Метод зберігаються в класі, а не інстансі. Використовує параметр self, який представляє екземпляр класу.

class MyClass:
    def instance_method(self):
        return f"Instance method called. Attribute: {self.attribute}"

obj = MyClass()
obj.attribute = 5
print(obj.instance_method())  # Output: Instance method called. Attribute: 5

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

Це можна імітувати за допомогою MethodType із модуля types. Перший параметр цього класу має бути callable, а другий — це об'єкт, до якого прив'язується ця функція. Щось подібне до цього використовують об'єкти функцій у Python, щоб вони могли працювати як методи, коли їх визначають всередині класу. У цьому прикладі абстракція MyClass намагається імітувати об'єкт функції, оскільки в реальному інтерпретаторі це реалізовано на C.

from types import MethodType

class Method:
    def __init__(self, name):
        self.name = name

    def __call__(self, instance, arg1, arg2):
        print(f"{self.name}: {instance} called with {arg1} and {arg2}")

    def __get__(self, instance, owner):
        if instance is None:
            return self
        return MethodType(self, instance)

3 типи методів

• метод інстансу - тільки від інстансу. Якщо від класу - помилка. Перший параметр - інстанс self. Цей метод має доступ до атрибутів і методів екземпляра.
• метод класу @classmethod - першим параметром приймає клас cls. Може викликатись як від інстансу, так і від класу.
• статичний метод @staticmethod

І @staticmethod, і @classmethod реалізовані за допомогою дескриптора.

@staticmethod Статичний метод не використовує self або cls. Він не має доступу до атрибутів екземпляра або класу. Це по суті функція всередині класу.

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

Коли використовувати:

• Коли метод не потребує доступу до екземпляра або класу.
• Коли метод логічно зв'язаний з класом, але не використовує його атрибути або методи.

class MyClass:
    @staticmethod
    def static_method():
        return "Static method called"

print(MyClass.static_method())  # Output: Static method called

@classmethod Метод класу приймає параметр cls, який представляє сам клас. Це дозволяє методам класу доступ до атрибутів і методів класу.

Функція __get__ у дескрипторі забезпечує, що клас передається як перший параметр до функції, яка декорується, незалежно від того, викликається вона безпосередньо з класу чи через екземпляр.

Коли використовувати:

• Коли метод повинен працювати з класом як з об'єктом.
• Коли потрібно створити метод, що працює з загальними для всіх екземплярів даними.

class MyClass:
    class_attribute = "Class attribute"

    @classmethod
    def class_method(cls):
        return f"Class method called. Attribute: {cls.class_attribute}"

print(MyClass.class_method())  # Output: Class method called. Attribute: Class attribute

48. Які типи даних є в Python⚑

🔥 34/100 · python/data_types.md

Примітивні типи даних:

• Цілі числа (int)
  • Python не має обмеження по значенню int
  • Числа від -5 до 256 кешуються при старті інтерпретатора CPython (станом на 3.14; у 3.15 діапазон розширили до -5..1024): якщо створити ціле число в цьому діапазоні, воно посилатиметься на той самий об'єкт у пам'яті
• Дійсні числа (float) - числа з плаваючою комою
• Комплексні числа (complex)
• Рядки (str)
• Булеві значення (bool) - True, False
• None - тип, який вказує на відсутність значення.

Кешування малих цілих (int) у CPython:

a = 1
b = 1
a is b  # True - values in range -5..256 are cached (small-int cache)
a = 300
b = 300
a is b  # False - outside the cache range
a == b  # True

Колекції (містять в собі інші об'єкти):

• Списки (list)
• Кортежі (tuple)
• Словники (dict)
• Множини (set)
• Фрозенсет (frozenset) - аналог множини, але не змінюється після створення

Також до примітивних типів ще відносять:

• Байти (bytes) - незмінний (immutable) тип даних, який використовується для представлення послідовності байтів - b'hello'
• Байтові масиви (bytearray) - подібно до байтів, але можуть бути змінюваними -bytearray(b'hello')

Також типи даних діляться на mutable and immutable:

• Mutable - list, dict, set
• Immutable - int, string, tuple, frozenset, boolean, NoneType

49. Що таке лямбди. Які їх особливості⚑

🔥 34/100 · python/functions.md

Лямбда (lambda) - це анонімна функція, яка не резервує ім'я в просторі імен.

Лямбда може приймати необмежену кількість аргументів та мати будь-яку кількість параметрів. Однак лямбда-функція може мати лише один вираз або інструкцію, і вона завжди повертає результат цього виразу.

Лямбди використовується в ситуаціях, коли потрібна анонімна функція на короткий період часу. Наприклад передати в map, reduce, filter, або для сортування.

У Python лямбди можуть складатися лише з одного виразу. Використовуючи синтаксис дужок, можна оформити тіло лямбди у декілька рядків.

Не можна використовувати крапку з комою для розділення операторів.

a = lambda x, y: x + y
print(a(5, 6))  # 11

students = [{"name": "Alice", "age": 25}, {"name": "Bob", "age": 20}]
sorted(students, key=lambda x: x["age"])  # [{"name": "Bob", "age": 20}, {"name": "Alice", "age": 25}]

Наступні вирази при завантаженні модуля викличуть SyntaxError. Тіло лямбди може містити лише вирази. pass і raise є операторами.

nope = lambda: pass
riser = lambda x: raise Exception(x)

Пастка пізнього зв'язування (late binding) у циклі

Класична особливість лямбд у циклі: лямбда - це замикання, а замикання захоплює саму змінну (за іменем), а не її значення на момент створення. Тому всі лямбди, створені в циклі, бачать останнє значення змінної циклу, а не те, що було на відповідній ітерації:

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]   # [2, 2, 2], not [0, 1, 2]

Усі три лямбди посилаються на ту саму змінну i, яка після циклу дорівнює 2. Щоб зафіксувати значення кожної ітерації, його прив'язують через аргумент за замовчуванням - він обчислюється в момент визначення функції:

funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]   # [0, 1, 2]

Це той самий механізм захоплення за посиланням, що й у секції про замикання (Closure) нижче, - тут він лише найчастіше проявляється з лямбдами.

50. Види дескрипторів⚑

🔥 33/100 · python/class_and_object.md

Є два види дескрипторів

• дескриптор даних
• дескриптор не даних

Якщо об’єкт визначає __set__() або __delete__(), він вважається дескриптором даних. Дескриптори, які визначають лише __get__(), називаються дескрипторами не даних (вони часто використовуються для методів, але можливі й інші способи використання).

Функції в Python являються дескрипторами (дескрипторами не даних) - так як реалізовують __get__()

>>> def foo(x):  
...   return x * 2  
...  
>>> '__get__' in dir(foo)  
True

Дескриптори даних і не даних відрізняються тим, як обчислюються перевизначення щодо записів у словнику екземпляра. Якщо в словнику екземпляра є запис із таким самим іменем, як і дескриптор даних, дескриптор даних має пріоритет. Якщо в словнику екземпляра є запис із таким же ім’ям, що й дескриптор не даних, пріоритет має словниковий запис.

Щоб створити дескриптор даних лише для читання, визначте __get__() і __set__() з __set__(), що викликає AttributeError під час виклику. Щоб зробити його дескриптором даних, достатньо визначити метод __set__(), що викликає винятки.

51. Які магічні методи відповідають за перетворення типів?⚑

🔥 33/100 · python/class_and_object.md

Summary

Кожна вбудована функція-конвертер шукає у класі відповідний дандр-метод: int() → __int__, float() → __float__, str() → __str__, bool() → __bool__, bytes() → __bytes__, complex() → __complex__, repr() → __repr__.

Коли викликаємо int(obj), Python шукає у класі obj метод __int__ і повертає його результат. Аналогічно для решти. Це дозволяє кастомним класам поводитися як числа, рядки чи булеві значення в контекстах, де очікується відповідний тип.

class Money:
    def __init__(self, value):
        self.value = value

    def __int__(self):
        return int(self.value)

    def __float__(self):
        return float(self.value)

    def __str__(self):
        return f"${self.value:.2f}"

    def __bool__(self):
        return self.value != 0

m = Money(42.7)
int(m)    # 42
float(m)  # 42.7
str(m)    # '$42.70'
bool(m)   # True

Якщо __bool__ не визначений - Python пробує __len__ (порожній об'єкт → False). Якщо немає ні того, ні іншого - об'єкт завжди істинний.

52. Що таке потік (Thread)? Що таке процес (Process)?⚑

🔥 33/100 · python/gil_threads_processes.md

Потік - це легкий підпроцес, що існує в межах основного процесу і може виконувати паралельні задачі. Кожен потік має свій стек викликів, але поділяє адресний простір, купу та регістри процесора з іншими потоками в рамках процесу. Потоки дозволяють програмі виконувати багатозадачні операції, розділюючи I/O завдання між різними потоками для збільшення продуктивності. У Python, для роботи з потоками можна використовувати модуль threading.

Процес - це незалежний виконуваний екземпляр програми, який має свою власну пам'ять та ресурси (файлові дескриптори, незалежні стеки викликів, купи та регістри процесора) і виконує код незалежно від інших процесів. Кожен процес має власний ідентифікатор процесу (PID) та виконується в окремому розділі пам'яті. У Python, для роботи з процесами можна використовувати модуль multiprocessing. Процеси є корисними для використання багатоядерних систем, оскільки кожен процес може працювати на власному ядрі процесора, що підвищує продуктивність програм. Особливо у випадку Python, де через GIL багатозадачність не дає справжнього паралелізму.

Links

• Python без блокувань. Як працюють потоки - dou.ua
• Розділяй і володарюй. Як працюють процеси в Python - dou.ua

53. Що таке локальні та глобальні змінні в Python? global, nonlocal⚑

🔥 33/100 · python/namespace_and_context_manager.md

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

Локальні змінні - будь-яка змінна, оголошена всередині функції, відома як локальна змінна. Ця змінна присутня в локальному просторі, а не в глобальному.

a = 2
def add():
    b = 3
    c = a + b
    print(c)
add()  # 5

if, for, while не мають власного скоупу (області видимості) - змінні будуть доступні після виконання

• global: Ключове слово global дозволяє звертатися до глобальних змінних всередині функцій та змінювати їх значення. Глобальні змінні оголошуються на рівні програми та є видимими в усій програмі.
• nonlocal: Ключове слово nonlocal дозволяє звертатися до локальних змінних в зовнішніх функціях (батьківських функціях) з внутрішніх функцій (вкладених функцій). Це дозволяє змінювати значення змінних у батьківській функції з внутрішньої функції.

global використовується для роботи з глобальними змінними, а nonlocal - для роботи з локальними змінними у вкладених функціях.

>>> def function():
...     global x
...     x = 'global assigned inside function'
...     print (x)
...
>>> function()
global assigned inside function
>>> x
'global assigned inside function'
>>>

>>> def outer():
...     x = "x assigned inside outer"
...     def inner():
...         nonlocal x
...         x = "x assigned inside inner"
...         print("inner():", x)
...     inner()
...     print("outer():", x)
...
>>> outer()
inner(): x assigned inside inner
outer(): x assigned inside inner
>>>

Links

• http://ruslan.rv.ua/python-essential/functions/scope.html

54. Нормалізація баз даних⚑

🔥 32/100 · infrastructure/database.md

Нормалізація баз даних - це процес поділу таблиці на дрібніші, пов'язані таблиці для уникнення надмірності даних та забезпечення узгодженості та цілісності бази даних.

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

Денормалізація баз даних - це процес об'єднання даних із кількох таблиць в одну або кілька денормалізованих таблиць для оптимізації продуктивності та спрощення запитів.

Денормалізації включає

• Зменшення числа з'єднань таблиць, щоб покращити продуктивність під час виконання запитів.
• Дублювання даних для спрощення та прискорення вилучення даних.
• Використання агрегованих стовпців для попереднього обчислення агрегатних функцій.

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

Існують такі рівні нормалізації: перша нормальна форма (1НФ), 2НФ, 3НФ, нормальна форма Бойса-Кодда (БКНФ), 4НФ, 5НФ. Але дотепер жодна з реляційних СКБД не надає належної підтримки усім п'яти нормальним формам. Це відбувається через жорсткі вимоги до продуктивності. Суть справи полягає в тому, що в повністю нормалізованій БД для виконання запиту треба з'єднати настільки багато таблиць, що продуктивність такої системи не зможе задовольнити користувачів. Тому на практиці використовують лише перші три рівня нормалізації – 1НФ, 2НФ, ЗНФ.

Види нормальних форм

• Перша нормальна форма (1NF) утворює ґрунт для структурованої схеми бази даних
  • Кожна таблиця повинна мати первинний ключ: мінімальний набір колонок, які ідентифікують запис.
  • Відсутні групи атрибутів з однаковими за змістом значеннями, які повторюються у межах одного кортежу.
  • Атомарність - кожен атрибут повинен мати лише одне значення, а не множину значень. Наприклад, якщо у атрибуті "Прізвище, ім'я, по батькові" міститься прізвище, ім'я та по батькові читача, вимога неподільності не виконується
• Друга нормальна форма (2NF)
  • Таблиця повинна бути у 1NF
  • Всі неключові стовпці повинні повністю залежати від первинного ключа.
• Третя нормальна форма (3NF)
  • Таблиця повинна бути у 2NF
  • Усуває транзитивні залежності, тобто кожен неключовий атрибут повинен прямо залежати від первинного ключа, а не від інших неключових атрибутів. Це ще більше зменшує надмірність і підвищує цілісність.

Переваги нормалізації

• Зменшення надмірності даних та забезпечення цілісності бази даних.
• Поліпшення продуктивності під час оновлення даних.
• Спрощення структури бази даних, що робить її легшою для розуміння та підтримки.

Недоліки нормалізації

• Збільшення складності при вилученні даних із кількох пов'язаних таблиць.
• Збільшення числа з'єднань таблиць при виконанні складних запитів, що може негативно позначитися на продуктивності.

Links

• https://youtu.be/0kq99Y8m0gw?si=PY9bqnrF4ReGHDbv

55. Ітератор⚑

🔥 32/100 · python/iterator_and_generator.md

Summary

Ітератор - об'єкт, який знає, як повертати свої елементи по одному за раз, підтримує ітерацію по послідовності. З точки зору Python він повинен мати метод __iter__(), який повертає сам об'єкт ітератора, і метод __next__(), який повертає наступний елемент послідовності або викидає виняток StopIteration, якщо більше немає елементів.

Ітератори використовуються в циклі for для ітерації по колекції. Кожен об'єкт, який підтримує ітератор, є ітерабельним, але не кожен ітерабельний об'єкт є ітератором. Наприклад рядки та словники - оскільки вони не мають методу __next__, натомість їхня ітерабельність забезпечується методом __iter__, який повертає окремий об'єкт-ітератор (для словника - ітератор по ключах).

Ітерабельність - це властивість об'єкта підтримувати ітерацію. Всі послідовності в Python є ітерабельними, оскільки вони підтримують ітерацію через свої елементи.

Ітератори представлені абстрактним класом collections.abc.Iterator:

class Iterator(Iterable):

    __slots__ = ()

    @abstractmethod
    def __next__(self):
        """Return the next item from the iterator. When exhausted, raise StopIteration"""
        raise StopIteration

    def __iter__(self):
        return self

    @classmethod
    def __subclasshook__(cls, C):
        if cls is Iterator:
            return _check_methods(C, '__iter__', '__next__')
        return NotImplemented

• __next__ повертає наступний доступний елемент і викликає виняток StopIteration, коли елементів не залишилося.
• __iter__ повертає self. Це дозволяє використовувати ітератор там, де очікується ітерабельний об'єкт, наприклад, в циклі for.
• __subclasshook__ перевіряє наявність у класу методів __iter__ і __next__

По ітератору можна пройтись тільки один раз.

Вимога __iter__ для протоколу for

for не викликає __next__ напряму - він спершу запитує ітератор через iter(obj). Сам iter(), за документацією, "raises TypeError if it does not support either of those protocols" (__iter__ або застарілий __getitem__ з цілочисельним індексом):

class OnlyNext:
    def __next__(self):
        return 1

obj = OnlyNext()
next(obj)           # 1 - direct call works
for x in obj: ...   # TypeError: 'OnlyNext' object is not iterable

Реалізація лише __next__ без __iter__ технічно можлива, але такий об'єкт не сумісний із циклом for, розпакуванням, list() тощо - усі вони покладаються на iter(). Канонічна форма ітератора реалізує обидва методи, де __iter__ повертає self.

my_list = [1, 2, 3, 4, 5]
my_iterator = iter(my_list)

print(next(my_iterator))  # 1
print(next(my_iterator))  # 2
print(next(my_iterator))  # 3

for item in my_iterator:
    print(item)  # 4, 5

try:
    print(next(my_iterator))  # raises StopIteration
except StopIteration:
    print("Iteration is done")

56. Microservices - Мікросервіси⚑

🔥 31/100 · architecture/microservices.md

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

Кожен сервіс є незалежним, має свою кодову базу, базу даних (або доступ до окремих таблиць) і виконує одне конкретне завдання. Взаємодія між сервісами зазвичай відбувається через легкі протоколи, такі як HTTP (REST, GraphQL) або брокери повідомлень (RabbitMQ, Kafka).

Підходить для великих і динамічних проєктів, де важлива можливість масштабувати окремі частини системи або швидко впроваджувати зміни. Мікросервіси дозволяють створювати гнучкі та масштабовані системи, але потребують ретельного планування, щоб уникнути зростання складності в управлінні.

Переваги мікросервісів

• Зручність масштабування: кожен сервіс можна масштабувати незалежно від інших.
• Можливість використовувати різні технології для різних сервісів залежно від їхніх потреб.
• Полегшення підтримки: зміни в одному сервісі не впливають на інші (за умови чітких контрактів).
• Зменшення ризику: збій в одному сервісі не зупиняє роботу всієї системи.

Недоліки мікросервісів

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

57. В чому різниця між списком і кортежем⚑

🔥 31/100 · python/sequences.md

Кортеж (tuple), тюпл - це незмінна послідовності. Представлені класом tuple.

Список (list), ліст - це змінна послідовність, яка зазвичай використовується для зберігання однотипних даних (хоча Python не забороняє зберігати в них дані різних типів). Представлені класом list.

На рівні мови вони відрізняються тим, що до кортежу не можна додати або видалити елемент. Внутрішньо list і tuple реалізований як масив вказівників на об'єкти в пам'яті.

Tuple

• a = (), a = (25,), a = tuple()
• Оскільки розмір кортежа фіксований, його можна зберігати більш компактно, ніж списки, які потребують додаткового виділення пам'яті для ефективної операції append().
• Кортежі зберігаються в одному блоку пам'яті. Кортежі є незмінними, тому не потребують додаткового місця для зберігання нових об'єктів. Це причина, чому створення кортежу є швидшим за створення списку. Це також пояснює невелику різницю в швидкості індексування, яка є швидшою ніж в списках, оскільки в кортежах для індексування слідкує за меншою кількістю вказівників (оскільки структура фіксована).

typedef struct {
    PyObject_VAR_HEAD
    /* ob_item contains space for 'ob_size' elements.
     Items must normally not be NULL, except during construction when
     the tuple is not yet visible outside the function that builds it. */
    PyObject *ob_item[1];
} PyTupleObject;

• Макрос PyObject_HEAD додає лічильник посилань та вказівник на батьківський тип до об'єкта.
• Макрос PyObject_VAR_HEAD включає в себе PyObject_HEAD і додає поле Py_ssize_t ob_size, в якому зберігається кількість елементів.
• PyObject *ob_item[1] - це масив вказівників на об'єкти, які зберігаються в кортежі і є статичним масивом.
• Порожній кортеж у CPython - кешований singleton: усі () посилаються на один об'єкт, тоді як кожен новий порожній список створюється заново (бо список змінний, спільний об'єкт неможливий). Це деталь реалізації CPython (не гарантія мови), яка економить пам'ять:

() is ()        # True  - same cached object
[] is []        # False - a fresh list each time

List

• a = [] - швидша ініціалізація ніж list()
• Списки виділяються в двох блоках: фіксованому з усією інформацією об'єкта Python і блоку змінного розміру для даних.

typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;
    Py_ssize_t allocated;
} PyListObject;

• PyObject_VAR_HEAD - це макрос, який використовується для реалізації базового об'єкта Python. Він містить розмір та посилання на тип об'єкта.
• PyObject **ob_item - це масив вказівників на об'єкти, які зберігаються в списку.
• Py_ssize_t allocated - це кількість виділеної пам'яті для об'єктів списку. Поле 'allocated' дорівнює розміру буфера, до якого додавання нових елементів відбувається швидко. Якщо кількість елементів 'ob_size' стає рівною 'allocated', то створюється новий масив більшої місткості і копіюються в нього елементи старого масиву. Встановлюється новий 'allocated', який є більшим відносно старого. 'allocated' завжди кратний 4, і модель його зростання наступна: 0, 4, 8, 16, 24, 32, 40, 52, 64, 76 і так далі.

Незмінність кортежа поверхнева

Кортеж фіксує лише власні вказівники - якщо елемент сам є змінним об'єктом (наприклад, списком), його можна змінити на місці; сам кортеж при цьому "не змінюється", бо вказівник лишається тим самим. Звідси неочевидна поведінка доповненого присвоєння +=:

t = ([1], 2)
t[0] += [3]      # TypeError: 'tuple' object does not support item assignment
print(t)         # ([1, 3], 2) - the list was extended anyway!

+= для списку - це __iadd__ (зміна на місці), яка відпрацьовує до спроби переприсвоїти t[0]. Тому операція і кидає виняток, і встигає змінити список - вона не атомарна.

Множення списку копіює посилання, а не об'єкти. Оператор * для списку не клонує вкладені об'єкти - він заповнює новий список тими самими посиланнями. Тому [[]] * 3 створює три посилання на той самий список, і зміна одного видно в усіх:

a = [[]] * 3
a[0].append(1)
print(a)        # [[1], [1], [1]] - not three independent lists

matrix = [[0] * 3] * 3   # the same trap for a "matrix"
matrix[0][0] = 1
print(matrix)            # [[1, 0, 0], [1, 0, 0], [1, 0, 0]]

Щоб отримати незалежні вкладені списки, використовують генератор - [[] for _ in range(3)] (чи [[0] * 3 for _ in range(3)] для матриці). Множення безпечне лише для незмінних елементів: [0] * 3 коректно дає [0, 0, 0].

58. Словник (dict)⚑

🔥 31/100 · python/set_and_dict.md

Summary

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

Ініціалізація - a = {}, a = dict()

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

Починаючи з версії 3.7, усі словники зберігають порядок вставки ключів - вони будуть прочитані в тому порядку, в якому були записані. Це гарантія, яку дає сам dict, а не окремий клас OrderedDict.

В Python практично всі обєкти - dict.

Доступ до ключа - O(1)

this_dict = {  
    "brand":"Ford",  
    "model":"Mustang",  
    "year": 1964  
}  
print(this_dict["brand"])  # Ford

59. Що таке колізія⚑

🔥 31/100 · python/set_and_dict.md

Колізія - ситуація, коли хеш-функція повертає однакове значення (або однаковий індекс після взяття по модулю розміру таблиці) для двох різних ключів. CPython вирішує колізії виключно через open addressing (відкрите адресування); chaining (ланцюжки) - це альтернативна стратегія, яка використовується в інших реалізаціях (наприклад, у Java HashMap), але не у CPython.

Open addressing (стратегія CPython)

При колізії алгоритм не створює окрему структуру для конфліктуючих ключів - він шукає іншу вільну комірку у тому ж самому масиві. Пошук наступної комірки називається пробінгом (probing). Найпростіші його варіанти - лінійний (i+1, i+2, …) і квадратичний (i+1, i+4, i+9, …) - використовуються в навчальних реалізаціях, але страждають від кластеризації колізій.

CPython використовує власну схему пробінгу з перетурбацією (perturbation), яка залучає всі біти хешу, а не лише ті, що потрапили в початковий індекс. Це знижує кластеризацію для типових структур ключів. Формула наступного індексу взята з коментаря "Major subtleties ahead" у Objects/dictobject.c (CPython main, актуальна на момент написання):

#define PERTURB_SHIFT 5

perturb >>= PERTURB_SHIFT;
i = (i*5 + perturb + 1) & mask;     /* mask = size - 1, size is a power of 2 */

perturb ініціалізується значенням хешу і на кожній ітерації зсувається на PERTURB_SHIFT біт вправо, поступово підмішуючи у пробінг старші біти хешу. Вибір значення 5 для PERTURB_SHIFT - результат експериментів Tim Peters (з того ж коментаря у джерелі): значення оптимізує сумарну кількість колізій, але 4 чи 6 дають порівнянний результат.

Алгоритм пошуку ключа:

1. Обчислити hash(key), взяти index = hash & (size - 1) (size - степінь двійки).
2. Якщо комірка порожня - ключа немає.
3. Якщо у комірці є ключ і його __eq__ дорівнює шуканому - повернути значення.
4. Інакше це колізія - обчислити наступний індекс за схемою пробінгу з перетурбацією і повторити.

При видаленні елемента на його місце ставиться спеціальний маркер dummy (tombstone) замість повного очищення комірки - інакше пошук міг би зупинитися на порожньому слоті, не дійшовши до ключа, який раніше при колізії перейшов далі.

Переваги open addressing у CPython над chaining

• Cache locality. Усі дані лежать в одному суцільному масиві, що добре дружить з кешем процесора. Chaining натомість змушує переходити по вказівниках між елементами ланцюжка, які лежать у довільних місцях heap'у.
• Менше алокацій. Не потрібно виділяти окремі вузли списку при кожній колізії.
• Передбачуваний layout. Розмір таблиці завжди степінь двійки; пробінг не вимагає додаткових структур.

Chaining (для порівняння)

У реалізаціях з chaining (Java HashMap, C++ std::unordered_map) кожна комірка таблиці зберігає вказівник на ланцюжок (зв'язаний список або, у нових версіях Java, збалансоване дерево) елементів з однаковим індексом. Пошук - спочатку по індексу, потім по ланцюжку через __eq__. Простіша модель, але гірша cache locality і додаткові алокації на колізію.

Links

• Objects/dictobject.c (CPython source)
• https://habr.com/ru/companies/otus/articles/448350/

60. Що таке індекси? Навіщо вони потрібні? Як вони працюють?⚑

🔥 30/100 · infrastructure/database.md

Summary

Індекси - це структури даних у базах даних, які допомагають прискорити пошук і фільтрацію даних. Вони створюються для певних полів таблиць і дозволяють базі даних здійснювати швидший доступ до конкретних рядків.

Індекси потрібні для покращення продуктивності запитів, особливо коли потрібен пошук або фільтрація даних за певними полями. Вони допомагають зменшити кількість рядків, які база даних повинна перевірити, щоб знайти відповідні результати.

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

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

Індекси підвищують продуктивність запитів на вибірку даних, але одночасно можуть збільшити час виконання операцій вставки, оновлення та видалення, адже база даних також повинна оновити індекс.

Тому індекси додають свідомо, а не "про всяк випадок". Дві типові помилки в обидва боки: колонки, за якими йде JOIN, **недо**індексовані - PostgreSQL автоматично індексує лише первинний ключ, а колонки зовнішнього ключа ні, тож без ручного індексу кожен JOIN дає seq scan приєднуваної таблиці; натомість давно створені **не**використовувані індекси лише з'їдають місце і сповільнюють запис - кандидатів на видалення видно у pg_stat_user_indexes (idx_scan = 0 - індексом жодного разу не скористались).

У PostgreSQL індекси реалізовані різними способами. Наприклад, B-дерева є одним з найпоширеніших типів індексів. Вони дозволяють швидкий пошук значень і забезпечують ефективну підтримку різних операцій порівняння, таких як менше, більше, дорівнює тощо.

Принцип роботи B-дерева. Індекс - це збалансоване дерево зі сторінок. Пошук починається з кореневої сторінки, що містить ключі-межі та посилання на дочірні сторінки, кожна з яких відповідає за неперервний діапазон ключів. Спускаючись від кореня через проміжні сторінки, пошук доходить до сторінки-листа із самими значеннями (або посиланнями на них). Кількість посилань на одній сторінці - коефіцієнт розгалуження (branching factor) - зазвичай кількасот, тому навіть мільярди ключів вкладаються в дерево глибиною 3-4 рівні. При вставці, якщо на потрібній сторінці бракує місця, її розбивають на дві напівпорожні, а батьківську оновлюють. Сторінки-листи часто зв'язані вказівниками вліво та вправо, що дає впорядкований обхід діапазону без повернення до батьківських сторінок. Для відмовостійкості зміни спершу пишуть у журнал упереджувального запису (WAL, redo log) і лише потім застосовують до сторінок дерева - після збою дерево відновлюють із WAL.

Links

• https://www.youtube.com/watch?v=ju9F8OvnL4E

61. Як Kafka працює під капотом?⚑

🔥 30/100 · infrastructure/mq.md

Kafka - розподілена лог-орієнтована система повідомлень, спроектована для високої продуктивності, стійкості й обробки великих потоків даних у реальному часі.

1. Основні сутності

• Producer - відправляє повідомлення в Kafka.
• Consumer - читає повідомлення з Kafka.
• Broker - сервер Kafka, що зберігає й передає дані.
• Topic - логічна категорія/канал повідомлень.
• Partition - фізичний сегмент усередині топіка (забезпечує масштабування).
• Consumer Group - група консьюмерів, що спільно читають партиції.

2. Зберігання повідомлень (лог-файли)

Kafka зберігає повідомлення у файлах на диску як стійкий впорядкований лог:

• Кожна партиція - це append-only лог-файл.
• Нові повідомлення дописуються в кінець, старі не змінюються.
• Дані передаються з диску з використанням zero-copy.

3. Чому Kafka швидка

• Append-only запис - найшвидша операція на диску.
• Zero-copy I/O - дані передаються з page cache у сокет, обходячи user-space.
• Партиції дозволяють розпаралелювати обробку.

4. Підписка і зсуви (offsets)

• У кожного консьюмера є offset - позиція в партиції.
• Консьюмер сам вирішує, де починати читати (можна "перемотати").
• Kafka не видаляє повідомлення одразу після прочитання (на відміну від RabbitMQ) - вони зберігаються за часом (retention.ms) або розміром (retention.bytes).

Consumer lag - ключова метрика стану. Lag - це різниця між останнім записаним у партицію offset (log end) і зафіксованим offset споживача, тобто скільки повідомлень ще не оброблено. Це головний сигнал здоров'я конвеєра: стабільний lag (хай і ненульовий) означає, що споживачі встигають; зростаючий lag - що не встигають, і потрібно масштабувати споживачів (до кількості партицій - більше консьюмерів за партиції не прискорить) або шукати повільну обробку. На відміну від CPU чи пам'яті, lag видно лише зсередини брокера, тож на нього обов'язково вішають окреме сповіщення - інакше відставання накопичується непомітно, поки споживачі формально "живі". У RabbitMQ аналог - довжина черги (queue depth): росте так само, коли продюсери випереджають консьюмерів цієї черги.

5. Масштабування і відмовостійкість

• Кластер складається з кількох брокерів.
• Кожна партиція може мати репліки на інших брокерах.
• Один брокер - leader партиції, решта - followers.
• Kafka використовує Zookeeper (або KRaft у нових версіях) для виборів лідерів, метаданих і кворуму.

62. Анотації типів (Type Hints). PEP 484⚑

🔥 30/100 · python/data_types.md

Підказки типів (Type Hints), Аннотації типів (Type Annotations) — це спосіб вказати очікувані типи аргументів функцій, значень змінних і результатів, що повертаються. Це допомагає зробити код більш зрозумілим, полегшує підтримку і знижує ризик помилок.

PEP 484 (Python Enhancement Proposal 484) - вводить підтримку підказок типів у Python. Він стандартизує синтаксис та семантику аннотацій типів і надає рекомендації щодо їх використання в Python-проектах.

• Анотації додаються до сигнатури функцій або змінних, але вони не впливають на виконання коду. Python ігнорує їх під час виконання, залишаючи це на розсуд розробника чи сторонніх інструментів, таких як статичні аналізатори (наприклад, mypy).
• mypy - інструмент для перевірки типів (Type Checking). mypy аналізує код і перевіряє, чи відповідають вказані типи фактичним типам даних, що передаються та повертаються функціями.
• Основне призначення анотацій типів — документування і поліпшення якості коду. Вони дозволяють чітко вказати, з якими типами даних працює функція, що значно спрощує розуміння логіки програми.
• Анотації виконуються під час компіляції (у момент інтерпретації файлу Python), але лише у вигляді метаданих. Їх можна отримати через атрибут __annotations__.
• Хоча анотації не виконуються під час виконання коду, їх можна використовувати в спеціалізованих сценаріях, наприклад, для генерації API або перевірки типів у реальному часі.

def add_numbers(x: int, y: int) -> int:    
    return x + y  # Function takes two integers and returns an integer

Анотації також можна використовувати зі змінними

age: int = 30  # Variable is expected to be of type int
name: str = "Alice"

Для складних структур, таких як списки чи словники, в старіших версіях Python використовують модуль typing

from typing import List, Dict

numbers: List[int] = [1, 2, 3]  # List of integers
user_data: Dict[str, int] = {"age": 30, "score": 100}  # Dictionary with string keys and integer values

63. Опишіть функції map, filter (вбудовані) та functools.reduce⚑

🔥 30/100 · python/functional_programming.md

Функція map застосовує функцію до кожного елемента послідовності.

Функція filter залишає тільки ті елементи послідовності, для яких задана функція є істинною.

Для Python більш канонічним є використання спискових виразів замість map-filter.

Функція reduce приймає функцію з двома аргументами, послідовність і опціональне початкове значення і обчислює скорочення (складання) послідовності як результат послідовного застосування даної функції до поточного значення (так званого аккумулятора) і наступного елемента послідовності.

64. Як Python працює з пам'яттю?⚑

🔥 30/100 · python/interpreter.md

В Python диспетчер пам'яті відповідає за розподіл і звільнення пам'яті. Він виділяє пам'ять у вигляді простору в купі, в якому зберігаються всі об'єкти Python та структури даних. Пам’ять у Python можна розділити на 4 категорії, кожна з яких відповідає за зберігання різних типів даних і структур. Цей простір недоступний для програміста безпосередньо, проте базовий API дозволяє розробнику отримати доступ до деяких інструментів для написання коду.

• Об'єктно-специфічна пам’ять — це частина пам’яті, яка виділяється для об’єктів, що використовують спеціалізовані механізми управління пам’яттю, відмінні від стандартних. Це дозволяє оптимізувати зберігання та доступ до даних для певних типів об’єктів.
• Необ'єктна пам’ять ядра Python — це частина пам’яті, яка виділяється для зберігання даних та структур, що не є об’єктами Python. Вона використовується самим інтерпретатором для забезпечення своєї роботи та управління виконанням програм. Вона містить дані, необхідні для роботи самого інтерпретатора Python, такі як стеки викликів, таблиці символів, інформація про потоки виконання, конфігураційні параметри, налаштування середовища виконання.
• Пам'ять об’єктів — це частина пам’яті, яка виділяється для зберігання самих об’єктів Python. Кожен об’єкт у Python (числа, рядки, кастомні класи тощо) займає певний обсяг пам’яті, який необхідний для зберігання його даних та метаданих. Ця частина пам’яті містить у собі реальні дані, які зберігає об’єкт (наприклад, значення числа, текст рядка тощо).
• Внутрішні буфери — це області пам’яті, які виділяються інтерпретатором Python для тимчасового зберігання даних під час виконання різних операцій. Вони потрібні для оптимізації роботи та забезпечення ефективності різних процесів.
  • Буфери вводу/виводу зберігають дані, що читаються з файлів або мережі, а також дані, що готуються для запису. Це дозволяє оптимізувати операції вводу/виводу, зменшуючи кількість системних викликів.
  • Буфери інтерпретації коду зберігають проміжні результати під час компіляції та виконання байт-коду Python.
  • Кеші слугують для зберігання даних, що часто використовуються, або результатів обчислень, щоб уникнути повторних витратних операцій.

Коли програма запитує пам’ять, CPython-інтерпретатор використовує malloc метод для запиту цієї пам’яті в операційної системи, і розмір приватної купи збільшується. Щоб уникнути виклику malloc і free для кожного створення і видалення невеликого об’єкта, CPython визначає кілька алокаторів і деалокаторів для різних цілей. Алокатор пам’яті — це "менеджер", що відповідає за виділення і звільнення пам’яті для програм, які її потребують.

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

Стандартний алокатор складається з трьох компонентів: арени, пули та блоки.

• Арена — це велика область пам’яті (1 МБ на 64-бітних системах; на 32-бітних — 256 кБ), яка виділяється операційною системою. Python керує кількома аренами, кожна з яких може містити кілька пулів.
• Пул — це фрагмент пам’яті фіксованого розміру (зазвичай 4 кБ), що виділяється з арени. Кожен пул спеціалізується на виділенні пам’яті під об’єкти певного розміру. Наприклад, один пул може використовуватися для об’єктів розміром 16 байтів, інший — для об’єктів розміром 32 байти тощо. Це дозволяє ефективно використовувати пам’ять і зменшити фрагментацію.
• Блок — це найменша одиниця пам’яті, яка виділяється для об’єктів. Кожен пул ділиться на блоки однакового розміру. Коли створюється об’єкт, пам’ять під нього виділяється у вигляді одного або кількох блоків з відповідного пулу.

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

Стандартний інтерпретатор Python (CPython) використовує два алгоритми збирання сміття: підрахунок посилань (reference counting) та збирач сміття (generational garbage collector або GC).

Також важливо відзначити, що в Python є різні види об'єктів, такі як незмінні (immutable) і змінні (mutable), і вони мають різні правила використання пам'яті та керування нею.

Links

• Мистецтво управління пам’яттю в Python: розуміння, використання та оптимізація
• Как работает память в Python
• Память и Python

65. Основні принципи DDD⚑

💡 29/100 · architecture/ddd.md

Domain-Driven Design (DDD) — це підхід до проєктування складних програмних систем, спрямований на чітке вираження бізнес-логіки та її ізоляцію від технічних деталей. Головна ідея DDD полягає в тому, щоб модель програми максимально відповідала реальним бізнес-процесам і була зрозумілою як для розробників, так і для експертів предметної області.

DDD складається з двох основних рівнів:

Стратегічний рівень

• Bounded Contexts — визначає межі системи та контексти, в яких певні терміни мають специфічне значення
• Ubiquitous Language — формує єдину мову для ефективної взаємодії з бізнес-експертами та між командами
• Context Mapping — керує відносинами між різними контекстами та їх інтеграцією

Тактичний рівень - описує конкретні шаблони реалізації всередині bounded context

• Entities — сутності з унікальною ідентичністю
• Aggregates — кластери пов'язаних об'єктів
• Value Objects — об'єкти без ідентичності
• Domain Services — сервіси для бізнес-логіки, що не належить конкретній сутності

Уся бізнес-логіка зосереджена в доменному шарі, а саме в сутностях, агрегатах та Value Objects. Тут визначаються:

• Бізнес-інваріанти (правила, що завжди мають виконуватися)
• Допустимі переходи станів
• Валідні операції

Зміна стану та перевірка інваріантів відбуваються виключно через методи сутності, які явно виражають бізнес-зміст: complete(), cancel(), change_owner() тощо.

Доменні моделі не залежать від інфраструктури (ані від баз даних, ані від транспорту, ані від зовнішніх DTO), і це дозволяє повторно використовувати бізнес-логіку незалежно від того, які технології використовуються в інфраструктурному шарі. Репозиторії, адаптери, транспорт, логування, моніторинг та інша інфраструктура виносяться за межі домену й використовуються тільки в application-шарі.

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

Переваги використання DDD:

• Чітке вираження бізнес-логіки — код відображає реальні бізнес-процеси
• Покращена комунікація — спільна мова з бізнес-експертами
• Модульність — чіткі межі між компонентами
• Тестованість — легко тестувати бізнес-логіку ізольовано
• Еволюційність — система легко адаптується до змін у бізнесі
• Повторне використання — доменна логіка не залежить від технологій

66. Що таке mocking⚑

💡 29/100 · computer_science/testing.md

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

Стандартна бібліотека надає об'єкти Mock і MagicMock у модулі unittest.mock. Перший є тестовим двійником, який можна налаштувати на повернення будь-якого значення та відстежуватиме виклики, зроблені до нього. Другий робить те саме, але також підтримує магічні методи. Це означає, що якщо потрібно протестувати код, який використовує магічні методи (і частини коду, які тестуються, будуть від них залежати), доведеться використовувати екземпляр MagicMock замість простого Mock.

Links

• Модуль Mock: макеты-пустышки в тестировании

67. Чим Реляційні БД відрізняються від NoSQL БД?⚑

💡 29/100 · infrastructure/database.md

Реляційні бази даних (РБД) та нереляційні бази даних (NoSQL) відрізняються за своєю структурою, способом зберігання та обробки даних.

• Схема даних
• РБД: Використовують жорстку, попередньо визначену схему даних з таблицями, колонками і типами даних, з визначеними відношеннями між ними.

• NoSQL БД: Забезпечують гнучку схему даних, що дозволяє зберігати дані різного типу без жорсткої фіксованої структури.

• Масштабованість

• РБД: Масштабування може бути складнішим, особливо при горизонтальному масштабуванні.

• NoSQL БД: Зазвичай пропонують легше горизонтальне масштабування завдяки спеціалізованій архітектурі.

• Запити

• РБД: Використовують мову запитів SQL для взаємодії з даними.

• NoSQL БД: Використовують різні мови запитів або інтерфейси для операцій з даними.

• Транзакції та консистентність

• РБД: Забезпечують гарантії ACID для збереження цілісності даних.
• NoSQL БД: Можуть пропонувати менш жорсткі гарантії цілісності, забезпечуючи вищу швидкість та масштабованість.