Python Programozás

Az érettségi legfontosabb témakörének teljes összefoglalója. Tanuld meg a mintákat és a tipikus feladattípusokat – ez a feladat adja a pontok ~felét!

💡

Hogyan használd ezt az oldalt?

Kattints egy leckére a tartalom megjelenítéséhez. A kódpéldákat a 📋 gombbal másolhatod. A feladatoknál először te próbáld meg megoldani, csak utána nézd meg a megoldást!

1. Alapok

A Python dinamikusan típusos – nem kell előre megadni a változó típusát. A típus automatikusan az értékből következik.

Python

# Egész szám (int)
kor = 17
pontszam = 95

# Tizedes tört (float)
atlag = 4.75
pi = 3.14159

# Szöveg (str)
nev = "Kovács Péter"
varos = 'Budapest'

# Igaz/Hamis (bool)
aktiv = True
kilepo = False

# Típus ellenőrzése
print(type(kor))       # <class 'int'>
print(type(atlag))     # <class 'float'>
print(type(nev))       # <class 'str'>
print(type(aktiv))     # <class 'bool'>

# Típuskonverzió (nagyon fontos!)
szoveg_szam = "42"
egesz = int(szoveg_szam)    # "42" → 42
tizedes = float("3.14")     # "3.14" → 3.14
visszaalakitva = str(egesz) # 42 → "42"

⚠️

Fájlból beolvasásnál mindig konvertálj!

A fájlból beolvasott adat mindig szöveg (str). Ha számolni akarsz vele, int() vagy float() segítségével alakítsd át!

Python

# Egyszerű kiírás
print("Hello, világ!")
print(42)
print(3.14)

# Több érték egyszerre
nev = "Anna"
kor = 17
print(nev, kor)          # Anna 17  (space elválasztó)
print(nev, kor, sep="-") # Anna-17

# f-string (leggyakrabban használt módszer!)
print(f"Szia, {nev}! Koros: {kor} éves.")
# Kimenet: Szia, Anna! Koros: 17 éves.

# Formázás f-stringben
szam = 3.14159
print(f"Pi értéke: {szam:.2f}")   # Pi értéke: 3.14
print(f"Szam: {szam:.4f}")        # Szam: 3.1416

# Egész szám szélességgel (pl. sorszámozáshoz)
for i in range(1, 6):
    print(f"{i:2}. elem")   # jobbra igazítva, 2 karakter

# ─── BEMENET ───
nev   = input("Add meg a neved: ")
szam  = int(input("Adj meg egy számot: "))
tized = float(input("Adj meg egy tizedes törtet: "))

print(f"Szia, {nev}! A szám négyzete: {szam**2}")

✅

f-string formázási cheat sheet

{ertek:.2f} → 2 tizedes | {ertek:5} → 5 karakter széles | {ertek:05} → 0-kal tölti | {ertek:>10} → jobbra igazít

2. Vezérlési szerkezetek

Python

jegy = int(input("Jegy (1-5): "))

if jegy == 5:
    print("Jeles!")
elif jegy == 4:
    print("Jó!")
elif jegy == 3:
    print("Közepes")
elif jegy == 2:
    print("Elégséges")
else:
    print("Elégtelen")

# ─── Logikai operátorok ───
x = 15
if x > 10 and x < 20:
    print("10 és 20 között van")

if x < 0 or x > 100:
    print("Tartományon kívül")

if not (x == 0):
    print("Nem nulla")

# ─── Tagság ellenőrzése ───
napok = ["hétfő", "kedd", "szerda"]
if "szerda" in napok:
    print("Igen, benne van!")

# ─── Összehasonlító operátorok ───
# ==  egyenlő
# !=  nem egyenlő
# <   kisebb
# >   nagyobb
# <=  kisebb vagy egyenlő
# >=  nagyobb vagy egyenlő

💪 Feladat

Írj programot, ami bekéri a BMI értéket, és kiírja a kategóriát:
< 18.5 → Sovány | 18.5–25 → Normál | 25–30 → Túlsúlyos | > 30 → Elhízott

Python

bmi = float(input("BMI értéke: "))

