Kihagyás

Nagy ZH

Tartalom

Egész órás nagy ZH

A gyakorlat anyaga

Ezen a gyakorlaton nincs új tananyag, cserében gyakorló feladatokkal készülhetsz fel a nagy zárthelyire. A gyakorlatvezetők a gyakorlat teljes ideje alatt rendelkezésre állnak és válaszolnak a feladatokkal kapcsolatos kérdéseidre.

Feladatok

Szótárak (Dictionary)

1. feladat - Előfordulások számlálása

Írj egy függvényt szavak_gyakorisaga(szoveg) néven, amely egy szöveget kap paraméterként, és visszaad egy szótárat, amelyben a kulcsok a szavak, az értékek pedig az előfordulásaik száma.

Példa: 

1
2
3
szoveg = "alma körte alma szilva körte alma"
print(szavak_gyakorisaga(szoveg))
# {'alma': 3, 'körte': 2, 'szilva': 1}

Példamegoldás 
1
2
3
4
5
6
7
8
9
def szavak_gyakorisaga(szoveg):
    szavak = szoveg.split()
    gyakorisag = {}
    for szo in szavak:
        if szo in gyakorisag:
            gyakorisag[szo] += 1
        else:
            gyakorisag[szo] = 1
    return gyakorisag
2. feladat - Szótár inverz (kulcs-érték csere)

Írj egy függvényt szotar_inverz(szotar) néven, amely egy szótár kulcs-érték párjait megfordítja. Ha több kulcsnak ugyanaz az értéke, akkor az új szótárban az érték egy lista legyen a kulcsokkal.

Példa: 

1
2
3
eredeti = {"a": 1, "b": 2, "c": 1, "d": 3}
print(szotar_inverz(eredeti))
# {1: ["a", "c"], 2: ["b"], 3: ["d"]}

Példamegoldás 
1
2
3
4
5
6
7
8
def szotar_inverz(szotar):
    inverz = {}
    for kulcs, ertek in szotar.items():
        if ertek in inverz:
            inverz[ertek].append(kulcs)
        else:
            inverz[ertek] = [kulcs]
    return inverz
3. feladat - Készletek összefésülése és szűrése

Írj egy függvényt keszletek_osszevonasa(raktar1, raktar2, min_mennyiseg) néven, amely két raktár készletét vonja össze. Mindkét szótárban a kulcsok terméknevek, az értékek pedig mennyiségek (egész számok). A függvény:

  • Hozzon létre egy új szótárt, amely tartalmazza az összes terméket mindkét raktárból.
  • Ha egy termék mindkét raktárban van, az összege kerüljön az új szótárba.
  • Csak azok a termékek kerüljenek bele, amelyeknek az összmennyisége eléri vagy meghaladja a min_mennyiseg értéket.

Példa: 

1
2
3
4
raktar1 = {"alma": 15, "körte": 8, "szilva": 20}
raktar2 = {"alma": 10, "banán": 12, "körte": 3}
print(keszletek_osszevonasa(raktar1, raktar2, 15))
# {'alma': 25, 'szilva': 20}

Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
def keszletek_osszevonasa(raktar1, raktar2, min_mennyiseg):
    osszevont = {}

    # Raktar1 hozzáadása
    for termek, mennyiseg in raktar1.items():
        osszevont[termek] = mennyiseg

    # Raktar2 hozzáadása vagy összeadása
    for termek, mennyiseg in raktar2.items():
        if termek in osszevont:
            osszevont[termek] += mennyiseg
        else:
            osszevont[termek] = mennyiseg

    # Szűrés min_mennyiseg alapján
    szurt = {}
    for termek, mennyiseg in osszevont.items():
        if mennyiseg >= min_mennyiseg:
            szurt[termek] = mennyiseg

    return szurt
4. feladat - Szavak csoportosítása és szűrése

Írj egy függvényt szavak_csoportositasa(szavak, min_hossz) néven, amely egy szavakat tartalmazó listát kap, és visszaad egy szótárat, ahol a kulcsok az első betűk (kisbetűre alakítva), az értékek pedig az adott betűvel kezdődő szavak listái. Azonban csak azok a szavak kerüljenek bele, amelyek hossza legalább min_hossz!

Példa: 

1
2
3
szavak = ["alma", "Ananász", "banán", "Barack", "citrom", "autó", "bicikli"]
print(szavak_csoportositasa(szavak, 5))
# {'a': ['alma', 'Ananász', 'autó'], 'b': ['banán', 'Barack', 'bicikli'], 'c': ['citrom']}

Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
def szavak_csoportositasa(szavak, min_hossz):
    csoportok = {}
    for szo in szavak:
        if len(szo) >= min_hossz:
            elso_betu = szo[0].lower()
            if elso_betu in csoportok:
                csoportok[elso_betu].append(szo)
            else:
                csoportok[elso_betu] = [szo]
    return csoportok
