🚀 Лайфхак: @lru_cache ускоряет рекурсию в тысячи раз!

import time
from functools import lru_cache

@lru_cache(maxsize=None)  # Неограниченный кэш — храним ВСЕ уникальные результаты
def fibonacci(n: int) -> int:
    """Рекурсивное вычисление n-го числа Фибоначчи."""
    if n < 2:
        return n
    return fibonacci(n - 1) + fibonacci(n - 2)

if __name__ == "__main__":
    try:
        n = 40  # Без кэша это заняло бы минуты или часы!
        start = time.time()
        result = fibonacci(n)
        duration = time.time() - start
        
        print(f"Фибоначчи({n}) = {result}")
        print(f"Время с мемоизацией: {duration:.6f} сек")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Декоратор @lru_cache автоматически кэширует результаты вызовов функции. Повторные вычисления с теми же аргументами мгновенно берутся из памяти — никаких лишних рекурсий. Идеально для динамического программирования, алгоритмов на графах, парсинга и любых функций с повторяющимися подзадачами.

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

✨ singledispatch: Полиморфизм по типу без if и классов!

from functools import singledispatch
from typing import Any

@singledispatch
def format_value(value: Any) -> str:
    """Обработка по умолчанию для неизвестных типов."""
    return f"Неизвестный тип ({type(value).__name__}): {value}"

@format_value.register
def _(value: int) -> str:
    return f"Целое число: {value} (в hex: {value:x})"

@format_value.register
def _(value: float) -> str:
    return f"Число с плавающей точкой: {value:.4f}"

@format_value.register
def _(value: str) -> str:
    return f"Строка длиной {len(value)}: \"{value[:50]}{'...' if len(value) > 50 else ''}\""

@format_value.register(list)
@format_value.register(tuple)
def _(value) -> str:
    formatted = [format_value(item) for item in value[:3]]
    return f"Коллекция ({len(value)} элементов): [{', '.join(formatted)}]"

if __name__ == "__main__":
    try:
        tests = [42, 3.14159, "Привет из Python!", [1, 2, "текст", 4.5]]
        for test in tests:
            print(format_value(test))
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Декоратор @singledispatch превращает одну функцию в набор реализаций по типу первого аргумента. Никаких if isinstance — просто регистрируй обработчики. Идеально для парсеров данных, сериализаторов, валидаторов и API, где нужно красиво обрабатывать int, str, list, dict и свои классы.

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

🔥 @cached_property: Дорогие свойства вычисляются только один раз!

from functools import cached_property
import time
from typing import List

class DataAnalyzer:
    def __init__(self, dataset: List[float]):
        self.dataset = dataset

    @cached_property
    def mean(self) -> float:
        """Вычисляет среднее значение (имитация тяжелой операции)."""
        print("🔄 Вычисляем среднее...")
        time.sleep(1.2)  # Имитация долгого расчёта
        return sum(self.dataset) / len(self.dataset)

    @cached_property
    def std_dev(self) -> float:
        """Вычисляет стандартное отклонение."""
        print("🔄 Вычисляем стандартное отклонение...")
        time.sleep(0.9)
        mean_val = self.mean
        variance = sum((x - mean_val) ** 2 for x in self.dataset) / len(self.dataset)
        return variance ** 0.5

if __name__ == "__main__":
    try:
        data = [2.5, 3.7, 6.8, 9.1, 4.3, 7.6]
        analyzer = DataAnalyzer(data)
        
        start = time.time()
        
        print(f"Среднее: {analyzer.mean:.2f}")
        print(f"Стандартное отклонение: {analyzer.std_dev:.2f}")
        
        # Повторные обращения — мгновенно
        print(f"Среднее (повтор): {analyzer.mean:.2f}")
        
        print(f"Общее время: {time.time() - start:.2f} секунд")
    except Exception as e:
        print(f"Ошибка: {e}")

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

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

🔥 Retry-декоратор: спасение от нестабильных API и сетевых сбоев

import time
import random
from functools import wraps
from typing import Callable, Any

