🔥 Typer: CLI-приложения уровня профи за 5 минут

import typer
from typing import Optional

app = typer.Typer()

@app.command()
def greet(
    name: str = typer.Argument("Мир", help="Кого приветствуем"),
    times: int = typer.Option(1, "--times", "-t", help="Сколько раз повторить"),
    uppercase: bool = typer.Option(False, "--upper", help="В верхнем регистре")
):
    """Приветствует пользователя с кастомными опциями."""
    message = f"Привет, {name}!"
    if uppercase:
        message = message.upper()
    
    for _ in range(times):
        typer.echo(message)

@app.command()
def calculate(
    a: int, 
    b: int, 
    operation: str = typer.Option("add", help="Операция: add, sub, mul")
):
    """Простой калькулятор через CLI."""
    if operation == "add":
        result = a + b
    elif operation == "sub":
        result = a - b
    elif operation == "mul":
        result = a * b
    else:
        typer.echo("❌ Неизвестная операция")
        raise typer.Exit(code=1)
    typer.echo(f"✅ Результат: {result}")

if __name__ == "__main__":
    try:
        app()
    except Exception as e:
        typer.echo(f"❌ Ошибка: {e}")

📌 Typer автоматически создаёт красивый CLI с подсказками, валидацией типов, автодополнением и помощью — всё из type hints. Никаких argparse и click вручную. Идеально для утилит, dev-tools, скриптов автоматизации и внутренних команд.

🛠 pip install typer

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Rich: Красивый терминал за 10 секунд

from rich.console import Console
from rich.table import Table
from rich.progress import track
import time
from typing import List

console = Console()

def process_items(items: List[str]):
    """Пример обработки списка с красивым прогресс-баром и таблицей."""
    table = Table(title="Результат обработки")
    table.add_column("Элемент", style="cyan")
    table.add_column("Статус", style="green")

    for item in track(items, description="Обрабатываем элементы..."):
        time.sleep(0.3)  # имитация работы
        status = "✅ Успешно"
        table.add_row(item, status)
    
    console.print(table)

if __name__ == "__main__":
    try:
        data = ["user1.json", "config.yaml", "data.csv", "report.pdf", "logs.txt"]
        console.print("[bold magenta]🚀 Запуск обработки файлов[/bold magenta]")
        process_items(data)
        console.print("[bold green]✅ Все задачи выполнены![/bold green]")
    except Exception as e:
        console.print(f"[bold red]Ошибка: {e}[/bold red]")

📌 Rich позволяет легко создавать цветной вывод, таблицы, прогресс-бары, статусы и даже markdown в терминале. Один из самых любимых инструментов Python-разработчиков для CLI-приложений, скриптов и дашбордов.

🛠 pip install rich

Подпишись 👉🏻 @KodduuPython 🤖

🔥 httpx: Современная замена requests — быстрее, удобнее и с лучшей обработкой ошибок

import httpx
from typing import Dict, Any

def get_user_info(user_id: int) -> Dict[str, Any]:
    """Пример безопасного запроса к публичному API с httpx."""
    url = f"https://jsonplaceholder.typicode.com/users/{user_id}"
    
    # httpx.Client автоматически управляет соединениями и таймаутами
    with httpx.Client(timeout=10.0) as client:
        try:
            response = client.get(url)
            response.raise_for_status()  # автоматически бросает исключение при 4xx/5xx
            return response.json()
        except httpx.HTTPStatusError as e:
            print(f"HTTP ошибка {e.response.status_code}: {e.response.text}")
            raise
        except httpx.RequestError as e:
            print(f"Ошибка запроса (таймаут/соединение): {e}")
            raise

if __name__ == "__main__":
    try:
        user = get_user_info(1)
        print(f"✅ Пользователь: {user['name']}")
        print(f"Email: {user['email']}")
        print(f"Город: {user['address']['city']}")
    except Exception as e:
        print(f"❌ Не удалось получить данные: {e}")