5. feladat - Sportolók átlageredményei

Adott egy szótár, amely sportolók neveit tárolja kulcsként, és minden sportolóhoz egy újabb szótár tartozik a versenyek eredményeivel (lista) és a csapat nevével. Írj egy függvényt legjobb_sportoló(sportolok) néven, amely:

  • Kiszámolja minden sportoló átlageredményét
  • Visszaad egy szótárat, ahol a kulcsok a sportolók nevei, az értékek pedig az átlageredményeik
  • PLUSZ: Kiírja a képernyőre a legjobb átlageredménnyel rendelkező sportoló nevét és átlagát!

Példa: 

1
2
3
4
5
6
7
8
9
sportolok = {
    "Kiss Anna": {"versenyek": [12.5, 13.1, 12.8, 13.0], "csapat": "Gyorsak"},
    "Nagy Péter": {"versenyek": [14.2, 13.9, 14.1], "csapat": "Futók"},
    "Szabó Éva": {"versenyek": [12.0, 11.8, 12.2, 11.9], "csapat": "Gyorsak"}
}
eredmenyek = legjobb_sportoló(sportolok)
print(eredmenyek)
# Legjobb: Szabó Éva - 11.975 másodperc
# {'Kiss Anna': 12.85, 'Nagy Péter': 14.067, 'Szabó Éva': 11.975}

Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
def legjobb_sportoló(sportolok):
    atlagok = {}
    legjobb_nev = ""
    legjobb_atlag = float('inf')  # Nagyon nagy szám (minél kisebb az idő, annál jobb)

    for nev, adatok in sportolok.items():
        versenyek = adatok["versenyek"]
        atlag = sum(versenyek) / len(versenyek)
        atlagok[nev] = round(atlag, 3)

        if atlag < legjobb_atlag:
            legjobb_atlag = atlag
            legjobb_nev = nev

    print(f"Legjobb: {legjobb_nev} - {legjobb_atlag:.3f} másodperc")
    return atlagok

Fájlkezelés

6. feladat - Páros számok összege fájlból

Írj egy függvényt paros_szamok_osszege(fajlnev, hatarertek) néven, amely beolvas egy fájlt, amelyben soronként egy-egy egész szám szerepel, és visszaadja azoknak a páros számoknak az összegét, amelyek nagyobbak a hatarertek értéknél!

Példa:

Fájl tartalma (szamok.txt): 

1
2
3
4
5
6
10
25
30
15
8
20


1
2
print(paros_szamok_osszege("szamok.txt", 12))
# 50  (30 + 20, mert 10 és 8 nem nagyobb mint 12)
Példamegoldás 
1
2
3
4
5
6
7
8
9
def paros_szamok_osszege(fajlnev, hatarertek):
    osszeg = 0
    with open(fajlnev, "r", encoding="utf-8") as f:
        sorok = f.readlines()
    for sor in sorok:
        szam = int(sor.strip())
        if szam % 2 == 0 and szam > hatarertek:
            osszeg += szam
    return osszeg
7. feladat - Sorok számozása

Írj egy függvényt sorok_szamozasa(bemeneti_fajl, kimeneti_fajl) néven, amely beolvassa a bemeneti fájl tartalmát, és kiírja a kimeneti fájlba úgy, hogy minden sor elé odaírja a sorszámát és egy kettőspontot!

Példa:

Bemeneti fájl (bemenet.txt): 

1
2
3
alma
körte
szilva

Kimeneti fájl (kimenet.txt): 

1
2
3
1: alma
2: körte
3: szilva

Példamegoldás 
1
2
3
4
5
6
7
def sorok_szamozasa(bemeneti_fajl, kimeneti_fajl):
    with open(bemeneti_fajl, "r", encoding="utf-8") as f:
        sorok = f.readlines()

    with open(kimeneti_fajl, "w", encoding="utf-8") as f:
        for i, sor in enumerate(sorok, 1):
            f.write(f"{i}: {sor.rstrip()}\n")
8. feladat - CSV feldolgozás és számítások

Írj egy függvényt termekek_atlagara(fajlnev) néven, amely beolvas egy CSV-szerű fájlt, amelyben soronként terméknév,darabszám,egységár formátumú adatok vannak. A függvény számítsa ki minden termék teljes értékét (darabszám × egységár), és adja vissza az átlagos termékértéket!

