Python w programowaniu mobilnym: automatyzacja, AI i ML

Czym jest Python?

Python — interpretowany język z dynamicznym silnym typowaniem i automatycznym zarządzaniem pamięcią. Stworzony przez Guido van Rossuma w 1991 roku. Filozofia języka (The Zen of Python) propaguje czytelność kodu: „jawne jest lepsze niż niejawne”, „proste jest lepsze niż złożone”. Python 3.12+ obsługuje dopasowywanie wzorców (match-case) i ulepszone generyki.

Standardowa biblioteka Pythona zawiera moduły do pracy z JSON (json), HTTP (urllib), archiwami (zipfile), wyrażeniami regularnymi (re) i bazami danych (sqlite3). Strony trzecie — dziesiątki tysięcy pakietów w PyPI z łączną liczbą pobrań ponad 500 miliardów. PyPI (Python Package Index) — największe repozytorium pakietów Pythona.

Python używa interpretera CPython napisanego w C. Alternatywne implementacje: PyPy (kompilacja JIT, 2–5 razy szybszy dla czystego Pythona), Cython (kompilacja Pythona do C), Numba (JIT dla obliczeń numerycznych). Do skryptów mobilnych wystarcza CPython — szybkość interpretacji nie jest krytyczna dla zadań automatyzacji.

Wersje Pythona

Python 2 zakończył wsparcie w 2020 roku. Wszystkie nowoczesne projekty używają Pythona 3. Aktualna wersja to 3.13 (2025) z ulepszonym kompilatorem JIT i eksperymentalną obsługą wolnych wątków (free-threaded Python). Do programowania mobilnego stabilna jest wersja 3.11–3.12, kompatybilna ze wszystkimi głównymi bibliotekami.

Python do automatyzacji programowania mobilnego

Python — główny język do skryptów automatyzacji w programowaniu mobilnym. Jest używany do kompilacji APK i IPA, przetwarzania zasobów tekstowych, generowania ekranów z projektów i wdrażania w sklepach z aplikacjami. Według danych Bitrise (2025), ponad 60% CI/CD pipeline'ów aplikacji mobilnych zawiera kroki w Pythonie.

Najczęstszy scenariusz — Fastlane w Ruby nie zaspokaja wszystkich potrzeb, a Python go uzupełnia: złożona logika przetwarzania obrazów, praca z API App Store Connect, parsowanie raportów Xcode i generowanie zrzutów ekranu. Skrypty Pythona są wywoływane przez sh-kroki w Fastfile lub bezpośrednio w GitHub Actions.