📌 httpx — это современный HTTP-клиент с автоматической поддержкой JSON, context manager, таймаутами и отличной обработкой ошибок. Работает и в синхронном, и в асинхронном режиме. Идеально для API, парсинга, микросервисов.

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Faker: Генерируем реалистичные тестовые данные за секунды

from faker import Faker
from typing import List, Dict
import json

fake = Faker("ru_RU")  # Русская локаль для правдоподобных данных

def generate_users(n: int = 5) -> List[Dict]:
    """Генерирует список пользователей с реалистичными данными."""
    return [{
        "id": fake.uuid4()[:8],
        "fio": fake.name(),
        "email": fake.email(),
        "phone": fake.phone_number(),
        "city": fake.city(),
        "profession": fake.job(),
        "registered": fake.date_this_year().isoformat()
    } for _ in range(n)]

if __name__ == "__main__":
    try:
        users = generate_users(6)
        print(f"✅ Сгенерировано {len(users)} пользователей\n")
        for u in users:
            print(f"👤 {u['fio']} | {u['email']} | {u['city']}")
        
        # Сохраняем в JSON для дальнейшего использования
        with open("fake_users.json", "w", encoding="utf-8") as f:
            json.dump(users, f, ensure_ascii=False, indent=2)
        print("\n💾 Данные сохранены в fake_users.json")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Faker мгновенно создаёт правдоподобные тестовые данные на русском: имена, emails, телефоны, адреса и многое другое. Идеально для unit-тестов, заполнения БД, демо-приложений и моков API — без ручного копипаста и выдумывания.

🛠 pip install faker

Подпишись 👉🏻 @KodduuPython 🤖

🔥 orjson: Самый быстрый JSON в Python

import orjson
import time
from typing import Any, Dict, List

def fast_json_serialize(data: Any) -> bytes:
    """Быстрая сериализация в JSON с помощью orjson."""
    try:
        # Опции: отступы + сериализация дополнительных типов
        return orjson.dumps(
            data, 
            option=orjson.OPT_INDENT_2 | orjson.OPT_SERIALIZE_NUMPY
        )
    except Exception as e:
        print(f"Ошибка сериализации: {e}")
        raise

if __name__ == "__main__":
    try:
        test_data: Dict[str, List[Dict]] = {
            "users": [
                {
                    "id": i,
                    "name": f"Пользователь {i}",
                    "email": f"user{i}@example.com",
                    "tags": ["python", "dev", "api"],
                    "created": "2025-05-01T12:00:00Z"
                }
                for i in range(500)
            ]
        }
        
        start = time.time()
        json_bytes = fast_json_serialize(test_data)
        duration = time.time() - start
        
        print(f"✅ Сериализовано {len(json_bytes):,} байт за {duration:.5f} сек")
        print(f"Пользователей в данных: {len(test_data['users'])}")
        
        # Проверка десериализации
        parsed = orjson.loads(json_bytes)
        print(f"Успешно десериализовано {len(parsed['users'])} записей")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 orjson работает в разы быстрее встроенного json и умеет сериализовать numpy-массивы, datetime и другие типы. Идеально для API, логирования больших объёмов данных, парсинга и микросервисов, где каждая миллисекунда на счету.

🛠 pip install orjson

Подпишись 👉🏻 @KodduuPython 🤖

🔥 tqdm — самый удобный прогресс-бар в Python

from tqdm import tqdm, trange
import time
from random import random

if __name__ == "__main__":
    try:
        print("🚀 Демонстрация tqdm\n")
        
        # Простой прогресс-бар
        for i in tqdm(range(100), desc="Обычная обработка", unit="итерация"):
            time.sleep(0.02)
        
        # Прогресс-бар с trange
        for i in trange(50, desc="Быстрый расчёт", unit="шаг"):
            time.sleep(0.015)
        
        # Прогресс-бар с обновлением описания
        pbar = tqdm(total=80, desc="Скачивание файлов")
        for i in range(80):
            time.sleep(0.025)
            pbar.set_description(f"Файл {i+1:2d}/80")
            pbar.update(1)
        pbar.close()
        
        print("\n✅ Все задачи завершены успешно!")
    except KeyboardInterrupt:
        print("\n⛔ Операция прервана пользователем")
    except Exception as e:
        print(f"❌ Ошибка: {e}")