if bmi < 18.5:
    print("Sovány")
elif bmi < 25:
    print("Normál")
elif bmi < 30:
    print("Túlsúlyos")
else:
    print("Elhízott")

Python

# ─── for ciklus ───
# range(n)        → 0, 1, ..., n-1
# range(a, b)     → a, a+1, ..., b-1
# range(a, b, s)  → a-tól b-1-ig, s lépésenként

for i in range(1, 11):
    print(i, end=" ")   # 1 2 3 4 5 6 7 8 9 10
print()

# Lista elemein végigmenni
gyumolcsok = ["alma", "körte", "szilva"]
for gy in gyumolcsok:
    print(gy)

# enumerate() → index + érték egyszerre
for i, gy in enumerate(gyumolcsok, 1):
    print(f"{i}. {gy}")   # 1. alma, 2. körte ...

# ─── while ciklus ───
szam = 1
while szam <= 5:
    print(szam)
    szam += 1

# Felhasználói bevitel ellenőrzéssel
while True:
    x = int(input("Adj meg egy pozitív számot: "))
    if x > 0:
        break
    print("A szám nem pozitív, próbáld újra!")

# ─── break és continue ───
for i in range(1, 20):
    if i % 2 == 0:
        continue    # páros számokat átugorja
    if i > 10:
        break       # leáll, ha i > 10
    print(i)        # 1 3 5 7 9

💪 Feladat

Számítsd ki az 1-től 100-ig terjedő páros számok összegét for ciklussal!

Python

osszeg = 0
for i in range(2, 101, 2):
    osszeg += i
print(f"Páros számok összege 1–100: {osszeg}")
# Eredmény: 2550

# Vagy sum()-mal:
osszeg = sum(range(2, 101, 2))
print(osszeg)   # 2550

3. Függvények

Python

# ─── Egyszerű függvény ───
def koszont(nev):
    print(f"Szia, {nev}!")

koszont("Anna")    # Szia, Anna!

# ─── Visszatérési értékkel ───
def negyzet(x):
    return x ** 2

print(negyzet(5))   # 25

# ─── Több paraméter, alapértékkel ───
def hatvanyo(alap, kitevo=2):
    return alap ** kitevo

print(hatvanyo(3))       # 9  (kitevo=2)
print(hatvanyo(3, 3))    # 27

# ─── Több visszatérési érték (tuple-ként) ───
def min_max(lista):
    return min(lista), max(lista)

lo, hi = min_max([5, 2, 8, 1, 9])
print(lo, hi)   # 1 9

# ─── Hasznos beépített függvények ───
szamok = [5, 2, 8, 1, 9, 3]

print(len(szamok))       # 6   – elemszám
print(min(szamok))       # 1   – legkisebb
print(max(szamok))       # 9   – legnagyobb
print(sum(szamok))       # 28  – összeg
print(round(3.567, 2))  # 3.57 – kerekítés

# ─── Átlag-számítás (nincs beépített!) ───
def atlag(lista):
    return sum(lista) / len(lista)

print(f"Átlag: {atlag(szamok):.2f}")   # Átlag: 4.67

💡

Érettségin: bontsd függvényekre!

Minden részfeladatot írj külön függvénybe. Így könnyebben kezelhető a kód, és részpontokat is könnyebb kapni, ha valami nem fut.

4. Adatszerkezetek

Python

# ─── Lista létrehozása ───
szamok   = [5, 2, 8, 1, 9, 3]
nevek    = ["Anna", "Béla", "Csilla"]
vegyes   = [1, "szöveg", 3.14, True]
ures     = []

# ─── Indexelés ───
print(nevek[0])    # "Anna"   (első elem, index 0-tól indul!)
print(nevek[-1])   # "Csilla" (utolsó elem)
print(nevek[1:3])  # ["Béla", "Csilla"]  (szelet)

# ─── Módosítás ───
nevek[0] = "Adél"

# ─── Hozzáadás / törlés ───
nevek.append("Dávid")          # végére hozzáad
nevek.insert(1, "Borbála")     # adott indexre szúr
nevek.remove("Béla")           # első előfordulást töröl
del nevek[0]                    # adott indexű töröl
utolso = nevek.pop()           # utolsót kivesz és visszaadja

