Új lapon nyílik meg

8. lecke

Fájlkezelés

8 rész14 kódpélda1 ábra
Miről szól ez a lecke?

Ha egy program leáll, a memóriában tartott adatai elvesznek — ami megmarad, azt fájlba kell írni. Ez a lecke megmutatja, hogyan írj és olvass szöveges fájlokat, miért biztonságosabb a with szerkezet, hogyan fűzz hozzá egy meglévő fájlhoz, hogyan kezdj el CSV-fájlokkal dolgozni, és hogyan kezeld a hibákat a try/except segítségével. A gépi tanulás adatai is szinte mindig fájlokból érkeznek.

Amit ebben a leckében megtanulsz
  • Fájl létrehozása és írása — open() és write()
  • A with szerkezet — biztonságosabb módszer
  • Fájl olvasása — read()
  • Fájl olvasása soronként — readlines() / for ciklus
  • Hozzáfűzés egy meglévő fájlhoz — "a" mód
  • Gyakorlati példa — nevek listájának kiírása fájlba
  • CSV fájlok — egyszerű bevezetés
  • Hibakezelés fájloknál — try / except
Tudnivalók
  • Olvasási idő: kb. 10 perc (a kódok kipróbálásával több)
  • 8 rész · 14 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat
A program adatot ír a fájlba és olvas belőle
A fájlkezelés két irány: a program ír adatot a lemezen lévő fájlba (megőrzés), és olvas belőle (visszatöltés). Így marad meg a munka a program bezárása után is.

1. Fájl létrehozása és írása — open() és write()

PYTHON● ● ●
fajl = open("peldafajl.txt", "w")
fajl.write("Szia, ez az első sor.\n")
fajl.write("Ez a második sor.\n")
fajl.close()   # FONTOS: mindig zárd le a fájlt írás után!
SzéljegyzetMiért kell külön 'megnyitni' és 'lezárni' a fájlt — mi történik, ha ezt elfelejtem?

Amikor megnyitsz egy fájlt, a géped operációs rendszere (Windows, Mac, Linux) lefoglal egy korlátozott számú erőforrást ehhez a művelethez (ún. "file handle"-t) — ez olyan, mintha "kibérelnél" egy kaput, ahol be- és kiléptetheted az adatokat. Ha nem zárod le (close()), ez a "bérelt kapu" foglalt marad, még akkor is, ha már régen végeztél vele — ha ezt sokszor elfelejted egy nagyobb programban, elfogyhatnak az elérhető "kapuk", és a program hibát dobhat, amikor újabb fájlt próbálnál megnyitni. A close() "visszaadja a kulcsot", jelezve a rendszernek, hogy már nincs rá szükséged.

Mit jelent a '\\n' a szöveg végén? A \\n egy speciális, kétkarakteres jelölés (nem egy "n" betű és egy "\\" jel külön-külön!), amit "escape szekvenciának" hívnak — ez újsor-t (Enter leütést) jelent a szövegben. Azért kell speciális jelölés, mert a billentyűzeteden nincs "nyomtatható" gomb magára az "újsor" fogalomra — a \\n egy megállapodás, amit a programozási nyelvek (nem csak Python) évtizedek óta használnak erre a célra. Enélkül az egymás után írt fajl.write() sorok egyetlen, egybefüggő sorban jelennének meg a fájlban, olvashatatlanul összefolyva.

SzéljegyzetMiért lehet gond ékezetes szövegekkel fájlba írva?

Ha nem adod meg kifejezetten, a fájl kódolása gépenként (főleg Windows-on) eltérő lehet, és az ékezetes karakterek (á, é, ő, ű) olvasáskor/íráskor összekavarodhatnak. A biztonságos megoldás: open("fajl.txt", "w", encoding="utf-8") — az encoding="utf-8" paraméter megadásával a fájl minden gépen ugyanúgy, helyesen fog megjelenni.

2. A with szerkezet — biztonságosabb módszer

PYTHON● ● ●
with open("peldafajl.txt", "w") as fajl:
    fajl.write("Első sor a with-szel.\n")
    fajl.write("Második sor.\n")

A fájl itt automatikusan bezáródik, nem kell fajl.close()

Miért 'biztonságosabb' a with, mint a fajl.close() kézzel kiírása? Képzeld el, hogy a fájl írása közben valamilyen hiba történik (pl. megtelik a merevlemez, vagy a program összeomlik egy másik hiba miatt) — ha kézzel írtad a fajl.close()-t a kód végére, de a hiba a close() előtt történt, a Python soha nem jutna el odáig, hogy lezárja a fájlt! A with szerkezet ezzel szemben egy beépített garanciát ad: mindegy, mi történik a blokk belsejében (akár hiba is), a with gondoskodik arról, hogy a fájl lezáródjon, amint kilépsz a behúzott részből — még akkor is, ha közben hiba történt. Ez az oka, hogy a modern Python kódban szinte mindig with-et használnak fájlkezelésnél, nem a kézi open()/close() párost.

