Python v produkci: Architektura, výkon a best practices pro 2026¶

Python dominuje v AI/ML, data engineeringu, automatizaci i backendu. Ale přechod z Jupyter notebooku do produkce vyžaduje disciplínu. Tento průvodce shrnuje osvědčené přístupy pro rok 2026.

Architektura produkčního Python projektu¶

my-project/
├── src/
│   └── myproject/
│       ├── __init__.py          # Verze, public API
│       ├── core/                # Business logika (čistý Python)
│       │   ├── models.py        # Dataclasses, Pydantic modely
│       │   ├── engine.py        # Hlavní výpočetní logika
│       │   └── validators.py    # Validace, constraints
│       ├── adapters/            # Vstup/výstup (DB, API, soubory)
│       │   ├── database.py
│       │   ├── api_client.py
│       │   └── file_handler.py
│       ├── services/            # Orchestrace (spojuje core + adapters)
│       │   └── pipeline.py
│       └── cli/                 # CLI rozhraní
│           └── main.py
├── tests/
│   ├── unit/                    # Rychlé, izolované
│   ├── integration/             # S externími závislostmi
│   └── conftest.py
├── pyproject.toml               # Jediný konfigurační soubor
├── Dockerfile
├── Makefile
└── README.md

Klíčové principy¶

1. Separace I/O od logiky — core/ nemá žádné importy externích služeb
2. Dependency injection — adaptéry se předávají jako parametry, ne jako globální importy
3. Dataclasses všude — typované datové struktury místo diktů
4. Jeden vstupní bod — CLI nebo API, nikdy oba v jednom modulu

Typing — povinnost, ne luxus¶

Python 3.12+ přináší vyspělý typový systém. V roce 2026 netypovaný kód nepatří do produkce.

from dataclasses import dataclass
from typing import Optional, Protocol
from collections.abc import Sequence


# Dataclass místo dict
@dataclass(frozen=True, slots=True)
class TradeSignal:
    symbol: str
    direction: float  # -1.0 to 1.0
    strength: float   # 0.0 to 1.0
    strategy: str
    timestamp: str

    def __post_init__(self):
        if not -1 <= self.direction <= 1:
            raise ValueError(f"direction must be [-1, 1], got {self.direction}")
        if not 0 <= self.strength <= 1:
            raise ValueError(f"strength must be [0, 1], got {self.strength}")


# Protocol místo ABC (structural typing)
class DataFetcher(Protocol):
    def fetch_ohlcv(self, symbol: str, timeframe: str, limit: int) -> list[dict]: ...
    def fetch_ticker(self, symbol: str) -> dict: ...


# Generické funkce s přesnými typy
def combine_signals(
    signals: Sequence[TradeSignal],
    weights: Optional[dict[str, float]] = None,
) -> TradeSignal:
    """Kombinuje signály z více strategií."""
    if not signals:
        raise ValueError("No signals to combine")

    total_weight = 0.0
    weighted_dir = 0.0

    for sig in signals:
        w = (weights or {}).get(sig.strategy, 1.0)
        weighted_dir += sig.direction * sig.strength * w
        total_weight += w

    avg_direction = weighted_dir / total_weight if total_weight > 0 else 0.0

    return TradeSignal(
        symbol=signals[0].symbol,
        direction=max(-1.0, min(1.0, avg_direction)),
        strength=abs(avg_direction),
        strategy="ensemble",
        timestamp=signals[0].timestamp,
    )

Nástroje pro typing¶

Nástroj	Účel	Doporučení
mypy	Static type checker	--strict mode v CI
pyright	Rychlejší alternativa	VS Code integrace
Pydantic v2	Runtime validace + serialization	Pro API modely
beartype	Runtime type checking (dekorátor)	Pro critical paths

# pyproject.toml — mypy strict mode
[tool.mypy]
python_version = "3.12"
strict = true
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true

Výkon — Python nemusí být pomalý¶

NumPy/Pandas vektorizace¶

# ❌ Pomalé — Python loop
def slow_moving_average(prices: list[float], window: int) -> list[float]:
    result = []
    for i in range(len(prices)):
        if i < window:
            result.append(float('nan'))
        else:
            result.append(sum(prices[i-window:i]) / window)
    return result

# ✅ Rychlé — NumPy vektorizace (100-1000× rychlejší)
import numpy as np

def fast_moving_average(prices: np.ndarray, window: int) -> np.ndarray:
    cumsum = np.cumsum(np.insert(prices, 0, 0))
    return (cumsum[window:] - cumsum[:-window]) / window

Profiling a optimalizace¶

# cProfile pro identifikaci bottlenecků
python -m cProfile -s cumtime my_script.py

# line_profiler pro řádkovou analýzu
kernprof -l -v my_script.py