# ─── Keresés ───
print("Anna" in nevek)         # True / False
print(nevek.index("Csilla"))   # index száma
print(nevek.count("Anna"))     # hányszor szerepel

# ─── Rendezés ───
szamok.sort()              # helyben rendez, növekvő
szamok.sort(reverse=True)  # helyben rendez, csökkenő
rendezett = sorted(szamok) # új listát ad vissza!

# ─── Lista comprehension (NAGYON hasznos!) ───
negyzetek = [x**2 for x in range(1, 11)]
# [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

parosak = [x for x in range(1, 21) if x % 2 == 0]
# [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

nagybetus = [s.upper() for s in nevek]

# ─── Szűrés ───
nagy_szamok = [x for x in szamok if x > 5]

💪 Feladat

Adott a következő lista: [12, 5, 8, 3, 19, 7, 14, 2, 11]
Határozd meg a listából: elemszám, legkisebb, legnagyobb, összeg, átlag. Majd listázd ki a 10-nél nagyobb elemeket!

Python

szamok = [12, 5, 8, 3, 19, 7, 14, 2, 11]

print(f"Elemszám:     {len(szamok)}")
print(f"Legkisebb:    {min(szamok)}")
print(f"Legnagyobb:   {max(szamok)}")
print(f"Összeg:       {sum(szamok)}")
print(f"Átlag:        {sum(szamok)/len(szamok):.2f}")

nagy = [x for x in szamok if x > 10]
print(f"10-nél nagyobb elemek: {nagy}")

A szótár a leggyakrabban használt adatszerkezet a valós adatkezelési feladatoknál. Rekordok (sorok) tárolásához ideális.

Python

# ─── Szótár létrehozása ───
diak = {
    "nev":     "Kiss Anna",
    "kor":     17,
    "osztaly": "12A",
    "atlag":   4.75
}

# ─── Értékek olvasása ───
print(diak["nev"])              # Kiss Anna
print(diak.get("varos", "N/A")) # ha nincs meg, alapértéket ad

# ─── Módosítás, hozzáadás ───
diak["varos"] = "Debrecen"   # ha nincs, létrehozza
diak["kor"] = 18              # ha van, frissíti

# ─── Ellenőrzés ───
if "osztaly" in diak:
    print("Van osztály mező")

# ─── Bejárás ───
for kulcs in diak:
    print(kulcs, ":", diak[kulcs])

for k, v in diak.items():
    print(f"{k}: {v}")

print(list(diak.keys()))    # kulcsok listája
print(list(diak.values()))  # értékek listája

# ─── Lista szótárakból (érettségi mintaszerkezet!) ───
tanulok = [
    {"nev": "Kiss Anna",    "pont": 85, "varos": "Budapest"},
    {"nev": "Nagy Péter",   "pont": 72, "varos": "Pécs"},
    {"nev": "Varga Éva",    "pont": 91, "varos": "Budapest"},
    {"nev": "Szabó Márton", "pont": 68, "varos": "Debrecen"},
]

# Lekérdezések:
print(len(tanulok))                             # hányan vannak
print(max(tanulok, key=lambda x: x["pont"]))    # legjobb tanuló
print(sum(t["pont"] for t in tanulok) / len(tanulok))  # átlag

# Budapest-iek szűrése:
bpiek = [t for t in tanulok if t["varos"] == "Budapest"]

5. Szövegkezelés

Python

s = "  Hello, Világ!  "

# ─── Whitespace kezelés ───
print(s.strip())         # "Hello, Világ!"  (szélső szóközök el)
print(s.lstrip())        # balról töröl
print(s.rstrip())        # jobbról töröl

# ─── Kis/nagybetű ───
print(s.lower())         # "  hello, világ!  "
print(s.upper())         # "  HELLO, VILÁG!  "
print(s.title())         # "  Hello, Világ!  "  (minden szó első betűje nagy)

