👩‍💻 Викторина: что выведет код?

import time

history = []

def delay_printer(sec):
def decorator(func):
def wrapper(n):
time.sleep(sec)
result = func(n)
history.append(result)
return f"[D{sec}] {result}"
return wrapper
return decorator

def counter(func):
def wrapper(n):
wrapper.count += 1
result = func(n)
return f"[#{wrapper.count}] {result}"
wrapper.count = 0
return wrapper

@delay_printer(1)
@counter
def double(x):
return x * 2

@delay_printer(2)
@counter
def triple(x):
return x * 3

print(double(5))
print(triple(5))
print(double(5))
print(f"history: {history}")

🐍 Ghostly Python | #викторина

👩‍💻 Самый быстрый способ читать Excel в Python

В статье результаты тестирования pandas, openpyxl, Tablib, DuckDB, LibreOffice и даже связки с Rust. Кто справился лучше всех и как за 4 секунды Python «проглотил» полмиллиона строк.

➡️ Ссылка на статью

🐍 Ghostly Python | #статьи

📱 Фишка: functools.cached_property — ленивое свойство с кэшированием

cached_property превращает метод в свойство, которое вычисляется один раз при первом доступе и кэшируется в экземпляре. Полезно для дорогих вычислений и ленивой инициализации

from functools import cached_property
import time

class Report:
def init(self, user_id):
self.user_id = user_id

@cached_property
def stats(self):
    print("Вычисляю...")  # выполнится только при первом доступе
    time.sleep(1)
    return {"orders": 42, "spent": 199.99}


r = Report(123)
print(r.stats) # первый доступ — расчёт и кэширование
print(r.stats) # последующие — мгновенно из кэша
del r.dict["stats"] # инвалидация кэша
print(r.stats) # пересчёт после инвалидации

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

🟢 @cached_property сохраняет результат в instance.__dict__ под именем свойства.
🟢 Для обновления данных удалите кэш: del obj.__dict__["attr"] — значение пересчитается при следующем доступе.
🟢 Идеально для «ленивых» параметров: конфигов, аггрегатов из БД/API, тяжёлых вычислений

🐍 Ghostly Python | #фишки

🐍 Ghostly Python | #мем

🖼️ Легковесная и мощная платформа для многоагентных рабочих процессов

OpenAI Agents SDK — это легковесная, но мощная платформа для создания рабочих процессов с участием нескольких агентов. Она не зависит от конкретного поставщика услуг и поддерживает API OpenAI Responses и Chat Completions, а также более 100 других LLM-модулей.

➡️ Ссылка на платформу

🐍 Ghostly Python | #ресурс

👩‍💻 Викторина: что выведет код?

def make_counter():
count = [0]

def increment():
count[0] += 1
return count[0]

def get():
return count[0]

return increment, get

inc1, get1 = make_counter()
inc2, get2 = make_counter()

inc1()
inc1()
inc2()
inc1()

print(get1(), get2())
print(inc2())
print(get1(), get2())

🐍 Ghostly Python | #викторина

📱 Фишка: __slots__ — отключаем_slots__ —для экономии памяти

По умолчанию каждый экземпляр Python хранит атрибуты в словаре dict. Это удобно, но съедает много памяти.__ —для экофиксирует набор атрибутов, убираяlots__ —дли� Фишка: __sl

class Report:
    — отключае= ('user_id', 'stats')  # только эти атрибуты
    
    def __init__(self, user_id):
        self.user_id = user_id
        self.stats = {}  # теперь stats не динамический

r = Report(123)
r.new_attr = 42  # ❌ AttributeError!

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

— Вместо dict создаются дескрипторы для каждого атрибута из slots.
— Экземпляр хранит значения в компактном массиве, не в хэш-таблице.

🐍 Ghostly Python | #фишки

Не репутация, а мечта

🐍 Ghostly Python | #мем

🖼️ Библиотека: glom

glom — декларативная библиотека для извлечения и трансформации вложенных структур данных (dict/list/tuple). Позволяет описывать «что достать и как преобразовать» короткой спецификацией вместо ручных циклов и if.

ℹ️ Основные возможности:

🟢 Доступ к глубоко вложенным полям без try/except
🟢 Маппинг и агрегирование списков одной строкой
🟢 Значения по умолчанию и безопасные обходы отсутствующих ключей
🟢 Композиция спецификаций для сложных преобразований

⚙️ Пример использования:

from glom import glom, T

data = {
    "user": {"name": "Alice", "age": 30, "emails": ["a@x.io", "b@y.io"]},
    "orders": [{"id": 1, "total": 99.9}, {"id": 2, "total": 15.0}]
}

spec = {
    "username": T["user"]["name"],
    "primary_email": T["user"]["emails"][0],
    "order_ids": (T["orders"], [T["id"]]),
    "sum_total": (T["orders"], sum, [T["total"]]),  # суммируем totals
}

print(glom(data, spec))
# ➔ {'username': 'Alice', 'primary_email': 'a@x.io', 'order_ids': [1, 2], 'sum_total': 114.9}

