🤔 Что такое многопоточность/многопроцессорность?

В программировании многопоточность и многопроцессорность помогают выполнять задачи параллельно, но работают по-разному.

🟠Многопоточность (Multithreading)
Многопоточность позволяет одной программе запускать несколько потоков (threads), которые работают одновременно.

import threading
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

# Создаём два потока
t1 = threading.Thread(target=task, args=("Поток 1",))
t2 = threading.Thread(target=task, args=("Поток 2",))

t1.start()
t2.start()

t1.join()
t2.join()
print("Все потоки завершены")

Вывод

Поток 1 начал работу
Поток 2 начал работу
Поток 1 завершил работу
Поток 2 завершил работу
Все потоки завершены

🟠2. Многопроцессорность (Multiprocessing)
Многопроцессорность запускает отдельные процессы, которые работают полностью независимо и могут использовать разные ядра процессора.

import multiprocessing
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=task, args=("Процесс 1",))
    p2 = multiprocessing.Process(target=task, args=("Процесс 2",))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print("Все процессы завершены")

Вывод (процессы действительно работают параллельно)

Процесс 1 начал работу
Процесс 2 начал работу
Процесс 1 завершил работу
Процесс 2 завершил работу
Все процессы завершены

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как можно проитерироваться по листу и вывести некий id последовательности?

Для перебора элементов списка с идентификаторами (номерами) можно использовать встроенную функцию enumerate()
Параметр start=1 задаёт, с какого номера начинать (по умолчанию с 0). Это удобно, если нужен "человеческий" ID

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие ограничения есть у рекурсии в Python?

Рекурсия — это мощный инструмент, но в Python она имеет ограничения, которые нужно учитывать при написании кода.

🟠Ограничение на глубину рекурсии (`sys.getrecursionlimit()`)
В Python по умолчанию рекурсия ограничена 1000 вызовами, чтобы избежать переполнения стека.

import sys
print(sys.getrecursionlimit())  # 1000 (обычное значение)

Если превысить этот лимит, программа вызовет ошибку

def recursive():
    return recursive()

recursive()  # RecursionError: maximum recursion depth exceeded

🚩Как изменить лимит?

Можно увеличить глубину рекурсии, но это небезопасно

sys.setrecursionlimit(2000)  # Увеличиваем до 2000

🟠Рекурсия требует много памяти
Каждый рекурсивный вызов создаёт новый фрейм в стеке вызовов.

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(10000))  # Ошибка из-за переполнения стека

🟠Отсутствие оптимизации хвостовой рекурсии
Другие языки (например, Lisp, JavaScript) автоматически оптимизируют хвостовую рекурсию (Tail Call Optimization, TCO).
Python не делает этого, поэтому даже "идеальная" рекурсия всё равно переполняет стек.

def tail_recursive(n, acc=1):
    if n == 1:
        return acc
    return tail_recursive(n - 1, n * acc)

print(tail_recursive(1000))  # Всё равно вызовет RecursionError

🟠Рекурсия медленнее цикла
Рекурсивный вызов требует больше накладных расходов (создание стек-фреймов), чем обычный for или while.

# Итеративный вариант (быстрее)
def factorial_iter(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Рекурсивный вариант (медленнее)
def factorial_rec(n):
    if n == 1:
        return 1
    return n * factorial_rec(n - 1)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Где можно хранить бизнес-логику приложения?

Бизнес-логику обычно хранят в сервисах или отдельных модулях, предназначенных для обработки данных и реализации правил приложения.
1. В многослойной архитектуре это уровень service или domain.
2. Хранение логики в контроллерах или представлениях считается плохой практикой.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое параллелизм?

Параллелизм — это способ выполнения программ, при котором несколько задач выполняются одновременно (реально параллельно). Он используется для ускорения работы программ, особенно на многоядерных процессорах.

🚩1. Как работает параллелизм?

Пример без параллелизма (последовательное выполнение)
Допустим, у нас есть две задачи:
1. Скачать файл (3 секунды).
2. Обработать данные (2 секунды).
Если выполнять их последовательно

[1] Скачать файл... (3 сек)
[2] Обработать файл... (2 сек)
[Готово за 5 секунд]

Пример с параллелизмом (оба процесса выполняются одновременно)
Если у нас 2 ядра процессора, можно выполнить задачи одновременно.

[1] Скачать файл... (3 сек) ──► Готово!
[2] Обработать файл... (2 сек) ──► Готово!
[Готово за 3 секунды]  ✅ Быстрее!

🚩Как реализовать параллелизм в Python?

🟠`multiprocessing` – настоящий параллелизм
В Python multiprocessing создаёт отдельные процессы, которые работают на разных ядрах.

import multiprocessing
import time

def task(name):
    print(f"Начал {name}")
    time.sleep(2)
    print(f"Закончил {name}")

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=task, args=("Процесс 1",))
    p2 = multiprocessing.Process(target=task, args=("Процесс 2",))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print("Все процессы завершены")

