Python-alapok

A változó egy felcímkézett doboz. A címkét te adod, a tartalmat te teszed bele. Semmi több misztikum nincs benne.

# egy termék adatai a bolt nyilvántartásában
termek_nev = "zabpehely"     # str: szöveg
ar = 890                     # int: egész szám (forint)
keszlet_db = 40              # int
suly_kg = 0.5                # float: tizedes tört
bio = True                   # bool: igaz vagy hamis

print(termek_nev, ar)

Négy típus, amellyel az idő nagy részében dolgozni fogsz: int, float, str, bool. A típus nem dekoráció: meghatározza, mit lehet csinálni az értékkel.

3 + 4            # 7: összeadás
"3" + "4"        # "34": összefűzés!
"3" + 4          # TypeError: hiba

Klasszikus buktató. Ha CSV-ből vagy beviteli mezőből olvasol számot, az szövegként érkezik. A "150" nem ugyanaz, mint a 150. Átalakítás: int("150") vagy float("0.5").

f-string: szöveg és érték együtt

cimke = f"{termek_nev}: {ar} Ft ({keszlet_db} db raktáron)"
print(cimke)   # zabpehely: 890 Ft (40 db raktáron)

A lista rendezett elemsorozat. Bármilyen típusú elemet tartalmazhat, akár vegyesen is, de leggyakrabban akkor használod, ha ugyanolyan fajta dolgokból van több: napi hőmérsékletek, árak, dolgozatpontszámok.

homersekletek = [21.2, 20.9, 21.5, 19.8, 22.0]   # öt nap szobahőmérséklete [°C]

print(homersekletek[0])       # 21.2: az első elem indexe 0!
print(homersekletek[-1])      # 22.0: az utolsó
print(len(homersekletek))     # 5: hány elem van

homersekletek.append(21.4)    # hozzáfűz a végére
homersekletek.remove(19.8)    # kivesz egy konkrét értéket

Nulláról indexelünk. Az első elem a [0]. Egy ötelemű lista utolsó eleme a [4]. Az [5] már IndexError. Ez az első hét leggyakoribb hibája, és soha nem szűnik meg teljesen.

Szeletelés

homersekletek[1:3]     # [20.9, 21.5]: 1-től 3-ig, a 3 NEM kell
homersekletek[:2]      # az első kettő
homersekletek[-2:]     # az utolsó kettő

Hasznos beépített függvények

sum(homersekletek)                       # összeg
max(homersekletek)                       # legnagyobb
min(homersekletek)                       # legkisebb
sum(homersekletek) / len(homersekletek)  # átlag
sorted(homersekletek)                    # rendezett MÁSOLAT

A dict kulcsokhoz rendel értékeket. Gyakori használata, hogy egy dolog különböző tulajdonságait tárolja névvel, de lehet benne például terméknév és darabszám párok sora is. Egy termék nem négy szám egymás után, hanem név, ár, kategória, tömeg, és mindegyiknek neve van.

termek = {
    "nev": "zabpehely",
    "ar": 890,
    "kategoria": "reggeli",
    "suly_kg": 0.5,
}

print(termek["kategoria"])        # reggeli
print(termek.get("akcio"))        # None: nincs ilyen kulcs, de nem áll le
print(termek.get("akcio", 0))     # 0: alapérték, ha nincs kulcs

termek["bio"] = True              # új kulcs felvétele

Mikor melyik. A lista[0] hibát dob, ha nincs elem. A dict["kulcs"] szintén (KeyError). A .get() viszont csendben None-t ad. Éles kódban a .get() alapértékkel gyakran biztonságosabb, de vigyázz: a csendes None később, messzebb okoz hibát.

Dictek listája: ez a leggyakoribb szerkezet

keszlet = [
    {"nev": "alma",   "ar": 450, "db": 12},
    {"nev": "körte",  "ar": 690, "db": 4},
    {"nev": "szilva", "ar": 790, "db": 0},
]

print(keszlet[1]["nev"])   # körte