📌 tqdm превращает любой цикл в красивый прогресс-бар с процентами, скоростью и оставшимся временем. Поддерживает вложенные бары, кастомные описания и работает в терминале и Jupyter. Must-have для парсеров, обучения моделей, обработки больших данных и любых длительных операций.

🛠 pip install tqdm

Подпишись 👉🏻 @KodduuPython 🤖

🔥 pathlib: Забудь os.path — современный Python-стиль работы с файлами

from pathlib import Path
from datetime import datetime

if __name__ == "__main__":
    try:
        # Текущая рабочая директория как объект Path
        base = Path.cwd()
        
        # Создаём структуру проекта (mkdir не падает, если уже есть)
        project = base / "my_project"
        project.mkdir(exist_ok=True)
        (project / "data").mkdir(exist_ok=True)
        (project / "logs").mkdir(exist_ok=True)
        
        # Запись в файл одной строкой
        log_file = project / "logs" / "app.log"
        log_file.write_text(
            f"🚀 Приложение запущено: {datetime.now()}\n",
            encoding="utf-8"
        )
        
        # Чтение файла
        content = log_file.read_text(encoding="utf-8")
        print("📄 Содержимое лога:\n" + content.strip())
        
        # Рекурсивный поиск всех файлов
        all_files = list(project.rglob("*"))
        print(f"Найдено файлов и папок: {len(all_files)}")
        
        print(f"✅ Структура проекта готова: {project}")
    except PermissionError:
        print("❌ Нет прав на создание папок")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 pathlib — это современная альтернатива os и os.path. Всё в виде объектов, удобные методы (.mkdir, .write_text, .rglob), кросс-платформенность и читаемый код. Идеально для скриптов, CLI-утилит, парсеров и любого проекта, где нужно работать с файлами.

Подпишись 👉🏻 @KodduuPython 🤖

from dataclasses import dataclass, field
from typing import List, Optional
from datetime import datetime

@dataclass
class Order:
    """Модель заказа — автоматически генерирует __init__, __repr__ и методы сравнения."""
    order_id: int
    customer_name: str
    items: List[str] = field(default_factory=list)      # mutable default через factory
    total: float = 0.0
    status: str = "new"
    created_at: datetime = field(default_factory=datetime.now)
    notes: Optional[str] = None

    def add_item(self, item: str, price: float):
        """Добавляет товар и пересчитывает сумму."""
        self.items.append(item)
        self.total += price


if __name__ == "__main__":
    try:
        order = Order(order_id=1001, customer_name="Анна Смирнова")
        order.add_item("Ноутбук", 89990.0)
        order.add_item("Мышь", 1290.0)
        
        print(f"Заказ #{order.order_id} для {order.customer_name}")
        print(f"Товары: {order.items}")
        print(f"Сумма: {order.total:,.0f} ₽")
        print(f"Создан: {order.created_at.strftime('%Y-%m-%d %H:%M')}")
        print(f"Статус: {order.status}")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 @dataclass избавляет от бойлерплейта: не нужно писать __init__, __repr__ и __eq__ вручную. Поддерживает поля по умолчанию, mutable defaults через field, asdict`/`astuple и frozen. Идеально для моделей, DTO, конфигов и любых структур данных.

Подпишись 👉🏻 @KodduuPython 🤖

from dotenv import load_dotenv, find_dotenv
import os
from typing import Optional

# Автоматически находим и загружаем .env из корня проекта
load_dotenv(find_dotenv())

