Python projektai praktikai

Kodėl Python – ne tik pradedantiesiems

Yra tokia klišė, kad Python – tai kalba mokykloms ir kursams. Žmonės išmoksta spausdinti „Hello, World!”, supranta, kas yra kintamasis, ir tada… sustoja. Arba pereina prie kažko „rimtesnio” – Java, C++, Rust. Bet čia ir slypi didelė klaida.

Python šiandien naudojamas visur – nuo NASA misijų valdymo sistemų iki Instagram backend’o. Netflix naudoja Python automatizuoti turinio testavimą. Spotify – rekomendacijų algoritmams. Dropbox buvo parašytas Python. Tai nėra „pradedantiesiems skirta kalba” – tai kalba, kuri leidžia greitai paversti idėją veikiančiu kodu, nepraleisdamas savaitės kovodamas su kompiliatoriaus klaidomis.

Bet teorija be praktikos – tai tik žinios, kurios niekur neveda. Šiame straipsnyje kalbėsime apie konkrečius projektus, kuriuos galima realiai sukurti, išmokti iš jų, ir – svarbiausia – panaudoti kasdieniniame gyvenime arba CV.

Web scraping: kai duomenys yra, bet API nėra

Vienas pirmųjų projektų, kuris iš tikrųjų parodo Python galią – web scraping. Situacija tokia: yra svetainė su informacija, kuri jums reikalinga, bet nėra jokio oficialaus API. Ką daryti? Parašyti scrapperį.

Pradėkime nuo requests ir BeautifulSoup bibliotekų. Tai klasikinė kombinacija, kuri veikia 80% atvejų:

import requests
from bs4 import BeautifulSoup

url = "https://example.com/produktai"
response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
soup = BeautifulSoup(response.text, "html.parser")

produktai = soup.find_all("div", class_="product-card")
for p in produktai:
    pavadinimas = p.find("h2").text.strip()
    kaina = p.find("span", class_="price").text.strip()
    print(f"{pavadinimas}: {kaina}")

Praktinis patarimas: visada pridėkite User-Agent antraštę. Daug svetainių blokuoja užklausas be jos, nes jos atrodo kaip robotų generuotos (na, techniškai taip ir yra, bet vis tiek). Taip pat – nepamirškite time.sleep() tarp užklausų. Siųsti 500 užklausų per sekundę – tai ne tik nemandagu, bet ir greičiausias būdas gauti savo IP užblokuotą.

Kai svetainė naudoja JavaScript turiniui generuoti (React, Vue ir panašiai), requests nebepadės – gausite tuščią HTML. Čia į pagalbą ateina Selenium arba modernesnė alternatyva – Playwright. Playwright šiandien yra geresnė rekomendacija: greitesnis, stabilesnis, turi async palaikymą iš karto.

Realus projektas: sukurkite kainų stebėjimo sistemą. Rinkite duomenis iš kelių elektroninių parduotuvių, saugokite į SQLite duomenų bazę, ir siųskite el. laišką, kai kaina nukrenta žemiau jūsų nustatytos ribos. Tai ne tik praktika – tai realiai naudinga priemonė.

Automatizavimas: Python kaip jūsų asmeninis asistentas

Automatizavimas – tai vieta, kur Python tikrai šviečia. Ir čia kalbame ne apie kažkokius sudėtingus enterprise sprendimus, o apie kasdienius dalykus, kurie atima laiką.

Pavyzdžiui – failų organizavimas. Jei turite aplanką su šimtais failų, kuriuos reikia surūšiuoti pagal tipą, datą ar pavadinimą – tai galima padaryti rankiniu būdu (ir praleisti valandą), arba parašyti 20 eilučių Python skriptą:

import os
import shutil
from pathlib import Path

šaltinis = Path("/Users/vardas/Downloads")
kategorijos = {
    "Nuotraukos": [".jpg", ".jpeg", ".png", ".gif", ".webp"],
    "Dokumentai": [".pdf", ".docx", ".xlsx", ".txt"],
    "Video": [".mp4", ".mov", ".avi"],
    "Archyvai": [".zip", ".rar", ".7z"]
}