🟠`threading` – многопоточность (НЕ параллельность в Python!)
Python не может выполнять потоки параллельно из-за GIL, но threading всё же полезен для задач ввода-вывода.

import threading
import time

def task(name):
    print(f"Начал {name}")
    time.sleep(2)
    print(f"Закончил {name}")

t1 = threading.Thread(target=task, args=("Поток 1",))
t2 = threading.Thread(target=task, args=("Поток 2",))

t1.start()
t2.start()

t1.join()
t2.join()
print("Все потоки завершены")

🟠`asyncio` – асинхронность (НЕ параллелизм, но эффективное переключение задач)
Асинхронность позволяет не ждать выполнения операции, а переключаться на другие задачи.

import asyncio

async def task(name):
    print(f"Начал {name}")
    await asyncio.sleep(2)  # НЕ блокирует другие задачи
    print(f"Закончил {name}")

async def main():
    await asyncio.gather(task("Задача 1"), task("Задача 2"))

asyncio.run(main())

🚩Виды параллелизма

🟠Параллелизм на уровне инструкций (ILP, CPU-level)
Процессор выполняет несколько инструкций одновременно. Например, в современных процессорах есть конвейер (pipeline), который выполняет несколько операций параллельно.

🟠Параллелизм на уровне данных (Data Parallelism)
Одна операция применяется к разным данным одновременно (используется в нейросетях, GPU).

import numpy as np

arr = np.array([1, 2, 3, 4])
result = arr * 2  # Все элементы умножаются одновременно (векторизация)
print(result)  # [2 4 6 8]

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое алгоритм Ричарда Фейнмана?

Алгоритм Фейнмана — это метод обучения, который заключается в следующем:
1. Изучи концепт так, чтобы мог объяснить его простыми словами.
2. Найди, что непонятно, и углубись в эти части.
3. Перепиши и уточни объяснение, используя аналогии. Это способ глубокого понимания за счёт упрощения и переобъяснения.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что делает git commit?

Команда git commit используется для фиксации изменений в локальном репозитории Git. Она сохраняет текущие изменения в коде (добавленные, изменённые или удалённые файлы), которые были подготовлены с помощью команды git add. По сути, git commit создаёт "снимок" текущего состояния проекта, который можно использовать для отслеживания истории изменений, их анализа или отката к более ранним версиям.

🚩Как это работает?

Когда вы работаете с Git, ваши изменения сначала попадают в рабочую директорию. После этого, чтобы зафиксировать их, вы добавляете их в индекс (staging area) с помощью команды git add. Только те изменения, которые находятся в индексе, будут включены в следующий коммит. Команда git commit фиксирует все изменения из staging area и сохраняет их как новую версию в истории проекта.

🚩Почему это нужно?

🟠История изменений
Каждый коммит сохраняет подробную информацию о том, что было изменено, когда и почему. Это позволяет отслеживать развитие проекта.
🟠Версионность
Можно вернуться к любой точке в истории и восстановить состояние проекта.
🟠Совместная работа
В командной разработке коммиты позволяют другим разработчикам видеть изменения и их причины.
🟠Разделение задач
Коммиты разбивают изменения на логические единицы, что упрощает их понимание.

# Шаг 1. Внести изменения в файл
echo "Hello, Git!" > example.txt

# Шаг 2. Добавить изменения в staging area
git add example.txt

# Шаг 3. Зафиксировать изменения
git commit -m "Добавил файл example.txt с приветственным текстом"

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как устроен список?

Список (list)— это изменяемая упорядоченная коллекция объектов любого типа.
Особенности устройства:
- Реализован как динамический массив, который автоматически расширяется при добавлении элементов.
- Элементы хранятся по ссылкам, что позволяет хранить смешанные типы.
- Обеспечивает быстрый доступ по индексу (O(1)), но вставка и удаление из середины — медленные (O(n)).

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие нюансы есть в использовании чисел как ключей?