def get_env(key: str, default: Optional[str] = None, required: bool = False) -> str:
    """Безопасное получение переменной окружения."""
    value = os.getenv(key, default)
    if required and value is None:
        raise EnvironmentError(f"❌ Обязательная переменная {key} не найдена в .env")
    return value

if __name__ == "__main__":
    try:
        API_KEY = get_env("API_KEY", required=True)
        DEBUG = get_env("DEBUG", "false").lower() in ("true", "1", "yes")
        HOST = get_env("HOST", "127.0.0.1")
        PORT = int(get_env("PORT", "8000"))
        
        print(f"✅ API_KEY загружен (длина {len(API_KEY)})")
        print(f"Режим отладки: {DEBUG}")
        print(f"Сервер: {HOST}:{PORT}")
    except EnvironmentError as e:
        print(e)
        print("💡 Создайте файл .env с нужными переменными")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 python-dotenv загружает секреты и настройки из .env-файла прямо в os.environ. Никаких хардкодных ключей в коде — безопасно, удобно и по всем best practices. Идеально для любого реального проекта, FastAPI, Django, ботов и скриптов.

🛠 pip install python-dotenv

Подпишись 👉🏻 @KodduuPython 🤖

Злые OpenAI, Gemini и Anthropic

Недавно OpenRouter заблокировал доступ к нейронкам топ-3 для пользователей из РФ, при этом они используют разные способы вычисления, что вы из РФ.

Мы активно тестируем альтернативные нейронки, очень хорошо себя показывает minimax-m2.7, по сути, на одном из ботов OpenClaw просто переключили на неё, и все задачи, которые делал gpt-5.4, выполняются точно так же.

Попробуйте, может, вам тоже зайдёт.

Подпишись 👉🏻 @aigentto 🤖

🔥 tenacity: Самый мощный retry-декоратор в Python

from tenacity import retry, stop_after_attempt, wait_exponential
import random
import time

@retry(
    stop=stop_after_attempt(5),
    wait=wait_exponential(multiplier=0.8, min=1, max=8),
    reraise=True
)
def unstable_service_call():
    """Имитация вызова нестабильного внешнего сервиса."""
    if random.random() < 0.7:
        raise TimeoutError("Таймаут подключения к сервису")
    time.sleep(0.4)
    return "Данные успешно загружены!"

if __name__ == "__main__":
    try:
        print("🔄 Вызываем нестабильный сервис...")
        result = unstable_service_call()
        print(f"✅ {result}")
    except Exception as e:
        print(f"❌ Сервис не ответил после всех попыток: {e}")

📌 tenacity — это промышленный стандарт для автоматических повторов. Поддерживает экспоненциальный backoff, остановку по времени/попыткам, условия retry, логирование и многое другое. Идеально для работы с API, сетевыми запросами и любыми ненадёжными операциями.

🛠 pip install tenacity

Подпишись 👉🏻 @KodduuPython 🤖

🔥 icecream: Умная отладка вместо print()

from icecream import ic
import time
from typing import Any, List

def process_data(items: List[Any]) -> int:
    """Пример обработки данных с автоматической отладкой."""
    ic(items)  # Покажет тип, значение и место вызова
    start = time.time()
    
    total = sum(len(str(item)) for item in items)
    duration = time.time() - start
    
    ic(total, duration)  # Красиво выводит несколько переменных
    return total

if __name__ == "__main__":
    try:
        test_data = ["Python", 2026, [1, 2, 3], {"key": "value"}, True]
        ic("🚀 Запуск обработки")  # Простая метка
        
        result = process_data(test_data)
        ic("✅ Готово!", result)
    except Exception as e:
        ic("❌ Ошибка!", e)  # icecream красиво логирует исключения

📌 icecream (ic) — это «умный print», который автоматически показывает имя переменной, её значение, файл и строку кода. Никаких лишних f-строк и print'ов — просто ic() в любом месте. Идеально для отладки скриптов, алгоритмов и сложной логики.

