Эффективное использование памяти: подсчет ссылок и сборка мусора

Привет! С вами Иван. Сегодня разберём одну из самых закулисных и магических тем Python — управление памятью: подсчёт ссылок и сборку мусора. Если вы когда-нибудь задумывались, почему Python не просит у вас явно освобождать память, то этот пост для вас!

## Подсчёт ссылок: сколько “рук” держат объект?

Python использует reference counting — счётчик ссылок на каждый объект. Когда переменная указывает на объект, счётчик увеличивается. Как только ни одна переменная на него больше не ссылается, объект считается “ненужным” и подлежит удалению.

Пример:

import sys

a = []
print(sys.getrefcount(a))  # Обычно вернёт 2 (a и аргумент функции)
b = a
print(sys.getrefcount(a))  # Уже 3 ссылки (a, b, и аргумент)
del b
print(sys.getrefcount(a))  # Снова 2

Магия проста: пока есть хотя бы одна “рука”, держащая объект, он живёт. Как только все переменные и ссылки исчезают — память освобождается.

## Сборка мусора: борьба с “каруселями”

Но что, если объекты ссылаются друг на друга? Простое удаление переменных не сработает — каждый будет держать “за руку” другого, и счётчики не опустятся до нуля! Тут появляется garbage collector.

В Python модуль gc следит за такими “каруселями”:

import gc

class Node:
    def __init__(self):
        self.ref = None

x = Node()
y = Node()
x.ref = y
y.ref = x

del x, y  # Ссылок на объекты нет, но карусель всё ещё существует
gc.collect()  # Явно собираем мусор, объекты будут удалены

Garbage collector периодически сканирует объекты, чтобы найти непростые циклы, и удаляет их, когда доступ к ним невозможен.

## Практические советы

- Не бойтесь “загрязнить” память — Python делает всё сам.
- Если работаете с большим количеством данных и видите рост памяти — попробуйте вызвать gc.collect().
- Используйте weakref, если нужен временный “тонкий” доступ без увеличения счётчика ссылок.

Пусть ваша память всегда будет свободна для новых идей!

Как переназначить поток вывода и ввода в Python

Привет! На связи Иван, и сегодня в нашем блоге разберём магию перенаправления потоков ввода и вывода в Python. Зачем это нужно? Например, если вы хотите записывать вывод вашей программы не только на экран, но и в файл, или "обмануть" функцию, которая традиционно ждёт пользовательский ввод, подсовывая ей данные автоматически. Готовы? Погнали!

## Перенаправляем stdout: вывод в файл и обратно

Для работы с потоками в Python служит модуль sys. Самый популярный поток — это sys.stdout, который по умолчанию пишет в консоль. Давайте заставим его писать в файл:

import sys

with open('output.txt', 'w') as file:
    original_stdout = sys.stdout  # сохраняем ссылку на стандартный поток
    sys.stdout = file             # перенаправляем stdout в файл
    print("Hello, file!")
    sys.stdout = original_stdout  # возвращаем stdout обратно

print("Hello, console!")

Теперь строка "Hello, file!" попадёт в файл, а "Hello, console!" — как обычно, в терминал.

## Подменяем stdin: автоматизируем ввод

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

import sys
from io import StringIO

test_input = StringIO('42\n')
original_stdin = sys.stdin
sys.stdin = test_input

number = int(input("Enter a number: "))
print("Number x2:", number * 2)

sys.stdin = original_stdin

В этом примере input не ждёт ввода, а сразу получает '42'. Удобно для юнит-тестов!

## А если хочется перехватить вывод программы?

Трюк с подменой stdout особенно крут, когда хочется легко перехватывать и анализировать результат работы каких-то функций. Например, сделаем функцию, возвращающую всё, что она напечатала:

def capture_output(func):
    import sys
    from io import StringIO

    output = StringIO()
    original_stdout = sys.stdout
    sys.stdout = output
    try:
        func()
    finally:
        sys.stdout = original_stdout
    return output.getvalue()

def hello():
    print("Hello from function!")

text = capture_output(hello)
print("Captured:", text)

Теперь мы можем обработать результат как строку — не круто ли?

На этом всё! Не стесняйтесь экспериментировать с потоками: это ключ к автоматизации, тестированию и оптимизации ваших программ. Желаю отличной практики и новых открытий с Python!
Иван.

Работа с метаклассами: расширенное использование классов

Привет! С вами Иван, сегодня копнем чуточку глубже — поговорим о метаклассах в Python.

Многие слышали про метаклассы как о чем-то мистическом, но на деле — это просто классы, которые создают другие классы. Да-да, в Python даже классы — это объекты, и за тем, как они создаются, следит метакласс. В обычной жизни мы редко сталкиваемся с ними, но если нужно гибко и аккуратно управлять поведением всех классов в проекте — метаклассы становятся отличным инструментом.

## Для чего нужны метаклассы?

С их помощью можно:
- Автоматически модифицировать классы при создании (например, добавлять методы или атрибуты);
- Навязывать единый стиль (например, проверять именование или структуру классов);
- Реализовывать паттерны, вроде Singleton, прямо “на уровне класса”.

## Базовый пример

Создадим метакласс, который автоматически добавляет атрибут category = 'custom_class' во все классы:

class BaseMeta(type):
    def __new__(mcs, name, bases, attrs):
        attrs['category'] = 'custom_class'
        return super().__new__(mcs, name, bases, attrs)

class ExampleClass(metaclass=BaseMeta):
    pass

print(ExampleClass.category)  # custom_class

## Валидация структуры класса

Иногда хочется убедиться, что каждый класс имеет нужные методы:

class MethodCheckerMeta(type):
    def __new__(mcs, name, bases, attrs):
        if 'process' not in attrs:
            raise TypeError('Class must define "process" method')
        return super().__new__(mcs, name, bases, attrs)

class DataWorker(metaclass=MethodCheckerMeta):
    def process(self):
        print("Processing...")

# class BadWorker(metaclass=MethodCheckerMeta):
#     pass  # Ошибка при определении класса!

## Подмена методов на лету

Допустим, хотим, чтобы все методы начинали логировать своё вызовы:

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f'Call {func.__name__}')
        return func(*args, **kwargs)
    return wrapper

class LoggerMeta(type):
    def __new__(mcs, name, bases, attrs):
        for key, val in attrs.items():
            if callable(val):
                attrs[key] = log_decorator(val)
        return super().__new__(mcs, name, bases, attrs)

class UserAction(metaclass=LoggerMeta):
    def update_profile(self):
        print("Profile updated")

u = UserAction()
u.update_profile()

Как видите, метаклассы — секретная дверца Python к по-настоящему мощным и гибким фичам. Пользуются ими редко, но знать о них точно стоит!