Ez a forma köszön vissza minden CSV-beolvasásnál, minden API-válasznál és minden adatbázis-lekérdezésnél. Ha ezt érted, a későbbi anyag fele már ismerős lesz.

Az if ott dönt, ahol te is döntenél. A hétköznapi döntések pont ilyenek: elég meleg van-e, van-e még raktáron, jár-e kedvezmény. A példában a szobahőmérséklet célja 21 fok, legfeljebb 1 fok eltéréssel.

homerseklet = 22.5
cel = 21.0
elteres_hatar = 1.0

if abs(homerseklet - cel) <= elteres_hatar:
    print("RENDBEN")
elif homerseklet > cel:
    print("TÚL MELEG")
else:
    print("TÚL HIDEG")

A behúzás nem csak stílus. Pythonban a behúzás a szintaxis része. Hogy hány szóközzel húzol be, azt a nyelv nem írja elő, de egy blokkon belül következetesnek kell lennie; a négy szóköz a hivatalos stílusajánlás (PEP 8), érdemes mindig azt használni. Ami beljebb van, az tartozik az if-hez. Rossz behúzás más programot jelent, vagy IndentationError-t. A behúzás eleinte szokatlan lehet, de gyakorlással könnyen megszokható.

Összehasonlítás és logika

Egy = vagy két ==. Az = értékadás, a == összehasonlítás. Az if ar = 890: szintaktikai hiba. Ez a klasszikus kezdő elgépelés.

Ha egy műveletet sok elemen kell elvégezned, nem másolod le ötvenszer. A for végigmegy egy gyűjteményen.

meresek = [21.2, 20.9, 22.5, 19.8]   # négy nap szobahőmérséklete [°C]

for fok in meresek:
    print(fok)

A fok nevet te adod, és minden körben a következő elemet tartalmazza. Ennyi.

Ciklus és feltétel: szűrés

kilogo = []

for fok in meresek:
    if abs(fok - 21.0) > 1.0:
        kilogo.append(fok)

print(f"{len(kilogo)} nap lógott ki a kényelmes sávból")   # 2 nap (22.5 és 19.8)

Dictek listáján végigmenni

for tetel in keszlet:
    if tetel["db"] == 0:
        print(f"ELFOGYOTT: {tetel['nev']}")   # ELFOGYOTT: szilva

Számláló, ha kell. Ha a sorszám is érdekel: for i, fok in enumerate(meresek):. Az i a 0-tól induló index.

kilogo = [f for f in meresek if abs(f - 21.0) > 1.0]

Amit ne csinálj. Ne módosítsd azt a listát, amelyen épp végigmész. Elemek fognak kimaradni, és órákig keresed majd, miért. Gyűjts egy új listába, aztán cserélj.

A függvény egy megnevezett művelet, amelyet többször használsz. Ha ugyanazt a kódot kétszer másolod le, függvény kell.

def rendben(ertek, cel, hatar):
    """Igaz, ha az érték legfeljebb 'hatar'-nyira tér el a céltól."""
    return abs(ertek - cel) <= hatar


if rendben(21.5, 21.0, 1.0):
    print("OK")

Három része van: a név (rendben), a bemenetek (ertek, cel, hatar) és a visszatérési érték (return). Ha nincs return, a függvény None-t ad vissza; ez is gyakori hibaforrás.

Alapértelmezett paraméter

def rendben(ertek, cel, hatar=1.0):
    return abs(ertek - cel) <= hatar

rendben(21.5, 21.0)              # 1.0-s határral számol: True
rendben(21.5, 21.0, hatar=0.2)   # felülírva: False

A jó függvény ismérve. Egy dolgot csinál, és a neve elárulja, mit. Ha a névbe „és” kerül (beolvas_es_kiertekel), érdemes elgondolkodni, nem két külön feladatról van-e szó. Ez jó jelzés, nem kötelező szabály: a döntő szempont, hogy a kód átlátható maradjon.