# ─── Keresés ───
t = "alma körte szilva alma"
print(t.find("körte"))   # 5  (index, -1 ha nincs)
print(t.count("alma"))   # 2  (hányszor szerepel)
print(t.startswith("al")) # True
print(t.endswith("ma"))   # True
print("körte" in t)       # True

# ─── Csere ───
print(t.replace("alma", "barack"))  # "barack körte szilva barack"

# ─── Darabolás (NAGYON fontos fájlolvasásnál!) ───
sor = "Kiss Anna;17;Budapest;85"
reszek = sor.split(";")
# ['Kiss Anna', '17', 'Budapest', '85']

szavak = "hello world python".split()   # szóközre darabolja
# ['hello', 'world', 'python']

# ─── Összeillesztés ───
lista = ["alma", "körte", "szilva"]
print(", ".join(lista))    # "alma, körte, szilva"
print("-".join(lista))     # "alma-körte-szilva"

# ─── Hasznos műveletek ───
print(len("hello"))        # 5  – karakterszám
print("hello"[0])          # 'h' – karakterek indexelhetők
print("hello"[-1])         # 'o'
print("hello"[1:4])        # 'ell'
print("abc" * 3)            # 'abcabcabc'

# ─── Számjegy ellenőrzés ───
print("123".isdigit())     # True
print("12.3".isdigit())    # False  (pont miatt!)
print("abc".isalpha())     # True

💡

split() + strip() kombó – fájlolvasás alap

Amikor fájlból olvasol: először strip() az üres karakterek ellen, majd split(";") a mezők szétválasztásához. Ez a kombináció szinte minden érettségi feladatban szerepel!

6. Fájlkezelés

Python

# ─── Fájl beolvasása (alap minta) ───
adatok = []

with open("adatok.txt", "r", encoding="utf-8") as f:
    for sor in f:
        sor = sor.strip()       # sortörés eltávolítása
        if sor:                  # üres sorok kihagyása
            adatok.append(sor)

# ─── Fájl beolvasása szótárak listájába ───
# (Ez a leggyakoribb érettségi minta!)
# adatok.txt tartalma pl.:
# Kiss Anna;17;Budapest;85
# Nagy Péter;18;Pécs;72

tanulok = []

with open("adatok.txt", "r", encoding="utf-8") as f:
    for sor in f:
        sor = sor.strip()
        if not sor:
            continue
        reszek = sor.split(";")
        tanulo = {
            "nev":   reszek[0],
            "kor":   int(reszek[1]),
            "varos": reszek[2],
            "pont":  int(reszek[3])
        }
        tanulok.append(tanulo)

print(f"Beolvasott sorok: {len(tanulok)}")

# ─── Fájlba írás ───
with open("eredmeny.txt", "w", encoding="utf-8") as f:
    f.write("Eredmények:\n")
    for t in tanulok:
        f.write(f"{t['nev']}: {t['pont']} pont\n")

# ─── Hozzáfűzés meglévő fájlhoz ───
with open("naplo.txt", "a", encoding="utf-8") as f:
    f.write("Új bejegyzés\n")

# ─── Egyszerre az összes sor beolvasása ───
with open("adatok.txt", "r", encoding="utf-8") as f:
    sorok = f.readlines()   # lista, minden elem egy sor (sortöréssel!)
    # VAGY
    tartalom = f.read()     # az egész fájl egyetlen stringként

⚠️

Encoding mindig legyen utf-8!

Magyar szövegekkel dolgozol, amelyek ékezetes karaktereket tartalmaznak. A encoding="utf-8" elhagyása hibát okozhat. Mindig add meg!

7. Rendezés és keresés

Python

tanulok = [
    {"nev": "Kiss Anna",    "pont": 85, "kor": 17},
    {"nev": "Nagy Péter",   "pont": 72, "kor": 18},
    {"nev": "Varga Éva",    "pont": 91, "kor": 17},
    {"nev": "Szabó Márton", "pont": 85, "kor": 18},
]

# ─── Rendezés egy kulcs szerint ───
rendelve_pont = sorted(tanulok, key=lambda x: x["pont"])
# növekvő sorrend (legkisebb pontszámú az első)

