1-2. óra (09.05) A Python programozási nyelv alapjai
A Python programozási nyelv jellemzői (nagyon magas szintű nyelv, interpreteres, dinamikus adatkezelésű, jól áttekinthetű forrásprogramok írhatók benne, behúzásos technika, ...)
Alapvető matematikai műveletek elvégzése az interpreter segítségével (+, -, *, /, **, //, %)
Kerekítés: round(szám, tizedesjegyek száma)
Kiírás a képernyőre: print() utasítás segítségével
Beolvasás a billentyűzetről: input() utasítással
Számtípusok: int (integer, egész); float (valós)
Egyszerű programok írása Pythonban:
- téglalap területének és kerületének kiszámítása és kiíratása
- téglatest felszínének és térfogatának kiszámítása és kiíratása

5-6. óra (09.19.) Ciklusok a Pythonban. Programozási tételek
I. A házi feladat ellenőrzése
II. Ciklusok a Pythonban
Írassuk ki a 100-nál kisebb, 3-mal osztva 1 maradékot adó pozitív egész számokat!
A program (megszámlálásos):
for i in range(100):
    if i % 3 == 1:
        print(i)

Ugyanennek a feladatnak a megoldása elöl tesztelő ciklussal:
i = 1
while i < 100:
    if i % 3 == 1:
        print(i)
    i += 1

III. Programozási tételek
1. Összegzés tétele: adjunk össze N darab számot, amik egy a() vektorban vannak tárolva!
Az algoritmus mondatszerű leírása:
s = 0
ciklus i = 1-től N-ig
    s = s + a(i)
ciklus vége
Ki: s

2. Eldöntés tétele: adott egy N elemű a() sorozat és a sorozat elemein értelmezett T tulajdonság. Van-e a sorozatban T tulajdonságú elem?
Az algoritmus mondatszerű leírása:
i = 1
ciklus amíg i <= N és a(i) nem T tulajdonságú
i = i + 1
ciklus vége
van = (i <= N)
Ha van, akkor ki: van T tulajdonságú elem; különben ki: nincs T tulajdonságú elem

Példaprogramok a programozási tételek alkalmazására.
1. Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám osztható-e 2-vel, illetve 3-mal!

x = int(input("Írd be a számot!"))
if x % 2 == 0:
    if x % 3 == 0:
        print("A szám osztható 6-tal.")
    else:
        print("A szám osztható 2-vel, de 3-mal nem.")
else:
    if x % 3 != 0:
        print("A szám nem osztható sem 2-vel, sem 3-mal.")
    else:
        print("A szám nem osztható 2-vel, de 3-mal igen.")

2. Döntsük el, hogy egy N=10 egész számot tartalmazó <a> listában van-e 5-tel osztható szám!
A Python program:
a = [2, 6, 8, 1, 4, 12, 16, 11, 22, 7]
n = len(a)
i = 0
while i <= n-1 and a[i] %5 != 0:
    i = i + 1
van = (i <= n-1)
if van:
    print('Van.')
else:
    print('Nincs.')

3. Olvassunk be a konzolról egy szöveget, majd döntsük el, hogy van-e a szövegben magánhangzó!

x = input('Kérem, írja be a szöveget: ')
valasz = False
for betu in x:
    if betu == 'a' or betu == 'e' or betu == 'i' or betu == 'o' or betu == 'u':
        valasz = True
if valasz:
    print('Van a szövegben magánhangzó.')
else:
    print('Nincs a szövegben magánhangzó.')

A 3. feladat megoldásának javított változata. Az első változatban (for.. ciklus) a program minden egyes betűjét megvizsgálja a szövegnek, amire sok esetben NINCS szükség. Ezért célszerű előltesztelő ciklust alkalmazni. Íme:

x = input('Kérem, írja be a szöveget: ')
n = len(x)   #a szövegben levő karakterek számát adja értékül az N változónak
i = 0       # mert a stringet indexelése is 0-val kezdődik
while i < n and (x[i] != 'a' and x[i] != 'e' and x[i] != 'i' and x[i] != 'o' and x[i] != 'u'):
    i += 1      # i értékét növeljük 1-gyel
valasz = (i < n)
if valasz:
    print("Van a szövegben magánhangzó.")
else:
    print("Nincs a szövegben magánhangzó.")

Házi feladat: írjunk programot, amely bekér egy szöveget és megszámolja, hogy hány darab magánhangzó van a szövegben!

9-10. óra (10.03.): Feladatok megoldása
1. Feladat: írjunk programot, ami beolvassa egy háromszög 3 oldalát és azokból kiszámolja a háromszög
területét (Héron-képlettel).
A program:
import math
a = float(input('a= '))
b = float(input('b= '))
c = float(input('c= '))
if a>0 and b>0 and c>0 and (a+b>c) and (a+c>b) and (b+c>a):
    s = (a+b+c)/2
    t = math.sqrt(s*(s-a)*(s-b)*(s-c))
    print('A háromszög területe: ', round(t, 2))
else:
    print('Nem létezik a háromszög!')

2. Feladat: OLvassunk be egy szöveget a billentyűzetről egy sztringbe, majd számoljuk meg, hogy hány magánhangzó van a szövegben!
A program:
x = input('Kérem, írja be a szöveget: ')
s = 0 #a szövegben levő magánhangzók számát adja majd eredményül
for betu in x:
    if betu == 'a' or betu == 'e' or betu == 'i' or betu == 'o' or betu == 'u':
        s = s + 1
print('A szövegben levő magánhangzók száma: ', s)

3. Feladat: Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám osztható-e 2-vel, illetve 3-mal!
A program:
x = int(input("Írd be a számot!"))
if x % 2 == 0:
    if x % 3 == 0:
        print("A szám osztható 6-tal.")
    else:
        print("A szám osztható 2-vel, de 3-mal nem.")
else:
    if x % 3 != 0:
        print("A szám nem osztható sem 2-vel, sem 3-mal.")
    else:
        print("A szám nem osztható 2-vel, de 3-mal igen.")

4. Feladat: Írj egy programot, mely egy beolvasott számról eldönti, hogy a különböző
pénzérmékből/papírcímletekből (5, 10, 20, 50, 100, 200, 500, 1000, 2000, 5000) hány darab
szükséges ahhoz, hogy összértékük a beolvasott szám legyen, de a lehető legkevesebb címletet használjuk fel ehhez!
A program:
cimletek = [5000, 2000, 1000, 500, 200, 100, 50, 20, 10, 5]
x = int(input('Kérem az összeget! '))
darab = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
i = 0
while x >= 5 and i <= 10:
    db = x // cimletek[i]
    darab[i] = db
    x = x - db * cimletek[i]
    i = i + 1
n = len(cimletek)
for j in range(0, n):
    print(cimletek[j],'Ft-osból ',darab[j],' darab kell.')

5. Feladat: Írj egy programot, mely beolvas egy 10-es számrendszerbeli számot, majd kiírja annak a 2-es és 16-os számrendszerbeli megfelelőjét/alakját!

6. Feladat: Írj egy programot, mely bekéri a billentyűzetről az éjfél óta eltelt másodpercek számát, és kiírja az időpontot óra:perc:másodperc formában!
A program:
x = int(input('Kérem a másodpercek számát! '))
ora = x // 3600
x = x - ora * 3600
perc = x // 60
mperc = x - perc * 60
print(ora,':',perc,':',mperc)

7. Feladat: Olvassunk be a billentyűzetről egy egész számot és írassuk ki az 1-nél nagyobb legkisebb pozitív osztóját!
A program:
n = int(input('Kérem az egész számot! '))
i = 2
while n % i != 0:
    i = i + 1
print('Az 1- nél nagyobb legkisebb osztó: ', i)

8. Feladat: Olvassunk be egy egész számot a billentyűzetről és döntsük el, hogy a szám prím-e!
A program:
n = int(input('Kérem az egész számot! '))
i = 2
while n % i != 0:
    i = i + 1
if i == n:
    print('A szám prím.')
else:
    print('A szám nem prím.')

13-14. óra: Maximum-kiválasztás tétele, gyakorló feladatok (2019.11.07 és 11.14)

Eddig megismertük az Összegzés tételét és az Eldöntés tételét. Mindkét tételt gyakran kell alkalmazni feladatok megoldásában, így az emelt szintű érettségin is.
Hasonlóan fontos és gyakran előfordul a Maximum-kiválasztás tétele is.
Miről is van itt szó?
Adva van például egy számokból álló sorozat. Az a feladat, hogy mondjuk meg, melyik ezek közül a legnagyobb?
Előfordulhat, hogy a sorozatban több legnagyobb elem van. Ilyenkor általában elég egyet megadni eredményként.
Azt is megkérdezhetjük, hogy hányadik tagja a sorozatnak a legnagyobb elem?
Nézzük az algoritmus mondatszerű leírását:
Eljárás: Be: N, a() 
max = a(1)
ciklus i = 2-től n-ig
   Ha a(i) > max, akkor max = a(i)          (*)
ciklus vége
Ki: max
Most értelmezzük az algoritmust sorról-sorra.
Az első lépésben egy max nevű változónak értéket adunk: legyen egyenlő a sorozat első elemével.
Ezután elindítunk egy megszámlálásos ciklust, ami i=2-tól indul, hiszen az első elem lett a max értéke.
A ciklusmagban egy feltételvizsgálat van: megvizsgáljuk, hogy a sorozat i-edik eleme nagyobb-e a max értékénél.
Ha igen, akkor ez azt jelenti, hogy az addigi legnagyobb elemnél találtunk nagyobbat, tehát erre az értékre kell beállítani a max értékét.
Ha nem, akkor vesszük a sorozat következő elemét.
Amikor vége a ciklusnak, a max nevű változóban lesz a sorozat legnagyobb eleme.
Megjegyzés: ennek a tételnek a párja a minimum-kiválasztás tétele. Ennek az algoritmusában max helyett min van,
továbbá a (*)-gal jelölt sorban a következő szerepel: Ha a(i) < min, akkor min = a(i)
Nézzünk erre egy konkrét feladatot! Legyenek a sorozat elemei egy listában, a neve adatok.
adatok = [2, 1, 9, 6, 7, 3, 4, 11, 5, 8]. Itt az elemek száma: N = 10.
A Python program:
adatok = [2, 1, 9, 6, 7, 3, 4, 11, 5, 8]
n = len(adatok)   #meghatározzuk a sorozat elemszámát
max = adatok[0]   #vigyázat! Már sokszor mondtam, hogy a listában az indexelés 0-val kezdődik!
for i in range(1, n):
   if adatok[i] > max:
      max = adatok[i]
print('A sorozat legnagyobb eleme: ', max)

Ennyi!
Feladatok a maximum-kiválasztás tételére:
1. Adott egy listában N darab szó. Mondjuk meg, hogy melyik a leghosszabb, ez hányadik a sorban és hány karakterből áll?
A Python program:
szoveg = ['alma', 'banan', 'mandarin', 'fuge', 'kelkaposzta', 'dio', 'eper', 'szilva']
maxszo = szoveg[0]
max = len(maxszo)
index = 0
n = len(szoveg)
for i in range(1, n):
    if len(szoveg[i]) > max:
        max = len(szoveg[i])
        maxszo = szoveg[i]
        index = i
print('A leghosszabb szó a(z) {0}, indexe {1}, hossza {2} karakter.'.format(maxszo, index+1, max))

2. Írjunk programot, amely egy N elemet tartalmazó tömbről megmondja, hogy a szomszédos elemek között mekkora a legnagyobb különbség abszolút értékben!
A Python program:
tomb = [2, 1, 5, 4, 11, 6, 8, 20, 14, 7]
n1 = len(tomb)
max = abs(tomb[1] - tomb[0])
for i in range(1, n1-1):
    if abs(tomb[i+1] - tomb[i]) > max:
        max = abs(tomb[i+1] - tomb[i])
print('A legnagyobb különbség abszolut értékben: ', max)

3. Írjunk programot, amely egy N elemet tartalmazó tömbről megmondja, hogy melyik két eleme között legkisebb a különbség!

Fájlkezelés a Pythonban
Legyen a fizikai fájl neve: adat.txt. Ha a logikai fájl neve f, akkor a két fájl egymáshoz rendelése és egyben a fizikai állomány megnyitása történhet például így:
f = open('adat.txt', 'r')    #itt 'open' a fájl megnyitására, 'r' az olvasására (read) utal
És ha már belekezdtünk a fájlkezelésbe, akkor nézzük meg a legújabb (2019. őszi) emelt szintű informatika érettségi első néhány feladatának a megoldását!
A feladat szövege az alábbi volt:
eUtazás
Egyre több országban fordul elő, hogy a közlekedési eszközökön használatos bérleteket és jegyeket valamilyen elektronikus eszközön (például: chipes kártya) tárolják. Egy nagyváros
ilyen rendszert szeretne bevezetni a helyi közlekedésben, amelyet néhány buszjáraton tesztelnek. Ezekre a buszokra csak az első ajtónál lehet felszállni, ahol egy ellenőrző eszközhöz
kell érinteni a kártyát, amelynek chipje tartalmazza a jegy vagy bérlet információkat. A busz ellenőrző eszköze statisztikai és fejlesztési célból rögzíti a felszállók kártyájának
adatait. Az utasadat.txt szóközökkel tagolt állomány egy, a tesztelésben részt vevő busz végállomástól-végállomásig tartó útjának adatait tartalmazza.
Az utasadat.txt állomány legfeljebb 2000 sort tartalmaz és minden sorában 5 adat szerepel. Ezek:
• a megálló sorszáma (0-29; 0 az indulás helye és a 30 a végállomás, ahol már nem lehet felszállni.)
• a felszállás dátuma és időpontja (ééééhhnn-óópp formátumban, kötőjellel elválasztva a dátum és az idő)
• a kártya egyedi azonosítója (hétjegyű szám), egy utas a járaton legfeljebb egyszer utazik
• a jegy vagy bérlet típusa:
Azonosítók és megnevezésük: FEB Felnőtt bérlet; TAB Tanulóbérlet (kedvezményes); NYB Nyugdíjas bérlet (kedvezményes); NYP 65 év feletti bérlet (ingyenes) RVS Rokkant, vak, siket vagy kísérő bérlet (ingyenes); GYK Iskolakezdés előtti gyerekbérlet (ingyenes); JGY Jegy
• a bérlet érvényességi ideje, vagy a felhasználható jegyek száma. A bérlet esetén a dátum [i]ééééhhnn formátumban szerepel, jegy esetén egy 0-10 közötti szám szerepel.
Például:
0 20190326-0700 6572582 RVS 20210101
0 20190326-0700 8808290 JGY 7
0 20190326-0700 1680423 TAB 20190420
12 20190326-0716 3134404 FEB 20190301
12 20190326-0716 9529716 JGY 0
A fenti példában szereplő adatoknál látható, hogy az induló állomáson (0. állomás) 2019. 03. 26-án 7:00-kor a 1680423 kártyaazonosítójú utas tanulóbérlettel szállt fel, amely
2019. 04. 20-ig érvényes. A 12. állomáson 2019. 03. 26-án 7:16-kor a 9529716 kártyaazonosítójú utas jeggyel szállt volna fel, de már elhasználta az összes jegyét (0).
Készítsen programot, amely az utasadat.txt állomány felhasználásával a következő kérdésekre válaszol! A program forráskódját eutazas néven mentse!

1. Olvassa be és tárolja el az utasadat.txt fájl tartalmát!
adat = []
f = open('utasadat.txt', 'r')
for sor in f:
   sor = sor.strip().split()
   adat.append(sor)

2. Adja meg, hogy hány utas szeretett volna felszállni a buszra!
print('2. feladat')
n = len(adatok)                     #egyszerűen lekérdezzük a listában levő elemek számát, majd kiíratjuk a képernyőre a print utasítással
print('A buszra felszállók száma: ', n)

3. A közlekedési társaság szeretné, ha a járművőn csak az érvényes jeggyel vagy bérlettel rendelkezők utaznának. Ezért a jegyeket és bérleteket a buszvezető a felszálláskor ellenőrzi.
(A bérlet még érvényes a lejárat napján.) Adja meg, hogy hány esetben kellett a buszvezetőnek elutasítania az utas felszállását, mert lejárt a bérlete vagy már nem volt jegye!
print('3. feladat')
db3 = 0                             #ebben a változóban számoljuk össze azokat, akik nem szállhattak fel a buszra
for sor3 in adatok:                 #ehhez egy megszámlálásos ciklust szervezünk
    if sor3[4] == '0':              #egyrészt az nem szállhat fel, akinek NINCS jegye
        db3 += 1                    #ekkor megnöveljük a db3 változó értékét 1-gyel
    if len(sor3[4]) == 8:           #másrészt ahol az utolsó adat dátum (8 karakterből áll!)
        if sor3[1][:8] > sor3[4]:  #az sem szállhat fel, akinek bérlete van, de az már lejárt
            db3 += 1                   #ekkor is megnöveljük 1-gyel a db3 változó értékét
print('A buszra {} utas nem szállhatott fel.'.format(db3))

És ha már a mai alkalommal a maximum-kiválasztás tételével foglalkoztunk, akkor oldjuk meg a 4. feladatot is, ami éppen ennek a tételnek az alkalmazását kívánja.

4. Adja meg, hogy melyik megállóban próbált meg felszállni a legtöbb utas! (Több azonos érték esetén a legkisebb sorszámút adja meg!)
print('4. feladat')
darab4 = []                         #létrehozunk egy darab4 nevű listát (üres)
for i in range(30):
    darab4.append(0)                #feltöltjük a listát 30 darab 0-val
for sor4 in adatok:                 #végig iterálunk az adatok nevű listán
    ssz = int(sor4[0])              #lekérdezzük az aktuális allistában a nap sorszámát, majd
    darab4[ssz] += 1                #a darab4 lista adott sorszámú elemét 1-gyel megnöveljük
#print(darab4)
max4 = darab4[0]                    #Most indul egy maximum-kiválasztás, ahol
maxindex = 0                        #meghatározzuk annak a napnak a sorszámát (maxindex) és az előfordulások számát (max4)
for i in range(1, 30):
    if darab4[i] > max4:            #ahol a legtöbb utas próbált felszállni
        max4 = darab4[i]
        maxindex = i
print('A legtöbb utas ({0} fő) a {1}. megállóban próbált felszállni.'.format(max4, maxindex))

5. A közlekedési társaságnak kimutatást kell készítenie, hogy hányszor utaztak valamilyen kedvezménnyel a járművön. Határozza meg, hogy hány kedvezményes és hány ingyenes
utazó szállt fel a buszra! (Csak az érvényes bérlettel rendelkező szállhatott fel a buszra!)
Megoldás: ha megnézzük a sorok értelmezését, láthatjuk, hogy kedvezményesen a tanulóbérletesek (TAB) és a nyugdíjas bérletesek (NYB) utaznak.
Ugyanakkor ingyenesen a 65 év feletti bérletesek (NYP), a rokkant, vak, siket vagy kísérő bérlettel utazók (RVS), valamint az iskolakezdés előtti gyerekbérletesek (GYK) utaznak.
Ennek megfelelően a program:
print('5. feladat')
kedv5, ingy5 = 0, 0                 # két változónak (kedv5 és ingy5) kezdőértéket adunk (0). Ezekben lesz a végén a kedvezményesen, illetve ingyenesen utazók száma.
for sor5 in adatok:                  #végigmegyünk az adatok nevű lista minden elemén (al-listáján).
    if sor5[3] == 'TAB' or sor5[3] == 'NYB':    #ha kedvezményezett az illető, vagyis ha tanuló- vagy nyugdíjas bérlettel rendelkezik,
        kedv5 += 1                              #ekkor a kedv5 értékét megnöveljük 1-gyel
    if sor5[3] == 'RVS' or sor5[3] == 'NYP' or sor5[3] == 'GYK': #ingyen azok utaznak, akik rokkantak vagy 65 év felettiek
        ingy5 += 1                              #vagy gyermekbérlettel rendelkeznek. Ekkor az ingy5 értékét növeljük 1-gyel
print('Ingyenesen utazók száma: {} fő'.format(ingy5))
print('A kedvezményesen utazók száma: {} fő'.format(kedv5)) #a végén kiíratjuk ennek a két változónak az értékét

################################################################

6. Készítsen függvényt napokszama néven az alábbi algoritmus alapján. Az algoritmus a paraméterként megadott két dátumhoz (év, hónap, nap) megadja a közöttük eltelt napok
számát! (A MOD a maradékos osztást, a DIV az egészrészes osztást jelöli.) Az algoritmust a fuggveny.txt fájlban is megtalálja. A függvényt a következő feladat megoldásához
felhasználhatja.
Megoldás: a megadott algoritmust át kell írni Pythonba. A MOD-nak a Pythonban a % felel meg, míg a DIV-nek a //.
Ennek megfelelően a program:
print('6. feladat')
print('Függvény létrehozása...')
def fgv_napoksz(e1,  h1, n1, e2, h2, n2):       #utazás éve, hónapja és napja, valamint a bérlet érvényességének éve, hónapja és napja
    h1 = (h1 + 9) % 12
    e1 = e1 - h1 // 10
    d1 = e1*365 + e1 // 4 -  e1 // 100 + e1 // 400 + (h1*306 + 5) // 10 + n1 - 1
    h2 = (h2 + 9) % 12
    e2 = e2 - h2 // 10
    d2 = e2*365 + e2 // 4 -  e2 // 100 + e2 // 400 + (h2*306 + 5) // 10 + n2 - 1
    napokszama = d2 - d1                        # a két dátum közötti napok száma
    return napokszama                           #ez a függvény kimeneti értéke

######################################################################x

7. A közlekedési társaság azoknak az utasoknak, akiknek még érvényes, de 3 napon belül lejár a bérlete, figyelmeztetést szeretne küldeni e-mailben.
(Például, ha a felszállás időpontja 2019. február 5., és a bérlet érvényessége 2019. február 8., akkor már kap az utas levelet,
ha 2019. február 9. az érvényessége, akkor még nem kap levelet.) Válogassa ki és írja a figyelmeztetes.txt állományba ezen utasok kártyaazonosítóját és a bérlet
érvényességi idejét (éééé-hh-nn formátumban) szóközzel elválasztva!
Az utolsó részfeladat megoldásának programja:
print('7. feladat')
print('Adatok kiírása fájlba.')
g = open('figyelmeztetes.txt', 'w')
for sor7 in adatok:
    if sor7[3] != 'JGY':
        e1 = int(sor7[1][:4])
        h1 = int(sor7[1][4:6])
        n1 = int(sor7[1][6:8])
        e2 = int(sor7[4][:4])
        h2 = int(sor7[4][4:6])
        n2 = int(sor7[4][6:8])
        delta = fgv_napoksz(e1, h1, n1, e2, h2, n2)
        if delta <= 3:
            ki = sor7[2] + ' ' + sor7[4][:4] + '-' + sor7[4][4:6] + '-' + sor7[4][6:8] + '\n'
            g.write(ki)
g.close()

See You Later!

21 - 22. óra 2019. december 05.
Most oldjuk meg ugyanazokat a feladatokat, mint az előző 2 alkalommal, csak más adatszerkezet alkalmazásával.
Az adatok nevű lista elemei listák legyenek, mégpedig olyanok, amik az adott vásárlás árucikkeit tartalmazzák.
Ezzel a módszerrel látni fogjuk, hogy több feladat is lényegesen egyszerűbben lesz megoldható, mint az előző esetben.
Íme a program:
print('1. feladat: adatok beolvasása fájlból egy listába.')
adatok = []     #üres lista létrehozása
adat = []
f = open('penztar.txt', 'r')        #fájl megnyitása olvasásra
for sor in f:
    sor = sor.strip()
    if sor != 'F':
        adat.append(sor)            #ha a beolvasott szöveg nem az 'F' betű, akkor hozzáfűzzük az adat nevű listához
    else:
        adatok.append(adat)         #ha a beolvasott szöveg az 'F' betű, akkor vége a vásárlásnak, az adat listát
        adat = []                   #hozzáfűzzük az adatok listához, majd az adat listát kiüresítjük
f.close()                           #az utolsó sor beolvasása után lezárjuk a fájlt
#print(adatok)

#########################################################

print('2. feladat: hányszor fizettek a pénztárnál?')
n = len(adatok)                     #annyiszor fizettek a pénztárnál, ahány allista van az adatok nevű listában
print('A pénztárnál {0} esetben fizettek.'.format(n))
########################################################

print('3. feladat: az első vásárlónak hány arucikk volt a kosarában?')
db3 = len(adatok[0])                #az első vásárlás az adatok nevű lista 0. elemének (allistájának) elemszáma
print('Az első vásárlónak {0} darab árucikk volt a kosarában.'.format(db3))
########################################################

print('4. feladat: egy sorszám, áruckk név és darabszám bekérése.')
ssz4 = int(input('Kérem a vásárlás sorszámát! '))
nev4 = input('Kérem az árucikk nevét!')
db4 = int(input('Kérem a darabszámot!'))
########################################################

print('5. feladat')
i50 = 0
while nev4 not in adatok[i50]:      #egy elöltesztelő ciklust indítunk, ami akkor fejeződik be, ha az allistában szerepel az árucikk
    i50 += 1
print('A bekért árucikkből a(z) {0}. alkalommal vásároltak először.'.format(i50 + 1))
i51 = n-1
while nev4 not in adatok[i51]:      #egy ciklussal az adatok lista végétől indulunk, amíg az adott árucikket meg nem találjuk
    i51 -= 1
print('A bekért árucikkből a(z) {0}. alkalommal vásároltak utoljára.'.format(i51 + 1))
db5 = 0
for sor5 in adatok:                 #végig iterálunk az adatok listán és ha , akkor a darabszámot
    if nev4 in sor5:                #van az adott allistában az árucikkből, akkor
        db5 += 1                    #a darab változó értékét megnöveljük 1-gyel
print('A bekért árucikkből összesen {0} alkalommal vásároltak.'.format(db5))

########################################################
print('\n6. feladat')
def ertek (x):
    if x == 1:
        fiz6 = 500
    elif x == 2:
        fiz6 = 950
    elif x > 2:
        fiz6 = 950 + (x -  2) * 400
    return fiz6
fizetes6 = ertek(db4)
print(db4, ' darab termék vásárlásakor a fizetendő összeg: ', fizetes6)
########################################################
print('\n7. feladat')
allista = adatok[ssz4 - 1]
alhalmaz = set(allista)
for sor7 in alhalmaz:
    db7 = 0
    for sor77 in allista:
        if sor77 == sor7:
            db7 += 1
    print(db7, sor7)
########################################################
print('\n8. feladat')
for i in range (10):
    allista = adatok[i]
    alhalmaz = set(allista)
    alh = []
    szum8 = 0
    for sor8 in alhalmaz:
        db8 = 0
        for sor87 in allista:
            if sor87 == sor8:
                db8 += 1
        alh.append(db8)
    #print(alh)
    for x in alh:
        szum8 += ertek(x)
    print(i+1, ':', szum8)
########################################################
Még hiányzik a végéről a fájlba való kiírás.