def retry(max_attempts: int = 5, 
          initial_delay: float = 1.0, 
          backoff: float = 2.0,
          exceptions: tuple = (Exception,)):
    """Декоратор для автоматического повторения функции при ошибках."""
    def decorator(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> Any:
            delay = initial_delay
            last_exception = None
            
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    last_exception = e
                    if attempt == max_attempts:
                        break
                    print(f"⚠️ Попытка {attempt}/{max_attempts} не удалась: {e}")
                    print(f"⏳ Ждём {delay:.1f} сек...")
                    time.sleep(delay)
                    delay *= backoff  # экспоненциальный backoff
            raise last_exception
        return wrapper
    return decorator

# Пример использования
@retry(max_attempts=4, initial_delay=0.5, exceptions=(ValueError, ConnectionError))
def unreliable_api_call():
    """Имитируем нестабильный внешний сервис."""
    if random.random() < 0.7:  # 70% шанс ошибки
        raise ConnectionError("Сервер временно недоступен")
    return "Успешный ответ от API!"

if __name__ == "__main__":
    try:
        result = unreliable_api_call()
        print(f"✅ Результат: {result}")
    except Exception as e:
        print(f"❌ Все попытки исчерпаны. Последняя ошибка: {e}")

📌 Этот декоратор автоматически повторяет функцию при указанных ошибках с увеличивающейся задержкой. Exponential backoff + возможность указывать исключения — must-have для работы с API, базами данных, парсерами и любыми внешними сервисами.

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

🔥 Pydantic v2: Самая мощная валидация данных в Python

from pydantic import BaseModel, Field, ValidationError, EmailStr
from typing import List
from datetime import datetime

class User(BaseModel):
    """Модель пользователя с автоматической валидацией полей."""
    id: int
    username: str = Field(min_length=4, max_length=20)
    email: EmailStr
    age: int = Field(ge=16, le=99)
    is_active: bool = True
    skills: List[str] = Field(default_factory=list)

if __name__ == "__main__":
    try:
        data = {
            "id": 101,
            "username": "devpython",
            "email": "hello@kodduu.ru",
            "age": 27,
            "skills": ["Python", "FastAPI", "Pydantic"]
        }
        
        user = User.model_validate(data)
        print(f"✅ Пользователь валиден: {user.username}")
        print(f"Email: {user.email}")
        print(f"Навыки: {user.skills}")
        
        # Пример ошибки валидации
        bad_data = data.copy()
        bad_data["email"] = "неправильный email"
        bad_data["age"] = 10
        User.model_validate(bad_data)
        
    except ValidationError as e:
        print("❌ Ошибка валидации:")
        for error in e.errors(include_url=False):
            print(f"   • {' -> '.join(map(str, error['loc']))}: {error['msg']}")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Pydantic автоматически проверяет типы, формат email, диапазоны значений, конвертирует строки в datetime и выдаёт понятные ошибки. Must-have для REST API, конфигов, форм, парсинга JSON и любой работы с внешними данными.

🛠 pip install pydantic

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

🔥 Loguru: Логирование, которое реально удобно использовать

from loguru import logger
import sys

# Удаляем стандартные обработчики, чтобы не было дублей
logger.remove()

# Вывод в консоль с цветами и красивым форматом
logger.add(
    sys.stdout,
    format="<green>{time:HH:mm:ss}</green> | <level>{level:8}</level> | {message}",
    level="DEBUG",
    colorize=True
)

# Запись в файл с автоматической ротацией
logger.add(
    "logs/app_{time:YYYY-MM-DD}.log",
    rotation="10 MB",
    retention="7 days",
    level="INFO"
)

@logger.catch
def risky_operation(x: int) -> float:
    """Пример опасной операции с автоматическим логированием исключений."""
    return 100 / x

if __name__ == "__main__":
    try:
        logger.info("🚀 Приложение успешно запущено")
        logger.debug("Это отладочное сообщение для разработчика")
        
        result = risky_operation(25)
        logger.success(f"✅ Результат расчёта: {result}")
        
        # Вызовем ошибку специально
        risky_operation(0)
        
    except Exception as e:
        logger.error(f"❌ Неожиданная ошибка: {e}")

📌 Loguru заменяет стандартный logging одной строкой настройки. Красивые цвета, автоматическая запись в файл, ротация логов, перехват всех исключений через @logger.catch — и никаких boilerplate-кодов. Идеально для скриптов, CLI, веб-сервисов и продакшена.

🛠 pip install loguru

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

Проблема автоматизации чего-либо — это не технология

Начну издалека: автоматизация чего-либо — это не новшество: 100+ лет назад человек переходил от лошади к трактору, примерно в то же время — от ручного труда к ткацкому станку и т. д.

Каждый раз производительность росла, и ВВП на душу населения рос, что приводило к увеличению благ на каждого человека. Поэтому страх, что всех уволят, сильно преувеличен, а точнее, это может стать правдой в моменте, но в долгую AI увеличит блага на душу населения, и так или иначе они все равно будут распределены между людьми.

Теперь переместимся чуть ближе в 2014 год: я нанят в "Большой зеленый банк" как Head автоматизации всего QA, то есть автоматизировать все тестирования всех систем компании (200+ очень разношерстных приложений). Тогда еще не было современного AI, хотя эксперимент мы проводили по автоматизации через распознавание экрана с помощью библиотек Google, все на самом деле даже работало, но со скроллами и legacy интерфейсами были проблемы 🤷‍♂️

Короче, взяли на тот момент уже стандарт BDD+Java+Selenium driver для всего зоопарка Web+Rest API и уникальные всякие штуки для других областей — была там и знаменитая роборука, которая физически тестировала карточки, вставляя их в терминал 🙂

В тот момент проблемой была не технология, хотя с ней были отдельные решаемые сложности. То же самое сейчас - AI не является блокером, в том же паттерне ReAct (читай OpenClaw) может делать 95% дел которые люди делают за компом.

Тогда главной проблемой были люди, а точнее, их интересы: 5 топ-менеджеров компании управляли большими секторами тестирования и с удовольствием выбивали себе огромные бюджеты на найм ручных тестировщиков. Я, по сути, был призван остановить этот бесконечный найм в ручное тестирование и, по факту, стал главным врагом как минимум этих топ-5 менеджеров, а как максимум — всех 2000+ ручных тестировщиков, которые хотели получать зарплату, тыкать кнопки и не очень хотели учить Java и переходить на автоматизацию.

Для понимания накала страстей, в один момент один из этих топ-5 менеджеров то ли в шутку, то ли всерьёз начал на меня кидаться, так сильно я ему мешал 🙂

Я бы хотел сказать, что победили автоматизация и здравый смысл, но так не работает на больших системах, тем не менее через 4 года уровень автоматизации QA вырос с 0 до 30+%, с учетом того, что за это время внедрили еще 10-ки новых приложений и сам объем тестирования вырос в разы. То есть цель автоматизации в 100% была убегающей: вчера 100% — это было 100 000 тестов, завтра — это 200 000 тестов и так далее.

Почему всё-таки получилось сдержать рост ручного труда и, по факту, сэкономить до 300 млн руб. в год на ручном тестировании? Причина была не в том, что я гений автоматизации, причина была не в технологии. Причина была только в том, что мне дали полный ownership, и директор департамента требовал с меня результат, но не лез в то, как и с помощью чего я буду это делать: вначале там была технология и команда из XIX века, я её убрал за один день, несмотря на большую любовь многих к этой технологии и команде, а любовь была потому, что ребята были приятные и никого сильно не напрягали.

И главное — директор департамента дал мне право на внедрение изменений и всегда его поддерживал. Да, конечно, я не шел напролом, я договаривался с теми 5 топ-менеджерами, но у меня было абсолютное право финального решения по всем вопросам автоматизации.

Только полный ownership и право принимать финальные решения по вопросам в моей зоне ответственности позволили добиться большого результата.

Следующими постами я расскажу, как проваливают текущую AI-автоматизацию большие и малые компании. Нельзя просто дать денег и не дать ownership. Нельзя просто нанять ИТшников, чтобы они сделали инструмент, и все: они его сделают, но он будет лежать в сторонке, и деньги будут потрачены зря.

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

🔥 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 🤖