for failas in šaltinis.iterdir():
    if failas.is_file():
        for kategorija, plėtiniai in kategorijos.items():
            if failas.suffix.lower() in plėtiniai:
                tikslas = šaltinis / kategorija
                tikslas.mkdir(exist_ok=True)
                shutil.move(str(failas), str(tikslas / failas.name))
                break

Kitas puikus automatizavimo projektas – el. pašto siuntimas su priedais naudojant smtplib ir email bibliotekas. Galite sukurti sistemą, kuri automatiškai siunčia savaitines ataskaitas, primena apie artėjančius terminus arba informuoja, kai serveris nustoja veikti.

Dar viena sritis – Excel ir Google Sheets automatizavimas. Bibliotekos openpyxl (Excel failams) ir gspread (Google Sheets) leidžia manipuliuoti skaičiuoklėmis programiškai. Jei dirbate su duomenimis, kurie reguliariai atnaujinami iš skirtingų šaltinių – tai gali sutaupyti valandas per savaitę.

Svarbus patarimas: automatizuodami procesus, visada įtraukite logging. Ne print(), o tikrą logging modulį. Kai skriptas veikia fone ir kažkas eina ne taip – žurnalas yra vienintelis būdas suprasti, kas nutiko:

import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler("skriptas.log"),
        logging.StreamHandler()
    ]
)

logging.info("Skriptas pradėjo darbą")
logging.error("Klaida apdorojant failą: failas.csv")

REST API kūrimas su FastAPI

Jei norite sukurti kažką, ką galėtų naudoti kiti – ar tai būtų mobiliosios programėlės frontend, ar kita paslauga – jums reikia API. Ir čia Python turi vieną geriausių įrankių rinkoje: FastAPI.

FastAPI nėra tik dar vienas web framework’as. Jis automatiškai generuoja dokumentaciją (Swagger UI), naudoja Python type hints validacijai, ir yra vienas greičiausių Python framework’ų – greičiu lenkia net kai kuriuos Node.js sprendimus.

Paprastas pavyzdys – knygų bibliotekos API:

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI()

class Knyga(BaseModel):
    id: int
    pavadinimas: str
    autorius: str
    metai: int
    prieinama: bool = True

knygos_db: List[Knyga] = []

@app.get("/knygos", response_model=List[Knyga])
def gauti_knygas(autorius: Optional[str] = None):
    if autorius:
        return [k for k in knygos_db if k.autorius == autorius]
    return knygos_db

@app.post("/knygos", response_model=Knyga, status_code=201)
def prideti_knyga(knyga: Knyga):
    knygos_db.append(knyga)
    return knyga

@app.get("/knygos/{knyga_id}", response_model=Knyga)
def gauti_knyga(knyga_id: int):
    for knyga in knygos_db:
        if knyga.id == knyga_id:
            return knyga
    raise HTTPException(status_code=404, detail="Knyga nerasta")

Paleiskite su uvicorn main:app --reload ir iš karto turėsite veikiantį API su dokumentacija adresu /docs. Tai vienas dalykų, kurie FastAPI daro tokį patrauklų – nuo idėjos iki veikiančio endpoint’o praeina minutės, ne valandos.

Realiam projektui rekomenduočiau pridėti SQLAlchemy duomenų bazei, Alembic migracijoms, ir JWT autentifikacijai. Tai jau pilnavertis stack’as, kurį galima diegti į produkciją.

Duomenų analizė ir vizualizacija: kai skaičiai pasakoja istoriją

Duomenų mokslas – tai viena iš sričių, kur Python dominuoja be konkurencijos. Bet čia noriu kalbėti ne apie machine learning (tai atskira tema), o apie praktinę duomenų analizę, kuri naudinga beveik kiekvienam.

Trijulė, kurią turite žinoti: Pandas (duomenų manipuliavimui), Matplotlib arba Seaborn (vizualizacijai), ir Jupyter Notebook (interaktyviai aplinkai). Ši kombinacija leidžia analizuoti duomenis taip, kaip Excel niekada neleido.

Praktinis projektas: atsisiųskite viešai prieinamus duomenis (pvz., Lietuvos statistikos departamento duomenis apie gyventojus, arba Kaggle platformos duomenų rinkinius) ir atlikite analizę:

