Python sa mobile development: automation, AI at ML

Ano ang Python?

Python — isang nai-interpret na language na may dynamic strong typing at awtomatikong pamamahala ng memorya. Nilikha ni Guido van Rossum noong 1991. Ang pilosopiya ng language (The Zen of Python) ay nagtataguyod ng pagiging nababasa ng code: „ang eksplito ay mas mahusay kaysa sa implicit”, „ang simple ay mas mahusay kaysa sa complex”. Ang Python 3.12+ ay sumusuporta sa pattern matching (match-case) at pinahusay na generics.

Ang standard library ng Python ay may kasamang mga module para sa paggawa sa JSON (json), HTTP (urllib), archives (zipfile), regular expressions (re), at databases (sqlite3). Third party — sampu-sampung libong package sa PyPI na may kabuuang bilang ng downloads na higit sa 500 bilyon. PyPI (Python Package Index) — ang pinakamalaking repository ng Python packages.

Gumagamit ang Python ng CPython interpreter na nakasulat sa C. Mga alternatibong implementasyon: PyPy (JIT compilation, 2–5 beses na mas mabilis para sa purong Python), Cython (compilation ng Python sa C), Numba (JIT para sa numerical computations). Para sa mobile scripts, sapat na ang CPython — ang bilis ng interpretasyon ay hindi kritikal para sa mga gawain ng automation.

Mga bersyon ng Python

Ang Python 2 ay tumigil sa suporta noong 2020. Lahat ng modernong proyekto ay gumagamit ng Python 3. Ang kasalukuyang bersyon — 3.13 (2025) na may pinahusay na JIT compiler at eksperimental na suporta para sa free-threaded Python. Para sa mobile development, stable ang bersyon 3.11–3.12, compatible sa lahat ng pangunahing library.

Python para sa automation ng mobile development

Python — ang pangunahing language para sa automation scripts sa mobile development. Ginagamit ito para sa pag-build ng APK at IPA, pagproseso ng text resources, pag-generate ng screens mula sa layouts, at pag-deploy sa app stores. Ayon sa datos ng Bitrise (2025), higit sa 60% ng CI/CD pipelines ng mobile apps ay may kasamang Python steps.

Ang pinakakaraniwang scenario — Fastlane na may Ruby ay hindi sumasaklaw sa lahat ng pangangailangan, at kinukumpleto ito ng Python: kumplikadong image processing logic, paggawa sa App Store Connect API, pag-parse ng Xcode reports, at pag-generate ng screenshots. Ang Python scripts ay tinatawag sa pamamagitan ng sh steps sa Fastfile o direkta sa GitHub Actions.

# Script para sa awtomatikong pagbabago ng laki ng screenshots ng app
import os
from PIL import Image