Использование чисел в качестве ключей в словарях Python – это достаточно распространённый случай. Однако у этого подхода есть несколько нюансов, которые нужно учитывать для избежания ошибок.

🚩Хешируемость чисел

Ключи в словаре должны быть хешируемыми, поскольку словари в Python основаны на хеш-таблицах. Хешируемость означает, что объект имеет неизменное значение хеша в течение его жизни. Числа (как int, так и float) являются хешируемыми, поэтому их можно использовать в качестве ключей.

d = {1: "один", 2: "два"}
print(d[1])  # "один"

🚩Взаимодействие `int` и `float`

Python не делает различий между int и float, если их значения равны. Это связано с тем, что у них одинаковое хеш-значение при равенстве.

d = {1: "один", 1.0: "float один", 2: "два"}
print(d)  # {1: 'float один', 2: 'два'}

🚩Непредсказуемое поведение при работе с `float`

Числа с плавающей запятой (float) иногда ведут себя непредсказуемо из-за ошибок округления, которые возникают из-за особенностей представления чисел в памяти компьютера.

d = {0.1 + 0.2: "значение"}  # 0.1 + 0.2 не равно точно 0.3 из-за округления
print(d.get(0.3))  # None, ключ не найден!

🚩Производительность

Использование чисел как ключей в словарях эффективно с точки зрения производительности. Поскольку числа хешируются быстро и занимают меньше памяти, операции добавления, удаления и поиска выполняются очень быстро.

🚩Проблемы при преобразованиях

Если ключами словаря являются числа, то при обработке данных (например, чтении из файла или API) можно случайно преобразовать их в строки, что приведёт к созданию новых ключей вместо использования существующих.

d = {1: "один", 2: "два"}
print(d.get("1"))  # None, строка "1" и число 1 – это разные ключи!

🚩Пользовательские объекты с числовыми свойствами

Если вы используете пользовательские объекты как ключи и они ведут себя как числа (например, реализуют методы __hash__ и __eq__), то их поведение должно быть совместимо с ожидаемым использованием.

class MyNumber:
    def __init__(self, value):
        self.value = value
    
    def __hash__(self):
        return hash(self.value)
    
    def __eq__(self, other):
        return self.value == other.value

d = {MyNumber(1): "один"}
print(d[MyNumber(1)])  # "один"

Ставь 👍 и забирай 📚 Базу знаний

🤔 В чем разница между from foo import bar и from foo import *?

from foo import bar импортирует только конкретный элемент, тогда как from foo import * импортирует всё содержимое модуля. Последний вариант не рекомендуется, так как он загрязняет пространство имён и делает код менее понятным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие объекты можно положить в множество?

В Python множество (set) — это неупорядоченная коллекция уникальных элементов, которая работает на основе хеш-таблицы. Это значит, что только хешируемые (immutable) объекты могут быть добавлены в set.

🚩Можно добавить в `set`:

Числа (int, float, complex)

   s = {1, 2.5, 3+4j}

Строки (str)

   s = {"apple", "banana", "cherry"}

Кортежи (tuple), если они тоже содержат только неизменяемые объекты

   s = {(1, 2), ("a", "b")}

Булевые значения (bool)** (но True считается 1, а False — 0)

   s = {True, False, 1, 0}
   print(s)  # {False, True} (0 и 1 не добавятся повторно)

🚩Нельзя добавить в `set`

Изменяемые объекты (list, set, dict)

   s = { [1, 2, 3] }  #  Ошибка: TypeError: unhashable type: 'list'

   s = { {"key": "value"} }  #  Ошибка: TypeError: unhashable type: 'dict'

Кортежи с изменяемыми элементами

   s = { (1, [2, 3]) }  #  Ошибка: TypeError

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие методы есть у итератора?

Итератор обязан реализовать два метода:
- iter — возвращает сам итератор;
- next — возвращает следующий элемент или выбрасывает исключение StopIteration при завершении.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть методы чтобы реализовать протокол итерирования данных?

Для реализации протокола итерирования данных в Python необходимо использовать два метода: __iter__() и __next__().

🚩Протокол итератора

🟠Метод `__iter__()`
Этот метод должен возвращать объект-итератор. В простом случае он возвращает сам объект, если объект реализует метод __next__(). Метод __iter__() необходим для того, чтобы объект можно было использовать в конструкциях, которые требуют итерируемого объекта, таких как циклы for.
🟠Метод __next__()
Этот метод возвращает следующий элемент в последовательности. Когда элементы заканчиваются, метод должен вызвать исключение StopIteration для остановки итерации.

