Python | Вопросы собесов – Telegram
Python | Вопросы собесов
13.6K subscribers
37 photos
3 videos
1 file
1.17K links
Cайт: easyoffer.ru
Реклама: @easyoffer_adv
ВП: @easyoffer_vp

Тесты t.me/+20tRfhrwPpM4NDQy
Задачи t.me/+nsl4meWmhfQwNDVi
Вакансии t.me/+cXGKkrOY2-w3ZTky
Download Telegram
🤔 Что такое 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'


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍6
🤔 Чем асинхронность отличается от многопоточности?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥8👍1💊1
🤔 Что такое хешируемые типы данных?

Это такие типы данных, которые имеют постоянное (неизменяемое) хеш-значение на протяжении всего времени их существования. Это означает, что их можно использовать в качестве ключей в словарях (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) } # Все элементы хешируемые


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3
🤔 Что такое dict comprehensions?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5
🤔 Что такое многопоточность/многопроцессорность?

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

🟠Многопоточность (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 завершил работу
Все процессы завершены


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍7
🤔 Как можно проитерироваться по листу и вывести некий id последовательности?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4🔥1💊1
🤔 Какие ограничения есть у рекурсии в 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)


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍6
🤔 Где можно хранить бизнес-логику приложения?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍4🔥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]


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2💊2
🤔 Что такое алгоритм Ричарда Фейнмана?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
💊8🔥5
🤔 Что делает 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 с приветственным текстом"


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍7
🤔 Как устроен список?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥2👍1
🤔 Какие нюансы есть в использовании чисел как ключей?

Использование чисел в качестве ключей в словарях 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)]) # "один"


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5
🤔 В чем разница между from foo import bar и from foo import *?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5💊1
🤔 Какие объекты можно положить в множество?

В 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, а False0)
   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


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍1
🤔 Какие методы есть у итератора?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍3🔥1💊1
🤔 Какие есть методы чтобы реализовать протокол итерирования данных?

Для реализации протокола итерирования данных в 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)


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍2
🤔 Есть ли какая-то область видимости над глобальной?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍5🔥1
🤔 Для чего нужен счетчик ссылок 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() # Явный вызов сборщика мусора удалит его


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍6
🤔 Что такое EXPLAIN?

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


Ставь 👍 если знал ответ, 🔥 если нет
Забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍9
🤔 Какие есть особенности исключения в 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("Это моя ошибка!")


Ставь 👍 и забирай 📚 Базу знаний
Please open Telegram to view this post
VIEW IN TELEGRAM
👍8