🛠 pip install icecream

Подпишись 👉🏻 @KodduuPython 🤖

import psutil
from datetime import datetime
from typing import Dict

def get_system_info() -> Dict:
    """Собирает ключевую информацию о системе с помощью psutil."""
    info = {}
    
    # CPU
    info["cpu_percent"] = psutil.cpu_percent(interval=0.8)
    info["cpu_cores"] = psutil.cpu_count(logical=False)
    info["cpu_logical"] = psutil.cpu_count(logical=True)
    
    # Память
    mem = psutil.virtual_memory()
    info["ram_percent"] = mem.percent
    info["ram_used_gb"] = round(mem.used / (1024 ** 3), 2)
    info["ram_total_gb"] = round(mem.total / (1024 ** 3), 2)
    
    # Диск
    disk = psutil.disk_usage("/")
    info["disk_percent"] = disk.percent
    info["disk_used_gb"] = round(disk.used / (1024 ** 3), 2)
    info["disk_total_gb"] = round(disk.total / (1024 ** 3), 2)
    
    # Время работы системы
    info["boot_time"] = datetime.fromtimestamp(psutil.boot_time()).strftime("%Y-%m-%d %H:%M")
    
    return info

if __name__ == "__main__":
    try:
        sys_info = get_system_info()
        
        print("🖥️  Информация о системе:\n")
        print(f"CPU загрузка: {sys_info['cpu_percent']}%  | Ядер: {sys_info['cpu_cores']} | Логических: {sys_info['cpu_logical']}")
        print(f"ОЗУ: {sys_info['ram_percent']}% ({sys_info['ram_used_gb']}/{sys_info['ram_total_gb']} ГБ)")
        print(f"Диск /: {sys_info['disk_percent']}% ({sys_info['disk_used_gb']}/{sys_info['disk_total_gb']} ГБ)")
        print(f"Система работает с: {sys_info['boot_time']}")
    except Exception as e:
        print(f"❌ Ошибка получения данных: {e}")

📌 psutil — кросс-платформенная библиотека для получения реальной информации о CPU, памяти, дисках, сети и процессах. Одна строка — и у вас актуальные метрики системы. Идеально для мониторинга, дашбордов, скриптов администрирования и devops-утилит.

🛠 pip install psutil

Подпишись 👉🏻 @KodduuPython 🤖

🔥 BeautifulSoup: Парсинг HTML и веб-скрапинг за 10 строк

from bs4 import BeautifulSoup
from typing import List, Dict

# Пример HTML-кода (можно заменить на requests.get().text)
html_example = """
<html>
<head><title>Каталог товаров</title></head>
<body>
    <h1>Наши продукты</h1>
    <div class="product">
        <h2>Ноутбук ASUS</h2>
        <p class="price">74990 ₽</p>
        <a href="/product/123">Подробнее</a>
    </div>
    <div class="product">
        <h2>Смартфон Xiaomi</h2>
        <p class="price">32990 ₽</p>
        <a href="/product/456">Подробнее</a>
    </div>
</body>
</html>
"""

def parse_products(html: str) -> List[Dict]:
    """Парсит HTML и извлекает товары по классам и тегам."""
    soup = BeautifulSoup(html, "html.parser")
    products = []
    
    for item in soup.find_all("div", class_="product"):
        try:
            product = {
                "title": item.find("h2").get_text(strip=True),
                "price": item.find("p", class_="price").get_text(strip=True),
                "link": item.find("a")["href"]
            }
            products.append(product)
        except AttributeError:
            continue  # пропускаем некорректные блоки
    return products

if __name__ == "__main__":
    try:
        products = parse_products(html_example)
        print(f"✅ Найдено товаров: {len(products)}\n")
        for p in products:
            print(f"📦 {p['title']}")
            print(f"   Цена: {p['price']}")
            print(f"   Ссылка: {p['link']}\n")
    except Exception as e:
        print(f"❌ Ошибка парсинга: {e}")

