🤔 Что даёт Poetry?

Это инструмент для управления зависимостями и пакетов Python.
1. Упрощает установку, обновление и управление зависимостями через файл pyproject.toml.
2. Поддерживает изоляцию зависимостей, автоматически создавая виртуальное окружение.
3. Помогает публиковать собственные Python-пакеты в PyPI, упрощая процесс сборки и выпуска.

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

🤔 Что такое CRUD?

CRUD — это аббревиатура из четырех основных операций с данными:

C (Create) – создание
R (Read) – чтение
U (Update) – обновление
D (Delete) – удаление

🚩Разберем CRUD на примере работы с базой данных в Python

🟠Create (Создание)
Добавление новой записи в базу данных.

import sqlite3

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

# Создаем таблицу, если её нет
cursor.execute("CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)")

# Добавляем пользователя
cursor.execute("INSERT INTO users (name) VALUES (?)", ("Алиса",))

conn.commit()  # Сохраняем изменения
conn.close()

🟠Read (Чтение)
Получение данных из базы.

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("SELECT * FROM users")
users = cursor.fetchall()  # Получаем все записи

for user in users:
    print(user)

conn.close()

🟠Update (Обновление)
Изменение существующей записи.

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("UPDATE users SET name = ? WHERE id = ?", ("Боб", 1))

conn.commit()
conn.close()

🟠Delete (Удаление)
Удаление записи из базы.

conn = sqlite3.connect("example.db")
cursor = conn.cursor()

cursor.execute("DELETE FROM users WHERE id = ?", (1,))

conn.commit()
conn.close()

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

🤔 Какой алгоритм работы CSRF middleware?

Защищает Django-приложения от поддельных запросов. Алгоритм работы:
1. При загрузке формы сервер вставляет CSRF-токен в скрытое поле
2. При отправке запроса клиент должен отправить этот токен в заголовке
3. Django сверяет токен с тем, что хранится в сессии пользователя
4. Если токены не совпадают, запрос отклоняется

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

🤔 Что такое set?

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

🚩Основные характеристики `set`

🟠Неупорядоченность
Элементы множества не имеют фиксированного порядка, то есть вы не можете обращаться к элементам по индексу, как в списках или кортежах.

🟠Уникальность элементов
Во множестве не может быть дубликатов. Если вы добавите во множество несколько одинаковых элементов, они будут храниться как один экземпляр.

🟠Изменяемость
Множества в Python изменяемы: вы можете добавлять, удалять и изменять их элементы. Однако сами элементы множества должны быть неизменяемыми (например, числа, строки, кортежи).

🟠Быстродействие
Операции проверки принадлежности (in), добавления и удаления элементов работают очень быстро, благодаря использованию хэш-таблиц в реализации множества.

🚩Создание множества

🟠Пустое множество
Для создания пустого множества используется функция set(), так как {} создаёт пустой словарь

empty_set = set()
print(empty_set)  # Output: set()

🟠Создание множества с элементами
Вы можете передать список, строку, кортеж или другой итерируемый объект в функцию set().

# Создание множества из списка
numbers = set([1, 2, 3, 4, 5])
print(numbers)  # Output: {1, 2, 3, 4, 5}

# Создание множества из строки (уникальные символы)
chars = set("hello")
print(chars)  # Output: {'h', 'e', 'l', 'o'}  (порядок может быть разным)

🟠Использование литералов
Вы также можете использовать фигурные скобки {} для создания множества

fruits = {"apple", "banana", "cherry"}
print(fruits)  # Output: {'apple', 'banana', 'cherry'}

🚩Основные операции с множествами

🟠Добавление элементов
Используется метод add()

my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # Output: {1, 2, 3, 4}

🟠Удаление элементов
remove() — удаляет элемент, выбрасывая ошибку, если его нет.
discard() — удаляет элемент, не выбрасывая ошибку, если его нет.

my_set = {1, 2, 3}
my_set.remove(2)  # Удаляем элемент 2
print(my_set)  # Output: {1, 3}

my_set.discard(5)  # Ошибки не будет, если элемента 5 нет

pop() — удаляет и возвращает случайный элемент (так как множество неупорядочено)

