Python in Mobile Development: Automation, AI and ML

What is Python?

Python is an interpreted language with dynamic strong typing and automatic memory management. Created by Guido van Rossum in 1991. The language philosophy (The Zen of Python) promotes code readability: "explicit is better than implicit", "simple is better than complex". Python 3.12+ supports pattern matching (match-case) and improved generics.

The Python standard library includes modules for working with JSON (json), HTTP (urllib), archives (zipfile), regular expressions (re) and databases (sqlite3). Third-party — tens of thousands of packages on PyPI with over 500 billion total downloads. PyPI (Python Package Index) is the largest repository of Python packages.

Python uses the CPython interpreter written in C. Alternative implementations: PyPy (JIT compilation, 2–5x faster for pure Python), Cython (compiling Python to C), Numba (JIT for numerical computing). For mobile scripts, CPython is sufficient — interpretation speed is not critical for automation tasks.

Python Versions

Python 2 ended support in 2020. All modern projects use Python 3. The current version is 3.13 (2025) with an improved JIT compiler and experimental support for free-threaded Python. For mobile development, versions 3.11–3.12 are stable and compatible with all major libraries.

Python for Mobile Development Automation

Python is the primary language for automation scripts in mobile development. It is used for building APK and IPA, processing string resources, generating screens from layouts, and deploying to app stores. According to Bitrise (2025), over 60% of CI/CD pipelines for mobile applications include Python steps.

The most common scenario — Fastlane with Ruby does not cover all needs, and Python complements it: complex image processing logic, working with App Store Connect API, parsing Xcode reports and generating screenshots. Python scripts are called via sh steps in Fastfile or directly in GitHub Actions.

# Script for automatic resizing of app screenshots
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Resizes all PNG screenshots to the required store size."""
    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))

In the example, the script goes through all PNG files in a folder, resizes them to iPhone 6.5" size (1242x2208) with the LANCZOS filter for best quality. The f-string in print substitutes the filename. This script saves hours of manual work when preparing for the store.

Android Resource Processing

For Android, Python is useful when processing string resources (strings.xml), generating dimen files for different screen densities, and converting vector graphics. LXML and xml.etree.ElementTree allow parsing and modifying Android XML resources.

# Generating strings.xml from a CSV file with translations
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 and ML: Training Models for Mobile Platforms

Python is the primary language for machine learning. TensorFlow, PyTorch, scikit-learn, JAX and Hugging Face Transformers are written for Python. Mobile developers use Python to train models, which are then converted to TFLite (Android) or Core ML (iOS) for on-device execution.

TensorFlow Lite is Google's framework for on-device machine learning. A model trained in Python is converted to .tflite via the TensorFlow Converter and loaded into an Android app through the Interpreter API. For iOS, a similar pipeline uses PyTorch -> Core ML.

# Training a simple model for gesture classification
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"])

# Conversion to TFLite after training
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")

The Sequential model includes two convolutional layers (Conv2D) with pooling, a fully connected layer (Dense) and Dropout for regularization. After conversion, the .tflite model takes 4–6 times less space than the original SavedModel and runs on mobile CPU or GPU.

Edge ML and Federated Learning

A modern approach — training directly on the device with TensorFlow Federated or MLX (Apple). The Python script defines the architecture, while training runs on user data without sending it to the server. This improves privacy but is more complex to implement. Most projects use the classic pipeline: Python training -> TFLite -> on-device inference.

Python for the Server Side of Mobile Applications

Python is a popular choice for mobile app backends. Django REST Framework (DRF) and FastAPI allow quickly creating REST APIs or GraphQL servers. The Python backend processes requests from mobile clients, manages authentication and synchronizes data via WebSocket.

FastAPI is a modern framework with async support, automatic OpenAPI specification generation and validation via Pydantic. FastAPI performance is comparable to Node.js and Go — up to 10,000 requests/s on a single core. For mobile backends, FastAPI is chosen for development speed and built-in documentation.

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

The Pydantic model UserCreate validates input data: username and email are required strings, avatar_url is optional. Async endpoints (async def) do not block the server while waiting for the database. Status code 201 is returned on successful user creation.

WebSocket for Real-Time

Python supports WebSocket via FastAPI WebSocket or the websockets library. For chats, real-time notifications and collaborative editing, WebSocket is the optimal transport. FastAPI uses asyncpg for async PostgreSQL access and aioredis for caching.

Python for Prototyping and Testing Ideas

Python is indispensable for rapid prototyping. A developer can write a prototype API in Flask in 15 minutes and test the idea with users before implementing in Kotlin/Swift for production. The cost of an error at the prototype stage is minimal, and hypothesis testing time shrinks from weeks to hours.

Prototyping tools: Flask (minimal REST), Streamlit (dashboards), Jupyter Notebooks (data analysis), Flet and Kivy (mobile MVPs). A Python prototype often becomes the specification for production implementation: data types, business logic and tests are ported to Kotlin or Swift.

Performance Testing Scripts

Python is used for load testing mobile APIs with Locust — a framework for simulating thousands of users. A Locust script describes user behavior scenarios, and the web interface shows RPS, latencies and percentiles.

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) specifies the weight — GET /posts requests are executed twice as often as POST /posts requests. wait_time simulates a 1–5 second pause between requests. Locust is launched from the command line and shows real-time results via a web interface on port 8089.

Python vs Kotlin and Swift: When to Choose What

Python and native mobile languages solve different problems. Kotlin and Swift are for UI, navigation and direct platform API access. Python is for automation, AI/ML, server logic and prototyping. Let's compare key parameters.

Optimal architecture: Python for AI/model training, CI/CD scripts and server side; Kotlin/Swift for UI and native integration.

Common Mistakes When Using Python in Mobile Development

The first mistake — using the wrong Python version. macOS comes with Python 3.9 preinstalled, but automation scripts need a version pinned via pyenv or .python-version. The difference between 3.9 and 3.12 can break syntax (e.g., match-case is only available from 3.10).

The second typical mistake — ignoring virtual environments. Python dependencies conflict globally between projects. Use venv or poetry for isolation. The requirements.txt or pyproject.toml file should be in the repository for reproducible builds.

Lack of error handling — the third common problem. A script that crashes on a missing file or network error stops the entire CI/CD pipeline. Use try-except-finally, logging via the logging module, and return a non-zero code on error (sys.exit(1)).

Mixing Python 2 and Python 3 syntax — another mistake. print without parentheses, old except Exception, e and xrange worked in Python 2 but not in Python 3. Always check code with flake8 and mypy for static type analysis.

# Best practice: error handling in automation script
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:
        # build command here
        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)