rendelve_csokk = sorted(tanulok, key=lambda x: x["pont"], reverse=True)
# csökkenő sorrend (legjobb az első)

# ─── Rendezés több kulcs szerint ───
# Először pontszám szerint csökkenő, azonos pont esetén név szerint ABC
rendelve_tobb = sorted(
    tanulok,
    key=lambda x: (-x["pont"], x["nev"])
)
# A negatív előjel (-x["pont"]) miatt az első szempont csökkenő!

# ─── Helyben rendezés (a listát módosítja) ───
tanulok.sort(key=lambda x: x["nev"])  # név szerint ABC

# ─── min() és max() kulccsal ───
legjobb  = max(tanulok, key=lambda x: x["pont"])
legrosszabb = min(tanulok, key=lambda x: x["pont"])
legidosebb  = max(tanulok, key=lambda x: x["kor"])

print(f"Legjobb: {legjobb['nev']} – {legjobb['pont']} pont")

# ─── Holtverseny esetén (azonos max értékkel) ───
max_pont = max(t["pont"] for t in tanulok)
legjobb_ok = [t for t in tanulok if t["pont"] == max_pont]
print(f"Legjobb(ak): {[t['nev'] for t in legjobb_ok]}")

✅

sorted() vs .sort()

sorted(lista, key=...) → új listát ad vissza, az eredeti változatlan marad.
lista.sort(key=...) → helyben rendezi a listát, nem ad vissza értéket.

8. Érettségi minták – tipikus feladattípusok

🎯

A nagy titkos minta

Szinte MINDEN emelt szintű programozási feladat ezt a szerkezetet követi: Fájl beolvasás → Szűrés → Rendezés → Statisztika → Csoportosítás → Fájlba írás. Ha ezt begyakorlod, a pontok java jön magától!

Pl. városonként hány tanuló van, vagy osztályonként mi az átlag pont.

Python

tanulok = [
    {"nev": "Kiss Anna",    "varos": "Budapest", "pont": 85},
    {"nev": "Nagy Péter",   "varos": "Pécs",     "pont": 72},
    {"nev": "Varga Éva",    "varos": "Budapest", "pont": 91},
    {"nev": "Tóth Bence",   "varos": "Pécs",     "pont": 78},
    {"nev": "Szabó Márton", "varos": "Budapest", "pont": 68},
]

# ─── Városonként hány tanuló van? ───
varosonkent = {}
for t in tanulok:
    v = t["varos"]
    if v not in varosonkent:
        varosonkent[v] = 0
    varosonkent[v] += 1

print(varosonkent)
# {'Budapest': 3, 'Pécs': 2}

# ─── Városonként átlagpontszám ───
osszeg = {}
darab  = {}
for t in tanulok:
    v = t["varos"]
    osszeg[v] = osszeg.get(v, 0) + t["pont"]
    darab[v]  = darab.get(v, 0)  + 1

for v in sorted(osszeg):
    atl = osszeg[v] / darab[v]
    print(f"{v}: {atl:.2f}")

# ─── Városonként tanulók listája ───
csoportok = {}
for t in tanulok:
    v = t["varos"]
    if v not in csoportok:
        csoportok[v] = []
    csoportok[v].append(t["nev"])

for v, nevek in sorted(csoportok.items()):
    print(f"{v}: {', '.join(nevek)}")

Python

pontszamok = [85, 72, 91, 78, 68, 95, 63, 88]

# ─── Alapstatisztikák ───
n        = len(pontszamok)
ossz     = sum(pontszamok)
atlag    = ossz / n
minimum  = min(pontszamok)
maximum  = max(pontszamok)

print(f"Elemszám:     {n}")
print(f"Összeg:       {ossz}")
print(f"Átlag:        {atlag:.2f}")
print(f"Legkisebb:    {minimum}")
print(f"Legnagyobb:   {maximum}")

# ─── Határ feletti elemek száma ───
hatar = 80
felette = sum(1 for p in pontszamok if p >= hatar)
print(f"{hatar} pont felett: {felette} fő ({felette/n*100:.1f}%)")

