Olvasd be a rendelesek.txt fájlt egy adatbazis nevű listába.

📥 Fájlok letöltése

📋 A beolvasott adatok mezői

A zárójelben lévő információk azt mutatják, hogyan kezeld őket a feldolgozás során.
Ne felejtsd el átalakítani a mezőket a megfelelő adattípusra, kivéve ahol a feladat azt írja, hogy ne.

• x[0]: Rendelés ID (int)
• x[1]: Vevő neve (str)
• x[2]: Város (str)
• x[3]: Kategória (str)
• x[4]: Darabszám (int)
• x[5]: Fizetendő összeg (float vagy "HIBÁS") (ne alakítsd át)
• x[6]: Fizetési mód (str)
• x[7]: Kiszállítva státusz (bool)
• x[8]: Vevői értékelés 1.0–5.0 (float vagy "" ha hiányzik) (ne alakítsd át)
• x[9]: Szállítási idő napokban (int, vagy -1 ha hibás)

⚙️ A metódusok működése és sorrendje:

1. SZŰRÉS: Kiválogatjuk a megfelelő sorokat
   szurt_adatok = list(filter(lambda x: <FELTÉTEL>, adatbazis))
2. RENDEZÉS: Sorba állítjuk a szűrt listát (reverse=True, ha csökkenő)
   rendezett_adatok = sorted(szurt_adatok, key=lambda x: <MI_ALAPJÁN>)
3. MAP-ELÉS: Csak a kért oszlopokat tartjuk meg
   eredmeny = list(map(lambda x: <KÉRT_OSZLOPOK>, rendezett_adatok))

📖 Bevezető feladatok:

1. Szűrd ki a már kiszállított (True) rendeléseket, rendezd őket a darabszám szerint növekvő sorrendbe, majd szűkítsd a listát csak a Vevő nevére és a Darabszámra!

szurt_1 = list(filter(lambda x: x[7], adatbazis))
rendezett_1 = sorted(szurt_1, key=lambda x: x[4])
megoldas_1 = list(map(lambda x: [x[1], x[4]], rendezett_1))

Megoldás részletezése (olvasd el)

• szurt_1 = list(filter(lambda x: x[7], adatbazis))
  • adatbazis: ez a lista (ebbe pakoltad bele a fájl tartalmát). A megoldás legvégén áll, de ez az, amin a szűrést el akarjuk végezni. Mindig ez lesz az utolsó paraméter.
  • filter() függvény: A filter() a „szűrőberendezés”. Két dolgot vár tőled, hogy működni tudjon:
    • Mit szűrjön meg? Ez a második paraméter, jelenleg az adatbazis lista.
    • Milyen feltétel alapján szűrjön? Ez az első paraméter, ide egy függvényt kell adnunk (ami általában lambda, de def is lehetne), ami eldönti minden egyes sorról, hogy megtartjuk-e vagy sem.
  • lambda x: x[7] kifejezés (a szűrési feltétel): Az x itt egyetlen rendelés adatsorát jelenti. A filter elkezdi végigpörgetni az adatbazis-t (mint egy ciklus), és minden egyes lépésben az aktuális felhasználó listája lesz az x.
  • x[7]: A kettőspont után jön az a feltétel, amire a lambda függvénynek True vagy False választ kell adnia.
    • A Kiszállítva státusz a lista 8. eleme, tehát az 7-es indexen található (mivel a számozás 0-tól indul).
    • Az x[7] önmagában egy logikai érték (True vagy False).
    • Ha egy rendelésnél az x[7] értéke True (tehát aktív), a filter átengedi (bekerül a szurt_1 filterbe). Ha False (inaktív), akkor eldobja (nem kerül be a szurt_1 filterbe).
  • list() konverzió: Amikor a filter() befejezi a munkát, az eredmény nem egy lista lesz, hanem egy speciális filter objektum. Ahhoz, hogy ezt újra egy normális, olvasható listaként tudjuk használni, át kell alakítani (ki kell csomagolni) egy listába a list(...) paranccsal. Ez „kicsomagolja” a szűrt eredményeket egy új listába, amit eltárolunk a szurt_1 változóban.
