Python a mobilfejlesztésben: automatizálás, AI és ML

Mi a Python?

Python — interpretált nyelv dinamikus erős típusozással és automatikus memóriakezeléssel. Guido van Rossum alkotta 1991-ben. A nyelv filozófiája (The Zen of Python) a kód olvashatóságát hirdeti: „a kifejezett jobb, mint a hallgatólagos”, „az egyszerű jobb, mint a bonyolult”. A Python 3.12+ támogatja a mintailesztést (match-case) és a továbbfejlesztett generikusokat.

A Python szabványos könyvtára modulokat tartalmaz JSON (json), HTTP (urllib), archívumok (zipfile), reguláris kifejezések (re) és adatbázisok (sqlite3) kezeléséhez. Harmadik fél — több tízezer csomag a PyPI-ben, összesen több mint 500 milliárd letöltéssel. PyPI (Python Package Index) — a Python-csomagok legnagyobb tárháza.

A Python a C-ben írt CPython értelmezőt használja. Alternatív implementációk: PyPy (JIT-fordítás, 2–5-ször gyorsabb tiszta Python esetén), Cython (Python fordítása C-be), Numba (JIT numerikus számításokhoz). Mobil szkriptekhez a CPython elegendő — az értelmezés sebessége nem kritikus az automatizálási feladatoknál.

Python verziók

A Python 2 támogatása 2020-ban megszűnt. Minden modern projekt Python 3-at használ. A jelenlegi verzió — 3.13 (2025) továbbfejlesztett JIT fordítóval és kísérleti szabad szálak (free-threaded Python) támogatással. Mobilfejlesztéshez a 3.11–3.12 verzió stabil, kompatibilis az összes fő könyvtárral.

Python a mobilfejlesztés automatizálásához

Python — a fő nyelv az automatizálási szkriptekhez a mobilfejlesztésben. APK és IPA build-elésére, szöveges erőforrások feldolgozására, képernyők generálására tervekből és alkalmazásboltokba történő telepítésre használják. A Bitrise (2025) adatai szerint a mobilalkalmazások CI/CD pipeline-jainak több mint 60%-a tartalmaz Python lépéseket.

A leggyakoribb forgatókönyv — a Fastlane Ruby-val nem fed le minden igényt, és a Python kiegészíti azt: összetett képfeldolgozási logika, App Store Connect API-val való munka, Xcode jelentések elemzése és képernyőképek generálása. A Python szkripteket sh-lépéseken keresztül hívják meg a Fastfile-ban vagy közvetlenül a GitHub Actions-ben.