Buktató. A print() és a return nem ugyanaz. A print kiír a képernyőre, a return értéket ad vissza a hívónak. Számoló függvényben szinte mindig return kell.

A program futás közben hibába ütközhet. A kérdés az, hogy ezt kezelni tudja-e, vagy váratlanul leáll. Valódi adatokkal dolgozva ez nem elméleti különbség.

try:
    ar = int(sor["ar"])
except ValueError:
    print(f"Hibás ár: {sor['ar']}")
    ar = None
except KeyError:
    print("Hiányzik az ár oszlop")
    ar = None

A leggyakoribb hibatípusok

Amit soha. Ne írj except: vagy except Exception: pass formát. Ez elnyeli az összes hibát, azokat is, amelyekről tudnod kellene. Egy elnyelt hiba rosszabb, mint egy leálló program: a leálló programról tudsz, az elnyelt hibáról nem.

Itt kezd a Python valódi eszközzé válni: amikor nem beírt adatokkal, hanem a saját fájljaiddal dolgozol.

Szövegfájl

with open("naplo.txt", encoding="utf-8") as f:
    for sor in f:
        print(sor.strip())

A with gondoskodik róla, hogy a fájl akkor is bezáruljon, ha hiba történik. A strip() a szöveg elejéről és végéről is levágja a szóközt, a tabulátort és a sortörést. Ha csak a sorvéget akarod levágni, használd az rstrip("\n")-t. Az encoding="utf-8" nélkül az ékezetek elszállhatnak; magyar szöveggel ez nem opcionális.

CSV: a táblázatos adatok közös nyelve

import csv

with open("eladasok.csv", encoding="utf-8", newline="") as f:
    olvaso = csv.DictReader(f)
    for sor in olvaso:
        print(sor["termek"], sor["kategoria"])

A DictReader minden sort dictté alakít, a fejléc alapján. Vagyis pontosan azt a szerkezetet kapod, amelyet a 3. szinten kézzel építettél.

Táblázatkezelőből jövő CSV. A magyar beállítású táblázatkezelők gyakran pontosvesszővel mentenek, nem vesszővel, és a tizedesjel vessző. Ilyenkor: csv.DictReader(f, delimiter=";"), a számoknál pedig float(ertek.replace(",", ".")). Magyar környezetben ez nem kivétel, hanem az alapeset.

JSON: a programok közti adatcsere nyelve

import json

# kiírás
with open("keszlet.json", "w", encoding="utf-8") as f:
    json.dump(keszlet, f, ensure_ascii=False, indent=2)

# beolvasás
with open("keszlet.json", encoding="utf-8") as f:
    keszlet = json.load(f)

A JSON tömbje Python-listára, objektuma dictre képeződik le, ezért lesz ismerős minden API-válasz, például a RAG-laborban. Teljesen azonos azonban nem: a JSON-ban a kulcs csak szöveg lehet, és a típuskészlet is szűkebb (nincs benne például tuple vagy dátum).

Az osztály összecsomagolja az adatot és a rá vonatkozó műveleteket. Nem kell szeretni, és nem kell mindent osztályba tenni, de olvasni tudnod kell, mert a legtöbb könyvtár így épül.

class Termek:
    def __init__(self, nev, ar, db):
        self.nev = nev
        self.ar = ar
        self.db = db

    def cimke(self):
        return f"{self.nev}: {self.ar} Ft"


t = Termek("zabpehely", 890, 40)
print(t.cimke())     # zabpehely: 890 Ft
print(t.ar)          # 890

Az __init__ a létrehozáskor fut le. A self maga a példány: a példánymetódusok első paramétere, és hívásnál nem te adod meg. (Vannak osztály- és statikus metódusok is, ezeknél másképp van; itt nem lesz rájuk szükség.)

Mikor kell osztály. Ha ugyanaz az adathalmaz és a rá vonatkozó műveletek együtt mozognak, és több példány van belőlük. Egyszerű adattároláshoz a dict vagy a dataclass elég. A „mindent osztályba” reflex más nyelvekből hozott szokás; Pythonban nem érdem.