# ─── Rendezés és rang ───
rendezett = sorted(pontszamok, reverse=True)
print(f"1. hely:  {rendezett[0]}")
print(f"2. hely:  {rendezett[1]}")
print(f"Medián:   {rendezett[n//2]}")

# ─── Tanulók pontszámaira ───
tanulok = [
    {"nev": "Kiss Anna",  "pont": 85},
    {"nev": "Nagy Péter", "pont": 72},
    {"nev": "Varga Éva",  "pont": 91},
]

pontok = [t["pont"] for t in tanulok]  # lista komprehenzió!
atlag  = sum(pontok) / len(pontok)

legjobb = max(tanulok, key=lambda t: t["pont"])
print(f"Átlag: {atlag:.1f}, Legjobb: {legjobb['nev']}")

9. Megoldott érettségi mintafeladatok

🏆

Teljes érettségi feladatminta

Az alábbi feladat szorosan követi az emelt szintű érettségin előforduló programozási feladatok szerkezetét. Próbáld meg önállóan megcsinálni, és utána hasonlítsd össze a megoldással!

📋 Feladatleírás

Adott a verseny.txt fájl, amelynek minden sora egy versenyző adatait tartalmazza pontosvesszővel elválasztva:

verseny.txt (minta)

Kiss Anna;12A;Budapest;87
Nagy Péter;12B;Debrecen;72
Varga Éva;11A;Budapest;95
Tóth Bence;12A;Pécs;68
Szabó Márton;11B;Budapest;91
Horváth Lili;12B;Győr;84
Fekete Dániel;11A;Debrecen;79

Mezők: Név ; Osztály ; Városra ; Pontszám

Olvasd be az adatokat fájlból!
Írj ki hány versenyző adatát olvastuk be!
Ki érte el a legjobb pontszámot?
Mi a budapestiek átlagpontszáma?
Írd ki az eredménylistát pontszám szerint csökkenő sorrendben (sorszámmal)!
Városonként hány versenyző indult? Írd ki névsor szerint rendezve!
Az 80 pont feletti versenyző nevét és pontszámát írd fájlba (kivalok.txt)!

Python – megoldás

# ─── 1. Adatok beolvasása ───
versenyzok = []

with open("verseny.txt", "r", encoding="utf-8") as f:
    for sor in f:
        sor = sor.strip()
        if not sor:
            continue
        reszek = sor.split(";")
        v = {
            "nev":     reszek[0],
            "osztaly": reszek[1],
            "varos":   reszek[2],
            "pont":    int(reszek[3])
        }
        versenyzok.append(v)

# ─── 2. Hány versenyző ───
print(f"Versenyzők száma: {len(versenyzok)} fő")

# ─── 3. Legjobb versenyző ───
legjobb = max(versenyzok, key=lambda x: x["pont"])
print(f"Legjobb versenyző: {legjobb['nev']} ({legjobb['pont']} pont)")

# ─── 4. Budapestiek átlaga ───
bpiek = [v for v in versenyzok if v["varos"] == "Budapest"]
if bpiek:
    bp_atlag = sum(v["pont"] for v in bpiek) / len(bpiek)
    print(f"Budapestiek átlaga: {bp_atlag:.2f} pont")
else:
    print("Nincs budapesti versenyző.")

# ─── 5. Eredménylista csökkenő pontszám szerint ───
print("\nEredménylista:")
rendezett = sorted(versenyzok, key=lambda x: x["pont"], reverse=True)
for i, v in enumerate(rendezett, 1):
    print(f"  {i:2}. {v['nev']:20} – {v['pont']} pont")

# ─── 6. Városonként hány versenyző ───
varosonkent = {}
for v in versenyzok:
    varos = v["varos"]
    varosonkent[varos] = varosonkent.get(varos, 0) + 1

print("\nVárosonkénti létszám:")
for varos in sorted(varosonkent):
    print(f"  {varos}: {varosonkent[varos]} fő")

# ─── 7. Kiválók fájlba írása ───
kivalok = [v for v in versenyzok if v["pont"] > 80]
kivalok_rendezve = sorted(kivalok, key=lambda x: x["pont"], reverse=True)