📌 BeautifulSoup превращает любой HTML в удобный объект для поиска по тегам, классам и атрибутам. Никаких регулярных выражений — только понятные методы. Идеально для скрапинга сайтов, парсинга прайсов, новостей и автоматизации сбора данных.

🛠 pip install beautifulsoup4

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Оператор моржа (:=): Присваивание прямо в выражениях — чистый и эффективный код

from typing import List, Dict, Any

def process_users(users: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
    """Обрабатывает пользователей, используя := чтобы избежать повторных вычислений."""
    results = []
    for user in users:
        # Вычисляем полное имя один раз и сразу используем в условии
        if (full_name := f"{user.get('first_name', '')} {user.get('last_name', '')}".strip()) \
           and user.get("active", True):
            
            # То же самое со score — вычисляем один раз
            if (score := user.get("score", 0)) > 80:
                results.append({
                    "name": full_name,
                    "score": score,
                    "status": "top" if score > 90 else "good"
                })
    return results

if __name__ == "__main__":
    try:
        sample_users = [
            {"first_name": "Анна", "last_name": "Иванова", "active": True, "score": 95},
            {"first_name": "Петр", "last_name": "Сидоров", "active": False, "score": 70},
            {"first_name": "Мария", "last_name": "Петрова", "active": True, "score": 85},
            {"first_name": "Иван", "last_name": "Козлов", "active": True, "score": 88},
        ]
        
        top_users = process_users(sample_users)
        
        print("🏆 Топ-пользователи (score > 80):")
        for u in top_users:
            print(f"  • {u['name']}: {u['score']} ({u['status']})")
            
    except Exception as e:
        print(f"❌ Ошибка: {e}")

📌 Оператор моржа (:=) позволяет присваивать значение переменной прямо внутри условия или выражения. Это сокращает код, избегает повторных вычислений и делает логику чище — особенно полезно в if, циклах и list comprehensions. Настоящий must-have для Python 3.8+.

Подпишись 👉🏻 @KodduuPython 🤖

🔥 match-case: Структурное сопоставление с образцом — мощная альтернатива цепочкам if-elif

from typing import Any, Dict

def handle_event(event: Dict[str, Any]) -> str:
    """Обрабатывает разные типы событий с помощью match-case (Python 3.10+)."""
    match event:
        case {"type": "click", "x": x, "y": y}:
            return f"Клик в координатах ({x}, {y})"
        
        case {"type": "keypress", "key": k} if k in ("Enter", "Space", "Escape"):
            return f"Специальная клавиша нажата: {k}"
        
        case {"type": "keypress", "key": k}:
            return f"Обычная клавиша: {k}"
        
        case {"type": "scroll", "direction": direction, "amount": amount}:
            return f"Прокрутка {direction} на {amount} единиц"
        
        case {"type": "error", "message": msg}:
            return f"Ошибка: {msg}"
        
        case _:
            return "Неизвестный тип события"

if __name__ == "__main__":
    try:
        events = [
            {"type": "click", "x": 150, "y": 320},
            {"type": "keypress", "key": "Enter"},
            {"type": "scroll", "direction": "down", "amount": 5},
            {"type": "error", "message": "Connection timeout"},
            {"type": "unknown", "payload": 123}
        ]
        
        for event in events:
            print(handle_event(event))
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Конструкция match-case (появилась в Python 3.10) позволяет красиво и безопасно обрабатывать данные разных форм — словари, объекты, кортежи. Поддерживает guards (дополнительные условия после if`) и захват значений в переменные. Отлично заменяет длинные цепочки `if-elif при обработке событий, команд, API-ответов и конфигов.

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Enum: Типобезопасные константы и флаги вместо «магических» строк и чисел

from enum import Enum, auto, Flag, unique
from typing import List

@unique
class UserRole(Enum):
    """Роли пользователей системы (защищено от дубликатов)."""
    GUEST = auto()
    USER = auto()
    MODERATOR = auto()
    ADMIN = auto()

class Permission(Flag):
    """Права доступа — можно комбинировать через |."""
    READ = auto()
    WRITE = auto()
    DELETE = auto()
    ADMIN = READ | WRITE | DELETE   # комбинация флагов

def get_permissions(role: UserRole) -> Permission:
    """Возвращает набор прав в зависимости от роли."""
    if role == UserRole.ADMIN:
        return Permission.ADMIN
    elif role == UserRole.MODERATOR:
        return Permission.READ | Permission.WRITE
    return Permission.READ

if __name__ == "__main__":
    try:
        role = UserRole.ADMIN
        perms = get_permissions(role)
        
        print(f"Роль: {role.name} (значение = {role.value})")
        print(f"Права: {perms}")
        print(f"Может удалять: {Permission.DELETE in perms}")
        print(f"Может читать: {Permission.READ in perms}")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Enum и Flag делают код чище, безопаснее и самодокументируемым. Вместо строк "admin"/"user" и магических чисел вы получаете автодополнение в IDE, защиту от опечаток и удобные операции сравнения/комбинирования. Отлично подходит для статусов, ролей, типов документов и состояний приложения.

Подпишись 👉🏻 @KodduuPython 🤖

🔥 TopologicalSorter: Сортируем задачи с зависимостями как профи

from graphlib import TopologicalSorter
from typing import Dict, List

def order_tasks(dependencies: Dict[str, List[str]]) -> List[str]:
    """Возвращает правильный порядок выполнения задач с учётом зависимостей."""
    ts = TopologicalSorter(dependencies)
    try:
        return list(ts.static_order())
    except Exception as e:
        # В Python 3.9+ это будет graphlib.CycleError
        raise ValueError("Обнаружен цикл в зависимостях! Проверьте граф.") from e

if __name__ == "__main__":
    try:
        # Пример: зависимости задач в CI/CD пайплайне
        pipeline = {
            "install": [],
            "lint": ["install"],
            "test": ["install"],
            "build": ["lint", "test"],
            "deploy": ["build"]
        }
        
        order = order_tasks(pipeline)
        
        print("🚀 Правильный порядок выполнения задач:\n")
        for i, task in enumerate(order, 1):
            print(f"  {i}. {task}")
    except Exception as e:
        print(f"❌ Ошибка: {e}")

📌 TopologicalSorter из модуля graphlib (Python 3.9+) автоматически вычисляет правильный порядок выполнения задач с зависимостями. Поддерживает обнаружение циклов и статическую сортировку. Идеально для CI/CD пайплайнов, сборки проектов, обработки DAG и любых сценариев с зависимостями.

Подпишись 👉🏻 @KodduuPython 🤖

Разработчики стали говорить: Cursor так сказал

Появилась новая проблема у команд, которые на 100% пишут код с помощью ИИ. Они на вопрос, по сути, стали отвечать: ну, мне Cursor/Claude сказал, что это так.

Это звучит так: я не знаю, но там так написано 🙂

Не отвечайте так никогда — Cursor/Claude ничего вам не может сказать, вы должны сами во всем разобраться, провести анализ, понять root cause и ответить на все вопросы.

Молоток не может вам сказать, где забивать гвоздь, AI IDE, конечно, мощнее, но суть та же: вы должны все определять и знать как разработчик.

Если действительно не знаете — скажите: я узнаю, и узнайте, вернитесь с результатом.

Иначе возникает вопрос: а зачем мне спрашивать у тебя, я сам спрошу у Cursor/Claude.

Подпишись 👉🏻 @aigentto 🤖

🔥 Дескрипторы: Полный контроль над атрибутами класса (без геттеров/сеттеров)

class PositiveNumber:
    """Дескриптор, который не даёт установить отрицательное значение."""
    
    def __set_name__(self, owner, name):
        # Сохраняем имя приватного атрибута
        self.private_name = f"_{name}"
    
    def __get__(self, obj, objtype=None):
        # Возвращаем значение или 0 по умолчанию
        return getattr(obj, self.private_name, 0)
    
    def __set__(self, obj, value):
        # Валидация при присваивании
        if not isinstance(value, (int, float)):
            raise TypeError("Значение должно быть числом")
        if value < 0:
            raise ValueError("Значение не может быть отрицательным")
        setattr(obj, self.private_name, value)


class BankAccount:
    """Счёт в банке с защитой баланса через дескриптор."""
    balance = PositiveNumber()
    
    def __init__(self, owner: str, initial_balance: float = 0):
        self.owner = owner
        self.balance = initial_balance   # проходит через дескриптор
    
    def deposit(self, amount: float):
        self.balance += amount
    
    def withdraw(self, amount: float):
        self.balance -= amount


if __name__ == "__main__":
    try:
        account = BankAccount("Анна", 1000)
        print(f"Владелец: {account.owner}, баланс: {account.balance}")
        
        account.deposit(500)
        print(f"После пополнения: {account.balance}")
        
        account.withdraw(300)
        print(f"После снятия: {account.balance}")
        
        # Попробуем установить отрицательный баланс — вызовет ошибку
        account.balance = -100
    except (ValueError, TypeError) as e:
        print(f"❌ Защита сработала: {e}")

📌 Дескрипторы позволяют полностью контролировать чтение и запись атрибутов через магические методы __get__ и __set__. Это мощная альтернатива property и геттерам/сеттерам — особенно удобна для валидации, логирования доступа и создания переиспользуемой логики атрибутов.

Подпишись 👉🏻 @KodduuPython 🤖

🔥 Крестики-нолики в консоли: пишем настоящую игру за 25 строк

def print_board(board):
    """Красиво выводит игровое поле 3x3."""
    print("\n  " + " | ".join(board[0:3]))
    print("  " + "-" * 9)
    print("  " + " | ".join(board[3:6]))
    print("  " + "-" * 9)
    print("  " + " | ".join(board[6:9]) + "\n")

def check_winner(board, player):
    """Проверяет, победил ли игрок."""
    wins = [(0,1,2), (3,4,5), (6,7,8),   # строки
            (0,3,6), (1,4,7), (2,5,8),   # столбцы
            (0,4,8), (2,4,6)]            # диагонали
    return any(board[a] == board[b] == board[c] == player 
               for a, b, c in wins)

def is_draw(board):
    """Проверяет ничью."""
    return " " not in board

def play_game():
    """Основной игровой цикл."""
    board = [" "] * 9
    current_player = "X"
    
    print("🎮 Крестики-нолики! X ходит первым.")
    
    while True:
        print_board(board)
        try:
            move = int(input(f"Ход игрока {current_player} (1-9): ")) - 1
            
            if not 0 <= move <= 8:
                print("❌ Введите число от 1 до 9!")
                continue
            if board[move] != " ":
                print("❌ Эта клетка уже занята!")
                continue
                
            board[move] = current_player
            
            if check_winner(board, current_player):
                print_board(board)
                print(f"🎉 Победил игрок {current_player}!")
                break
            if is_draw(board):
                print_board(board)
                print("🤝 Ничья!")
                break
                
            current_player = "O" if current_player == "X" else "X"
            
        except (ValueError, KeyboardInterrupt):
            print("\n👋 Игра прервана. До встречи!")
            break

if __name__ == "__main__":
    try:
        play_game()
    except Exception as e:
        print(f"Неожиданная ошибка: {e}")

📌 Полноценная игра «Крестики-нолики» в консоли с проверкой победы, ничьей, защитой от неверного ввода и переключением игроков. Отличный пример чистой структуры, обработки ошибок и игрового цикла. Идеально для начинающих и как база для более сложных консольных игр.

Подпишись 👉🏻 @KodduuPython 🤖