Python în dezvoltarea mobilă: automatizare, AI și ML

Ce este Python?

Python — un limbaj interpretat cu tipizare dinamică puternică și gestionare automată a memoriei. Creat de Guido van Rossum în 1991. Filosofia limbajului (The Zen of Python) promovează lizibilitatea codului: „explicitul este mai bun decât implicitul”, „simplul este mai bun decât complexul”. Python 3.12+ suportă potrivirea modelelor (match-case) și generice îmbunătățite.

Biblioteca standard Python include module pentru lucrul cu JSON (json), HTTP (urllib), arhive (zipfile), expresii regulate (re) și baze de date (sqlite3). Terțe părți — zeci de mii de pachete în PyPI cu un număr total de descărcări de peste 500 de miliarde. PyPI (Python Package Index) — cel mai mare depozit de pachete Python.

Python folosește interpretorul CPython scris în C. Implementări alternative: PyPy (compilare JIT, de 2–5 ori mai rapid pentru Python pur), Cython (compilarea Python în C), Numba (JIT pentru calcule numerice). Pentru scripturi mobile, CPython este suficient — viteza de interpretare nu este critică pentru sarcinile de automatizare.

Versiunile Python

Python 2 a încetat suportul în 2020. Toate proiectele moderne folosesc Python 3. Versiunea actuală — 3.13 (2025) cu compilator JIT îmbunătățit și suport experimental pentru fire libere (free-threaded Python). Pentru dezvoltarea mobilă, versiunea 3.11–3.12 este stabilă, compatibilă cu toate bibliotecile principale.

Python pentru automatizarea dezvoltării mobile

Python — limbajul principal pentru scripturi de automatizare în dezvoltarea mobilă. Este folosit pentru compilarea APK și IPA, procesarea resurselor text, generarea ecranelor din machete și implementarea în magazinele de aplicații. Conform datelor Bitrise (2025), peste 60% din pipeline-urile CI/CD ale aplicațiilor mobile includ pași Python.

Cel mai frecvent scenariu — Fastlane cu Ruby nu acoperă toate nevoile, iar Python îl completează: logică complexă de procesare a imaginilor, lucrul cu API-ul App Store Connect, parsarea rapoartelor Xcode și generarea de capturi de ecran. Scripturile Python sunt apelate prin pași sh în Fastfile sau direct în GitHub Actions.