3. Fájl olvasása — read()

PYTHON● ● ●
with open("peldafajl.txt", "r") as fajl:
    tartalom = fajl.read()
    print(tartalom)

Mit csinál pontosan a read(), és miért kell a 'r' betű a mód megadásánál? A "r" (read = olvasás) módban megnyitott fájlnál a Python tudja, hogy csak olvasni szeretnél, nem írni — ez egy védelmi mechanizmus: ha "r" módban próbálnál írni (fajl.write(...)), a Python hibát dobna, mert "nem engedélyezted" az írást. Ez segít elkerülni a véletlen felülírást — ha csak olvasni akarsz egy fontos fájlt, de véletlenül write() -et hívnál rajta, a "r" mód megvéd attól, hogy véletlenül kárt tegyél benne. A read() maga egyetlen, hosszú szöveggé olvassa be a teljes fájl tartalmát — beleértve az újsorokat (\\n) is, amiket a print() aztán "értelmez", és tényleg új sorokba tördeli a kimenetet.

4. Fájl olvasása soronként — readlines() / for ciklus

PYTHON● ● ●
with open("peldafajl.txt", "r") as fajl:
    for sor in fajl:
        print("Beolvasott sor:", sor.strip())

Hogyan tud egy for ciklus 'végigmenni' egy fájlon, mint egy listán (emlékezz az 5-6. leckére)? Pontosan ugyanaz az elv érvényes itt is, mint a listáknál és szövegeknél: egy megnyitott fájl a Python szemében "iterálható" (végigjárható), ahol minden egyes "elem" egy sort jelent a fájlban. Ez azért praktikus, mert hatalmas fájlokat (akár gigabájtnyi adatot) is fel tudsz dolgozni soronként, anélkül, hogy az egész fájlt egyszerre be kellene tölteni a memóriába (mint a read() tenné) — ez sokkal hatékonyabb nagy fájloknál, amit majd az AI-adatoknál gyakran ki fogsz használni.

Mit csinál a .strip(), miért kell? Emlékezz: minden sor a fájlban egy \\n (újsor) karakterrel végződik (ezt írtuk bele korábban). Amikor a for ciklus soronként olvassa be a fájlt, ez a \\n karakter is része lesz a beolvasott szövegnek. Ha print()-tel kiírnád ezt felesleges, dupla üres sorokat eredményezne (mert a print() maga is tesz a végére egy újsort, plusz ott van a fájlból hozott \\n is). A .strip() egy metódus, ami eltávolítja a szöveg elején és végén lévő "felesleges" fehér karaktereket (szóköz, újsor, tabulátor) — ez egy nagyon gyakran használt "tisztító" eszköz, amikor fájlokból vagy felhasználói bemenetből dolgozol.

5. Hozzáfűzés egy meglévő fájlhoz — "a" mód

PYTHON● ● ●
with open("peldafajl.txt", "a") as fajl:
    fajl.write("Ez egy hozzáfűzött sor.\n")
PYTHON● ● ●
with open("peldafajl.txt", "r") as fajl:
    print(fajl.read())

Mi a különbség 'w' és 'a' mód között, miért nem elég csak a 'w'? Ez egy kritikus különbség, amit érdemes alaposan megérteni: a "w" (write) mód, amint megnyitod a fájlt, azonnal letörli a meglévő tartalmat (még mielőtt bármit is írnál!) — ez olyan, mintha egy tiszta lapot vennél elő minden alkalommal. Az "a" (append = hozzáfűzés) mód ezzel szemben a fájl végéhez illeszti az új tartalmat, megőrizve, ami addig ott volt. Ha véletlenül "w"-t használnál ott, ahol "a"-ra lett volna szükség, elveszítenéd a korábbi tartalmat — ez egy gyakori, kellemetlen hiba, amire érdemes odafigyelni.

6. Gyakorlati példa — nevek listájának kiírása fájlba

PYTHON● ● ●
nevek = ["Anna", "Béla", "Csilla", "Dénes"]
PYTHON● ● ●
with open("nevek.txt", "w") as fajl:
    for nev in nevek:
        fajl.write(nev + "\n")
PYTHON● ● ●
with open("nevek.txt", "r") as fajl:
    beolvasott_nevek = []
    for sor in fajl:
        beolvasott_nevek.append(sor.strip())
