8. lecke
Fájlkezelés
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.
- 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
- 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

1. Fájl létrehozása és írása — open() és write()
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!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.
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
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()
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
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
with open("peldafajl.txt", "a") as fajl:
fajl.write("Ez egy hozzáfűzött sor.\n")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
nevek = ["Anna", "Béla", "Csilla", "Dénes"]
with open("nevek.txt", "w") as fajl:
for nev in nevek:
fajl.write(nev + "\n")with open("nevek.txt", "r") as fajl:
beolvasott_nevek = []
for sor in fajl:
beolvasott_nevek.append(sor.strip())print(beolvasott_nevek)
7. CSV fájlok — egyszerű bevezetés
adatok = [
"nev,kor,varos",
"Anna,25,Budapest",
"Béla,30,Veszprém",
"Csilla,22,Szeged"
]with open("adatok.csv", "w") as fajl:
for sor in adatok:
fajl.write(sor + "\n")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.
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
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).
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).
- Hozz létre egy fájlt "naplo.txt" néven, és írj bele 3 sort arról, mit tanultál ma.
- Olvasd vissza a fájlt, és írasd ki soronként a tartalmát, sorszámmal együtt.
- Í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.
- Ú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.