Példa:

Fájl tartalma (termekek.txt): 

1
2
3
alma,10,150
körte,5,200
szilva,8,180


1
2
print(termekek_atlagara("termekek.txt"))
# 1640.0  ((10*150 + 5*200 + 8*180) / 3)
Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
def termekek_atlagara(fajlnev):
    with open(fajlnev, "r", encoding="utf-8") as f:
        sorok = f.readlines()

    ertekek = []
    for sor in sorok:
        sor = sor.strip()
        darabok = sor.split(",")
        darabszam = int(darabok[1])
        egysegar = int(darabok[2])
        teljes_ertek = darabszam * egysegar
        ertekek.append(teljes_ertek)

    return sum(ertekek) / len(ertekek)
9. feladat - Szűrt szavak megfordítva fájlba

Írj egy függvényt szurt_szavak_fajlba(szoveg, fajlnev, min_hossz) néven, amely egy szöveget kap paraméterként, és a szöveg szavait külön sorokba írja a megadott fájlba, de:

  • Csak azokat a szavakat, amelyek legalább min_hossz karakteresek
  • Minden szót megfordítva (visszafelé) írjon ki
  • Minden sor végére tegyen egy felkiáltójelet!

Példa: 

1
2
szoveg = "alma kör te szilva eper barack"
szurt_szavak_fajlba(szoveg, "gyumolcsok.txt", 4)

A gyumolcsok.txt tartalma: 

1
2
3
4
amla!
avlizs!
repe!
karab!

Megjegyzés: "kör" és "te" szavak 3 ill. 2 karakteresek, ezért nem kerültek be (min_hossz=4).

Példamegoldás 
1
2
3
4
5
6
7
def szurt_szavak_fajlba(szoveg, fajlnev, min_hossz):
    szavak = szoveg.split()
    with open(fajlnev, "w", encoding="utf-8") as f:
        for szo in szavak:
            if len(szo) >= min_hossz:
                megforditott = szo[::-1]
                f.write(megforditott + "!\n")

Komplex feladatok

10. feladat - Termékadatok komplex feldolgozása

Ez egy összetett feladat, amely három függvényt igényel!

Írj egy programot, amely termékadatokat dolgoz fel. A program három függvényből áll:

1. termekek_beolvasasa(fajlnev) függvény:

  • Beolvas egy fájlt, amelyben soronként terméknév,ár,kategória formátumú adatok vannak
  • Visszaad egy szótárat, ahol a kulcsok a terméknevek, az értékek pedig szótárak {"ar": int, "kategoria": str} formátumban

2. termekek_elemzese(termekek) függvény:

  • Paraméterként egy szótárat vár (az előző függvény kimenetét)
  • Visszaad egy új szótárat az alábbi szerkezettel:
    • "atlag_ar": az összes termék átlagára
    • "legdragabb": a legdrágább termék neve
    • "atlag_feletti": lista azokról a termékekről, amelyek drágábbak az átlagnál (csak a nevek)
    • "kategoriak": szótár, ahol a kulcsok a kategóriák, az értékek pedig az adott kategória termékeinek átlagára

3. eredmenyek_mentese(fajlnev, eredmenyek) függvény:

  • Paraméterként egy fájlnevet és az előző függvény által visszaadott szótárat várja
  • Kiírja az eredményeket egy fájlba olvasható formában: 
    1
2
3
4
5
6
    Átlagár: 1250.0
Legdrágább: laptop
Átlag feletti termékek: laptop, telefon
Kategória átlagok:
- elektronika: 1500.0
- ruha: 800.0

Példa használat:

Bemeneti fájl (termekek.txt): 

1
2
3
4
laptop,2000,elektronika
telefon,1500,elektronika
póló,600,ruha
nadrág,1000,ruha


 1
 2
 3
 4
 5
 6
 7
 8
 9
10
termekek = termekek_beolvasasa("termekek.txt")
eredmenyek = termekek_elemzese(termekek)
eredmenyek_mentese("osszefoglalo.txt", eredmenyek)
print(eredmenyek)
# {
#     "atlag_ar": 1275.0,
#     "legdragabb": "laptop",
#     "atlag_feletti": ["laptop", "telefon"],
#     "kategoriak": {"elektronika": 1750.0, "ruha": 800.0}
# }
Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
def termekek_beolvasasa(fajlnev):
    termekek = {}
    with open(fajlnev, "r", encoding="utf-8") as f:
        sorok = f.readlines()

    for sor in sorok:
        sor = sor.strip()
        darabok = sor.split(",")
        nev = darabok[0]
        ar = int(darabok[1])
        kategoria = darabok[2]
        termekek[nev] = {"ar": ar, "kategoria": kategoria}

    return termekek