# Skrypt do automatycznej zmiany rozmiaru zrzutów ekranu aplikacji
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Zmienia rozmiar wszystkich zrzutów PNG do wymaganego rozmiaru sklepu."""
    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))

W przykładzie skrypt przechodzi przez wszystkie pliki PNG w folderze, zmienia ich rozmiar do rozmiaru iPhone 6.5" (1242x2208) z filtrem LANCZOS dla najlepszej jakości. f-string w print podstawia nazwę pliku. Ten skrypt oszczędza godziny ręcznej pracy przy przygotowaniu sklepu.

Przetwarzanie zasobów Androida

Dla Androida Python jest przydatny przy przetwarzaniu zasobów tekstowych (strings.xml), generowaniu plików dimen dla różnych gęstości ekranu i konwersji grafiki wektorowej. LXML i xml.etree.ElementTree pozwalają parsować i modyfikować XML-owe zasoby Androida.

# Generowanie strings.xml z pliku CSV z tłumaczeniami
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 w AI i ML: uczenie modeli dla platform mobilnych

Python — główny język do uczenia maszynowego. TensorFlow, PyTorch, scikit-learn, JAX i Hugging Face Transformers są napisane dla Pythona. Programiści mobilni używają Pythona do uczenia modeli, które następnie są konwertowane do TFLite (Android) lub Core ML (iOS) do wykonywania na urządzeniu.

TensorFlow Lite — framework Google do uczenia maszynowego na urządzeniu. Model wytrenowany w Pythonie jest konwertowany do .tflite przez TensorFlow Converter i ładowany do aplikacji Android przez Interpreter API. Dla iOS analogiczny pipeline przez PyTorch -> Core ML.

# Uczenie prostego modelu do klasyfikacji gestów
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"])

# Konwersja do TFLite po uczeniu
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 zawiera dwie warstwy splotowe (Conv2D) z poolingiem, warstwę w pełni połączoną (Dense) i Dropout do regularyzacji. Po konwersji model .tflite zajmuje 4–6 razy mniej miejsca niż oryginalny SavedModel i działa na mobilnym CPU lub GPU.

Edge ML i federated learning

Nowoczesne podejście — uczenie bezpośrednio na urządzeniu przez TensorFlow Federated lub MLX (Apple). Skrypt w Pythonie określa architekturę, a uczenie odbywa się na danych użytkownika bez wysyłania na serwer. Zwiększa to prywatność, ale jest trudniejsze w implementacji. Większość projektów używa klasycznego pipeline'u: uczenie w Pythonie -> TFLite -> inferencja na urządzeniu.

Python dla serwerowej części aplikacji mobilnych

Python — popularny wybór na backend aplikacji mobilnych. Django REST Framework (DRF) i FastAPI pozwalają szybko stworzyć REST API lub serwer GraphQL. Backend w Pythonie obsługuje żądania od klientów mobilnych, zarządza uwierzytelnianiem i synchronizuje dane przez WebSocket.

FastAPI — nowoczesny framework z asynchronicznym wsparciem, automatyczną generacją specyfikacji OpenAPI i walidacją przez Pydantic. Wydajność FastAPI jest porównywalna z Node.js i Go — do 10 000 żądań/sek na jednym rdzeniu. Do backendu mobilnego FastAPI wybiera się za szybkość tworzenia i wbudowaną dokumentację.

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 waliduje dane wejściowe: username i email to wymagane ciągi, avatar_url jest opcjonalny. Asynchroniczne endpointy (async def) nie blokują serwera podczas oczekiwania na bazę danych. Kod statusu 201 jest zwracany przy pomyślnym utworzeniu użytkownika.

WebSocket dla real-time

Python obsługuje WebSocket przez FastAPI WebSocket lub bibliotekę websockets. Do czatów, powiadomień w czasie rzeczywistym i wspólnego edytowania WebSocket jest optymalnym transportem. FastAPI używa asyncpg do asynchronicznej pracy z PostgreSQL i aioredis do buforowania.

Python do prototypowania i testowania pomysłów

Python jest niezastąpiony do szybkiego prototypowania. Programista może napisać prototyp API na Flasku w 15 minut i przetestować pomysł na użytkownikach, zanim zaimplementuje go w Kotlin/Swift na produkcję. Koszt błędu na etapie prototypu jest minimalny, a czas weryfikacji hipotezy skraca się z tygodni do godzin.

Narzędzia do prototypowania: Flask (minimalne REST), Streamlit (dashboardy), Jupyter Notebooks (analiza danych), Flet i Kivy (mobilne MVP). Prototyp w Pythonie często staje się specyfikacją dla implementacji produkcyjnej: typy danych, logika biznesowa i testy są przenoszone do Kotlin lub Swift.

Skrypty do testowania wydajności

Python jest używany do testowania obciążeniowego mobilnego API przez Locust — framework do symulacji tysięcy użytkowników. Skrypt Locust opisuje scenariusz zachowania użytkownika, a interfejs webowy pokazuje RPS, opóźnienia i percentyle.

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) określa wagę — żądanie GET /posts jest wykonywane dwa razy częściej niż POST /posts. wait_time symuluje pauzę 1–5 sekund między żądaniami. Locust uruchamia się z wiersza poleceń i pokazuje wyniki w czasie rzeczywistym przez interfejs webowy na porcie 8089.

Python vs Kotlin i Swift: kiedy co wybrać

Python i natywne języki programowania mobilnego rozwiązują różne zadania. Kotlin i Swift — do UI, nawigacji i bezpośredniego dostępu do API platformy. Python — do automatyzacji, AI/ML, logiki serwerowej i prototypowania. Porównajmy według kluczowych parametrów.

Optymalna architektura: Python do uczenia modeli AI, skryptów CI/CD i części serwerowej, Kotlin/Swift do UI i integracji natywnej.

Typowe błędy przy użyciu Pythona w programowaniu mobilnym

Pierwszy błąd — używanie niewłaściwej wersji Pythona. Na macOS preinstalowany jest Python 3.9, ale do skryptów automatyzacji potrzebna jest wersja ustalona przez pyenv lub .python-version. Różnica między 3.9 a 3.12 może złamać składnię (np. match-case jest dostępny dopiero od 3.10).

Drugi typowy błąd — ignorowanie wirtualnego środowiska. Zależności Pythona globalnie kolidują między projektami. Używaj venv lub poetry do izolacji. Plik requirements.txt lub pyproject.toml powinien znajdować się w repozytorium dla odtwarzalności kompilacji.

Brak obsługi błędów — trzeci powszechny problem. Skrypt, który pada przy braku pliku lub błędzie sieciowym, zatrzymuje cały pipeline CI/CD. Używaj try-except-finally, logowania przez moduł logging i zwracaj niezerowy kod przy błędzie (sys.exit(1)).

Mieszanie składni Pythona 2 i 3 — kolejny błąd. print bez nawiasów, stary except Exception, e i xrange działały w Python 2, ale nie w Python 3. Zawsze sprawdzaj kod przez flake8 i mypy do statycznej analizy typów.

# Najlepsza praktyka: obsługa błędów w skrypcie automatyzacji
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:
        # tutaj polecenie kompilacji
        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)