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

🔥 Виселица в консоли: классическая игра за 25 строк

import random
from typing import List, Set

WORDS: List[str] = ["python", "программирование", "телеграм", "алгоритм", "разработчик", "функция", "декоратор"]

def play_hangman() -> None:
    """Основной игровой цикл виселицы."""
    word: str = random.choice(WORDS)
    guessed: List[str] = ["_"] * len(word)
    attempts: int = 6
    guessed_letters: Set[str] = set()

    print("🎮 Добро пожаловать в Виселицу!\n")

    while attempts > 0 and "_" in guessed:
        print("Слово: " + " ".join(guessed))
        print(f"Попыток осталось: {attempts}")
        print(f"Использованные буквы: {', '.join(sorted(guessed_letters)) or '—'}\n")

        letter: str = input("Введите букву: ").lower().strip()

        if not letter.isalpha() or len(letter) != 1:
            print("❌ Введите одну русскую или английскую букву!\n")
            continue

        if letter in guessed_letters:
            print("⚠️ Вы уже вводили эту букву!\n")
            continue

        guessed_letters.add(letter)

        if letter in word:
            for i, char in enumerate(word):
                if char == letter:
                    guessed[i] = letter
            print("✅ Есть такая буква!\n")
        else:
            attempts -= 1
            print("❌ Такой буквы нет.\n")

    if "_" not in guessed:
        print(f"🎉 Поздравляем! Вы угадали слово: {word.upper()}")
    else:
        print(f"💀 Вы проиграли. Загаданное слово было: {word.upper()}")

if __name__ == "__main__":
    try:
        play_hangman()
    except KeyboardInterrupt:
        print("\n\n👋 Игра прервана. До новых встреч!")
    except Exception as e:
        print(f"Неожиданная ошибка: {e}")

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

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

🔥 FastAPI: Современный веб-фреймворк, который пишет документацию за тебя

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
from typing import List, Optional
import uvicorn

app = FastAPI(
    title="Магазин API",
    description="Простой пример современного API",
    version="1.0.0"
)

class Item(BaseModel):
    """Модель товара с валидацией."""
    name: str = Field(..., min_length=2, max_length=50, description="Название товара")
    price: float = Field(..., gt=0, description="Цена в рублях")
    tags: List[str] = Field(default_factory=list, description="Теги товара")
    in_stock: bool = True

# Временное хранилище (в реальном проекте — БД)
items_db: dict[int, Item] = {}
item_id_counter = 1

@app.post("/items/", response_model=Item, status_code=201)
async def create_item(item: Item):
    """Создаёт новый товар."""
    global item_id_counter
    items_db[item_id_counter] = item
    item_id_counter += 1
    return item

@app.get("/items/{item_id}", response_model=Item)
async def get_item(item_id: int):
    """Получает товар по ID."""
    if item_id not in items_db:
        raise HTTPException(status_code=404, detail="Товар не найден")
    return items_db[item_id]

@app.get("/items/", response_model=List[Item])
async def list_items():
    """Возвращает список всех товаров."""
    return list(items_db.values())

if __name__ == "__main__":
    # Запуск: uvicorn main:app --reload
    uvicorn.run(app, host="127.0.0.1", port=8000, reload=True)

📌 FastAPI автоматически генерирует красивую документацию (Swagger + ReDoc), делает валидацию данных через Pydantic, поддерживает async/await из коробки и даёт отличные подсказки в IDE. Одна из самых приятных и продуктивных библиотек для создания API в 2025–2026 году.

🛠 pip install fastapi uvicorn

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

🔥 Polars: DataFrame, который работает в 5–50 раз быстрее pandas

import polars as pl
from datetime import date