# Szkript az alkalmazás képernyőképeinek automatikus átméretezéséhez
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Az összes PNG képernyőképet átméretezi a kívánt boltméretre."""
    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))

A példában a szkript végigmegy az összes PNG fájlon a mappában, átméretezi azokat iPhone 6.5" (1242x2208) méretűre LANCZOS szűrővel a legjobb minőség érdekében. A print-ben lévő f-string behelyettesíti a fájlnevet. Ez a szkript óráknyi kézi munkát takarít meg a bolt előkészítésekor.

Android erőforrások feldolgozása

Android esetén a Python hasznos a szöveges erőforrások (strings.xml) feldolgozásában, dimen fájlok generálásában különböző képernyősűrűségekhez és vektorgrafika konvertálásában. Az LXML és xml.etree.ElementTree lehetővé teszi az Android XML erőforrásainak elemzését és módosítását.

# Strings.xml generálása CSV-fájlból fordításokkal
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 az AI-ban és ML-ben: modellek tanítása mobil platformokhoz

Python — a fő nyelv a gépi tanuláshoz. A TensorFlow, PyTorch, scikit-learn, JAX és Hugging Face Transformers Python-ra íródtak. A mobilfejlesztők Python-t használnak modellek tanításához, amelyeket aztán TFLite-ba (Android) vagy Core ML-be (iOS) konvertálnak eszközön történő végrehajtáshoz.

TensorFlow Lite — a Google keretrendszere eszközön végzett gépi tanuláshoz. A Python-ban tanított modellt a TensorFlow Converter konvertálja .tflite formátumba, és az Interpreter API-n keresztül tölti be az Android alkalmazásba. iOS esetén hasonló pipeline működik PyTorch -> Core ML útvonalon.

# Egyszerű modell tanítása gesztusok osztályozásához
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"])

# Konvertálás TFLite-ba tanítás utá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")

A Sequential modell két konvolúciós réteget (Conv2D) tartalmaz pooling-gal, egy teljesen összekötött réteget (Dense) és Dropout-ot regularizációhoz. A konvertálás után a .tflite modell 4–6-szor kevesebb helyet foglal, mint az eredeti SavedModel, és mobil CPU-n vagy GPU-n fut.

Edge ML és federated learning

Modern megközelítés — közvetlenül az eszközön történő tanítás TensorFlow Federated vagy MLX (Apple) segítségével. A Python szkript határozza meg az architektúrát, a tanítás pedig a felhasználó adatain történik anélkül, hogy azokat elküldené a szerverre. Ez növeli az adatvédelmet, de nehezebben implementálható. A legtöbb projekt a klasszikus pipeline-t használja: Python tanítás -> TFLite -> eszközön végzett inferencia.

Python a mobilalkalmazások szerveroldalához

Python — népszerű választás a mobilalkalmazások backend-jéhez. A Django REST Framework (DRF) és a FastAPI lehetővé teszi a REST API vagy GraphQL szerver gyors létrehozását. A Python backend feldolgozza a mobil kliensektől érkező kéréseket, kezeli a hitelesítést és szinkronizálja az adatokat WebSocket-en keresztül.

FastAPI — modern keretrendszer aszinkron támogatással, automatikus OpenAPI specifikáció generálással és Pydantic-on keresztüli validációval. A FastAPI teljesítménye összevethető a Node.js-szel és Go-val — akár 10 000 kérés/mp egy magon. Mobil backendhez a FastAPI-t a fejlesztési sebesség és a beépített dokumentáció miatt választják.

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]}

A Pydantic UserCreate modell validálja a bemeneti adatokat: a username és email kötelező karakterláncok, az avatar_url opcionális. Az aszinkron végpontok (async def) nem blokkolják a szervert az adatbázisra várva. A 201-es státuszkód kerül visszaadásra sikeres felhasználó létrehozásakor.

WebSocket valós idejű működéshez

A Python támogatja a WebSocket-et a FastAPI WebSocket vagy a websockets könyvtáron keresztül. Csevegésekhez, valós idejű értesítésekhez és együttműködő szerkesztéshez a WebSocket az optimális szállítási mód. A FastAPI az asyncpg-t használja aszinkron PostgreSQL munkához és az aioredis-t gyorsítótárazáshoz.

Python prototípuskészítéshez és ötletek teszteléséhez

Python nélkülözhetetlen a gyors prototípuskészítéshez. A fejlesztő 15 perc alatt megírhat egy API prototípust Flask-ban, és tesztelheti az ötletet felhasználókon, mielőtt Kotlin/Swift-ben implementálná élesben. A hiba költsége a prototípus fázisban minimális, a hipotézis ellenőrzésének ideje hetekről órákra csökken.

Prototípuskészítő eszközök: Flask (minimális REST), Streamlit (irányítópultok), Jupyter Notebooks (adat elemzés), Flet és Kivy (mobil MVP-k). A Python prototípus gyakran specifikációvá válik az éles implementációhoz: az adattípusok, üzleti logika és tesztek átkerülnek Kotlin-ba vagy Swift-be.

Szkriptek teljesítményteszteléshez

A Python-t a mobil API terheléses tesztelésére használják a Locust segítségével — egy keretrendszerrel, amely több ezer felhasználót szimulál. A Locust szkript leírja a felhasználói viselkedés forgatókönyvét, a webes felület pedig RPS-t, késleltetéseket és percentiliseket mutat.

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"
        })

A @task(2) súlyt jelöl — a GET /posts kérés kétszer olyan gyakran fut le, mint a POST /posts. A wait_time 1–5 másodperces szünetet szimulál a kérések között. A Locust parancssorból indítható, és valós időben mutatja az eredményeket a webes felületen a 8089-es porton.

Python kontra Kotlin és Swift: mikor mit válasszunk

Python és a mobilfejlesztés natív nyelvei különböző feladatokat oldanak meg. Kotlin és Swift — UI-hoz, navigációhoz és a platform API közvetlen eléréséhez. Python — automatizáláshoz, AI/ML-hez, szerverlogikához és prototípuskészítéshez. Hasonlítsuk össze kulcsfontosságú paraméterek alapján.

Optimális architektúra: Python AI modellek tanításához, CI/CD szkriptekhez és szerveroldalhoz, Kotlin/Swift UI-hoz és natív integrációhoz.

Gyakori hibák a Python mobilfejlesztésben való használatakor

Az első hiba — rossz Python verzió használata. macOS-en előre telepítve van a Python 3.9, de az automatizálási szkriptekhez a pyenv vagy .python-version által rögzített verzió szükséges. A 3.9 és 3.12 közötti különbség eltörheti a szintaxist (pl. a match-case csak 3.10-től érhető el).

A második tipikus hiba — virtuális környezet figyelmen kívül hagyása. A Python függőségek globálisan ütköznek a projektek között. Használjon venv vagy poetry-t az elkülönítéshez. A requirements.txt vagy pyproject.toml fájlnak a tárházban kell lennie a build-ek reprodukálhatóságához.

Hibakezelés hiánya — a harmadik gyakori probléma. Az a szkript, amelyik fájl hiányakor vagy hálózati hibánál összeomlik, leállítja a teljes CI/CD pipeline-t. Használjon try-except-finally-t, naplózást a logging modulon keresztül, és adjon vissza nem nulla kódot hiba esetén (sys.exit(1)).

Python 2 és Python 3 szintaxis keverése — egy másik hiba. A zárójel nélküli print, régi except Exception, e és xrange működött Python 2-ben, de Python 3-ban nem. Mindig ellenőrizze a kódot flake8 és mypy segítségével statikus típusanalízishez.

# Legjobb gyakorlat: hibakezelés az automatizálási szkriptben
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:
        # itt a build parancs
        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)