# Script pentru redimensionarea automată a capturilor de ecran ale aplicației
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Redimensionează toate capturile de ecran PNG la dimensiunea cerută de magazin."""
    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))

În exemplu, scriptul parcurge toate fișierele PNG din folder, le redimensionează la dimensiunea iPhone 6.5" (1242x2208) cu filtrul LANCZOS pentru cea mai bună calitate. f-string-ul din print substituie numele fișierului. Acest script economisește ore de muncă manuală la pregătirea magazinului.

Procesarea resurselor Android

Pentru Android, Python este util la procesarea resurselor text (strings.xml), generarea fișierelor dimen pentru diferite densități de ecran și conversia graficii vectoriale. LXML și xml.etree.ElementTree permit parsarea și modificarea resurselor XML Android.

# Generarea strings.xml dintr-un fișier CSV cu traduceri
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 în AI și ML: antrenarea modelelor pentru platforme mobile

Python — limbajul principal pentru învățarea automată. TensorFlow, PyTorch, scikit-learn, JAX și Hugging Face Transformers sunt scrise pentru Python. Dezvoltatorii mobili folosesc Python pentru antrenarea modelelor care sunt apoi convertite în TFLite (Android) sau Core ML (iOS) pentru execuție pe dispozitiv.

TensorFlow Lite — framework-ul Google pentru învățarea automată pe dispozitiv. Modelul antrenat în Python este convertit în .tflite prin TensorFlow Converter și încărcat în aplicația Android prin Interpreter API. Pentru iOS există un pipeline similar prin PyTorch -> Core ML.

# Antrenarea unui model simplu pentru clasificarea gesturilor
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"])

# Conversia în TFLite după antrenare
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")

Modelul Sequential include două straturi convoluționale (Conv2D) cu pooling, un strat complet conectat (Dense) și Dropout pentru regularizare. După conversie, modelul .tflite ocupă de 4–6 ori mai puțin spațiu decât SavedModel-ul original și rulează pe CPU sau GPU mobil.

Edge ML și federated learning

Abordarea modernă — antrenarea direct pe dispozitiv prin TensorFlow Federated sau MLX (Apple). Scriptul Python definește arhitectura, iar antrenarea se face pe datele utilizatorului fără a le trimite pe server. Aceasta crește confidențialitatea, dar este mai dificil de implementat. Majoritatea proiectelor folosesc pipeline-ul clasic: antrenare Python -> TFLite -> inferență pe dispozitiv.

Python pentru partea de server a aplicațiilor mobile

Python — o alegere populară pentru backend-ul aplicațiilor mobile. Django REST Framework (DRF) și FastAPI permit crearea rapidă a unui API REST sau a unui server GraphQL. Backend-ul Python procesează cererile de la clienții mobili, gestionează autentificarea și sincronizează datele prin WebSocket.

FastAPI — un framework modern cu suport asincron, generare automată a specificației OpenAPI și validare prin Pydantic. Performanța FastAPI este comparabilă cu Node.js și Go — până la 10 000 de cereri/sec pe un singur nucleu. Pentru backend mobil, FastAPI este ales pentru viteza de dezvoltare și documentația integrată.

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

Modelul Pydantic UserCreate validează datele de intrare: username și email sunt șiruri obligatorii, avatar_url este opțional. Endpoint-urile asincrone (async def) nu blochează serverul în așteptarea bazei de date. Codul de stare 201 este returnat la crearea cu succes a utilizatorului.

WebSocket pentru timp real

Python suportă WebSocket prin FastAPI WebSocket sau biblioteca websockets. Pentru chat-uri, notificări în timp real și editare colaborativă, WebSocket este transportul optim. FastAPI folosește asyncpg pentru lucrul asincron cu PostgreSQL și aioredis pentru cache.

Python pentru prototipare și testarea ideilor

Python este de neînlocuit pentru prototiparea rapidă. Un dezvoltator poate scrie un prototip de API pe Flask în 15 minute și poate testa ideea pe utilizatori înainte de a o implementa în Kotlin/Swift pentru producție. Costul unei erori în faza de prototip este minim, iar timpul de verificare a ipotezei se reduce de la săptămâni la ore.

Instrumente de prototipare: Flask (REST minimal), Streamlit (dashboard-uri), Jupyter Notebooks (analiza datelor), Flet și Kivy (MVP-uri mobile). Prototipul Python devine adesea specificația pentru implementarea de producție: tipurile de date, logica de afaceri și testele sunt transferate în Kotlin sau Swift.

Scripturi pentru testarea performanței

Python este folosit pentru testarea de încărcare a API-ului mobil prin Locust — un framework pentru simularea a mii de utilizatori. Scriptul Locust descrie scenariul de comportament al utilizatorului, iar interfața web arată RPS, întârzieri și percentile.

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) indică greutatea — cererea GET /posts se execută de două ori mai frecvent decât POST /posts. wait_time simulează o pauză de 1–5 secunde între cereri. Locust se lansează din linia de comandă și afișează rezultatele în timp real prin interfața web pe portul 8089.

Python vs Kotlin și Swift: când să alegi ce

Python și limbajele native de dezvoltare mobilă rezolvă sarcini diferite. Kotlin și Swift — pentru UI, navigare și acces direct la API-ul platformei. Python — pentru automatizare, AI/ML, logică de server și prototipare. Să comparăm după parametrii cheie.

Arhitectura optimă: Python pentru antrenarea modelelor AI, scripturi CI/CD și partea de server, Kotlin/Swift pentru UI și integrare nativă.

Erori tipice la utilizarea Python în dezvoltarea mobilă

Prima eroare — utilizarea unei versiuni greșite de Python. Pe macOS este preinstalat Python 3.9, dar pentru scripturile de automatizare este necesară o versiune fixată prin pyenv sau .python-version. Diferența dintre 3.9 și 3.12 poate strica sintaxa (de exemplu, match-case este disponibil doar de la 3.10).

A doua eroare tipică — ignorarea mediului virtual. Dependențele Python intră în conflict global între proiecte. Folosiți venv sau poetry pentru izolare. Fișierul requirements.txt sau pyproject.toml trebuie să fie în depozit pentru reproductibilitatea compilărilor.

Lipsa gestionării erorilor — a treia problemă comună. Un script care se blochează la absența unui fișier sau la o eroare de rețea oprește întregul pipeline CI/CD. Folosiți try-except-finally, logare prin modulul logging și returnați un cod nenul la eroare (sys.exit(1)).

Amestecarea sintaxei Python 2 și Python 3 — o altă eroare. print fără paranteze, vechiul except Exception, e și xrange funcționau în Python 2, dar nu în Python 3. Verificați întotdeauna codul prin flake8 și mypy pentru analiză statică a tipurilor.

# Cea mai bună practică: gestionarea erorilor în scriptul de automatizare
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:
        # aici comanda de compilare
        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)