def analyze_employees() -> None:
    """Пример быстрой аналитики сотрудников с Polars."""
    # Создаём DataFrame (в реальности обычно читаем из CSV/Parquet)
    df = pl.DataFrame({
        "name": ["Анна", "Борис", "Виктория", "Григорий", "Дарья"],
        "department": ["IT", "HR", "IT", "Finance", "IT"],
        "salary": [120000, 85000, 135000, 95000, 110000],
        "hire_date": [
            date(2019, 3, 15),
            date(2021, 6, 1),
            date(2018, 11, 20),
            date(2022, 2, 10),
            date(2020, 8, 5)
        ]
    })

    # Мощные операции в одном выражении (ленивые вычисления под капотом)
    result = (
        df.filter(pl.col("salary") > 90000)
        .group_by("department")
        .agg([
            pl.col("salary").mean().alias("avg_salary"),
            pl.col("name").count().alias("employee_count"),
            pl.col("hire_date").min().alias("earliest_hire")
        ])
        .sort("avg_salary", descending=True)
    )

    print(result)

if __name__ == "__main__":
    try:
        analyze_employees()
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Polars — это современная библиотека для работы с табличными данными, написанная на Rust. Она использует ленивые вычисления, многопоточность и Arrow-формат, поэтому на больших объёмах данных работает в разы быстрее pandas. Отлично подходит для аналитики, ETL, обработки логов и любых задач с DataFrame.

🛠 pip install polars

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

🔥 concurrent.futures: Простой параллелизм без головной боли

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List

def cpu_heavy_task(n: int) -> int:
    """Имитация тяжёлой CPU-задачи (например, вычисление суммы квадратов)."""
    return sum(i * i for i in range(n))

def run_sequential(numbers: List[int]) -> List[int]:
    """Последовательное выполнение — медленно."""
    return [cpu_heavy_task(n) for n in numbers]

def run_parallel(numbers: List[int], max_workers: int = 4) -> List[int]:
    """Параллельное выполнение с ThreadPoolExecutor."""
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Отправляем все задачи сразу
        future_to_n = {executor.submit(cpu_heavy_task, n): n for n in numbers}
        
        # Получаем результаты по мере готовности
        for future in as_completed(future_to_n):
            try:
                results.append(future.result())
            except Exception as e:
                print(f"Ошибка в задаче: {e}")
    return results