class MyRange:
    def __init__(self, start, end):
        self.start = start
        self.end = end
        self.current = start

    def __iter__(self):
        self.current = self.start  # Перезапуск итератора при каждом вызове
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

# Использование
for number in MyRange(1, 5):
    print(number)

🚩Дополнительно: итераторы и генераторы

Для упрощения создания итераторов в Python можно использовать генераторы. Генераторы позволяют писать итераторы с использованием ключевого слова yield вместо определения методов __iter__() и __next__() вручную.

def my_range(start, end):
    current = start
    while current < end:
        yield current
        current += 1

# Использование
for number in my_range(1, 5):
    print(number)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Есть ли какая-то область видимости над глобальной?

Да, это встроенная (built-in) область видимости. Она содержит определения, доступные в любом месте Python: встроенные функции (len, type, range, print) и константы (True, None, Ellipsis и т.д.). Эта область всегда доступна, но идёт последней в цепочке поиска.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Для чего нужен счетчик ссылок Python?

В Python счетчик ссылок (reference count) используется для управления памятью. Он показывает, сколько раз объект используется в программе. Когда счетчик ссылок падает до нуля, Python автоматически удаляет объект, освобождая память.

🚩Как работает счетчик ссылок?

Python использует автоматическое управление памятью, основанное на подсчёте ссылок. Когда создаётся объект, Python хранит специальное число — количество ссылок на этот объект. Это число увеличивается, когда мы создаём новую ссылку на объект, и уменьшается, когда удаляем или перезаписываем переменную.

import sys

a = [1, 2, 3]  # Создаём список
print(sys.getrefcount(a))  # Выведет 2 (одна ссылка 'a' + вызов getrefcount)

b = a  # Новая ссылка на тот же объект
print(sys.getrefcount(a))  # Теперь 3 (a, b и сам getrefcount)

del a  # Удаляем одну ссылку
print(sys.getrefcount(b))  # Теперь 2

del b  # Удаляем последнюю ссылку, объект будет удалён из памяти

🚩Почему это важно?

🟠Эффективное управление памятью
Python сам удаляет ненужные объекты, не давая памяти переполняться.
🟠Понимание утечек памяти
Если объект имеет циклические ссылки (например, список ссылается сам на себя), Python не может освободить его сразу, поэтому дополнительно используется сборщик мусора (Garbage Collector, GC).

import gc

class Node:
    def __init__(self):
        self.ref = self  # Циклическая ссылка!

n = Node()
del n  # Обычный подсчёт ссылок не сработает, объект останется в памяти
gc.collect()  # Явный вызов сборщика мусора удалит его

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое EXPLAIN?

EXPLAIN — команда в SQL (особенно PostgreSQL), которая показывает план выполнения запроса:
- какие индексы используются;
- как идут соединения;
- примерная стоимость.
Это помогает оптимизировать производительность сложных запросов.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Какие есть особенности исключения в Python?

В Python исключения (exceptions) — это специальные объекты, которые возникают при ошибках и прерывают выполнение программы, если их не обработать.

Все исключения в Python — это объекты, унаследованные от BaseException.

try:
    1 / 0
except ZeroDivisionError as e:
    print(type(e))  # <class 'ZeroDivisionError'>
    print(e)  # division by zero

Все исключения унаследованы от BaseException:

BaseException
 ├── Exception
 │   ├── ArithmeticError
 │   │   ├── ZeroDivisionError
 │   │   ├── OverflowError
 │   ├── ValueError
 │   ├── IndexError
 │   ├── KeyError
 │   ├── TypeError
 ├── SystemExit
 ├── KeyboardInterrupt

Можно перехватывать несколько исключений

try:
    x = int("abc")  # Ошибка ValueError
except (ValueError, TypeError) as e:
    print(f"Ошибка: {e}")

Если не знаем, какая ошибка может произойти:

try:
    x = 1 / 0
except Exception as e:
    print(f"Ошибка: {e}")  # division by zero

finally выполняется всегда

try:
    1 / 0
except ZeroDivisionError:
    print("Ошибка!")
finally:
    print("Этот код выполнится всегда")

raise позволяет выбрасывать исключения вручную

raise ValueError("Ошибка: неверное значение!")

