Python v mobilním vývoji: automatizace, AI a ML

Co je Python?

Python — interpretovaný jazyk s dynamickým silným typováním a automatickou správou paměti. Vytvořil ho Guido van Rossum v roce 1991. Filozofie jazyka (The Zen of Python) propaguje čitelnost kódu: „explicitní je lepší než implicitní”, „jednoduché je lepší než složité”. Python 3.12+ podporuje porovnávání vzorů (match-case) a vylepšené generiky.

Standardní knihovna Pythonu obsahuje moduly pro práci s JSON (json), HTTP (urllib), archivy (zipfile), regulárními výrazy (re) a databázemi (sqlite3). Třetí strana — desítky tisíc balíčků v PyPI s celkovým počtem stažení přes 500 miliard. PyPI (Python Package Index) — největší úložiště balíčků Pythonu.

Python používá interpret CPython napsaný v C. Alternativní implementace: PyPy (JIT kompilace, 2–5krát rychlejší pro čistý Python), Cython (kompilace Pythonu do C), Numba (JIT pro numerické výpočty). Pro mobilní skripty stačí CPython — rychlost interpretace není pro úkoly automatizace kritická.

Verze Pythonu

Python 2 ukončil podporu v roce 2020. Všechny moderní projekty používají Python 3. Aktuální verze je 3.13 (2025) s vylepšeným JIT kompilátorem a experimentální podporou volných vláken (free-threaded Python). Pro mobilní vývoj je stabilní verze 3.11–3.12, kompatibilní se všemi hlavními knihovnami.

Python pro automatizaci mobilního vývoje

Python — hlavní jazyk pro skripty automatizace v mobilním vývoji. Používá se pro sestavení APK a IPA, zpracování textových zdrojů, generování obrazovek z návrhů a nasazení do obchodů s aplikacemi. Podle údajů Bitrise (2025) více než 60% CI/CD pipeline mobilních aplikací zahrnuje kroky v Pythonu.

Nejčastější scénář — Fastlane s Ruby nepokrývá všechny potřeby a Python ho doplňuje: složitá logika zpracování obrazu, práce s API App Store Connect, parsování zpráv Xcode a generování snímků obrazovky. Skripty Pythonu se volají pomocí sh kroků v Fastfile nebo přímo v GitHub Actions.