def termekek_elemzese(termekek):
    # Átlagár számítása
    osszes_ar = sum(adat["ar"] for adat in termekek.values())
    atlag_ar = osszes_ar / len(termekek)

    # Legdrágább termék
    legdragabb = max(termekek, key=lambda x: termekek[x]["ar"])

    # Átlag feletti termékek
    atlag_feletti = []
    for nev, adat in termekek.items():
        if adat["ar"] > atlag_ar:
            atlag_feletti.append(nev)

    # Kategória átlagok
    kategoriak = {}
    for nev, adat in termekek.items():
        kat = adat["kategoria"]
        if kat not in kategoriak:
            kategoriak[kat] = []
        kategoriak[kat].append(adat["ar"])

    kategoria_atlagok = {}
    for kat, arak in kategoriak.items():
        kategoria_atlagok[kat] = sum(arak) / len(arak)

    return {
        "atlag_ar": atlag_ar,
        "legdragabb": legdragabb,
        "atlag_feletti": atlag_feletti,
        "kategoriak": kategoria_atlagok
    }

def eredmenyek_mentese(fajlnev, eredmenyek):
    with open(fajlnev, "w", encoding="utf-8") as f:
        f.write(f"Átlagár: {eredmenyek['atlag_ar']}\n")
        f.write(f"Legdrágább: {eredmenyek['legdragabb']}\n")
        f.write(f"Átlag feletti termékek: {', '.join(eredmenyek['atlag_feletti'])}\n")
        f.write("Kategória átlagok:\n")
        for kat, atlag in eredmenyek["kategoriak"].items():
            f.write(f"- {kat}: {atlag}\n")
11. feladat - Könyvtári rendszer feldolgozás

Írj egy függvényt modern_konyvek_szerzokkel(fajlnev, evhatar) néven, amely:

  1. Beolvas egy fájlt, amelyben soronként könyvcím;szerző;kiadási_év formátumú adatok vannak (pontosvesszővel elválasztva!)
  2. Csak azokat a könyveket dolgozza fel, amelyek kiadási éve >= evhatar
  3. Visszaad egy szótárat, ahol a kulcsok a szerzők nevei, az értékek pedig az adott szerző modern könyveinek címei egy listában

Példa fájl (konyvek.txt): 

1
2
3
4
5
6
A Gyűrűk Ura;J.R.R. Tolkien;1954
Harry Potter;J.K. Rowling;1997
A Babó;J.R.R. Tolkien;1937
Trónok harca;George R.R. Martin;1996
A Witcher;Andrzej Sapkowski;2007
Legendárium;J.R.R. Tolkien;2004


1
2
3
4
5
6
7
print(modern_konyvek_szerzokkel("konyvek.txt", 1996))
# {
#     'J.K. Rowling': ['Harry Potter'],
#     'George R.R. Martin': ['Trónok harca'],
#     'Andrzej Sapkowski': ['A Witcher'],
#     'J.R.R. Tolkien': ['Legendárium']
# }

Megjegyzés: Tolkien 1954-es és 1937-es könyvei nem kerültek bele, mert nem érik el az 1996-os határt!

Példamegoldás 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
def modern_konyvek_szerzokkel(fajlnev, evhatar):
    szerzok = {}
    with open(fajlnev, "r", encoding="utf-8") as f:
        sorok = f.readlines()

    for sor in sorok:
        sor = sor.strip()
        darabok = sor.split(";")
        cim = darabok[0]
        szerzo = darabok[1]
        ev = int(darabok[2])

        # Csak a modern könyvek
        if ev >= evhatar:
            if szerzo in szerzok:
                szerzok[szerzo].append(cim)
            else:
                szerzok[szerzo] = [cim]

    return szerzok

Tippek

Tippek a nagy ZH-hoz

  • Mindig használd a with open() konstrukciót fájlkezelésnél!
  • Ne felejtsd el az encoding="utf-8" paramétert!
  • Használd az rstrip() vagy strip() függvényt sortörések eltávolítására!
  • A szótár bejárásánál az items() nagyon hasznos kulcs-érték párokhoz!
  • Komplex feladatoknál bontsd részfeladatokra a megoldást!
  • Tesztelj minden részfeladatot külön, mielőtt továbbmész!
  • Mindig olvasd el a Bíró reportját a konkrét hibákért!