my_set = {1, 2, 3}
removed_element = my_set.pop()
print(removed_element)  # Например: 1
print(my_set)  # Например: {2, 3}

🟠Очистка множества

my_set = {1, 2, 3}
my_set.clear()
print(my_set)  # Output: set()

🟠Проверка наличия элемента
Используется оператор in

my_set = {1, 2, 3}
print(2 in my_set)  # Output: True
print(5 in my_set)  # Output: False

🚩Операции над множествами

Python поддерживает классические операции теории множеств:

🟠Объединение (`union` или `|`)
Возвращает множество, содержащее все элементы из двух множеств.

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1 | set2)  # Output: {1, 2, 3, 4, 5}
print(set1.union(set2))  # То же самое

🟠Пересечение (`intersection` или `&`)
Возвращает элементы, которые присутствуют в обоих множествах.

print(set1 & set2)  # Output: {3}
print(set1.intersection(set2))  # То же самое

🟠Разность (`difference` или `-`)
Возвращает элементы, которые присутствуют только в одном множестве (а не в другом).

print(set1 - set2)  # Output: {1, 2} (только в set1)
print(set1.difference(set2))  # То же самое

🟠Симметрическая разность (`symmetric_difference` или `^`)
Возвращает элементы, которые есть в одном из множеств, но не в обоих сразу.

print(set1 ^ set2)  # Output: {1, 2, 4, 5}
print(set1.symmetric_difference(set2))  # То же самое

🚩Неизменяемое множество (`frozenset`)

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

frozen = frozenset([1, 2, 3])
print(frozen)  # Output: frozenset({1, 2, 3})

# frozen.add(4)  # Ошибка: 'frozenset' object has no attribute 'add'

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

🤔 Чем асинхронность отличается от многопоточности?

- Асинхронность не использует дополнительные потоки, работает в одном, переключаясь между задачами;
- Многопоточность использует несколько потоков ОС, где каждый может работать независимо; Асинхронность экономичнее по ресурсам, но подходит только для неблокирующих I/O-задач.

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

🤔 Что такое хешируемые типы данных?

Это такие типы данных, которые имеют постоянное (неизменяемое) хеш-значение на протяжении всего времени их существования. Это означает, что их можно использовать в качестве ключей в словарях (dict) и элементов в множествах (set), так как они поддерживают вычисление хеша с помощью функции hash().

🚩Как понять, что объект хешируемый?

🟠Объект должен быть неизменяемым
если объект можно изменить после создания, его хеш тоже изменится, что нарушает работу структур данных (словари, множества).
🟠Должен реализовывать метод `__hash__()`
который возвращает уникальный идентификатор объекта.

🚩Какие типы данных хешируемые?

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

  print(hash(42))       # 42
  print(hash(3.14))     # 322818021289917443
  print(hash(1 + 2j))   # 8389048192121911274

Строки (str)

print(hash("hello"))  # Например, 5320385861927423548

Кортежи (tuple), если все их элементы тоже хешируемые:

print(hash((1, 2, 3)))  # 529344067295497451

Булевы значения (bool):

  print(hash(True))   # 1
  print(hash(False))  # 0

🚩Какие типы НЕ хешируемые?

Списки (list)

hash([1, 2, 3])  # TypeError: unhashable type: 'list'

Множества (set)

hash({1, 2, 3})  # TypeError: unhashable type: 'set'

Словари (dict)

hash({"a": 1})  # TypeError: unhashable type: 'dict'

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

Хешируемые типы используются в словари (dict) и множества (set), так как они используют хеш-функцию для быстрого поиска данных.

my_dict = { (1, 2, 3): "tuple_key" }  # Работает, потому что кортеж неизменяемый
my_set = { 42, "hello", (1, 2) }      # Все элементы хешируемые

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

🤔 Что такое dict comprehensions?

Это способ быстро создать словарь из другого итерируемого объекта, задав, как именно формируются ключи и значения. Такой подход делает код компактным и читаемым, особенно когда нужно создать словарь на основе списка или другого словаря.

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

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

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

🟠Многопоточность (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 и т.д.). Эта область всегда доступна, но идёт последней в цепочке поиска.

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