with open("kivalok.txt", "w", encoding="utf-8") as f:
    f.write("Kiváló teljesítmények (80 pont felett):\n")
    for v in kivalok_rendezve:
        f.write(f"{v['nev']}: {v['pont']} pont\n")

print(f"\nKiválók száma: {len(kivalok)} fő → kivalok.txt elkészült")

📋 Feladatleírás

A idojaras.txt fájl napi időjárási adatokat tartalmaz:

idojaras.txt (minta)

2024.01.01;Budapest;-3;hó
2024.01.01;Pécs;2;eső
2024.01.02;Budapest;-1;köd
2024.01.02;Pécs;4;napos
2024.01.03;Budapest;5;napos
2024.01.03;Pécs;8;napos

Mezők: Dátum ; Állomás ; Hőmérséklet (°C) ; Időjárás

Olvasd be az adatokat!
Adj meg a legalacsonyabb mért hőmérsékletet és helyszínét!
Hány napos nap volt összesen?
Melyik állomáson volt a legmagasabb átlaghőmérséklet?
Írd ki az összes negatív hőmérsékletű napot (dátum, állomás, hőmérséklet)!

Python – megoldás

# ─── 1. Beolvasás ───
merések = []

with open("idojaras.txt", "r", encoding="utf-8") as f:
    for sor in f:
        sor = sor.strip()
        if not sor:
            continue
        reszek = sor.split(";")
        m = {
            "datum":     reszek[0],
            "allomas":   reszek[1],
            "homerseklet": int(reszek[2]),
            "idojaras":  reszek[3]
        }
        merések.append(m)

# ─── 2. Legalacsonyabb hőmérséklet ───
leghidegebb = min(merések, key=lambda x: x["homerseklet"])
print(f"Legalacsonyabb: {leghidegebb['homerseklet']}°C "
      f"({leghidegebb['allomas']}, {leghidegebb['datum']})")

# ─── 3. Napos napok száma ───
napos = sum(1 for m in merések if m["idojaras"] == "napos")
print(f"Napos napok száma: {napos}")

# ─── 4. Legjobb átlaghőmérsékletű állomás ───
ossz   = {}
darab  = {}
for m in merések:
    a = m["allomas"]
    ossz[a]  = ossz.get(a, 0)  + m["homerseklet"]
    darab[a] = darab.get(a, 0) + 1

legjobb_allomas = max(ossz, key=lambda a: ossz[a] / darab[a])
atl = ossz[legjobb_allomas] / darab[legjobb_allomas]
print(f"Legjobb állomás: {legjobb_allomas} ({atl:.1f}°C átlag)")

# ─── 5. Negatív hőmérsékletű napok ───
print("Negatív hőmérsékletű napok:")
negativ = [m for m in merések if m["homerseklet"] < 0]
for m in negativ:
    print(f"  {m['datum']}  {m['allomas']:12}  {m['homerseklet']}°C")

📌 Python gyors összefoglaló – érettségi cheat sheet

Mit csinálsz	Kód
Fájl beolvasás sorokban	with open("f.txt","r",encoding="utf-8") as f: for sor in f:
Sor darabokra vágása	reszek = sor.strip().split(";")
Szövegből szám	int(reszek[2]) vagy float(reszek[2])
Szótár létrehozása	d = {"nev": reszek[0], "pont": int(reszek[1])}
Listához hozzáad	lista.append(d)
Szűrés	[x for x in lista if feltétel]
Rendezés növekvő	sorted(lista, key=lambda x: x["mezo"])
Rendezés csökkenő	sorted(lista, key=lambda x: x["mezo"], reverse=True)
Több kulcs (csökk, majd növ)	sorted(lista, key=lambda x: (-x["a"], x["b"]))
Maximum elem	max(lista, key=lambda x: x["pont"])
Átlag	sum(x["pont"] for x in lista) / len(lista)
Csoportosítás	d[k] = d.get(k, 0) + 1
Fájlba írás	with open("ki.txt","w",encoding="utf-8") as f: f.write()