import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns

# Duomenų įkėlimas
df = pd.read_csv("duomenys.csv", encoding="utf-8")

# Greita apžvalga
print(df.head())
print(df.describe())
print(df.isnull().sum())  # Trūkstami duomenys

# Grupavimas ir agregavimas
pagal_metus = df.groupby("metai")["reikšmė"].mean().reset_index()

# Vizualizacija
plt.figure(figsize=(12, 6))
sns.lineplot(data=pagal_metus, x="metai", y="reikšmė", marker="o")
plt.title("Vidutinė reikšmė pagal metus")
plt.xlabel("Metai")
plt.ylabel("Reikšmė")
plt.tight_layout()
plt.savefig("grafikas.png", dpi=150)
plt.show()

Vienas dažniausių klaidų dirbant su Pandas – naudoti iterrows() ciklui per DataFrame. Tai katastrofiškai lėta su dideliais duomenų rinkiniais. Vietoj to naudokite vektorizuotas operacijas arba apply(). Skirtumas gali būti 100x greičio padidėjimas.

Jei norite interaktyvių vizualizacijų – pažiūrėkite į Plotly arba Streamlit. Streamlit ypač įdomus: galite sukurti interaktyvią duomenų analizės programėlę su web sąsaja per kelias dešimtis eilučių kodo, be jokio JavaScript.

Telegram botas: praktinis projektas su realiu naudojamu rezultatu

Telegram botai – tai vienas tų projektų, kurie iš karto duoda apčiuopiamą rezultatą. Sukūrėte botą – ir jis veikia, galite jį naudoti, galite parodyti draugams. Tai motyvuoja tęsti.

Biblioteka python-telegram-bot yra de facto standartas. Naujausioje versijoje ji naudoja async/await, kas daro ją modernią ir efektyvią:

from telegram import Update
from telegram.ext import Application, CommandHandler, MessageHandler, filters, ContextTypes

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await update.message.reply_text(
        "Sveiki! Aš esu jūsų asmeninis asistentas. "
        "Naudokite /pagalba norėdami pamatyti komandas."
    )

async def orų_prognozė(update: Update, context: ContextTypes.DEFAULT_TYPE):
    miestas = " ".join(context.args) if context.args else "Vilnius"
    # Čia integruotumėte OpenWeatherMap API
    await update.message.reply_text(f"Orai mieste {miestas}: 🌤 +15°C")

async def apdoroti_žinutę(update: Update, context: ContextTypes.DEFAULT_TYPE):
    tekstas = update.message.text.lower()
    if "labas" in tekstas or "sveiki" in tekstas:
        await update.message.reply_text("Labas! Kaip galiu padėti?")

def main():
    app = Application.builder().token("JŪSŲ_TOKEN").build()
    app.add_handler(CommandHandler("start", start))
    app.add_handler(CommandHandler("orai", orų_prognozė))
    app.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, apdoroti_žinutę))
    app.run_polling()

if __name__ == "__main__":
    main()

Idėjos, ką galima sukurti: botą, kuris primena apie užduotis, botą kuris seka kriptovaliutų kainas ir praneša apie pokyčius, botą kuris verčia tekstą naudojant Google Translate API, arba botą kuris generuoja atsitiktines citatas iš jūsų mėgstamų knygų.

Svarbu: niekada nekodinkite tokeno tiesiai į kodą. Naudokite aplinkos kintamuosius arba .env failą su python-dotenv biblioteka. Jei atsitiktinai įkelsite kodą su tokenu į GitHub – jūsų botas bus kompromituotas per minutes.

Testavimas: kodas, kuriuo galima pasitikėti

Čia daugelis Python kūrėjų (ypač pradedantieji) daro didelę klaidą – rašo kodą be testų. Ir viskas atrodo gerai, kol projektas mažas. Bet kai kodas auga, kai pradeda dirbti keli žmonės, kai reikia kažką pakeisti – be testų viskas tampa košmaru.

Python turi puikų testavimo ekosistemą. pytest yra standartas, kurį turėtumėte naudoti:

# failas: skaičiuotuvas.py
def padalinti(a: float, b: float) -> float:
    if b == 0:
        raise ValueError("Negalima dalyti iš nulio")
    return a / b