def resize_screenshots(input_dir: str, output_dir: str, size: tuple) -> None:
    """Binabago ang laki ng lahat ng PNG screenshots sa kinakailangang laki ng 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))

Sa halimbawa, ang script ay dumadaan sa lahat ng PNG file sa folder, binabago ang laki nito sa laki ng iPhone 6.5" (1242x2208) gamit ang LANCZOS filter para sa pinakamahusay na kalidad. Ang f-string sa print ay nagpapalit ng filename. Ang script na ito ay nakakatipid ng oras ng manu-manong trabaho sa paghahanda ng store.

Pagproseso ng Android resources

Para sa Android, ang Python ay kapaki-pakinabang sa pagproseso ng text resources (strings.xml), pagbuo ng dimen files para sa iba't ibang screen density, at pag-convert ng vector graphics. Ang LXML at xml.etree.ElementTree ay nagbibigay-daan sa pag-parse at pagbabago ng XML resources ng Android.

# Pagbuo ng strings.xml mula sa CSV file na may mga pagsasalin
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 sa AI at ML: pagsasanay ng mga modelo para sa mobile platforms

Python — ang pangunahing language para sa machine learning. Ang TensorFlow, PyTorch, scikit-learn, JAX, at Hugging Face Transformers ay isinulat para sa Python. Ginagamit ng mga mobile developer ang Python para sanayin ang mga modelo na pagkatapos ay kino-convert sa TFLite (Android) o Core ML (iOS) para sa execution sa device.

TensorFlow Lite — framework ng Google para sa on-device machine learning. Ang modelong sinanay sa Python ay kino-convert sa .tflite sa pamamagitan ng TensorFlow Converter at ni-load sa Android app sa pamamagitan ng Interpreter API. Para sa iOS, may katulad na pipeline sa pamamagitan ng PyTorch -> Core ML.

# Pagsasanay ng simpleng modelo para sa klasipikasyon ng kilos
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 sa TFLite pagkatapos ng pagsasanay
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")

Ang Sequential model ay may kasamang dalawang convolutional layer (Conv2D) na may pooling, fully connected layer (Dense), at Dropout para sa regularization. Pagkatapos ng conversion, ang .tflite model ay kumukuha ng 4–6 beses na mas kaunting espasyo kaysa sa orihinal na SavedModel at tumatakbo sa mobile CPU o GPU.

Edge ML at federated learning

Modernong approach — direktang pagsasanay sa device sa pamamagitan ng TensorFlow Federated o MLX (Apple). Ang Python script ay nagtatakda ng architecture, at ang pagsasanay ay ginagawa sa data ng user nang hindi ipinapadala sa server. Ito ay nagpapataas ng privacy, ngunit mas mahirap ipatupad. Karamihan sa mga proyekto ay gumagamit ng classic pipeline: Python training -> TFLite -> on-device inference.

Python para sa server-side ng mobile apps

Python — isang popular na pagpipilian para sa backend ng mobile applications. Ang Django REST Framework (DRF) at FastAPI ay nagbibigay-daan sa mabilis na paggawa ng REST API o GraphQL server. Ang Python backend ay nagpo-proseso ng mga request mula sa mobile clients, namamahala ng authentication, at nag-si-sync ng data sa pamamagitan ng WebSocket.

FastAPI — isang modernong framework na may asynchronous support, awtomatikong pagbuo ng OpenAPI specification, at validation sa pamamagitan ng Pydantic. Ang performance ng FastAPI ay maihahambing sa Node.js at Go — hanggang 10,000 request/sec sa isang core. Para sa mobile backend, pinipili ang FastAPI dahil sa bilis ng development at built-in na dokumentasyon.

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

Ang Pydantic model na UserCreate ay nagva-validate ng input data: ang username at email ay mandatory strings, ang avatar_url ay opsyonal. Ang asynchronous endpoints (async def) ay hindi bina-block ang server habang naghihintay sa database. Ang status code 201 ay binabalik kapag matagumpay na nagawa ang user.

WebSocket para sa real-time

Sinusuportahan ng Python ang WebSocket sa pamamagitan ng FastAPI WebSocket o websockets library. Para sa mga chat, real-time notification, at collaborative editing, ang WebSocket ay optimal na transport. Ang FastAPI ay gumagamit ng asyncpg para sa asynchronous na trabaho sa PostgreSQL at aioredis para sa caching.

Python para sa prototyping at pagsubok ng mga ideya

Python ay kailangang-kailangan para sa mabilis na prototyping. Maaaring magsulat ang developer ng prototype ng API sa Flask sa loob ng 15 minuto at subukan ang ideya sa mga user bago ito ipatupad sa Kotlin/Swift para sa produksyon. Ang halaga ng pagkakamali sa yugto ng prototype ay minimal, at ang oras ng pag-verify ng hypothesis ay nababawasan mula linggo hanggang oras.

Mga tool sa prototyping: Flask (minimal REST), Streamlit (dashboards), Jupyter Notebooks (data analysis), Flet at Kivy (mobile MVP). Ang prototype ng Python ay madalas nagiging specification para sa production implementation: data types, business logic, at tests ay inililipat sa Kotlin o Swift.

Script para sa performance testing

Ginagamit ang Python para sa load testing ng mobile API sa pamamagitan ng Locust — framework para sa simulation ng libu-libong user. Ang Locust script ay naglalarawan ng behavior scenario ng user, at ang web interface ay nagpapakita ng RPS, latencies, at 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"
        })

Ang @task(2) ay nagpapahiwatig ng weight — ang GET /posts request ay naisasagawa nang dalawang beses na mas madalas kaysa POST /posts. Ang wait_time ay nagsi-simulate ng pause na 1–5 segundo sa pagitan ng mga request. Ang Locust ay inilulunsad mula sa command line at nagpapakita ng mga resulta sa real-time sa pamamagitan ng web interface sa port 8089.

Python laban sa Kotlin at Swift: kailan pipili ng ano

Python at ang native na languages ng mobile development ay lumulutas ng iba't ibang gawain. Ang Kotlin at Swift — para sa UI, navigation, at direktang access sa platform API. Ang Python — para sa automation, AI/ML, server logic, at prototyping. Ihambing natin ayon sa pangunahing parameters.

Optimal na architecture: Python para sa pagsasanay ng AI models, CI/CD scripts at server side, Kotlin/Swift para sa UI at native integration.

Mga karaniwang pagkakamali sa paggamit ng Python sa mobile development

Unang pagkakamali — paggamit ng maling bersyon ng Python. Sa macOS, pre-installed ang Python 3.9, ngunit para sa automation scripts kailangan ng bersyon na naayos sa pamamagitan ng pyenv o .python-version. Ang pagkakaiba sa pagitan ng 3.9 at 3.12 ay maaaring masira ang syntax (halimbawa, ang match-case ay available lamang mula 3.10).

Pangalawang karaniwang pagkakamali — pagbalewala sa virtual environment. Ang Python dependencies ay nagko-conflik globally sa pagitan ng mga proyekto. Gumamit ng venv o poetry para sa isolation. Ang file na requirements.txt o pyproject.toml ay dapat nasa repository para sa reproducibility ng builds.

Kawalan ng error handling — pangatlong karaniwang problema. Ang script na nagca-crash kapag nawawala ang file o may network error ay humihinto sa buong CI/CD pipeline. Gumamit ng try-except-finally, pagla-log sa pamamagitan ng logging module, at magbalik ng non-zero code sa error (sys.exit(1)).

Paghahalo ng syntax ng Python 2 at Python 3 — isa pang pagkakamali. Ang print na walang parentheses, lumang except Exception, e at xrange ay gumagana sa Python 2, ngunit hindi sa Python 3. Laging suriin ang code sa pamamagitan ng flake8 at mypy para sa static type analysis.

# Pinakamahusay na kasanayan: paghawak ng error sa 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:
        # dito ang build command
        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)