Можно создать свой класс ошибки, унаследованный от Exception:

class MyError(Exception):
    pass

raise MyError("Это моя ошибка!")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие преимущества использования функций?

Функции упрощают поддержку кода, делают его переиспользуемым и модульным. Они способствуют разбиению программы на логические части, что облегчает отладку и тестирование. Также они позволяют сократить объём кода и сделать его более понятным.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Что такое паттерн Мост (Bridge)?

Паттерн "Мост" (Bridge) является структурным паттерном проектирования, который предназначен для разделения абстракции и реализации так, чтобы они могли изменяться независимо друг от друга. Этот паттерн полезен, когда класс должен работать с различными платформами или когда нужно избежать жесткой связки между абстракцией и ее реализацией.

🚩 Зачем нужен

🟠Разделение абстракции и реализации:
Он позволяет отделить абстракцию от ее реализации, что упрощает поддержку и расширение системы.
🟠Уменьшение количества подклассов:
Без применения этого паттерна, если у нас есть несколько вариантов абстракции и несколько вариантов реализации, то нам пришлось бы создавать классы для всех возможных комбинаций, что приводит к взрывному росту количества классов.
🟠Гибкость:
Это позволяет изменять и абстракцию, и реализацию независимо друг от друга.

🚩Как используется

🟠Абстракция (Abstraction):
Определяет интерфейс и хранит ссылку на объект Implementor.
🟠Расширенная абстракция (RefinedAbstraction):
Наследует Abstraction и расширяет интерфейс.
🟠Реализатор (Implementor):
Определяет интерфейс для всех реализаций.
🟠Конкретный реализатор (ConcreteImplementor):
Реализует интерфейс Implementor.

Допустим, у нас есть программа для управления различными типами устройств (например, телевизор и радио), которые можно включать и выключать. Мы хотим, чтобы способ управления устройствами мог изменяться независимо от типов устройств.

# Implementor
class Device:
    def is_enabled(self):
        pass

    def enable(self):
        pass

    def disable(self):
        pass

# ConcreteImplementor
class TV(Device):
    def __init__(self):
        self._on = False

    def is_enabled(self):
        return self._on

    def enable(self):
        self._on = True

    def disable(self):
        self._on = False

class Radio(Device):
    def __init__(self):
        self._on = False

    def is_enabled(self):
        return self._on

    def enable(self):
        self._on = True

    def disable(self):
        self._on = False

# Abstraction
class RemoteControl:
    def __init__(self, device):
        self._device = device

    def toggle_power(self):
        if self._device.is_enabled():
            self._device.disable()
        else:
            self._device.enable()

# RefinedAbstraction
class AdvancedRemoteControl(RemoteControl):
    def mute(self):
        print("Device is muted.")

# Клиентский код
tv = TV()
remote = RemoteControl(tv)
remote.toggle_power()  # Включает TV

radio = Radio()
advanced_remote = AdvancedRemoteControl(radio)
advanced_remote.toggle_power()  # Включает Radio
advanced_remote.mute()  # Заглушает Radio

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как работают операторы global и nonlocal?

Global позволяет объявить, что переменная в функции ссылается на глобальную переменную, а не создаёт локальную. Nonlocal указывает, что переменная находится в охватывающем, но не глобальном контексте — это полезно во вложенных функциях и замыканиях.

Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний

🤔 Как разбить список?

Разбить список (list) можно разными способами в зависимости от задачи:
На части фиксированной длины
На N частей
По условию

🚩Разбить список на части фиксированного размера

Если нужно разделить список на подсписки длиной n, можно использовать list comprehension

def split_list(lst, size):
    return [lst[i:i + size] for i in range(0, len(lst), size)]

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_list(data, 3))  

Вывод

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

🚩Разбить список на N частей (равных или почти равных)

Если нужно разделить список на N частей, можно использовать numpy или itertools

import numpy as np

def split_into_n_parts(lst, n):
    return np.array_split(lst, n)

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_into_n_parts(data, 4))  

Вывод

[array([1, 2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

🚩Разбить список по условию

Если нужно разделить список по какому-то критерию, например, на чётные и нечётные числа

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]

even = [x for x in data if x % 2 == 0]
odd = [x for x in data if x % 2 != 0]

print(even, odd)

Вывод

[2, 4, 6, 8] [1, 3, 5, 7, 9]

Ставь 👍 и забирай 📚 Базу знаний