# failas: test_skaičiuotuvas.py
import pytest
from skaičiuotuvas import padalinti

def test_paprasta_dalyba():
    assert padalinti(10, 2) == 5.0

def test_dalyba_iš_nulio():
    with pytest.raises(ValueError, match="Negalima dalyti iš nulio"):
        padalinti(10, 0)

def test_neigiami_skaičiai():
    assert padalinti(-10, 2) == -5.0

@pytest.mark.parametrize("a,b,laukiamas", [
    (10, 2, 5.0),
    (9, 3, 3.0),
    (7, 2, 3.5),
])
def test_daug_atvejų(a, b, laukiamas):
    assert padalinti(a, b) == laukiamas

Paleiskite su pytest -v ir gausite aiškią ataskaitą, kurie testai praėjo, kurie ne. Pridėkite --cov su pytest-cov biblioteka ir sužinosite, kiek procentų jūsų kodo yra padengta testais.

Praktinė rekomendacija: siekite bent 70-80% kodo padengimo testais. 100% – dažnai nerealu ir nebūtina, bet mažiau nei 70% – tai jau rizika. Ypač svarbu testuoti edge cases: tuščius sąrašus, nulines reikšmes, labai ilgus tekstus, netinkamus duomenų tipus.

Taip pat verta pažvelgti į TDD (Test-Driven Development) – metodologiją, kai testus rašote prieš kodą. Tai keičia mąstymą: prieš rašydami funkciją, turite pagalvoti, kaip ji turėtų elgtis. Daugelis kūrėjų, išbandę TDD, nebegrįžta prie senojo būdo.

Nuo projektų prie įgūdžių: kaip visa tai sudėti į vieną paveikslą

Jei perskaitėte iki čia, tikriausiai pastebėjote tam tikrą modelį. Kiekvienas projektas – scraperis, automatizavimo skriptas, API, duomenų analizė, botas – moko skirtingų dalykų, bet visi jie naudoja tas pačias pagrindines koncepcijas: funkcijos, klasės, klaidų valdymas, išorinės bibliotekos, duomenų struktūros.

Geriausia mokymosi strategija – niekada nerašyti kodo be tikslo. Kiekvienas projektas turėtų spręsti realią problemą – jūsų pačių arba kažkieno kito. Kai kodas turi tikslą, motyvacija išlieka net tada, kai kyla sunkumų.

Keletas praktinių rekomendacijų, kurios padės augti greičiau:

• Naudokite virtual environments (venv arba conda) kiekvienam projektui. Tai apsaugo nuo bibliotekų versijų konfliktų ir yra profesionali praktika.
• Rašykite requirements.txt arba naudokite pyproject.toml su poetry. Kitas žmogus (arba jūs po 6 mėnesių) turės galimybę paleisti jūsų projektą.
• Naudokite type hints. Python yra dinamiškai tipizuota kalba, bet type hints padeda IDE, padeda kitiems kūrėjams, ir padeda jums patiems suprasti kodą po laiko.
• Skaitykite kitų žmonių kodą. GitHub pilnas puikių Python projektų. Žiūrėkite, kaip rašo patyrę kūrėjai – tai vienas greičiausių būdų išmokti gero stiliaus.
• Neignoruokite dokumentacijos. Ne tik rašykite docstrings, bet ir skaitykite oficialią dokumentaciją bibliotekų, kurias naudojate. Ten dažnai yra atsakymai į klausimus, kurių ieškote Stack Overflow.

Python ekosistema nuolat auga. Kiekvienais metais atsiranda naujų bibliotekų, naujų framework’ų, naujų galimybių. Bet pagrindai – tie patys. Žmogus, kuris gerai supranta Python pagrindus ir turi keletą realių projektų portfelyje, gali išmokti bet ką nauja per kelias dienas, ne savaites.

Svarbiausia – pradėti. Ne laukti, kol „bus daugiau laiko”, ne ieškoti „tobulo” projekto. Paimkite vieną idėją iš šio straipsnio ir pradėkite šiandien. Net jei kodas bus netobulas – jis bus jūsų, ir iš jo išmoksite daugiau nei iš bet kurio kurso.