# memory_profiler pro paměťové úniky
python -m memory_profiler my_script.py

Kdy sáhnout po C rozšířeních¶

Situace	Řešení
Numerické výpočty	NumPy, SciPy (už v C)
Custom hot loop	numba JIT compilation
Datové transformace	Polars (Rust backend)
Paralelismus	multiprocessing, concurrent.futures
I/O bound	asyncio, httpx
Opravdu kritické	Cython, PyO3 (Rust)

# Numba — JIT kompilace pro numerický kód
from numba import njit

@njit
def fast_ewma(data: np.ndarray, alpha: float) -> np.ndarray:
    result = np.empty_like(data)
    result[0] = data[0]
    for i in range(1, len(data)):
        result[i] = alpha * data[i] + (1 - alpha) * result[i-1]
    return result

Testování — pyramida, ne ledovec¶

         /\
        /  \   E2E (5%)
       /    \
      / Integ \ Integration (15%)
     /  ration  \
    /____________\
   /   Unit Tests  \  Unit (80%)
  /________________\

# conftest.py — fixtures pro dependency injection
import pytest
from unittest.mock import AsyncMock

@pytest.fixture
def mock_fetcher():
    fetcher = AsyncMock()
    fetcher.fetch_ohlcv.return_value = [
        {"open": 100, "high": 105, "low": 98, "close": 103, "volume": 1000}
    ]
    return fetcher

@pytest.fixture
def engine(mock_fetcher):
    from myproject.core.engine import TradingEngine
    return TradingEngine(fetcher=mock_fetcher)


# test_engine.py — čisté unit testy
def test_signal_generation(engine):
    signal = engine.generate_signal("BTC/USDT")
    assert -1 <= signal.direction <= 1
    assert 0 <= signal.strength <= 1


# Parametrized testy
@pytest.mark.parametrize("direction,expected", [
    (0.8, "long"),
    (-0.8, "short"),
    (0.1, "flat"),
])
def test_signal_action(direction, expected):
    assert signal_to_action(direction, threshold=0.3) == expected

CI pipeline¶

# GitHub Actions
name: CI
on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.11", "3.12", "3.13"]
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - run: pip install -e ".[dev]"
      - run: mypy src/ --strict
      - run: ruff check src/ tests/
      - run: pytest tests/ -v --cov=src --cov-report=xml
      - run: pytest tests/integration/ -v -m integration

Packaging — pyproject.toml je standard¶

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "my-trading-framework"
version = "0.3.0"
description = "Quantitative trading framework"
requires-python = ">=3.11"
dependencies = [
    "numpy>=1.26",
    "pandas>=2.1",
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "mypy>=1.8",
    "ruff>=0.2",
    "pytest-cov",
]
exchange = [
    "ccxt>=4.0",
]

[tool.ruff]
target-version = "py312"
line-length = 100
select = ["E", "F", "I", "UP", "B", "SIM"]

[tool.pytest.ini_options]
testpaths = ["tests"]
markers = [
    "integration: marks tests requiring external services",
]

Deployment¶

Docker multi-stage build¶

# Build stage
FROM python:3.12-slim AS builder
WORKDIR /app
COPY pyproject.toml .
RUN pip install --no-cache-dir build && \
    pip wheel --no-cache-dir --wheel-dir /wheels -e ".[exchange]"

# Runtime stage
FROM python:3.12-slim
WORKDIR /app
COPY --from=builder /wheels /wheels
RUN pip install --no-cache-dir /wheels/*.whl && rm -rf /wheels
COPY src/ src/
USER nobody
CMD ["python", "-m", "myproject.cli.main"]

Monitoring v produkci¶

import structlog
import time
from functools import wraps

logger = structlog.get_logger()

def monitor(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        try:
            result = func(*args, **kwargs)
            duration = time.perf_counter() - start
            logger.info("function_completed",
                function=func.__name__,
                duration_ms=round(duration * 1000, 2),
            )
            return result
        except Exception as e:
            duration = time.perf_counter() - start
            logger.error("function_failed",
                function=func.__name__,
                error=str(e),
                duration_ms=round(duration * 1000, 2),
            )
            raise
    return wrapper

Závěr¶

Produkční Python v roce 2026 vyžaduje:

1. Striktní typing — mypy strict v CI, dataclasses všude
2. Čistá architektura — separace I/O od logiky
3. Vektorizace — NumPy/Polars pro numerické operace
4. Automatizace kvality — ruff + mypy + pytest v každém commitu
5. Kontejnerizace — multi-stage Docker, nobody user

Python zůstává dominantním jazykem pro data a AI. S disciplínou je připravený i na kritické produkční systémy.

---

Potřebujete pomoc s architekturou Python aplikace? Kontaktujte nás pro konzultaci.