# Безопасный доступ с дефолтом:
print(glom(data, "user.phone", default="no phone"))  # ➔ 'no phone'

✔️ Установка:

pip install glom

➡️ Ссылка на документацию

🐍 Ghostly Python | #библиотеки

👩‍💻 Создание MCP‑серверов на FastMCP: 7 ошибок, которых стоит избегать

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

➡️ Ссылка на статью

🐍 Ghostly Python | #статьи

📱 Фишка: asyncio.Semaphore — контроль одновременных корутин

Semaphore ограничивает количество корутин, которые могут выполнять определённый блок кода одновременно. Полезно для защиты API от превышения лимитов или для ограничения нагрузки на базу данных.

import asyncio

class ApiClient:
    def __init__(self, max_concurrent=3):
        self._semaphore = asyncio.Semaphore(max_concurrent)
    
    async def fetch(self, url):
        async with self._semaphore:
            print(f"Начало запроса к {url}")
            await asyncio.sleep(1)  # имитация сетевого вызова
            print(f"Завершён: {url}")
            return {"data": url}

async def main():
    client = ApiClient(max_concurrent=2)  # максимум 2 запроса одновременно
    
    urls = ["/api/1", "/api/2", "/api/3", "/api/4"]
    tasks = [client.fetch(url) for url in urls]
    results = await asyncio.gather(*tasks)
    
    print(f"Получено {len(results)} результатов")

asyncio.run(main())

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

— При входе в async with счётчик семафора уменьшается на 1.
— Если счётчик 0, корутина ждёт, пока кто-то не выйдет (счётчик не увеличится).
— При выходе из блока счётчик снова увеличивается.

🐍 Ghostly Python | #фишки

«Вайб-кодинг» — слово года по версии словаря Collins

(на сленге - безработный 🙂)

🐍 Ghostly Python | #мем

🖼️ Библиотека tenacity — умные повторные попытки для ненадёжного кода

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

⚙️ Пример использования:

from tenacity import retry, stop_after_attempt
import requests

# Повторить 3 раза при любой ошибке
@retry(stop=stop_after_attempt(3))
def get_data():
    return requests.get("https://api.example.com/data").json()

# Использование
data = get_data()  # если упадёт — автоматически повторит до 3 раз

✔️ Установка:

pip install tenacity

🐍 Ghostly Python | #библиотеки

👩‍💻 Автоматизация отдела продаж в Bitrix24

Автор статьи максимально рассказал об автоматизации продаж и квалифицировании лидов в битрикс.

➡️ Ссылка на статью

🐍 Ghostly Python | #статьи

📱 Фишка: asyncio.TaskGroup — надёжное управление группами задач

TaskGroup автоматически следит за всеми запущенными в нём задачами. Если любая задача падает с ошибкой — отменяются все остальные, и вы точно ничего не пропустите. Удобнее и безопаснее, чем ручной gather/wait.

import asyncio

async def worker(name, delay):
    print(f"Задача {name} стартует")
    await asyncio.sleep(delay)
    if name == "fail":
        raise ValueError("Ошибка в задаче!")
    print(f"Задача {name} завершена")
    return f"Результат {name}"

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            task1 = tg.create_task(worker("A", 1))
            task2 = tg.create_task(worker("B", 2))
            task3 = tg.create_task(worker("fail", 0.5))
            task4 = tg.create_task(worker("C", 1.5))
        # сюда мы попадём, только если все задачи успешны
        print("Все задачи завершены без ошибок")
    except Exception as e:
        print(f"Перехвачено исключение: {e}")
        # все незавершённые задачи уже отменены автоматически

asyncio.run(main())

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

— При входе в async with создаётся группа задач.
— Как только одна задача вызывает исключение — группа немедленно отменяет все остальные.
— После выхода из блока можно быть уверенным: либо все задачи выполнились успешно, либо ни одна «незакрытая» ошибка не осталась незамеченной.

🐍 Ghostly Python | #фишки

📱 Фишка: collections.deque — двусторонняя очередь с быстрой вставкой и удалением

deque (двусторонняя очередь) из модуля collections — это более эффективная альтернатива спискам, когда часто требуется вставка или удаление с начала и конца.

from collections import deque

# Создаём deque
queue = deque(["Алиса", "Боб", "Чарли"])

# Добавляем в конец и в начало
queue.append("Дэвид")
queue.appendleft("Эва")
print(queue)  # ➔ deque(['Эва', 'Алиса', 'Боб', 'Чарли', 'Дэвид'])

# Удаляем с конца и начала
queue.pop()        # ➔ 'Дэвид'
queue.popleft()    # ➔ 'Эва'
print(queue)       # ➔ deque(['Алиса', 'Боб', 'Чарли'])

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

🟢 deque оптимизирован для операций .append(), .appendleft(), .pop() и .popleft() — все выполняются за O(1), в отличие от обычного списка.
🟢 Можно ограничить длину (maxlen=N) — полезно для реализации кольцевых буферов.

🐍 Ghostly Python | #фишки