Python nello sviluppo mobile: automazione, AI e ML

Cos'è Python?

Python è un linguaggio interpretato con tipizzazione dinamica forte e gestione automatica della memoria. Creato da Guido van Rossum nel 1991. La filosofia del linguaggio (Il Zen di Python) promuove la leggibilità del codice: «esplicito è meglio che implicito», «semplice è meglio che complesso». Python 3.12+ supporta il pattern matching (match-case) e i generics migliorati.

La libreria standard di Python include moduli per lavorare con JSON (json), HTTP (urllib), archivi (zipfile), espressioni regolari (re) e database (sqlite3). Di terze parti — decine di migliaia di pacchetti su PyPI con oltre 500 miliardi di download totali. PyPI (Python Package Index) è il repository più grande di pacchetti Python.

Python utilizza l'interprete CPython scritto in C. Implementazioni alternative: PyPy (compilazione JIT, 2–5 volte più veloce per Python puro), Cython (compilazione di Python in C), Numba (JIT per calcolo numerico). Per script mobili, CPython è sufficiente — la velocità di interpretazione non è critica per le attività di automazione.

Versioni di Python

Python 2 ha terminato il supporto nel 2020. Tutti i progetti moderni usano Python 3. La versione attuale è 3.13 (2025) con un compilatore JIT migliorato e supporto sperimentale per free-threaded Python. Per lo sviluppo mobile, le versioni 3.11–3.12 sono stabili e compatibili con tutte le librerie principali.

Python per l'automazione dello sviluppo mobile

Python è il linguaggio principale per gli script di automazione nello sviluppo mobile. Viene utilizzato per compilare APK e IPA, elaborare risorse di stringhe, generare schermate da layout e distribuire negli store di applicazioni. Secondo Bitrise (2025), oltre il 60% delle pipeline CI/CD di applicazioni mobili include passaggi Python.

Lo scenario più comune — Fastlane con Ruby non copre tutte le esigenze, e Python lo completa: logica complessa di elaborazione immagini, lavoro con l'API di App Store Connect, analisi dei report Xcode e generazione di screenshot. Gli script Python vengono chiamati tramite passaggi sh in Fastfile o direttamente in GitHub Actions.

