Возникали ли проблемы с Python

# Проблемы с Python: мой опыт преодоления

За 10+ лет работы с Python столкнулся с множеством интересных проблем. Вот самые значительные и как я их решал.

1. Global Interpreter Lock (GIL) и многопоточность

Она из первых серьезных проблем, с которыми я столкнулся при работе с многопоточными приложениями. GIL предотвращает истинный параллелизм в потоках Python, что критично для CPU-bound задач.

import threading
import time

# ❌ Проблема: GIL не позволяет параллельное выполнение
def cpu_bound_task():
    total = sum(i * i for i in range(10**7))
    return total

start = time.time()
threads = [threading.Thread(target=cpu_bound_task) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(f"Threads: {time.time() - start:.2f}s")

# ✅ Решение: использовать multiprocessing
from multiprocessing import Process

start = time.time()
processes = [Process(target=cpu_bound_task) for _ in range(4)]
for p in processes:
    p.start()
for p in processes:
    p.join()
print(f"Processes: {time.time() - start:.2f}s")

Решение: для CPU-bound задач используюю multiprocessing, для IO-bound — async/await с asyncio.

2. Управление зависимостями и версионирование

Проблема с конфликтами версий при развёртывании на разных окружениях была постоянной головной болью.

# requirements.txt
requests==2.28.0  # точное совпадение версии
django>=3.2,<4.0  # диапазон версий

Решение: использую poetry или pip-tools с requirements.txt, всегда указываю точные версии в production и pyproject.toml для управления зависимостями с хешами.

3. Утечки памяти в long-running процессах

При разработке бот-приложений, которые работают 24/7, столкнулся с утечками памяти, вызванными циклическими ссылками и неправильным управлением ресурсами.

import gc
import sys
from weakref import WeakSet

# ❌ Проблема: циклические ссылки
class Node:
    def __init__(self):
        self.ref = None

a = Node()
b = Node()
a.ref = b
b.ref = a  # циклическая ссылка

# ✅ Решение 1: явно удалять ссылки
del a, b
gc.collect()

# ✅ Решение 2: использовать weakref
from weakref import ref as weakref
class Node:
    def __init__(self):
        self.ref = None

a = Node()
b = Node()
a.ref = weakref(b)  # слабая ссылка

Решение: регулярно профилирую память с memory_profiler, использую weakref для циклических зависимостей, явно закрываю ресурсы.

4. Производительность сериализации/десериализации

При работе с большими объёмами данных (миллионы записей JSON) упал performance из-за медленного парсинга.

import json
import orjson
import time

data = [{"id": i, "name": f"user_{i}"} for i in range(100000)]
json_str = json.dumps(data)

# ❌ Медленно
start = time.time()
for _ in range(10):
    json.loads(json_str)
print(f"json: {time.time() - start:.2f}s")

# ✅ Быстро (в 3-4 раза)
start = time.time()
for _ in range(10):
    orjson.loads(json_str)
print(f"orjson: {time.time() - start:.2f}s")

Решение: заменил json на orjson или ujson для критичных по производительности участков.

5. Asyncio: race conditions и deadlock'и

При переводе приложения на async столкнулся с тонкими race conditions, которые проявлялись только в production.

import asyncio

# ❌ Проблема: race condition
shared_data = {}

async def increment():
    value = shared_data.get('counter', 0)
    await asyncio.sleep(0.001)  # context switch может произойти здесь
    shared_data['counter'] = value + 1

async def main():
    await asyncio.gather(*[increment() for _ in range(100)])
    print(shared_data)  # ожидаем 100, получаем меньше

# ✅ Решение: использовать Lock
async def increment_safe():
    async with lock:
        value = shared_data.get('counter', 0)
        await asyncio.sleep(0.001)
        shared_data['counter'] = value + 1

lock = asyncio.Lock()

Решение: использую asyncio.Lock, asyncio.Semaphore и тщательное тестирование с pytest-asyncio.

6. Import cycles и circular dependencies

При росте проекта возникали циклические импорты между модулями, ломавшие initialization.

# ❌ Проблема
# models.py
from views import get_model

# views.py
from models import Model

# ✅ Решение: отложить импорт
# models.py
def get_view():
    from views import get_model  # импорт внутри функции
    return get_model()

Решение: использую отложенные импорты (lazy imports) и рефакторю архитектуру для соблюдения слоёв зависимостей.

Итоги

Ключ к успеху — понимать ограничения Python (GIL, динамическая типизация), выбирать правильные инструменты для задачи и постоянно профилировать код в production-like окружении. Опыт показал, что лучше потратить время на архитектуру и тестирование в начале, чем потом отлавливать проблемы в production.