PYTHON● ● ●
print(beolvasott_nevek)

7. CSV fájlok — egyszerű bevezetés

PYTHON● ● ●
adatok = [
    "nev,kor,varos",
    "Anna,25,Budapest",
    "Béla,30,Veszprém",
    "Csilla,22,Szeged"
]
PYTHON● ● ●
with open("adatok.csv", "w") as fajl:
    for sor in adatok:
        fajl.write(sor + "\n")
PYTHON● ● ●
with open("adatok.csv", "r") as fajl:
    for sor in fajl:
        sor = sor.strip()
        reszek = sor.split(",")   # vesszőnél vágja szét a sort
        print(reszek)

Miért pont a vessző a CSV-ben, és mit csinál a .split()? A CSV rövidítés jelentése: "Comma-Separated Values", azaz "vesszővel elválasztott értékek" — ez egy régóta elterjedt, egyszerű szabvány táblázatos adatok szöveges fájlban való tárolására, mert szinte minden program (Excel, adatbázisok, programozási nyelvek) tudja kezelni, anélkül, hogy bonyolult formátumot kellene megtanulnia. A .split(",") metódus pontosan azt csinálja, amit a neve sugall: szétvágja a szöveget minden vessző mentén, és egy listát ad vissza a "darabokból" — pl. "Anna,25,Budapest" .split(",") eredménye: ["Anna", "25", "Budapest"]. Fontos tudni: ezek a "darabok" még mindig szövegként (str) jelennek meg, tehát a "25" itt nem szám, hanem szöveg — emlékezz a 3. leckére, ha számként akarnád használni, át kellene alakítanod int()-tel.

SzéljegyzetMi van, ha egy CSV-mező maga is tartalmaz vesszőt?

Akkor a sima .split(",") rossz helyen vágná szét a sort. Éppen ezért valós CSV-fájlokhoz érdemesebb a beépített csv modult használni (import csv), ami helyesen kezeli az idézőjelbe tett, vesszőt tartalmazó mezőket is — ez a lecke a megértés kedvéért mutatja a kézi .split()-ot, de éles kódban a csv modul a biztonságosabb választás.

8. Hibakezelés fájloknál — try / except

PYTHON● ● ●
try:
    with open("nemletezo_fajl.txt", "r") as fajl:
        print(fajl.read())
except FileNotFoundError:
    print("A fájl nem található!")

Mi történik pontosan a try/except-tel, mi lenne, ha ezt nem használnám? Ha nem tennéd try/except-be a fájlolvasást, és a fájl nem létezne, a Python egy hibával (FileNotFoundError) leállítaná a teljes program futását — a program "összeomlana", és semmi más kód nem futna le utána, akkor sem, ha az teljesen független lenne a hiányzó fájltól. A try/except egy "biztonsági háló": a Python megpróbálja (try = "próbáld meg") lefuttatni a benne lévő kódot, és ha egy megadott típusú hiba történik (itt: FileNotFoundError), ahelyett hogy leállna, átugrik az except részhez, és folytatja onnan a programot — a program tovább fut, csak kezeli a hibát a te elképzelésed szerint (itt: kiír egy barátságos üzenetet ahelyett, hogy technikai hibaüzenettel "ijesztené meg" a felhasználót).

SzéljegyzetVan más módja is annak, hogy elkerüljem a FileNotFoundError-t, nem csak a try/except?

Igen, előre is ellenőrizheted: import os után az os.path.exists("fajlnev.txt") True/False-t ad vissza, hogy létezik-e a fájl, mielőtt megpróbálnád megnyitni. A try/except megközelítés viszont a legtöbb esetben biztonságosabb, mert az ellenőrzés és a tényleges megnyitás között elméletileg is történhet változás (pl. valaki törli a fájlt közben).

Gyakorlás
  1. Hozz létre egy fájlt "naplo.txt" néven, és írj bele 3 sort arról, mit tanultál ma.
  2. Olvasd vissza a fájlt, és írasd ki soronként a tartalmát, sorszámmal együtt.
  3. Írj egy CSV-szerű fájlt 3 autó adataival (márka, típus, évjárat), majd olvasd vissza és listázd ki szépen formázva.
  4. Új gyakorlat: próbáld ki a "w" mód veszélyét a saját bőrödön (biztonságosan): írj egy fájlba egy fontos szöveget "w" móddal, majd nyisd meg újra "w" móddal és írj bele valami mást — olvasd vissza, és figyeld meg, hogy az első szöveg teljesen eltűnt. Ez segít átérezni, miért kell óvatosnak lenni a "w" móddal éles, fontos fájloknál.