if __name__ == "__main__":
    try:
        numbers = [500_000, 600_000, 700_000, 800_000]  # 4 тяжёлые задачи
        
        print("⏱️  Последовательно:")
        start = time.time()
        seq_result = run_sequential(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {seq_result[:2]}...\n")
        
        print("⚡ Параллельно (4 потока):")
        start = time.time()
        par_result = run_parallel(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {par_result[:2]}...")
        
        print("\n✅ В параллельном режиме почти в 4 раза быстрее!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 concurrent.futures.ThreadPoolExecutor позволяет легко распараллеливать IO-bound и CPU-bound задачи без сложного управления потоками. Используйте as_completed, чтобы получать результаты по мере готовности, и контекстный менеджер — чтобы не забыть закрыть пул.

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

🔥 concurrent.futures: Простой параллелизм в Python

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List

def cpu_heavy_task(n: int) -> int:
    """Имитация тяжёлой CPU-задачи (например, вычисление суммы квадратов)."""
    return sum(i * i for i in range(n))

def run_sequential(numbers: List[int]) -> List[int]:
    """Последовательное выполнение."""
    return [cpu_heavy_task(n) for n in numbers]

def run_parallel(numbers: List[int], max_workers: int = 4) -> List[int]:
    """Параллельное выполнение с ThreadPoolExecutor."""
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_n = {executor.submit(cpu_heavy_task, n): n for n in numbers}
        for future in as_completed(future_to_n):
            try:
                results.append(future.result())
            except Exception as e:
                print(f"Ошибка в задаче: {e}")
    return results

if __name__ == "__main__":
    try:
        numbers = [300_000, 400_000, 500_000, 600_000]
        
        print("⏱️  Последовательно:")
        start = time.time()
        seq_result = run_sequential(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {seq_result[:2]}...\n")
        
        print("⚡ Параллельно (4 потока):")
        start = time.time()
        par_result = run_parallel(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {par_result[:2]}...")
        
        print("\n✅ В параллельном режиме значительно быстрее!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 concurrent.futures.ThreadPoolExecutor и ProcessPoolExecutor позволяют легко запускать задачи параллельно. Используйте as_completed(), чтобы получать результаты по мере готовности, и контекстный менеджер — чтобы не забыть закрыть пул. Отлично для IO-bound задач (ThreadPool) и CPU-bound задач (ProcessPool).

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

🔥 Виселица: текстовая игра в консоли за 25 строк

import random
from typing import List, Set

WORDS: List[str] = ["python", "программирование", "телеграм", "алгоритм", "разработчик", "функция", "декоратор"]

def print_board(guessed: List[str], attempts: int) -> None:
    """Выводит текущее состояние игры."""
    print(" ".join(guessed))
    print(f"Попыток осталось: {attempts}\n")

def check_winner(guessed: List[str]) -> bool:
    """Проверяет, угадано ли слово."""
    return "_" not in guessed

def play_hangman() -> None:
    """Основной игровой цикл."""
    word = random.choice(WORDS)
    guessed = ["_"] * len(word)
    attempts = 6
    guessed_letters: Set[str] = set()

    print("🎮 Добро пожаловать в Виселицу!\n")

    while attempts > 0 and not check_winner(guessed):
        print_board(guessed, attempts)
        letter = input("Введите букву: ").lower().strip()

        if len(letter) != 1 or not letter.isalpha():
            print("❌ Введите одну букву!\n")
            continue

        if letter in guessed_letters:
            print("⚠️ Вы уже вводили эту букву!\n")
            continue

        guessed_letters.add(letter)

        if letter in word:
            for i, char in enumerate(word):
                if char == letter:
                    guessed[i] = letter
            print("✅ Есть такая буква!\n")
        else:
            attempts -= 1
            print("❌ Такой буквы нет.\n")

    if check_winner(guessed):
        print(f"🎉 Поздравляем! Слово: {word.upper()}")
    else:
        print(f"💀 Вы проиграли. Слово было: {word.upper()}")

if __name__ == "__main__":
    try:
        play_hangman()
    except KeyboardInterrupt:
        print("\n👋 Игра прервана. До новых встреч!")
    except Exception as e:
        print(f"Неожиданная ошибка: {e}")

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

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

🔥 schedule: Простой планировщик задач в Python

import schedule
import time
from typing import Callable

def job(name: str):
    """Пример задачи, которая выполняется по расписанию."""
    print(f"✅ Задача '{name}' выполнена в {time.strftime('%H:%M:%S')}")

def main():
    """Настраиваем расписание."""
    schedule.every(2).seconds.do(job, name="Проверка почты")
    schedule.every(5).seconds.do(job, name="Обновление данных")
    schedule.every().day.at("10:00").do(job, name="Ежедневный отчёт")
    
    print("⏰ Расписание запущено. Ctrl+C для остановки.\n")
    
    try:
        while True:
            schedule.run_pending()
            time.sleep(1)
    except KeyboardInterrupt:
        print("\n👋 Расписание остановлено.")

if __name__ == "__main__":
    try:
        main()
    except Exception as e:
        print(f"Ошибка: {e}")

📌 schedule — лёгкая библиотека для запуска функций по расписанию (каждые N секунд, минут, в определённое время дня и т.д.). Не требует внешних сервисов вроде cron. Идеально для скриптов, ботов, мониторинга и автоматизации.

🛠 pip install schedule

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

🔥 @contextmanager: Создаём свои контекст-менеджеры как профи

from contextlib import contextmanager
import time
import os
from pathlib import Path

@contextmanager
def timer(name: str):
    """Контекст-менеджер для замера времени выполнения блока кода."""
    start = time.time()
    try:
        yield
    finally:
        print(f"⏱️ {name} заняло {time.time() - start:.4f} сек")

@contextmanager
def chdir(path: str):
    """Временно меняет текущую рабочую директорию."""
    old_cwd = os.getcwd()
    try:
        os.chdir(path)
        yield
    finally:
        os.chdir(old_cwd)

if __name__ == "__main__":
    try:
        with timer("Тяжёлая операция"):
            time.sleep(1.2)
        
        with chdir("/tmp") as tmp:
            print(f"Временно в директории: {os.getcwd()}")
        
        print("✅ Контекст-менеджеры сработали!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 @contextmanager из модуля contextlib позволяет создавать свои контекст-менеджеры одной функцией. Идеально для таймеров, временной смены директории, управления ресурсами, транзакций и любой логики «до/после».

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

🔥 Метаклассы: Динамическое создание классов и авто-регистрация плагинов

from typing import Dict, Type

class PluginMeta(type):
    """Метакласс, который автоматически регистрирует все плагины."""
    registry: Dict[str, Type] = {}

    def __new__(mcs, name, bases, attrs):
        cls = super().__new__(mcs, name, bases, attrs)
        if name != "PluginBase":
            mcs.registry[name] = cls
            print(f"🔌 Зарегистрирован плагин: {name}")
        return cls


class PluginBase(metaclass=PluginMeta):
    """Базовый класс для всех плагинов."""
    def run(self):
        raise NotImplementedError("Плагин должен реализовать метод run()")


class DataProcessor(PluginBase):
    """Пример плагина."""
    def run(self):
        print("📊 Обработка данных...")


class ReportGenerator(PluginBase):
    """Ещё один плагин."""
    def run(self):
        print("📄 Генерация отчёта...")


if __name__ == "__main__":
    try:
        print(f"Всего зарегистрировано плагинов: {len(PluginMeta.registry)}")
        
        for name, plugin_cls in PluginMeta.registry.items():
            plugin = plugin_cls()
            plugin.run()
        
        print("\n✅ Все плагины успешно выполнены!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 Метаклассы позволяют контролировать создание классов: автоматически регистрировать плагины, добавлять методы, валидировать атрибуты и многое другое. Это один из самых мощных и «волшебных» инструментов Python для создания фреймворков и плагин-систем.

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

🔥 concurrent.futures: Параллелизм в Python без боли

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List

def cpu_heavy_task(n: int) -> int:
    """Имитация тяжёлой CPU-задачи (вычисление суммы квадратов)."""
    return sum(i * i for i in range(n))

def run_sequential(numbers: List[int]) -> List[int]:
    """Последовательное выполнение (медленно)."""
    return [cpu_heavy_task(n) for n in numbers]

def run_parallel(numbers: List[int], max_workers: int = 4) -> List[int]:
    """Параллельное выполнение с ThreadPoolExecutor."""
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_n = {executor.submit(cpu_heavy_task, n): n for n in numbers}
        for future in as_completed(future_to_n):
            try:
                results.append(future.result())
            except Exception as e:
                print(f"Ошибка в задаче {future_to_n[future]}: {e}")
    return results

if __name__ == "__main__":
    try:
        numbers = [300_000, 400_000, 500_000, 600_000]
        
        print("⏱️  Последовательно:")
        start = time.time()
        seq_result = run_sequential(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {seq_result[:2]}...\n")
        
        print("⚡ Параллельно (4 потока):")
        start = time.time()
        par_result = run_parallel(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {par_result[:2]}...")
        
        print("\n✅ В параллельном режиме значительно быстрее!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 concurrent.futures.ThreadPoolExecutor и ProcessPoolExecutor позволяют легко запускать задачи параллельно. Используйте as_completed(), чтобы получать результаты по мере готовности, и контекстный менеджер — чтобы не забыть закрыть пул. Отлично для IO-bound задач (ThreadPool) и CPU-bound задач (ProcessPool).

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

🔥 concurrent.futures: Параллелизм в Python без боли

import time
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List

def cpu_heavy_task(n: int) -> int:
    """Имитация тяжёлой CPU-задачи (вычисление суммы квадратов)."""
    return sum(i * i for i in range(n))

def run_sequential(numbers: List[int]) -> List[int]:
    """Последовательное выполнение (медленно)."""
    return [cpu_heavy_task(n) for n in numbers]

def run_parallel(numbers: List[int], max_workers: int = 4) -> List[int]:
    """Параллельное выполнение с ThreadPoolExecutor."""
    results = []
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_n = {executor.submit(cpu_heavy_task, n): n for n in numbers}
        for future in as_completed(future_to_n):
            try:
                results.append(future.result())
            except Exception as e:
                print(f"Ошибка в задаче {future_to_n[future]}: {e}")
    return results

if __name__ == "__main__":
    try:
        numbers = [300_000, 400_000, 500_000, 600_000]
        
        print("⏱️  Последовательно:")
        start = time.time()
        seq_result = run_sequential(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {seq_result[:2]}...\n")
        
        print("⚡ Параллельно (4 потока):")
        start = time.time()
        par_result = run_parallel(numbers)
        print(f"Время: {time.time() - start:.2f} сек | Результаты: {par_result[:2]}...")
        
        print("\n✅ В параллельном режиме значительно быстрее!")
    except Exception as e:
        print(f"Ошибка: {e}")

📌 concurrent.futures.ThreadPoolExecutor и ProcessPoolExecutor позволяют легко запускать задачи параллельно. Используйте as_completed(), чтобы получать результаты по мере готовности, и контекстный менеджер — чтобы не забыть закрыть пул. Отлично для IO-bound задач (ThreadPool) и CPU-bound задач (ProcessPool).

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

🔥 BeautifulSoup: Умный парсинг HTML и веб-скрапинг

from bs4 import BeautifulSoup
from typing import List, Dict

# Пример HTML (можно заменить на requests.get(url).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 в удобный объект для поиска по тегам, классам, id и тексту. Никаких регулярных выражений — только понятные методы. Идеально для скрапинга сайтов, парсинга прайсов, новостей и автоматизации сбора данных.

🛠 pip install beautifulsoup4

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

🔥 asyncio: Асинхронное программирование в Python

import asyncio
import time
from typing import List

async def fetch_data(url: str) -> str:
    """Имитация асинхронного запроса к API."""
    print(f"🔄 Запрос к {url}...")
    await asyncio.sleep(1)  # имитация сети
    return f"Данные с {url} получены!"

async def main() -> None:
    """Запускает несколько асинхронных задач параллельно."""
    urls = [
        "https://api.example.com/users",
        "https://api.example.com/posts",
        "https://api.example.com/comments",
        "https://api.example.com/products"
    ]
    
    start = time.time()
    # gather запускает все задачи одновременно
    results = await asyncio.gather(*[fetch_data(url) for url in urls])
    
    print(f"\n✅ Получено {len(results)} ответов за {time.time() - start:.2f} сек")
    for result in results:
        print(f"  • {result}")

if __name__ == "__main__":
    try:
        asyncio.run(main())
    except Exception as e:
        print(f"Ошибка: {e}")

📌 asyncio + await/gather позволяют писать неблокирующий код, который одновременно обрабатывает тысячи запросов, файлов или задач. Это основа современных высоконагруженных сервисов, ботов и веб-приложений на FastAPI/Starlette.

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

🔥 SymPy: Символьная математика и решение уравнений в Python

from sympy import symbols, solve, diff, simplify, integrate
from sympy.abc import x

def math_demo():
    """Примеры возможностей SymPy."""
    # Решение уравнения
    eq = x**2 - 5*x + 6
    roots = solve(eq, x)
    ic("Корни уравнения x²-5x+6=0:", roots)
    
    # Производная
    f = x**3 + 2*x**2 - 5*x + 3
    derivative = diff(f, x)
    ic("Производная:", derivative)
    
    # Упрощение выражения
    expr = (x**2 + 2*x + 1) / (x + 1)
    simplified = simplify(expr)
    ic("Упрощённое выражение:", simplified)
    
    # Интеграл
    integral = integrate(x**2 + 3*x, x)
    ic("Интеграл:", integral)

if __name__ == "__main__":
    try:
        math_demo()
    except Exception as e:
        print(f"Ошибка: {e}")

📌 SymPy — это библиотека для символьной математики. Она может решать уравнения, вычислять производные, интегралы, упрощать выражения, работать с матрицами и даже рисовать графики (sympy.plotting). Идеально для научных расчётов, обучения, симуляций и автоматизации математических задач.

🛠 pip install sympy

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

Один Junior делает больше, чем команда из 7 человек

Я сейчас веду несколько компаний и имею возможность сравнить.

Вот вам две крайности:

Команда 1️⃣ из 7 человек: 2 Middle Back + 1 Middle Front + 2 аналитика + 1 дизайнер + 1 Lead.

Команды 2️⃣ 1 Junior + 1 Product Owner part-time.

Команда 1️⃣ за 12 месяцев сделала 1 продукт размером ~100k LOC.

Команда 2️⃣ за 3 месяца сделала 1 продукт размером ~45k LOC.

Но самое главное: продуктом команды 1️⃣ пользуются всего 2 человека, и это по сути back из мультиагентов + простой Front для ввода данных и генерации.

А продуктом команды 2️⃣ пользуются уже 30 человек, и это очень сложная scalable-система автономных агентов.

Я к чему это пишу: это все происходит одновременно, прямо сейчас во многих компаниях.

Ключевое преимущество команды 2️⃣ — дикое количество итераций: до 30 в день выкаток (фич/фиксов) на Prod.

Product придумал — LLM все нарисовала — Junior через Cursor сделал весь Back — LLM протестила — выкатили — и повторить ~ 20 минут.

В идеале команда должна вообще состоять из Product Owner + LLM. Но Junior за 1/12 от стоимости команды 1️⃣ вполне себя очень даже окупает.

Вот и думайте 🙂

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

Некогда объяснять, регистрируйся пока не поздно 🏃🏃‍♀️

Похоже количество серверов в мире очень ограничено, поэтому только сегодня ограниченный drop промокодов на регистрацию в DarwinClaw.

Действует только сегодня 🚨 до 23:59 МСК.

Кол-во регистраций по промокоду сильно ограничено, из-за ограничений по серверам для запуска ваших ИИ-ассистентов.

Зачем оно вам?

Если вы давно хотели, чтобы у каждого сотрудника появился свой персональный ИИ-ассистент (в духе OpenClaw), который работает прямо в Telegram, знает документы компании и соблюдает ваши правила, сейчас хороший момент.

Всё запускается в один клик 🔥

Промокод (он же инвайт-код) DARWINCLAW-KODDUU-500-30. Регистрируемся тут 👉 https://darwinclaw.ru/register 👈

Детали по самому сервису тут 👉 https://darwinclaw.ru/ 👈

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

🔥 NetworkX: Графы и алгоритмы в Python

import networkx as nx
from typing import List, Tuple

def build_and_analyze_graph() -> None:
    """Пример работы с графами: города и дороги."""
    G = nx.Graph()
    
    # Добавляем узлы (города) и рёбра (дороги)
    G.add_edges_from([
        ("Москва", "Питер", {"distance": 700}),
        ("Москва", "Казань", {"distance": 800}),
        ("Питер", "Новгород", {"distance": 200}),
        ("Казань", "Екатеринбург", {"distance": 900}),
        ("Новгород", "Екатеринбург", {"distance": 1200}),
    ])
    
    # Кратчайший путь
    path = nx.shortest_path(G, "Москва", "Екатеринбург", weight="distance")
    distance = nx.shortest_path_length(G, "Москва", "Екатеринбург", weight="distance")
    
    print("📍 Кратчайший путь Москва → Екатеринбург:", " → ".join(path))
    print(f"Расстояние: {distance} км\n")
    
    # Центральность узлов
    centrality = nx.degree_centrality(G)
    print("🔝 Самые связанные города:")
    for city, cent in sorted(centrality.items(), key=lambda x: x[1], reverse=True):
        print(f"  • {city}: {cent:.2f}")

if __name__ == "__main__":
    try:
        build_and_analyze_graph()
    except Exception as e:
        print(f"Ошибка: {e}")

📌 NetworkX — мощная библиотека для работы с графами: построение, поиск кратчайших путей, центральность, сообщества, визуализация и тысячи алгоритмов. Идеально для транспортных сетей, рекомендаций, социальных графов и анализа связей.

🛠 pip install networkx

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