# Script per il ridimensionamento automatico degli screenshot dell'app
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Ridimensiona tutti gli screenshot PNG alla dimensione richiesta dallo store."""
    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))

Nell'esempio, lo script scorre tutti i file PNG in una cartella, li ridimensiona alla dimensione iPhone 6.5" (1242x2208) con il filtro LANCZOS per la migliore qualità. La f-string in print sostituisce il nome del file. Questo script fa risparmiare ore di lavoro manuale nella preparazione dello store.

Elaborazione delle risorse Android

Per Android, Python è utile nell'elaborazione di risorse di stringhe (strings.xml), generazione di file dimen per diverse densità di schermo e conversione di grafica vettoriale. LXML e xml.etree.ElementTree consentono di analizzare e modificare le risorse XML di Android.

# Generazione di strings.xml da un file CSV con traduzioni
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 in AI e ML: addestramento di modelli per piattaforme mobili

Python è il linguaggio principale per l'apprendimento automatico. TensorFlow, PyTorch, scikit-learn, JAX e Hugging Face Transformers sono scritti per Python. Gli sviluppatori mobile usano Python per addestrare modelli, che vengono poi convertiti in TFLite (Android) o Core ML (iOS) per l'esecuzione sul dispositivo.

TensorFlow Lite è il framework di Google per l'apprendimento automatico sul dispositivo. Un modello addestrato in Python viene convertito in .tflite tramite TensorFlow Converter e caricato in un'app Android attraverso l'API Interpreter. Per iOS, una pipeline simile usa PyTorch -> Core ML.

# Addestramento di un modello semplice per la classificazione dei gesti
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"])

# Conversione in TFLite dopo l'addestramento
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")

Il modello Sequential include due strati convoluzionali (Conv2D) con pooling, uno strato completamente connesso (Dense) e Dropout per la regolarizzazione. Dopo la conversione, il modello .tflite occupa 4–6 volte meno spazio del SavedModel originale e funziona su CPU o GPU mobile.

Edge ML e apprendimento federato

Un approccio moderno — addestramento direttamente sul dispositivo con TensorFlow Federated o MLX (Apple). Lo script Python definisce l'architettura, mentre l'addestramento viene eseguito sui dati dell'utente senza inviarli al server. Questo migliora la privacy ma è più complesso da implementare. La maggior parte dei progetti utilizza la pipeline classica: addestramento Python -> TFLite -> inferenza sul dispositivo.

Python per la parte server delle applicazioni mobili

Python è una scelta popolare per il backend di app mobili. Django REST Framework (DRF) e FastAPI consentono di creare rapidamente API REST o server GraphQL. Il backend Python elabora le richieste dei client mobili, gestisce l'autenticazione e sincronizza i dati tramite WebSocket.

FastAPI è un framework moderno con supporto asincrono, generazione automatica di specifiche OpenAPI e validazione tramite Pydantic. Le prestazioni di FastAPI sono paragonabili a Node.js e Go — fino a 10.000 richieste/s su un singolo core. Per i backend mobili, FastAPI viene scelto per la velocità di sviluppo e la documentazione integrata.

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

Il modello Pydantic UserCreate valida i dati di input: username e email sono stringhe obbligatorie, avatar_url è opzionale. Gli endpoint asincroni (async def) non bloccano il server durante l'attesa del database. Il codice di stato 201 viene restituito alla creazione riuscita di un utente.

WebSocket per il real-time

Python supporta WebSocket tramite FastAPI WebSocket o la libreria websockets. Per chat, notifiche in tempo reale e modifica collaborativa, WebSocket è il trasporto ottimale. FastAPI utilizza asyncpg per l'accesso asincrono a PostgreSQL e aioredis per la cache.

Python per prototipazione e test di idee

Python è indispensabile per la prototipazione rapida. Uno sviluppatore può scrivere un'API prototipo in Flask in 15 minuti e testare l'idea con gli utenti prima di implementarla in Kotlin/Swift per la produzione. Il costo di un errore nella fase di prototipo è minimo e il tempo di verifica delle ipotesi si riduce da settimane a ore.

Strumenti di prototipazione: Flask (REST minimale), Streamlit (dashboard), Jupyter Notebooks (analisi dati), Flet e Kivy (MVP mobili). Un prototipo Python spesso diventa la specifica per l'implementazione in produzione: tipi di dati, logica di business e test vengono trasferiti su Kotlin o Swift.

Script di test delle prestazioni

Python viene utilizzato per il test di carico delle API mobili con Locust — un framework per simulare migliaia di utenti. Uno script Locust descrive scenari di comportamento utente e l'interfaccia web mostra RPS, latenze e percentili.

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) specifica il peso — le richieste GET /posts vengono eseguite il doppio delle volte rispetto alle richieste POST /posts. wait_time simula una pausa di 1–5 secondi tra le richieste. Locust viene avviato dalla riga di comando e mostra i risultati in tempo reale tramite un'interfaccia web sulla porta 8089.

Python vs Kotlin e Swift: quando scegliere cosa

Python e i linguaggi nativi mobili risolvono problemi diversi. Kotlin e Swift sono per UI, navigazione e accesso diretto all'API della piattaforma. Python è per automazione, AI/ML, logica server e prototipazione. Confrontiamo i parametri chiave.

Architettura ottimale: Python per addestramento AI/modelli, script CI/CD e lato server; Kotlin/Swift per UI e integrazione nativa.

Errori comuni quando si usa Python nello sviluppo mobile

Il primo errore — usare la versione sbagliata di Python. macOS viene fornito con Python 3.9 preinstallato, ma gli script di automazione necessitano di una versione fissata tramite pyenv o .python-version. La differenza tra 3.9 e 3.12 può rompere la sintassi (ad esempio, match-case è disponibile solo dalla 3.10).

Il secondo errore tipico — ignorare gli ambienti virtuali. Le dipendenze Python entrano in conflitto globalmente tra progetti. Usa venv o poetry per l'isolamento. Il file requirements.txt o pyproject.toml dovrebbe essere nel repository per build riproducibili.

Mancanza di gestione degli errori — il terzo problema comune. Uno script che si blocca su un file mancante o un errore di rete ferma l'intera pipeline CI/CD. Usa try-except-finally, registrazione tramite il modulo logging e restituisci un codice diverso da zero in caso di errore (sys.exit(1)).

Mescolare sintassi Python 2 e Python 3 — un altro errore. print senza parentesi, il vecchio except Exception, e e xrange funzionavano in Python 2 ma non in Python 3. Controlla sempre il codice con flake8 e mypy per l'analisi statica dei tipi.

# Buona pratica: gestione degli errori nello script di automazione
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:
        # comando di build qui
        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)