• rendezett_1 = sorted(szurt_1, key=lambda x: x[4])
  • szurt_1: Itt már nem az eredeti adatbazis listát adjuk meg, hanem az előző lépésben leszűrt szurt_1 listát! Csak a kiszállított rendeléseket akarjuk sorba állítani.
  • sorted() függvény: Ez a Python rendező metódusa. Két (néha három) dolgot adunk meg neki:
    • Mit rendezzen sorba? Ez az első paraméter (szurt_1).
    • Mi alapján rendezzen? Mivel egy rendelésben 10 különböző adat van, a sorted nem tudja magától, hogy a város, az összeg vagy a darabszám szerint akarod-e őket sorba rakni. A key = ... paraméterrel mutathatod meg neki, melyik oszlop szerint cselekedjen.
    • És mi lehet a harmadik dolog? A rendezés iránya! A sorted() alapértelmezetten növekvő sorrendbe rakja az adatokat (számoknál a legkisebbtől a legnagyobbig, szövegeknél A-tól Z-ig), ezért most nem kellett külön odaírnunk. Ha viszont csökkenő sorrendet szeretnél, akkor harmadik paraméterként meg kell adnod a reverse = True beállítást.
  • key = lambda x: x[4]: Darabszám szerint kell rendezned, ami a lista 5. eleme, vagyis negyedik indexe.
  • Hol van a list()? A filter()-rel és a map()-pel ellentétben a sorted() függvény egy kész listát ad vissza, amit egyből elment a rendezett_1 változóba.
• megoldas_1 = list(map(lambda x: [x[1], x[4]], rendezett_1))
  • rendezett_1: A sor legvégén most az előző lépésben már leszűrt (filter) és sorba rendezett (sorted) listánk áll.
  • map() függvény: A map() biztosítja, hogy szűkítsd az oszlopok számát. Felépítésében nagyon hasonlít a filter()-re, két dolgot vár:
    • Mit alakítson át? Ez a második paraméter, jelenleg a rendezett_1 lista.
    • Hogyan alakítsa át? Ez az első paraméter (a lambda függvény). A map() nem sorokat dob el, mint a filter(), hanem minden egyes sorból (x) pontosan azt csinál, amit a kettőspont után megadsz neki.
  • lambda x: [x[1], x[4]]: Az x továbbra is egy teljes, 10 adatból, elemből álló sor. A kettőspont után viszont megmondhatod, hogy ebből a 10 adatból egy 2 elemű kis listát ([...]) szeretnél csinálni:
    • x[1]: A vevő neve
    • x[4]: A darabszám
    • A külső szögletes zárójel [...] azért kell, mert egy sorból több adatot is meg akarsz tartani, ha csak egyet szeretnél, akkor ez nem kellene, és ezeket össze kell fognod egy belső listába. Az összes többi oszlop (ID, város, összeg stb.) ebben a lépésben eltűnik.
  • list() konverzió: Pontosan úgy, mint a filter()-nél, a map() is egy speciális objektumot ad vissza. Ahhoz, hogy ebből egy kiíratható lista legyen, be kell csomagolnod a list(...) parancsba.

2. Keresd meg a budapesti rendeléseket, rendezd őket a Vevő neve szerint ABC sorrendbe, végül csak egyetlen adatot (a Vevő nevét) tartsd meg a listában!

szurt_2 = list(filter(lambda x: x[2] == "Budapest", adatbazis))
rendezett_2 = sorted(szurt_2, key=lambda x: x[1])
megoldas_2 = list(map(lambda x: x[1], rendezett_2))

Megoldás részletezése (olvasd el)

• megoldas_2 = list(map(lambda x: x[1], rendezett_2))
• Mivel a lambda x: x[1] kifejezésben az x[1] köré nem tettünk szögletes zárójelet (nem [x[1]]-et írtunk), a map() függvény minden egyes sorból csak magát a szöveget (a vevő nevét) veszi ki.
• A korábbi kétdimenziós listából (lista a listában) egy egydimenziós lista lesz.
• A map előtt listák a listában (rendezett_2):
  [[1042, "Balogh Máté", "Budapest", ...], [1015, "Farkas Zita", "Budapest", ...]]
• A map után csak sima stringek egy listában (megoldas_2):
  ["Balogh Máté", "Farkas Zita", ...]

🚀 További feladatok és megoldások:

Figyelj arra, hogy jelenleg néhány adatod stringként maradt eltárolva a listában (pl. hiányzó vagy hibás értékek miatt)!

szurt_3 = list(filter(lambda x: x[3] == "Elektronika", adatbazis))
rendezett_3 = sorted(szurt_3, key=lambda x: x[0], reverse=True)
megoldas_3 = list(map(lambda x: [x[0], x[2], x[6]], rendezett_3))

szurt_4 = list(filter(lambda x: not x[7] and x[6].lower() == "utánvét", adatbazis))
rendezett_4 = sorted(szurt_4, key=lambda x: x[2])
megoldas_4 = list(map(lambda x: [x[2], x[1]], rendezett_4))

💻 Interaktív Kódszerkesztő és Tesztelés

A feladatok teszteléséhez előkészítettünk egy kisebb tesztadatbázist közvetlenül a szerkesztőbe ágyazva. Írd meg alá a szűréseket, és kattints a Futtatás gombra!

🧠 Tudásellenőrző Kvíz

Teszteld a tudásodat a Python filter, sorted és map metódusainak együttes használatáról! Válaszold meg a kérdéseket, és kattints a Teszt beküldése és értékelése gombra!