from dataclasses import dataclass

@dataclass
class Termek:
    nev: str
    ar: int
    db: int

Ha a fájlod nő, és jól elkülönülő részekből áll (beolvasás, ellenőrzés, jelentés), érdemes szétszedni. Nem a sorszám dönt, hanem hogy átlátható-e még. Minden .py fájl egy modul, amelyet importálhatsz.

bolt_elemzo/
├── main.py           # belépési pont
├── beolvasas.py      # CSV-kezelés
├── ellenorzes.py     # eltérés a tervtől
├── adatok/
│   └── eladasok.csv
├── requirements.txt
└── README.md

# main.py
from beolvasas import csv_betolt
from ellenorzes import rendben

sorok = csv_betolt("adatok/eladasok.csv")
for sor in sorok:
    ...

A __main__ trükk. Az if __name__ == "__main__": alá írt blokk csak akkor fut, ha a fájlt közvetlenül indítod, importáláskor nem. Enélkül az importálásnak mellékhatásai lennének. Minden komolyabb Python-fájlban látni fogod.

if __name__ == "__main__":
    fomuvelet()

README: ez is a munka része

Négy dolog kell bele: mit csinál, hogyan telepíted, hogyan futtatod, és milyen a bemenet formátuma. Öt sor is elég. Egy README nélküli projektből az derül ki, hogy a szerzője nem számolt azzal, hogy más is használni fogja.

Minden projektnek saját, elkülönített környezete van. Így nem törik el az egyik projekt attól, hogy a másikhoz frissítettél egy csomagot.

# környezet létrehozása (a projekt mappájában)
python -m venv .venv

# aktiválás: Windows, PowerShell
.\.venv\Scripts\Activate.ps1

# aktiválás: Windows, parancssor (cmd)
.venv\Scripts\activate.bat

# aktiválás: Linux és macOS
source .venv/bin/activate

# csomag telepítése
python -m pip install requests

# a jelenlegi állapot rögzítése
python -m pip freeze > requirements.txt

# máshol ugyanez visszaállítható
python -m pip install -r requirements.txt

Miért számít. A requirements.txt rögzíti a csomagokat és verzióikat, és ez sokat segít, hogy a kódod más gépen is fusson. Garancia nem: a Python-verzió, az operációs rendszer és egyes külső könyvtárak is számíthatnak. Ez nem formalitás: a „nálam működik” a programozás legrégebbi kifogása, és a venv az egyik válasz rá.

Ne tedd verziókövetésbe. A .venv mappát soha ne tedd gitbe: nagy, gépfüggő és felesleges. Erre való a .gitignore.

Nem AI, és nem is Python, de enélkül nincs rendezett munka. A git megmutatja, hogyan dolgozol: mikor, mit, milyen lépésekben.

git init                        # új repó a mappában
git status                      # mi változott
git add .                       # a változások előkészítése
git commit -m "CSV-beolvasás"   # mentés üzenettel
git log --oneline               # előzmények
git diff                        # mi változott pontosan, soronként

Ágak

git branch elteres-vizsgalat    # új ág
git switch elteres-vizsgalat    # átváltás
git switch main                 # vissza

Commit-üzenet. Azt írd le, mit és miért változtattál, ne azt, hogy „módosítás” vagy „javítás2”. Jó példa: eltérésvizsgálat kiterjesztése a terv alatti értékekre. Aki a kódodat olvassa, a commitok listájából érti meg leggyorsabban, hogyan gondolkodtál.

.gitignore. Legalább ennyi legyen benne: .venv/, __pycache__/, *.pyc, és minden, ami személyes adatot vagy kulcsot tartalmaz. Ha egy API-kulcs nyilvánosságra kerül, azonnal vond vissza vagy cseréld le a szolgáltatónál. A kiszivárgott kulcs vagy személyes adat bizalmasságát a fájl törlése önmagában nem állítja helyre: a git-előzményben és mások gépén is megmaradhat.