# Skript pro automatickou změnu velikosti snímků obrazovky aplikace
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Změní velikost všech PNG snímků na požadovanou velikost obchodu."""
    for filename in os.listdir(input_dir):
        if not filename.lower().endswith(".png"):
            continue
        path = os.path.join(input_dir, filename)
        img = Image.open(path)
        resized = img.resize(size, Image.LANCZOS)
        out_path = os.path.join(output_dir, filename)
        resized.save(out_path, "PNG")
        print(f"Resized {filename} -> {out_path}")

resize_screenshots("screenshots_raw", "screenshots_resized", (1242, 2208))

V příkladu skript prochází všechny PNG soubory ve složce, mění jejich velikost na velikost iPhone 6.5" (1242x2208) s filtrem LANCZOS pro nejlepší kvalitu. f-řetězec v print dosazuje název souboru. Tento skript šetří hodiny ruční práce při přípravě obchodu.

Zpracování Android zdrojů

Pro Android je Python užitečný při zpracování textových zdrojů (strings.xml), generování souborů dimen pro různé hustoty obrazovky a převodu vektorové grafiky. LXML a xml.etree.ElementTree umožňují parsování a úpravu XML zdrojů Androidu.

# Generování strings.xml z CSV souboru s překlady
import csv
from xml.etree import ElementTree as ET
from xml.dom import minidom

def csv_to_strings(csv_path: str, lang: str) -> str:
    root = ET.Element("resources")
    with open(csv_path, "r") as f:
        reader = csv.DictReader(f)
        for row in reader:
            el = ET.SubElement(root, "string")
            el.set("name", row["key"])
            el.text = row[lang]
    rough = ET.tostring(root, encoding="unicode")
    parsed = minidom.parseString(rough.encode())
    return parsed.toprettyxml(indent="  ")

print(csv_to_strings("translations.csv", "ru"))

Python v AI a ML: trénování modelů pro mobilní platformy

Python — hlavní jazyk pro strojové učení. TensorFlow, PyTorch, scikit-learn, JAX a Hugging Face Transformers jsou napsány pro Python. Mobilní vývojáři používají Python k trénování modelů, které se poté převádějí do TFLite (Android) nebo Core ML (iOS) pro spuštění na zařízení.

TensorFlow Lite — framework Google pro strojové učení na zařízení. Model natrénovaný v Pythonu se převede do .tflite pomocí TensorFlow Converter a načte se do Android aplikace přes Interpreter API. Pro iOS existuje podobná pipeline přes PyTorch -> Core ML.

# Trénování jednoduchého modelu pro klasifikaci gest
import tensorflow as tf
from tensorflow import keras

model = keras.Sequential([
    keras.layers.Input(shape=(64, 64, 3)),
    keras.layers.Conv2D(32, (3, 3), activation="relu"),
    keras.layers.MaxPooling2D(2, 2),
    keras.layers.Conv2D(64, (3, 3), activation="relu"),
    keras.layers.Flatten(),
    keras.layers.Dense(128, activation="relu"),
    keras.layers.Dropout(0.2),
    keras.layers.Dense(4, activation="softmax")
])

model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])

# Převod do TFLite po trénování
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open("gesture_model.tflite", "wb") as f:
    f.write(tflite_model)

print(f"Model size: {len(tflite_model)} bytes")

Model Sequential obsahuje dvě konvoluční vrstvy (Conv2D) s poolingem, plně propojenou vrstvu (Dense) a Dropout pro regularizaci. Po převodu zabírá model .tflite 4–6krát méně místa než původní SavedModel a běží na mobilním CPU nebo GPU.

Edge ML a federované učení

Moderní přístup — trénování přímo na zařízení přes TensorFlow Federated nebo MLX (Apple). Skript v Pythonu definuje architekturu a trénování probíhá na datech uživatele bez odesílání na server. To zvyšuje soukromí, ale je náročnější na implementaci. Většina projektů používá klasickou pipeline: trénování v Pythonu -> TFLite -> inference na zařízení.

Python pro serverovou část mobilních aplikací

Python — populární volba pro backend mobilních aplikací. Django REST Framework (DRF) a FastAPI umožňují rychle vytvořit REST API nebo GraphQL server. Backend v Pythonu zpracovává požadavky od mobilních klientů, spravuje autentizaci a synchronizuje data přes WebSocket.

FastAPI — moderní framework s asynchronní podporou, automatickým generováním specifikace OpenAPI a validací přes Pydantic. Výkon FastAPI je srovnatelný s Node.js a Go — až 10 000 požadavků/s na jednom jádře. Pro mobilní backend se FastAPI volí pro rychlost vývoje a vestavěnou dokumentaci.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List
import sqlite3

app = FastAPI(title="Mobile App API")

class UserCreate(BaseModel):
    username: str
    email: str
    avatar_url: str | None = None

@app.post("/users", status_code=201)
async def create_user(payload: UserCreate):
    conn = sqlite3.connect("app.db")
    cur = conn.execute(
        "INSERT INTO users (username, email) VALUES (?, ?)",
        (payload.username, payload.email)
    )
    conn.commit()
    user_id = cur.lastrowid
    conn.close()
    return {"id": user_id, "username": payload.username}

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    conn = sqlite3.connect("app.db")
    row = conn.execute(
        "SELECT id, username, email FROM users WHERE id = ?",
        (user_id,)
    ).fetchone()
    conn.close()
    if not row:
        raise HTTPException(status_code=404, detail="User not found")
    return {"id": row[0], "username": row[1], "email": row[2]}

Model Pydantic UserCreate validuje vstupní data: username a email jsou povinné řetězce, avatar_url je volitelný. Asynchronní endpointy (async def) neblokují server při čekání na databázi. Stavový kód 201 se vrací při úspěšném vytvoření uživatele.

WebSocket pro real-time

Python podporuje WebSocket přes FastAPI WebSocket nebo knihovnu websockets. Pro chaty, oznámení v reálném čase a společné úpravy je WebSocket optimální transport. FastAPI používá asyncpg pro asynchronní práci s PostgreSQL a aioredis pro ukládání do mezipaměti.

Python pro prototypování a testování nápadů

Python je nepostradatelný pro rychlé prototypování. Vývojář může napsat prototyp API na Flasku za 15 minut a otestovat nápad na uživatelích, než ho implementuje v Kotlin/Swift pro produkci. Náklady na chybu ve fázi prototypu jsou minimální a čas ověření hypotézy se zkracuje z týdnů na hodiny.

Nástroje pro prototypování: Flask (minimální REST), Streamlit (dashboardy), Jupyter Notebooks (analýza dat), Flet a Kivy (mobilní MVP). Prototyp v Pythonu se často stává specifikací pro produkční implementaci: datové typy, obchodní logika a testy se přenášejí do Kotlin nebo Swift.

Skripty pro testování výkonu

Python se používá pro zátěžové testování mobilního API přes Locust — framework pro simulaci tisíců uživatelů. Skript Locust popisuje scénář chování uživatele a webové rozhraní zobrazuje RPS, latence a percentily.

from locust import HttpUser, task, between

class MobileApiUser(HttpUser):
    wait_time = between(1, 5)

    @task(2)
    def get_posts(self):
        self.client.get("/api/v1/posts?page=1")

    @task(1)
    def create_post(self):
        self.client.post("/api/v1/posts", json={
            "title": "Test",
            "body": "Content"
        })

@task(2) označuje váhu — požadavek GET /posts se provádí dvakrát častěji než POST /posts. wait_time simuluje pauzu 1–5 sekund mezi požadavky. Locust se spouští z příkazového řádku a zobrazuje výsledky v reálném čase přes webové rozhraní na portu 8089.

Python vs Kotlin a Swift: kdy co vybrat

Python a nativní jazyky mobilního vývoje řeší různé úkoly. Kotlin a Swift — pro UI, navigaci a přímý přístup k API platformy. Python — pro automatizaci, AI/ML, serverovou logiku a prototypování. Porovnáme podle klíčových parametrů.

Optimální architektura: Python pro trénování AI modelů, skripty CI/CD a serverovou část, Kotlin/Swift pro UI a nativní integraci.

Typické chyby při použití Pythonu v mobilním vývoji

První chyba — použití nesprávné verze Pythonu. Na macOS je předinstalován Python 3.9, ale pro skripty automatizace je potřeba verze stanovená přes pyenv nebo .python-version. Rozdíl mezi 3.9 a 3.12 může zlomit syntaxi (např. match-case je dostupný až od 3.10).

Druhá typická chyba — ignorování virtuálního prostředí. Závislosti Pythonu globálně kolidují mezi projekty. Používejte venv nebo poetry pro izolaci. Soubor requirements.txt nebo pyproject.toml by měl být v úložišti pro reprodukovatelnost sestavení.

Chybějící zpracování chyb — třetí běžný problém. Skript, který selže při chybějícím souboru nebo síťové chybě, zastaví celou CI/CD pipeline. Používejte try-except-finally, protokolování přes modul logging a vracejte nenulový kód při chybě (sys.exit(1)).

Míchání syntaxe Python 2 a Python 3 — další chyba. print bez závorek, staré except Exception, e a xrange fungovaly v Python 2, ale ne v Python 3. Vždy kontrolujte kód přes flake8 a mypy pro statickou analýzu typů.

# Nejlepší praxe: zpracování chyb v automatizačním skriptu
import sys
import logging
from pathlib import Path

logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
log = logging.getLogger(__name__)

def build_apk(project_dir: str) -> bool:
    path = Path(project_dir)
    if not path.exists():
        log.error(f"Directory {project_dir} not found")
        return False
    try:
        # zde příkaz sestavení
        log.info("Build started")
        return True
    except Exception as e:
        log.exception(f"Build failed: {e}")
        return False

if __name__ == "__main__":
    success = build_apk("android/app")
    sys.exit(0 if success else 1)