Perifériák – monitorok

Perifériák – monitorok

Perifériák

Monitorok

A monitor a számítógép egyik legfontosabb kimeneti perifériája: ezen keresztül válik láthatóvá a digitális tartalom. A kijelzők fejlődése közben nemcsak a képminőség változott, hanem maga a képalkotás fizikája is: a katódsugárcsöves rendszerek pásztázó nyalábjától eljutottunk a folyadékkristályok fényvezérlésén át az önállóan világító pixelekig. A mai monitorok megértéséhez ezért nem elég csak annyit tudni, hogy „IPS” vagy „OLED”, hanem azt is látni kell, milyen problémákat oldott meg az egyes technológiák megjelenése.

Anime lány matekot tanul, füzetében halmazok és Venn-diagram, halmazelmélet alapok illusztrációja.

Mi az a periféria, és miért fontos a monitor?

A periféria olyan hardvereszköz, amely a gazdaszámítógép működését egészíti ki. A monitor tipikusan kimeneti periféria, mert a számítógép által feldolgozott információt jeleníti meg. A modern számítógépes környezetben a monitor szerepe különösen fontos, mert a teljes felhasználói élmény — olvashatóság, színhűség, mozgásmegjelenítés, reakcióidő — ezen a periférián keresztül érzékelhető.

A perifériák működéséhez gyakran szükség van illesztőprogramra, vagyis driverre is. Ez biztosítja, hogy az operációs rendszer és az adott eszköz megfelelően kommunikáljon egymással. A monitorok alapfunkcióit ma már az operációs rendszerek jellemzően automatikusan kezelik, de a speciális képfrissítési, színkezelési vagy HDR-funkciókhoz még mindig fontos lehet a megfelelő eszköz- és grafikus driver.

Katódsugárcsöves technológia (CRT)

A CRT (Cathode Ray Tube – katódsugárcső) az a klasszikus megjelenítési technológia, amely évtizedekig uralta a televíziózást és a számítástechnikát.

Történeti háttér

A technológia fejlődése több mint egy évszázadot ölel fel, jelentős magyar hozzájárulással:

  • 1897: Karl Ferdinand Braun megalkotja az első katódsugárcsövet (Braun-cső), amely még csak egyetlen fénypontot tudott megjeleníteni.

  • 1926. január 26.: Londonban bemutatják az első működőképes televíziót.

  • 1928: Tihanyi Kálmán feltalálja a töltéscsatolt elvű CRT tévét és kamerát, ami a modern televíziózás alapja.

  • 1928. július 3.: Az első színes adás továbbítása nagy távolságra.

    Hogyan épül fel a kép? (Működési elv)

    A képalkotás folyamata a következő lépésekből áll:

    • Elektronkibocsátás: A cső végén található katódot egy fűtőszállal (kb. 6,3 V) hevítik, hogy elektronokat bocsátson ki.

    • Gyorsítás: A kilőtt elektronokat hatalmas feszültség, színes monitoroknál jellemzően 20–30 kV  gyorsítja fel a képernyő felé.

    • Pásztázás (Raster Scan): Az elektronágyú balról jobbra, fentről lefelé haladva rajzolja ki a képet.

      • Blanking (Kioltás): A sor végén a nyaláb kikapcsol, amíg visszaugrik a következő sor elejére.

    • Képfrissítés (Hertz): Azt adja meg, hányszor rajzolódik újra a teljes kép egy másodperc alatt. A modern monitoroknál ez 60–130 Hz közötti érték.

    • Foszfor-perzisztencia: A foszforréteg az elektronbecsapódás után rövid ideig tovább világít. Ha ez az idő túl rövid, a kép vibrál; ha túl hosszú, mozgáskor „szellemképes” (elmosódott) lesz.

    Színmegjelenítés és felbontás

    A színes CRT monitorok három alapszínt (RGB: vörös, zöld, kék) használnak, minden színhez külön elektronágyú tartozik.

    • Maszk-technológia: Egy fém rács (lyukmaszk) gondoskodik róla, hogy az elektronnyalábok csak a nekik megfelelő színű foszforpontokat találják el.

    • Ponttávolság (Dot Pitch): Két azonos színű képpont távolsága. A jó minőségű monitoroknál ez 0,21–0,25 mm. Minél kisebb, annál élesebb a kép.

    • Monokróm változatok: Egyetlen elektronágyút használnak. A fekete-fehér mellett jellemző volt a borostyánsárga és a zöld kijelző is.

    Előnyök, hátrányok és egészségügy

    Előnyök Hátrányok
    Kiforrott technológia, természetes képérzet. Nagy tömeg és hatalmas helyigény.
    0 ms beviteli késleltetés (input lag). Magas fogyasztás és jelentős hőtermelés.
    Tökéletes mozgásmegjelenítés. Geometriai torzítások (pl. hordó- vagy párna-torzítás).

    .Egészségügyi hatások: A szemfáradtság elsődleges oka nem a sugárzás, hanem a villódzás, a tükröződés és a rossz környezeti megvilágítás. Az FDA és a nemzetközi szabványok szerint a CRT-k röntgensugárzása jól kontrollált, normál használat mellett nem jelent közegészségügyi kockázatot. 

    Egy Macintosh Plus belső képe, benne monokróm CRT kijelzővel és elektronikai alkatrészekkel

    A Macintosh Plus belsejében jól látható a monokróm CRT képcső és a hozzá tartozó elektronika. Forrás: Wikipedia

    LCD-fizika: hogyan lesz a folyadékkristályból "fénykapu"?

    Az LCD (Liquid Crystal Display) működésének lényege, hogy a kijelző nem maga termeli a fényt (ellentétben a CRT-vel), hanem egy külső fényforrás (háttérvilágítás) útját állja el vagy engedi szabadon – pontosan úgy, mint egy zsalu vagy egy fénykapu.

    Az alapanyag: folyadékkristály és anizotrópia

    A folyadékkristályok különleges anyagok, amelyek a folyadékok és a szilárd kristályok tulajdonságait egyesítik:

    • Folyadékszerűek: Alakjukat változtatják, folynak.

    • Kristályosak: Mikroszkopikus szinten rendezett szerkezetűek.

    • Optikai anizotrópia: Ez a kulcsfogalom. Azt jelenti, hogy az anyag fényre gyakorolt hatása függ a molekulák állásától. Ha megváltoztatjuk a molekulák irányát, megváltozik az, ahogy a fény áthalad rajtuk.

    A „Fénykapu” felépítése (a szendvics-szerkezet)

    Egyetlen képpont (pixel) az alábbi rétegekből áll:

    Hátsó polárszűrő: Csak egy bizonyos síkban rezgő fényhullámokat enged át.

    Üveglap mikronméretű árkokkal: Ezek az apró vájatok kényszerítik a folyadékkristály molekuláit egy meghatározott irányba.

    Folyadékkristály réteg: Kitölti a két lemez közötti teret.

    Első polárszűrő: Ez merőlegesen van elhelyezve a hátsóhoz képest. (Ha nem lenne közte semmi, itt a fény elakadna, és a kép sötét lenne).

    A működés mechanizmusa: TN (Twisted Nematic) elv

    A) Alapállapot (átlátszó kapu):

    A két üveglap közötti apró árkok elrendezése miatt a folyadékkristály molekulái csavart formát (Twisted) vesznek fel.

    • A hátulról érkező, már polarizált fény belép a kristályba.

    • A csavart kristályszerkezet elforgatja a fény rezgési síkját 90 fokkal.

    • Mivel a fény iránya elfordult, pont beleillik az első (merőleges) polárszűrő „résébe”, így átjut rajta.

    • Eredmény: A pixel világít.

    B) Feszültség alatt (zárt kapu):

    Amikor elektromos teret kapcsolunk a cellára:

    • A molekulák „katonásan” az elektromos tér irányába rendeződnek, és elveszítik csavart szerkezetüket.

    • A fény áthalad a kristályon, de a rezgési síkja nem fordul el.

    • Amikor a fény eléri az első (merőleges) polárszűrőt, az elnyeli azt, mivel a rezgési iránya nem egyezik a szűrőével.

    • Eredmény: A pixel sötét marad.

    Gyártási sajátosság: A pixelhiba

    Mivel az LCD-k több millió ilyen apró „fénykapuból” állnak, a gyártás során előfordulhat, hogy egy-egy tranzisztor vagy kristálycella meghibásodik.

    • Beragadt pixel: A kapu mindig nyitva van (színes/fehér pont).

    • Halott pixel: A kapu sosem nyílik ki (fekete pont).

    Anime lány rengeteg lebegő szám között tanulja a halmazelmélet alapok témát.

    Passzív mátrix: TN, STN, DSTN, FSTN és a multiplexelt vezérlés

    Passzív mátrix: A multiplexelt vezérlés és az STN-család

    Amíg az aktív mátrixos (TFT) kijelzőknél minden pixel saját vezérlést kap, addig a passzív mátrixnál a pixelek „osztoznak” a vezetékeken. Ez olyan, mint egy négyzethálós füzet, ahol csak a sorok és oszlopok szélén vannak elektródák.

    1. Multiplexelt vezérlés (a logikai alap)

    A passzív mátrixnál a pixelek a sor- és oszlopvezetők metszéspontjaiban vannak. Mivel nincs mindenhol saját tranzisztor, a kijelző nem tudja az összes pixelt egyszerre „nyitva tartani”.

    • Működése: A vezérlő soronként halad (pásztáz). Kiválaszt egy sort, és abban a pillanatban az oszlopvezetőkön keresztül kiküldi a jelet az adott sor összes pixelének. Majd ugrik a következő sorra.

    • A probléma (áthallás és kontraszt): Mivel a folyadékkristály lassan reagál, mire a vezérlő körbeér, az előző sor pixelje már elkezd „visszaállni”. Ha túl sok a sor, a kép halvány és kontrasztszegény lesz. Ezt hívják áthallásnak (crosstalk), amikor a szomszédos pixelek is elkezdhetnek halványan látszódni.

    2. A fejlődés útja: TN-től az FSTN-ig

    A technológiai fejlődést a csavarási szög növelése hajtotta. Minél jobban megcsavarjuk a kristályt, annál érzékenyebben (gyorsabban) reagál a feszültségre, ami lehetővé teszi több sor kezelését.

    TN (Twisted Nematic) – az alapok

    • Csavarás: 90°

    • Jellemzők: Egyszerű, olcsó, keveset fogyaszt.

    • Alkalmazás: Kvarcórák, számológépek (ahol kevés a megjelenítendő adat). Nagy kijelzőnek alkalmatlan volt a gyenge kontraszt miatt.

    STN (Super Twisted Nematic) – az áttörés

    • Csavarás: 180° – 270°

    • Működése: A nagyobb csavarás miatt a kristály „idegesebb”, azaz kisebb feszültségkülönbségre is drasztikusabban reagál. Ez lehetővé tette a több soros, komplexebb kijelzőket.

    • Hiba: Sajátos színtorzítás (sárgás vagy kékes háttér).

    DSTN (Double STN) és FSTN (Film Compensated STN)

    Az STN színhibáit orvosolták ezek a technológiák:

    • DSTN: Két STN panelt tettek egymásra, amelyek ellentétesen voltak csavarva. Az egyik létrehozta a képet, a másik kioltotta a színhibát. Eredmény: valódi fekete-fehér kép, de vastagabb és nehezebb kijelző.

    • FSTN: A második kristályréteget egy vékony optikai fóliával helyettesítették. Ez sokkal könnyebb és olcsóbb megoldás volt, így ez vált az ipari szabvánnyá a laptopok és mobiltelefonok (pl. Nokia 3310) előtt.

    Aktív mátrix és TFT: a modern kijelzők motorja

    A technológia győzelmének kulcsa az egyéni vezérlés. Míg a passzív mátrixnál a pixelnek „várnia kellett a sorára”, a TFT-nél minden képpont folyamatosan tudja, mi a dolga.

    A TFT felépítése (Thin-Film Transistor)

    A TFT jelentése vékonyréteg-tranzisztor. Ez egy speciális gyártási eljárás, ahol az üveghordozóra rágőzölögtetik a félvezető réteget.

    • A tranzisztor mint kapcsoló: Minden szubpixel (piros, zöld vagy kék) kap egy saját tranzisztort. Ez egy villámgyors kapcsoló, amely szabályozza, hogy mennyi feszültség jusson a folyadékkristályra.

    • A tárolókapacitás (Kondenzátor): Ez a TFT-rendszer „titkos fegyvere”. A tranzisztor csak egy töredékmásodpercre nyit ki, hogy beadja a feszültséget, majd lezár. A kondenzátor viszont megtartja (tárolja) ezt a töltést a következő képfrissítésig.

    A „Sample-and-Hold” működés

    Ez a fogalom magyarázza meg, miért nem villog az LCD úgy, mint a CRT:

    • Működése: A rendszer mintát vesz a videojelből (Sample), beállítja a pixel feszültségét, és azt folyamatosan szinten tartja (Hold) a teljes képkocka ideje alatt.

    • Eredmény: Mivel a fény nem alszik ki két frissítés között (mint a CRT-nél a foszfor), a kép stabil és teljesen villódzásmentes. Ez drasztikusan csökkenti a szem fáradását.

    Miért ez lett a nyertes? (Műszaki előnyök)

    Probléma a múltban Hogyan oldotta meg a TFT?
    Áthallás (Crosstalk) A tranzisztor elszigeteli a pixelt, így a szomszédos vezetékek jele nem zavarja be.
    Lassú válaszidő A pixel azonnal megkapja a maximális töltést, így a kristályok sokkal gyorsabban fordulnak el.
    Gyenge kontraszt A feszültség precíz tartása miatt a fekete tényleg feketébb, a fehér pedig világosabb maradhat.
    Nagy felbontás Mivel nincs szükség a passzív mátrixnál kritikus multiplexelésre, a sorok száma (pl. 4K-nál 2160 sor) nem rontja a képminőséget.

    A TFT-család változatai (TN, IPS, VA)

    Ma már szinte minden LCD monitor „TFT”, de a folyadékkristályok elrendezése alapján három fő típust különböztetünk meg az aktív mátrixon belül:

    TN (Twisted Nematic): A leggyorsabb és legolcsóbb. Hátránya a rossz betekintési szög (oldalról nézve invertálódnak a színek).

    IPS (In-Plane Switching): A kristályok nem csavarodnak, hanem síkban fordulnak el. Kiváló színek és hatalmas betekintési szög jellemzi. Grafikai munkára és prémium kijelzőkhöz ez az alap.

    VA (Vertical Alignment): A kettő között helyezkedik el. A legjobb natív kontrasztot (legmélyebb feketéket) ez a technológia nyújtja.

    A modern LCD panelek: TN, VA és IPS

    Mivel mindhárom technológia TFT-alapú, a különbség abban rejlik, hogyan és milyen irányba mozdulnak el a folyadékkristályok a feszültség hatására.

    TN + Film (Twisted Nematic)

    Ez a legrégebbi és legegyszerűbb technológia. A kristályok spirál alakban csavarodnak, és feszültségre „felállnak”.

    • A „+Film” jelentése: Egy extra optikai réteg a panel tetején, amely hivatott tágítani a szűk betekintési szöget.

    • Előnyök: Rendkívül gyors válaszidő (akár 0,5–1 ms) és alacsony gyártási költség. A magas képfrissítés (pl. 240 Hz+) itt érhető el a legolcsóbban.

    • Hátrányok: Rossz betekintési szögek. Ha nem szemből nézzük, a színek elmosódnak, a sötét részek pedig „invertálódnak” (negatívba fordulnak).

    • Kinek ajánlott? Hardcore e-sportolóknak, ahol csak a sebesség számít, a látvány nem.

    VA (Vertical Alignment)

    A VA-paneleknél a kristályok alaphelyzetben függőlegesen állnak, és feszültség hatására dőlnek el.

    • A „fekete királya”: Mivel függőleges állásban szinte tökéletesen zárják a fényt, a VA-panelek tudják a legmélyebb feketéket produkálni. A kontrasztarányuk (3000:1 – 5000:1) sokszorosa az IPS-nek.

    • Altípusok: MVA, PVA (Samsung fejlesztés), AMVA (javított válaszidő).

    • Hátrányok: A sötét árnyalatok váltásakor lassabbak lehetnek, ami „dark smearing” (sötét elmosódás) jelenséget okozhat gyors mozgásnál.

    • Kinek ajánlott? Filmnézésre, általános otthoni használatra és sötét környezetben végzett munkához.

    IPS (In-Plane Switching)

    A modern kijelzők „arany standardja”. Itt a kristályok nem billennek vagy csavarodnak, hanem síkban (vízszintesen) forognak el.

    • Szín és Látószög: Mivel a kristályok állása oldalról nézve sem változik meg drasztikusan, a színek 178 fokos szögből is hűek maradnak.

    • IPS Glow: Egy jellegzetes hátrány, ahol sötét szobában, fekete tartalomnál a képernyő sarkai felől enyhe derengés látható.

    • Altípusok: S-IPS (Super-IPS), AH-IPS (Advanced High Performance) – a jobb fényerőért és színpontosságért.

    • Kinek ajánlott? Grafikusoknak, fotósoknak és azoknak a játékosoknak, akiknek fontos a látványvilág (AAA játékok).

    Gyors összehasonlító táblázat 

    Jellemző TN + Film VA IPS
    Betekintési szög Gyenge (színeltolódás) Kiváló (legstabilabb)
    Kontraszt / Fekete Közepes Kiváló (legmélyebb) Jó (IPS glow lehet)
    Színpontosság Gyenge Kiváló
    Válaszidő Leggyorsabb Lassabb (sötétben) Gyors (modern típusok)
    Fő alkalmazás Olcsó irodai / E-sport Mozi / Általános Grafika / Prémium gaming

    • TN Inverzió: Amikor alulról nézel egy TN monitort, a kép feketévé válik, vagy a színek felcserélődnek. Ez fizikai korlát.

    • IPS Glow: Ez nem hiba, hanem a technológia sajátossága: a polárszűrők nem tudják 100%-ban elnyelni a fényt bizonyos szögekből, ezért látunk egyfajta „fényudvart” a sarkokban.

    Háttérvilágítás: a fénycsövektől a kvantumpontikig

    Az LCD fejlődése során nemcsak a kristályok mozgatása, hanem a fény előállításának módja is drasztikusan megváltozott. Ez határozza meg a monitor vastagságát, fogyasztását és a színek élénkségét.

    CCFL (A „neoncsöves” korszak)

    A régebbi LCD monitorok hátuljában apró, hidegkatódos fénycsövek (Cold Cathode Fluorescent Lamp) világítottak.

    • Jellemzők: Vastagabb készülékház (hely kell a csöveknek), lassú bemelegedés, magas fogyasztás és jelentős hőtermelés.

    • Hibaforrás: A fénycsövek idővel elöregedtek, a kép sárgásabbá vált, vagy a trafó (inverter) meghibásodása miatt vibrálni kezdett a kép.

    A LED-forradalom (W-LED)

    A LED-ek (fénykibocsátó diódák) leváltották a fénycsöveket, mert kisebbek, tartósabbak és energiatakarékosabbak.

    • W-LED (White LED): Valójában ezek kék LED-ek, amelyeket sárga foszforréteggel vonnak be, hogy fehér fényt kapjanak. Ez a legolcsóbb és legelterjedtebb megoldás.

    • Elhelyezési módok:

      • Edge-Lit (Oldalvilágítás): A LED-ek a képernyő szélén (keretében) vannak, a fényt egy diffúzor lemez teríti szét. Emiatt lehetnek a monitorok extra vékonyak.

      • Direct-Lit (Közvetlen): A LED-ek a panel mögött, mátrixszerűen helyezkednek el. Ez jobb fényeloszlást tesz lehetővé.

    Professzionális színek: RGB-LED

    Míg a W-LED „trükközik” a fehér fénnyel, az RGB-LED külön piros, zöld és kék diódákat használ.

    • Eredmény: Sokkal tisztább alapszínek és hatalmas színtartomány (színskála).

    • Alkalmazás: Mivel drága és bonyolult a vezérlése (a három szín egyensúlyát folyamatosan figyelni kell), csak a legdrágább profi grafikai monitorokban találkozunk vele.

    QLED (A kvantumpontos LCD)

    Fontos tisztázni: a QLED (Quantum Dot LED) nem OLED! Ez továbbra is egy LCD panel, de a háttérvilágítás és a folyadékkristály közé egy speciális kvantumpontos réteget (Quantum Dot film) helyeznek.

    • Hogyan működik? A kék LED-ek fénye gerjeszti a különböző méretű nanokristályokat (kvantumpontokat), amelyek ebből tűéles vörös és zöld színt állítanak elő.

    • Előnye: Sokkal tisztább és intenzívebb színek, mint a sima W-LED esetében, de megőrzi az LCD-k nagy fényerejét.

    Összefoglaló táblázat 

    Technológia Fényforrás Vastagság Színhűség Jellemző
    CCFL Fénycső Vastag Közepes Régi, melegszik, sokat fogyaszt.
    W-LED Fehér (kék+foszfor) LED Vékony Általános, minden mai monitorban ez van.
    RGB-LED Külön piros, zöld, kék LED Közepes Kiváló Drága, profi grafikai célra.
    QLED Kék LED + Kvantumpontok Vékony Kiemelkedő

      Anime lány örül, hogy megértette a halmazelmélet alapok témát, füzetében halmazműveletek és Venn-diagramok.

      Fogalmak

      A monitor teljesítményét három nagy csoportra oszthatjuk: a kép részletességére (felbontás), a látvány minőségére (kontraszt és szín) és a mozgás folyamatosságára (időzítés).

      Pixel és felbontás: a kép elemei

      A monitor képe apró pontokból, pixelekből áll.

          • Szubpixelek: Egy pixel valójában három alképpontból (RGB: vörös, zöld, kék) áll. Ezek fényerejének keverésével jön létre bármilyen szín. Ha minden szubpixel maximális erővel világít, fehéret látunk; ha mind ki van kapcsolva, feketét.

          • Felbontás: A képernyőn található vízszintes és függőleges pixelek száma.

            • Full HD: $1920 \times 1080$ pixel.

            • QHD (2K): $2560 \times 1440$ pixel.

            • 4K UHD: $3840 \times 2160$ pixel.

          • Képarány: A szélesség és magasság aránya (pl. a mozihatású 16:9, vagy az extra széles 21:9).

      Látvány és színmélység

      Hogyan látjuk a színeket és a sötét jeleneteket?

          • Kontrasztarány: A legfehérebb és a legfeketébb pont fényerejének különbsége. (VA panelnél ez kb. 3000:1, IPS-nél csak 1000:1).

          • Fényerő: cd/m²-ben (kandela per négyzetméter) vagy nitben mérik. (1 cd/m² = 1 nit). Egy átlagos monitor 250-350 nitet tud.

          • Színmélység (Bitmélység): Megmutatja, hány árnyalatot tud egy színcsatorna.

            • 8 bit: $2^8 = 256$ árnyalat színenként $\rightarrow$ összesen 16,7 millió szín.

            • 10 bit: Több mint 1 milliárd szín. Segít elkerülni a sávosodást (banding), amikor az égbolton látszanak az átmenetek vonalai.

      Időzítés: válaszidő és input lag

      Sokan összekeverik a kettőt, pedig teljesen mást jelentenek:

          • Válaszidő (GtG – Gray-to-Gray): Az az idő (ms), ami alatt egy pixel színt vált. Ha lassú, „szellemképet” vagy elmosódást látunk a mozgó tárgyak után.

          • Input Lag (Bemeneti késleltetés): A teljes idő, amíg a gombnyomásunk után a kép megjelenik. Ebben benne van a monitor elektronikájának feldolgozási ideje is. Lehet egy monitor szupergyors válaszidejű (1 ms), ha az elektronikája lassú, és magas az input lagja.

      Képfrissítés és szinkronizáció

      Ha a videokártya több vagy kevesebb képet küld, mint amennyit a monitor frissíteni tud, „képtörést” (tearing) látunk.

          • V-Sync: A szoftveres megoldás. Kényszeríti a videokártyát, hogy várja meg a monitort. Hátránya: növelheti az input laget.

          • G-Sync (Nvidia) és FreeSync (AMD/VESA): Ez az adaptív szinkronizáció. Itt a monitor igazodik a videokártyához: ha a játék épp csak 47 FPS-sel fut, a monitor is pontosan 47-szer frissít másodpercenként. Eredmény: sima, törésmentes kép akadás nélkül.

      • Meghajtás és színkezelés (FRC és Dithering)

        Gyakran látni olyat a leírásokban, hogy 6-bit + FRC vagy 8-bit + FRC.

        • FRC (Frame Rate Control): Ez egy trükk, amivel a monitor több színt mutat, mint amennyire a panel fizikailag képes. Ha egy monitor nem tudja megjeleníteni a pontos árnyalatot, két közeli színt váltogat nagyon gyorsan, amit a szemünk a kettő keverékének érzékel. Így lesz egy olcsóbb 8 bites panelből „látszólagos” 10 bites.

        • Dithering (Térbeli keverés): Hasonló az FRC-hez, de itt nem időben, hanem egymás melletti pixelek különböző színével „csapják be” a szemet, hogy egy harmadik színt lássunk.

        A válaszidő mélyebb rétegei (Overdrive és MPRT)

        A sima GtG (Gray-to-Gray) mellett két fontos rövidítés létezik még:

        • Overdrive: A monitor elektronikája egy rövid feszültséglökettel „meglöki” a folyadékkristályt, hogy gyorsabban forduljon el. Ha túltolják, Overshoot jelenség lép fel: fényes udvar jelenik meg a mozgó tárgyak körül.

        • MPRT (Motion Picture Response Time): Ez azt méri, mennyi ideig látható egy pixel a képernyőn. Itt jön képbe a BFI (Black Frame Insertion), ahol fekete képkockákat szúrnak be a valódiak közé, hogy „töröljék” az ideghártyánkról az előző kép emlékét, így élesebbnek érezzük a mozgást.

        Fényerő és kontraszt finomságok

        • Dinamikus kontraszt: Ne téveszd össze a statikus kontraszttal! A statikus az, amit a panel egyszerre tud (pl. 1000:1). A dinamikus kontraszt úgy jön ki, hogy a monitor teljesen leveszi a háttérvilágítást egy sötét jelenetnél, és maximumra tolja egy világosnál. Ez marketingeszköz, a valódi képminőséget a statikus kontraszt határozza meg.

        • Fényerő-homogenitás: Azt mutatja meg, hogy a képernyő szélei ugyanolyan fényesek-e, mint a közepe. Az olcsó Edge-Lit monitoroknál a szélek gyakran „bevilágítanak” (Backlight bleed).

        Csatlakozók és sávszélesség

        A képminőséghez kell a „cső” is, amin az adat átfolyik:

        • VGA (D-Sub): Analóg, a CRT korszak maradványa. Zajérzékeny.

        • DVI: Az első digitális szabvány, ma már kikopóban van.

        • HDMI: Multimédiás szabvány, hangot is visz.

        • DisplayPort (DP): A PC-s világ királya. Ez bírja a legnagyobb sávszélességet, a legmagasabb képfrissítést és a G-Sync/FreeSync technológiákat is.

        Ergonómia és kialakítás

        • Anti-glare (Matt) vs. Glare (Fényes): A matt bevonat szórja a fényt (nem tükröződik), de picit lágyítja a színeket. A fényes kijelző gyönyörű, mély színeket ad, de mindent látsz benne, ami mögötted van.

        • Kékfény-szűrő: Szoftveres vagy hardveres megoldás, ami csökkenti a rövid hullámhosszú kék fényt, hogy kevésbé zavarja meg az alvási ciklusunkat (melatonin termelés).

      Emisszív kijelzők: az OLED világa

      Az OLED (Organic Light-Emitting Diode) legnagyobb újítása, hogy a szerves vegyületekből álló réteg közvetlenül fényt bocsát ki, ha elektromos áramot kap.

      Miért más az OLED, mint az LCD?

      • Nincs háttérvilágítás: Mivel a pixel maga a fényforrás, ha feketét kell megjeleníteni, a pixel egyszerűen kikapcsol.
      • Végtelen kontraszt: Mivel a kikapcsolt pixel fényereje 0 nit, a kontrasztarány elméletileg végtelen. Nincs „bevilágítás” vagy szürkés fekete.

      • Válaszidő: Mivel nem kell folyadékkristályokat fizikailag elforgatni, az OLED válaszideje elképesztően gyors (akár 0,01 ms), ami nagyságrendekkel jobb bármelyik LCD-nél.

      • Vékonyság és rugalmasság: A háttérvilágító egység hiánya miatt a panelek papírvékonyak, sőt, hajlíthatóak (hajtogatható telefonok).

      Vezérlési módok: PMOLED vs. AMOLED

      Az elnevezés itt is a korábban tanult „mátrix” logikát követi:

      Típus Vezérlés Jellemzők Alkalmazás
      PMOLED Passzív mátrix Olcsó, egyszerű, soronkénti vezérlés. Nagy áramot igényel, ami hamarabb koptatja a szerves réteget. Okosórák kijelzője, MP3 lejátszók, kisméretű indikátorok.
      AMOLED Aktív mátrix (TFT) Minden pixelhez saját tranzisztor tartozik. Gyors, energiatakarékos, nagy felbontásra képes. Okostelefonok, tabletek, modern TV-k.

        Gyártástechnológia és anyagok

            • Small-molecule (SM-OLED): Apró szerves molekulákat használnak, amiket vákuumban párologtatnak fel a felületre. Ez a precízebb, de drágább eljárás, ma a legtöbb kijelző így készül.

            • PLED / LEP (Polymer OLED): Hosszú szénláncú polimereket használnak. Ezek előnye, hogy oldatban is felvihetőek (például „spin coating” vagy akár tintasugaras nyomtatás). Ez elméletileg olcsóbb gyártást tenne lehetővé, de a tartósságuk gyakran elmarad a kis molekulás társaikétól.

        Kihívások: a technológia árnyoldala

        Bár az OLED képe gyönyörű, vannak fizikai korlátai:

            • Beégés (Burn-in): Mivel a szerves anyagok elöregednek, a sokat használt, statikus képelemek (pl. hírcsatorna logója vagy tálca) „beleéghetnek” a kijelzőbe, halvány foltként ott maradva.

            • Élettartam: A kék színű OLED alpixel gyorsabban öregszik, mint a vörös vagy a zöld, ami idővel eltolhatja a színegyensúlyt.

            • PWM Villódzás: Sok OLED kijelző a fényerőt a háttérvilágítás gyors ki-be kapcsolgatásával (Pulse Width Modulation) szabályozza, ami az arra érzékenyeknél fejfájást okozhat.

        Speciális OLED-szerkezetek: Átlátszóság és Rugalmasság

        Az OLED nem csupán egy panel, hanem egy variálható rétegrend, amely lehetővé teszi, hogy a kijelző túllépjen a hagyományos monitorok korlátain.

        TOLED (Transparent OLED – Az átlátszó kijelző)

        A titok az elektródákban rejlik: míg a hagyományos kijelzők hátlapja fényvisszaverő vagy átlátszatlan, a TOLED mindkét oldalán átlátszó alapanyagokat használ.

        • Hogyan működik? A szerves rétegek maguk is félig áteresztőek, az elektródák pedig olyan vékonyak vagy olyan anyagból (pl. ITO) készülnek, hogy a fény átjut rajtuk.

        • Átlátszóság: A modern panelek (pl. az LG Display megoldásai) már 45%-os átlátszóságot érnek el, ami lehetővé teszi, hogy a kijelző mögötti tárgyakat is tisztán lássuk.

        • Felhasználás: „Okos” kirakatok, HUD-ok (Heads-up Display) autók szélvédőjén, vagy futurisztikus információs pultok.

        FOLED (Flexible OLED – A hajlítható kijelző)

        A FOLED szakít az üveggel. A szerves rétegeket egy rugalmas alapra, általában poliimidre (speciális műanyagra) viszik fel.

        • Miért forradalmi? Mert a kijelző nem törik el, ha meghajlítják. Ez teszi lehetővé a hajtogatható (foldable) telefonokat, az ívelt kijelzőket és a feltekerhető televíziókat.

        • Strapabírás: Bár rugalmas, a rétegek közötti feszültség miatt a hajtási vonalnál (zsanér) továbbra is komoly mérnöki kihívást jelent a tartósság.

        Tandem OLED (A „dupla motoros” kijelző)

        A tandem szerkezet lényege a hatékonyság többszörözése. Nem egy, hanem két vagy több emissziós (fénykibocsátó) réteget helyeznek egymás fölé, amelyeket egy összekötő réteg választ el.

        • Előnyei:

          • Élettartam: Mivel a fényerő megoszlik a két réteg között, egyiket sem kell „túlhajtani”, így lassabb a szerves anyag elöregedése (kisebb a beégés veszélye).

          • Fényerő: Képes jóval magasabb csúcsfényerőre, mint az egyrétegű változatok.

        • Alkalmazás: Elsősorban autók műszerfalaiban (ahol a tartósság kritikus) és a legújabb prémium táblagépekben találkozhatunk vele.

        Stacked RGB (Rétegzett struktúrák)

        A hagyományos kijelzőknél a piros, zöld és kék szubpixelek egymás mellett (laterálisan) helyezkednek el. A rétegzett (stacked) megoldásnál ezeket egymás fölé pakolják.

        • Pixelsűrűség (PPI): Mivel három szubpixel helyét egyetlen pixelnyi területen oldják meg, sokkal több képpont fér el ugyanakkora felületen.

        • A „háromszoros felbontás” tévhit: Fontos megérteni, hogy ez nem jelenti azt, hogy a kép automatikusan háromszor részletesebb lesz. Inkább az optikai tisztaság és a pixelsűrűség nő meg, mivel megszűnik a szubpixelek közötti üres tér (a „csirkeháló” effektus).

        Összegzés: speciális OLED-ek

        Rövidítés Kulcsszó Jelentőség
        TOLED Átlátszóság Kirakatok, AR-kijelzők, futurisztikus design.
        FOLED Műanyag hordozó Hajlítható, ívelt és törésállóbb panelek.
        Tandem Dupla réteg Hosszabb élettartam és nagyobb fényerő (autóipar, iPad).
        Stacked Egymás feletti RGB Nagyobb pixelsűrűség, jobb helykihasználás.

        WOLED, Top-Emitting és a MicroLED: a fény útja

        Míg az alap OLED technológia már érettnek számít, a WOLED, a Top-Emitting szerkezet és a MicroLED különböző mérnöki válaszok az élettartam, a fényerő és a pixelsűrűség kihívásaira.

        WOLED (White OLED) – a színszűrős OLED

        A hagyományos OLED minden szubpixele (R, G, B) saját színű fényt bocsát ki. Ezzel szemben a WOLED (fehér OLED) máshogy közelít:

        • Működése: A panel minden egyes pixelje fehér fényt bocsát ki (ezt általában kék és sárga, vagy kék-zöld-vörös emissziós rétegek egymásra helyezésével érik el).

        • Színszűrés: A fehér fény fölé egy színszűrő réteget (color filter) helyeznek, amely kiválasztja a vörös, zöld vagy kék komponenst.

        • Előnye: Egyszerűbb és olcsóbb gyártani nagy méretben (pl. TV-k), és kiküszöböli azt a hibát, hogy a különböző színű szerves anyagok eltérő ütemben öregednek. Az LG Display „Tandem WOLED” megoldása több fehér réteg egymásra pakolásával növeli a fényerőt és az élettartamot.

        Top-Emitting OLED (felső emissziós szerkezet)

        Ez nem egy új anyagtípus, hanem a fény kilépési irányának megváltoztatása.

        • Bottom-emitting (Hagyományos): A fény az áramkörök (TFT réteg) felé, alulról távozik. Itt a tranzisztorok „árnyékot” vetnek, így kevesebb fény jut ki, és kevesebb hely marad a szubpixeleknek.

        • Top-emitting: A fény a felső elektróda irányába távozik.

        • Miért jó? Mivel a fénynek nem kell átverekednie magát a vezérlő elektronikán, sokkal nagyobb lehet az aktív fénykibocsátó felület. Ez elengedhetetlen a mikrokijelzőknél (pl. VR-szemüvegek), ahol extrém magas pixelsűrűség mellett is nagy fényerőre van szükség.

        MicroLED – A „Szent Grál”

        A MicroLED a kijelzőtechnika csúcsa, amely egyesíti az LCD és az OLED minden előnyét, azok hátrányai nélkül.

        • Anyaga: Nem szerves (organic) vegyületeket használ, hanem szervetlen gallium-nitridet (GaN). Ezek lényegében mikroszkopikus méretű, hagyományos LED-ek.

        • Miért jobb, mint az OLED?

          • Fényerő: Sokkal intenzívebb fényt tud kibocsátani.

          • Tartósság: Nem fenyegeti a szerves anyagok elöregedése vagy a beégés.

          • Hatékonyság: Kevesebb energiát fogyaszt azonos fényerő mellett.

        • Kvantumpontos konverzió: Gyakran alkalmazzák azt a megoldást, hogy csak kék MicroLED-eket gyártanak, és kvantumpontokkal (Quantum Dots) alakítják át a fényt vörössé és zölddé. Ez egyszerűsíti a gyártási folyamatot.

        Összehasonlító összefoglalás 

        Technológia Fényforrás Színképzés Fő előny
        WOLED Fehér szerves réteg Színszűrőkkel Olcsóbb nagyüzemi gyártás (TV-k).
        Top-Emitting Bármilyen OLED Felső irányú kilépés Brutális pixelsűrűség (VR/AR).
        MicroLED Szervetlen LED-ek Saját szín vagy QD Örök élet, hatalmas fényerő, nincs beégés.

        Monitorbevonatok: matt (anti-glare) vs. fényes (Glossy)

        Bár a panel technológiája (IPS, VA, OLED) határozza meg a színeket, a külső bevonat dönti el, hogyan jut el ez a fény a szemedbe a külső fényforrások (ablak, lámpa) mellett.

        Anti-glare (matt bevonat)

        A matt felületű kijelzőket egy mikroszkopikus szinten érdesített réteggel látják el.

        • Működése: A beeső fényt nem egyenesen veri vissza (mint a tükör), hanem minden irányba szétszórja (diffúz visszaverődés).

        • Előnyök:

          • Szinte teljesen megszünteti a zavaró tükröződéseket.

          • Világos irodákban, ablak mellett is jól látható marad a tartalom.

          • Kevésbé látszódnak meg rajta az ujjlenyomatok és a por.

        • Hátrányok: A fényszórás miatt a színek picit fakóbbnak tűnhetnek, és a kép élessége (mikroszkopikus szinten) lágyabb lehet.

        Glossy (fényes bevonat)

        A fényes kijelzők felülete sima, mint az üveg vagy a tükör.

        • Működése: A fényt közvetlenül, egy irányba veri vissza.

        • Előnyök:

          • A színek élénkebbek, a fekete „feketébbnek” tűnik (mert nincs rajta a matt réteg szürkés fátyla).

          • A kép tűéles és tiszta érzetet kelt.

        • Hátrányok:

          • Sötét jeleneteknél úgy működik, mint egy tükör: látod magadat és a mögötted lévő lámpát.

          • Erős fényben szinte használhatatlanná válhat a csillogás miatt.

        A hibrid megoldások

        Ma már léteznek úgynevezett „semi-glossy” vagy speciális tükröződésmentesített (AR – Anti-Reflective) bevonatok (gyakran az Apple vagy prémium OLED gyártók eszközein). Ezek a fényes kijelzők élességét próbálják ötvözni a matt kijelzők tükröződésmentességével, egy speciális kémiai réteg segítségével, amely kioltja a visszaverődő fényhullámokat.

        Összehasonlító táblázat a választáshoz:

        Szempont Anti-glare (Matt) Glossy (Fényes)
        Tükröződés Minimális (szórt fény) Erős (tükörszerű)
        Színélmény Természetes, picit tompább Élénk, „pop-out” hatás
        Ideális helyszín Iroda, tanterem, világos szoba Sötétebb szoba, stúdió, mozi
        Tisztítás Nehezebb (az érdes felület miatt) Könnyebb (de gyakrabban kell)

        HDR vs. SDR: A dinamika forradalma

        Sokan elkövetik azt a hibát, hogy a HDR-t (High Dynamic Range) a felbontással (4K) azonosítják, pedig a HDR nem a pixelek számáról, hanem azok minőségéről szól.

        Mi a különbség?

        • SDR (Standard Dynamic Range): A régi televíziók és monitorok korlátaihoz igazított szabvány. A fényerőt és a színeket egy szűk skálán belül kezeli (jellemzően 100 nit fényerőig és 8 bites színmélységig kalibrálva).

        • HDR (High Dynamic Range): Lehetővé teszi, hogy a kép sötét részei rendkívül részletesek maradjanak, miközben a fényes részek (pl. a Nap vagy egy lámpa fénye) vakítóan ragyogjanak.

        A HDR alapfeltételei

        Ahhoz, hogy egy monitor valódi HDR élményt nyújtson, három dologra van szüksége:

        Nagy fényerő: Képesnek kell lennie rövid ideig tartó, nagy erejű fényfelvillanásokra (csúcsfényerő).

        Mély feketék: Itt jön képbe az OLED vagy a Local Dimminggel ellátott LCD, hogy a sötét részek ne szürküljenek be a világosak mellett.

        Széles színtér (WCG): A HDR általában 10 bites színmélységet használ, ami 1 milliárd színt jelent az SDR 16,7 milliójával szemben.

        Szabványok és formátumok

        Nem minden HDR egyforma. A gyártók különböző módon jelölik a képességeket:

        • VESA DisplayHDR: Ez egy hivatalos minősítés. A számok (HDR 400, 600, 1000) a monitor maximális fényerejét jelzik nitben. (A HDR 400 még csak „belépő” szint, az igazi HDR élmény 600-1000 nitnél kezdődik).

        • HDR10: A legelterjedtebb, nyílt szabvány. Statikus metaadatokat használ (a film elején beállít egy értéket az egész műsorra).

        • Dolby Vision & HDR10+: Dinamikus metaadatokat használnak. Ez azt jelenti, hogy jelenetről jelenetre (vagy akár képkockáról képkockára) változtatják a monitor beállításait a lehető legjobb látvány érdekében.

        A mastering fényerő

        Fontos szakmai részlet, hogy a filmeket gyakran 1000, 4000 vagy akár 10 000 nites monitorokon vágják (mastering). Az, hogy egy film „Dolby Vision” címkét kap, nem jelenti azt, hogy a te monitorod el is éri azt a fényerőt – csupán azt, hogy a monitor érti a jelet, és a saját képességeihez mérten a legjobban próbálja megjeleníteni (ezt hívják Tone Mapping-nek)

        Csatlakozók és jelátvitel: Az analógtól a mikrocsomagokig

        A csatlakozók fejlődése nemcsak a forma változásáról szólt, hanem egy alapvető paradigmaváltásról: hogyan kódoljuk a képet elektromos jelekké.

        VGA (D-Sub): az analóg örökség

        A VGA a CRT korszak szülötte, ahol a kép még hullámformákban (analóg jelekben) utazott.

        • A dupla átalakítás csapdája: A számítógép digitális jelet gyárt, amit a videokártya DAC-ja (Digital-to-Analog Converter) analóg hullámmá alakít. Ha ezt egy modern LCD monitorra kötjük, az kénytelen újra digitalizálni azt.

        • Minőségromlás: Mivel analóg, minden külső elektromos zavar (pl. egy közelben futó tápkábel) zajt, szellemképet vagy életlenséget okozhat. Nagy felbontásnál (Full HD felett) már látványosan romlik a kép élessége.

        DVI és HDMI: a TMDS korszak

        Ez a két szabvány hozta el a digitális forradalmat. Mindkettő a TMDS (Transition Minimized Differential Signaling) technológiát használja.

        • TMDS logika: Ez a rendszer differenciális jelátvitelt alkalmaz, ami azt jelenti, hogy két szálon küldi ugyanazt a jelet, csak ellentétes fázisban. Ezzel a módszerrel a kábelen érkező külső zajokat ki tudják oltani, így a kép tűéles marad.

        • DVI: Csak videót visz (néhány kivételtől eltekintve). Ma már háttérbe szorult.

        • HDMI: A nappalik királya. A TMDS-en keresztül nemcsak videót, hanem többcsatornás hangot és vezérlőjeleket (CEC) is továbbít.

        DisplayPort (DP): A mikrocsomag-alapú jövő

        A DisplayPort szakított a hagyományos televíziós logikával, és inkább az informatikai hálózatok (Ethernet) működéséhez hasonlít.

        • Mikrocsomag-architektúra: A DisplayPort nem egy végtelenített pixelsort küld, hanem az adatokat kis csomagokba (micro-packets) rendezi.

        • Miért jó ez?

          • Rugalmasság: Könnyebben osztható meg a sávszélesség több monitor között (Daisy Chaining).

          • Sávszélesség: Sokkal több adatot bír átvinni, mint a HDMI régebbi verziói, ezért a PC-s világban (nagy képfrissítés, G-Sync) ez a preferált szabvány.

          • Kiegészítő csatorna: Tartalmaz egy kétirányú segédcsatornát (AUX), amin keresztül a monitor és a gép kommunikálhat (pl. webkamera vagy USB-hub adatai).

        Összehasonlító összefoglaló

        Szabvány Jel jellege Fő jellemző Mikor használd?
        VGA Analóg DAC átalakítás, zajérzékeny. Csak ha nincs más (régi projektorok).
        DVI Digitális TMDS alapú, tiszta kép. Régebbi irodai monitorokhoz.
        HDMI Digitális Videó + Hang + Adat egyben. TV-k, konzolok, multimédia.
        DisplayPort Digitális Mikrocsomagok, nagy sávszélesség. Gaming, 4K@144Hz, több monitor.

        Ez az utolsó rész a gyakorlati matematika világába vezet át: hogyan fordítsuk le a látványt (felbontás és színmélység) konkrét adatmennyiséggé. Ez a számítás alapvető fontosságú a videokártyák (VRAM) és a hálózati sávszélesség tervezésekor.

        Számítási segédlet: mekkora helyet foglal egy kép?

        Amikor a monitoron megjelenik egy kép, a videokártyának azt el kell tárolnia a memóriájában (Frame Buffer). A nyers memóriaigény kiszámítása egyszerű szorzás, ahol a területet (pixelek száma) szorozzuk meg az „adatvastagsággal” (színmélység).

        1. A képlet felépítése

        A memóriaigényt az alábbi összefüggéssel kapjuk meg:

        Felbontás_X * Felbontás_Y * (színmélység_bitben / 8) = Byte

        Mivel a színmélységet általában bitben adjuk meg, először át kell váltanunk bájtra (8 bit = 1 bájt):
        X * Y * (bit / 8) = Byte

        2. Példa a számításra (Full HD esetén)

        Nézzük meg egy modern, Full HD (1920 × 1080) felbontású kép igényét 24 bites (True Color) színmélység mellett:

        Váltás bájtra: 24 bit / 8 = 3 bájt/pixel

        Szorzás: 1920 * 1080 * 3 = 6 220 800 bájt

        Váltás Megabájtra:

        6 220 800 / 1024 = 6075 KB
        6075 / 1024 = 5,93 MB

        Ez azt jelenti, hogy egyetlen állókép tárolásához a videokártyán kb. 6 MB helyre van szükség.

        3. Miért kell a gyakorlatban ennél több memória?

        A  valóságban a VRAM igénye jóval nagyobb:

        • Double/Triple Buffering: A sima mozgás érdekében a gép nem egy, hanem 2-3 képkockát tárol egyszerre (egyik látható, a másikat közben rajzolja).

        • Z-Buffer: A 3D grafikánál tárolni kell a pixelek mélységét is (távolság a nézőtől).

        • Textúrák: A játékokban a tárgyak felületei (falak, ruhák) külön képekként foglalják a helyet a memóriában.

         

        Ha szeretnél továbbhaladni a bevezetés a matematika anyagában, itt válogathatsz a leckék között:

        Listák bejárása Pythonban

        Listák bejárása Pythonban

        Python

        Listák bejárása

        A listák létrehozása még csak az első kör. Attól, hogy már tudsz ilyet írni:

        tantargyak = [„matek”, „töri”, „tesi”, „infó”]

        még nem sok minden történik.
        A programozás ott kezd érdekes lenni, amikor végig is tudsz menni a lista elemein. Ez a lista bejárása. Nem egyszerre akarjuk látni az egészet, hanem sorban dolgozunk vele. 

        Python while ciklus működése illusztráción

        Lista bejárása for ciklussal

        Ez a legegyszerűbb és legbarátibb megoldás. 

        • A for ciklus sorban végigmegy a lista elemein. 
        • Az aktuális elemet beteszi a tantargy valtozóba
        • A ciklusmag minden elemnél egyszer lefut. 

        Ez a módszer akkor a legjobb, ha magukra az értékekre vagy kiváncsi, és nem érdekel, hányadik helyen állnak. Másik példa:

         

        Számok bejárása range() segítségével

        A range akkor kell, amikor nem egy lista elemein akarsz közvetlenül végigmenni, hanem egy számtartományon. 

        A megadott végérték, amint látható, nem része a tartománynak. 10 darab számot ad vissza, de itt a 0 az első. 

        Két paraméterrel

        Az első a kezdőérték (2), a második szám a végérték. A kezdőérték benne van, a végérték nincs. 

        Három paraméterrel

        2 a kezdőérték, 20 a végérték, 3 pedig a lépésköz. A range(start, stop, step) formátumot a Python built-in dokumentációja is így írja le, és a range valójában egy beépített sorozattípus, nem sima lista.

        Még egy példa:

        Ha számolni kell, vagy valamit pl 5-ször megismételni, vagy ha indexekkel akarsz dolgozni, a range() gyakran előkerül. 

        Milyen indexen van az adott elem?

        Van ez a lista: tantargyak = [„matek”, „töri”, „tesi”, „infó”] és járjuk be újra:

        for tantargy in tantargyak:
             print(tantargy)

        Ez a legletisztultabb forma. De mi van akkor, ha azt is szeretnéd tudni, hogy milyen indexen van az adott elem? Na itt jönnek a következő módszerek:

        Indexek kezelése külön változóval

        Ez még teljesen érthető kezdő megoldás:

        • Létrehozol egy index változót 0 értékkel. 
        • Minden körben kiírod az aktuális indexet és elemet
        • A végén növeled az indexet eggyel. 

        Ennél azonban vannak szebb megoldások is. 

         

        Lista bejárása indexekkel (range(len(lista))

        A len() megadja, hány elem van a listában. A Python dokumentációja szerint a sorozatok indexei 0-tól n-1-ig tartanak, ahol n a hossz. Ezért működik szépen együtt a len() és a range().

        Ebben a példában: 

        • len(tantargyak) -> 4
        • range(4) -> 0, 1, 2, 3, Ezek lesznek az indexek. 
        • A tantargyak[index] segítségével elérjük az adott elemet. 

        Ez akkor hasznos, ha:

        • index alapján akarsz módosítani
        • két lista azonos helyű elemeit akarod összehasonlítani
        • szükséged van a pozícióra is, nem csak az értékre

        A legkényelmesebb megoldás: enumerate()

        Ez az a rész, amit érdemes megszeretni. 

        Az enumerate() a Python dokumentációja szerint egy olyan objektumot ad vissza, amely minden elemhez egy sorszámot és az értéket együtt adja, alapértelmezés szerint 0-ról indulva. Tehát ilyen párokat ad: 

        (0, „matek”)
        (1, „töri”)
        (2, „tesi”)
        (3, „infó”)

        A for index, tantargy in … sor ezeket rögtön két változóba bontja szét:

        • index
        • tantargy

        A számozás természetesen nem csak nulláról indulhat: 

        Melyiket mikor érdemes használni?

         

        1. for elem in lista: 

        • ha csak az elemek kellenek, nem érdekel az index

        2. for index in range(len(lista))

        • ha ténylegesen indexszel akarsz dolgozni
        • index alapján akarsz elemeket elérni
        • több lista azonos indexű elemeit hasonlítod össze

        3. for index, elem in enumerate(lista)

        • használd akkor, ha kell az index is, az elem is és nem akarsz kézzel számlálgatni

        Gyakorlás

        1. Tantárgyak kiírása for ciklussal

        Hozz létre egy tantargyak nevű listát legalább 5 tantárggyal. Járd be a listát for ciklussal, és írd ki az elemeket egyesével.

          Megoldás
          tantargyak = [„matek”, „töri”, „magyar”, „biológia”, „infó”]
          index = 0
          for tantargy in tantargyak:
              print(index, tantargy)
              index += 1

          tantargyak = [„matek”, „töri”, „magyar”, „biológia”, „infó”]
          for index in range(len(tantargyak)):
              print(index, tantargyak[index])

          tantargyak = [„matek”, „töri”, „magyar”, „biológia”, „infó”]
          for index, tantargy in enumerate(tantargyak):
              print(index, tantargy)
                 

          2. Kedvenc előadók listája

          Hozz létre egy listát 4 kedvenc előadóval vagy zenekarral. Járd be a listát, és minden elem elé írd ki ezt a szöveget:

          Most ezt hallgatnám:

            Megoldás
            zenekarok = [„Ed Sheeran”, „Lost Frequencies”, „Yungblud”, „Imagine Dragons”]
            for zenekar in zenekarok:
                print(„Most ezt hallgatnám: „, zenekar)

            3. Számok kiírása range() segítségével

            Írj programot, amely range() használatával kiírja a számokat:

            • 0-tól 9-ig
            • 3-tól 12-ig
            • 2-es lépésközzel 0-tól 20-ig

              Megoldás
              for szam in range(10):
                  print(szam)

               

              for szam in range(3, 13):
                  print(szam)

               

              for szam in range(0, 21, 2):
                  print(szam)
                     

              4. Visszaszámlálás

              Írj programot, amely 10-től 1-ig írja ki a számokat range() segítségével.

                Megoldás
                for szam in range(10, 0, 1):
                    print(szam)
                       

                5. Listaelemek indexszel – range(len(lista))

                Legyen egy filmek lista 5 filmmel és írd ki az indexet és a film címét.

                  Megoldás
                  filmek = [„Itt érzem magam otthon”, „Hadik”, „Toxikoma”, „Seveled”, „Aranyélet”]

                   

                  for index, film in enumerate(filmek):
                      print(index, film)
                         

                  6. Enumerate gyakorlása

                  Legyen egy jatekok lista 5 játékkal. Használj enumerate()-ot, és írd ki az indexet és az elemet.

                  Megoldás
                  filmek = [„Itt érzem magam otthon”, „Hadik”, „Toxikoma”, „Seveled”, „Aranyélet”]

                   

                  for index, film in enumerate(filmek):
                      print(index, film)
                         

                  7. Sorszámozás

                  Írj programot egy teendők listával, amely enumerate segítségével számozza meg a teendőket 1-től indulva

                  Megoldás
                  teendok = [„tanulni”, „mosni”, „rendet rakni”, „kutyát sétáltatni”, „bevásárolni”, „olvasni”]
                  for index, teendo in enumerate(teendok, start=1):
                      print(index, teendo)

                  8. Páros indexű elemek

                  Legyen egy lista 6 elemmel. Járd be range(len(lista)) segítségével, és csak azokat az elemeket írd ki, amelyek páros indexen vannak.

                    Megoldás
                    lista = [„aelem”, „belem”, „celem”, „delem”, „eelem”, „felem”]
                    for index in range(len(lista)):
                        if index % 2 == 0:
                            print(index, lista[index])
                           

                    9. Rövid szavak listája

                    Legyen egy lista különböző hosszúságú szavakkal. Járd be a listát for ciklussal, és csak azokat írd ki, amelyek 5 karakternél rövidebbek.

                    Megoldás
                    lista = [„bögre”, „kulcs”, „autó”, „mozi”, „bicikli”]
                    for index in range(len(lista)):
                        if len(lista[index]) < 5:
                            print(index, lista[index])
                           

                    10. Kombinált gyakorló

                    Kérj be a felhasználótól 5 szót egy listába. Ezután:

                    • írd ki az elemeket sima for ciklussal
                    • írd ki az indexet és az elemet range(len(lista)) segítségével
                    • írd ki az indexet és az elemet enumerate() használatával is

                      Megoldás
                      lista = []
                      darab = 0

                      while darab < 5:
                          szo = input(„Adj meg egy szot: „)
                          lista.append(szo)
                          darab += 1

                      for szo in lista:
                          print(szo)

                      for index in range(len(lista)):
                          print(index, lista[index])

                      for index, szo in enumerate(lista):
                          print(index, szo)
                             
                      Vidám anime lány számítógépnél grafikát készít, Inkscape alapok tanulása

                      Ha a ciklusok működését a hivatalos leírás alapján is szeretnéd megnézni, olvasd el a Python vezérlési szerkezetekről szóló tutorialját.

                      Ha szeretnél továbbhaladni a Python programozással, lépj a következő leckére:

                      Listák létrehozása

                      Listák létrehozása

                      Python

                      Listák létrehozása

                      Ha Pythonban programozol, nagyon gyorsan eljön az a pont, amikor már nem elég egyetlen adatot eltárolni. Oké, egy név, egy szám vagy egy életkor még simán mehet egy változóba. De mi van akkor, ha több hónapot, több nevet vagy több eredményt szeretnél együtt kezelni?

                      Na itt lépnek színre a listák.

                      Python while ciklus működése illusztráción

                      A lista Pythonban egy olyan adattípus, amiben több elemet tudsz eltárolni egyetlen név alatt. Ez azért hasznos, mert nem kell külön változót létrehoznod minden egyes adathoz. Elég egy lista, és máris átláthatóbban tudsz dolgozni.

                      Ebben a bejegyzésben megnézzük, hogyan működik a listák létrehozása Pythonban, hogyan kell őket helyesen megadni, és hogyan tudod kiíratni a tartalmukat.

                      Python listák létrehozása

                      Amikor programot írunk, gyakran szeretnénk adatokat tárolni. Ezek lehetnek például hónapok, tantárgyak, pontszámok vagy akár bevásárlólista-elemek. Egy-egy adatot könnyen el tudunk menteni változókba, de ha sok összetartozó adatunk van, akkor sokkal jobb megoldás a lista.

                      A lista abban segít, hogy több elemet egyetlen változóban tudjunk tárolni.

                      Miért jó a lista?

                      Képzeld el, hogy el akarod tárolni az év hónapjait. Megtehetnéd így is:

                      • honap1 = „január”
                      • honap2 = „február”
                      • honap3 = „március”

                      Ez működik, csak hosszú és nehezen kezelhető. Elég hamar káosz lesz belőle. A Python erre ad egy sokkal tisztább megoldást: a listát. 

                      Lista létrehozása Pythonban

                      A lista létrehozásához megadjuk a lista nevét, írunk egy egyenlőségjelet, majd szögletes zárójelek közé felsoroljuk a lista elemeit.

                      honapok = [„január”, „február”, „március”, „április”, „május”, „június”, „július”, „augusztus”, „szeptember”, „október”, „november”, „december”]

                      Ebben a példában:

                      • a lista neve: honapok
                      • az egyenlőségjel után adjuk meg a lista értékét
                      • a lista elemei [] közé kerülnek
                      • az elemeket vesszővel választjuk el egymástól
                      • mivel itt szövegeket tárolunk, ezért idézőjelbe kell írni őket

                      Ez nagyon fontos: ha a lista elemei szövegek, akkor idézőjel kell. Ha számok, akkor nem.

                      Egy számlista így nézne ki:
                      szamok = [3, 7, 12, 25, 40]

                      A lista elemei lehetnek különböző típusúak is: 

                      adatok = [„Anna”, 16, True]

                      Ez technikailag teljesen jó, de kezdőként érdemes azonos típusú adatokat egy listában tárolni, mert úgy átláthatóbb marad a program.

                      Üres lista létrehozása: olyan is van, hogy előre létrehozol egy listát, de még nincs benne semmi:

                      nevek = []

                      Ez egy üres lista. Később lehet elemeket hozzáadni.

                      Lista tartalmának kiiratása

                      Ha szeretnéd megnézni mi van a listában, akkor egyszerűen kiirathatod print() segítségével:

                      print(honapok)

                      A program ilyenkor kiírja a teljes lista tartalmát. A kimenet valami ilyesmi lesz:  

                      [‘január’, ‘február’, ‘március’, ‘április’, ‘május’, ‘június’, ‘július’, ‘augusztus’, ‘szeptember’, ‘október’, ‘november’, ‘december’]

                      A Python úgy mutatja meg a lista elemeit, ahogy eltárolta. 

                      A lista szebb kiiratása

                      Ha kulturáltabban szeretnéd megjeleníteni a lista elemeit, használhatod a join() metódust:

                      print(„, „.join(honapok))
                      print(” | „.join(honapok))

                      A join összefűzi a lista elemeit egyetlen szöveggé, és közéjük beszúrja azt az elválasztót, amit megadtál. Például a „, „.join(honapok) – vesszővel választja el a hónapok neveit: január, február, március.
                      A ” | „.join(honapok) függőleges vonallal választja el őket: január | feburár | március
                      A join() csak akkor működik jól, ha a lista elemei szövegek.  

                      A lista hosszának lekérdezése len() függvénnyel

                      Ha szeretnéd tudni, hány elem van a listában, használd a len() függvényt: 

                      print(len(honapok))

                      ez megadja a lista elemeinek számát. Ha a hónapok lista 12 hónapot tartalmaz, akkor a kimenet: 12. A len függvény gyakran előkerül Pythonban, érdemes megjegyezni- 

                      Adott listaelem kiíratása

                      Ha nem az egész listára vagyunk kiváncsiak, hanem csak egyetlen elemre, akkor index alapján tudsz hivatkozni rá. 
                      print(honapok[0])
                      Ez a lista első elemét írja ki. : január. 

                      A lista indexelése nulláról indul. Ez elsőre kicsit fura lehet, de programozásban teljesen alap. 

                      Több listaelem elérése szeleteléssel

                      Nemcsak egyetlen elemet kérhetsz le, hanem a lista egy részét is. Ezt szeletelésnek hívjuk. 
                      print(honapok[0:2] – ez a 0 és az 1. indexű elemeket írja ki, vagyis: január február.
                      Szeletelésnél a kezdő index még benne van, a záró index már nincs. Azt jelenti: induljon a 0. indextől és álljon meg a 2. index előtt. 

                      Kiíratás egy adott helytől a lista végéig 

                      Ha egy bizonyos elemtől kezdve az összes többit szeretnéd látni, akkor a második indexet el is hagyhatod: 

                      print(honapok[2:])

                      Ez a 2. indexű elemtől kezdi a kiírást, tehát: március, április, május …

                      Negatív indexelés

                      A Pythonban lehet visszafelé is számolni: 

                      print(honapok[-2]

                      Ez a lista végétől számított elemet adja vissza, azaz november lesz. Nem azt jelenti, hogy visszafelé végigmegy a listán, hanem a végétől számolod az indexeket:

                      honapok[-1] – december
                      honapok[-2]  november
                      honapok[-3] – október …

                      Ugyanez működik szövegeknél is

                      A szeletelés nemcsak listáknál működik, hanem stringeknél is, mert a szöveg is egy karakterből álló sorozat. 

                      szo = „Python”
                      print(szo[:4] ->  kimenet: Pyth. Itt az első 4 karaktert fogja kiírni, ugyanazon a logika mentén, mint a listáknál. 

                      Szavak bekérése és listán tárolása

                      Most nézzünk egy nagyon hasznos példát: azt szeretnénk, hogy a felhasználó több szót adjon meg, és ezeket egy listában tároljuk.

                      Üres lista létrehozása

                      Először létrehozunk egy üres listát:

                      szavak = []

                      Ide kerülnek majd a felhasználó által megadott szavak. Egy változó kezdőérték nélkül Ezután létrehozunk egy változót:

                      szo = None

                      A None azt jelenti, hogy a változónak egyelőre nincs valódi értéke. Ez egy gyakori megoldás Pythonban, ha később akarunk majd értéket adni neki. 

                      Szavak bekérése ciklusban

                      A cél az, hogy addig kérünk be szavakat, amíg a felhasználó nem nyom csak egy Entert. 

                      szavak = []
                      szo = None

                       

                      while szo != „”:
                          szo = input(„Adj meg egy szót: „)

                       

                          if szo != „”:
                              szavak.append(szo)
                      print(szavak)

                      Hogyan működik ez?

                      • létrehozunk egy üres listát
                      • bekérünk egy szót a felhasználótól
                      • ha a beírt szöveg nem üres, hozzáadjuk a listához az append() segítségével
                      • ha a felhasználó üresen hagyja a sort és csak Entert nyom, a ciklus leáll

                      Az append() egy listaelem-hozzáadó művelet: szavak.append(szo) -> a szo változó aktuális értékét hozzáfűzik a lista végéhez. 

                      Gyakorlás

                      1. Hónapok listája

                      Hozz létre egy honapok nevű listát, amely az év első 6 hónapját tartalmazza.

                      Feladatok:

                      • írasd ki az egész listát
                      • írasd ki a lista hosszát
                      • írasd ki az első elemet
                      • írasd ki a harmadik elemet
                      • írasd ki az utolsó elemet

                      Megoldás
                      honapok = [„január”, „február”, „március”, „április”, „május”, „június”]

                      print(honapok)
                      print(len(honapok))
                      print(honapok[0])
                      print(honapok[2])
                      print(honapok[5]) vagy
                      print(honapok[-1]
                             

                      2. Szebb kiíratás

                      A honapok listát írasd ki többféleképpen:

                      • vesszővel elválasztva
                      • | jellel elválasztva
                      • - jellel elválasztva

                      Megoldás
                      print(„, „.join(honapok))
                      print(” | „.join(honapok))
                      print(” – „.join(honapok))

                      3. Szeletelés gyakorlása

                      Egy napok listában tárold a hét napjait.

                      Feladatok:

                      • írasd ki az első 3 napot
                      • írasd ki a 2. elemtől a végéig
                      • írasd ki az utolsó 2 elemet
                      • írasd ki a lista középső részét szeleteléssel

                      Megoldás
                      nap = [„hétfő”, „kedd”, „szerda”, „csütörtök”, „péntek”, „szombat”, „vasárnap”]
                      print(nap[:3])
                      print(nap[1:])
                      print(nap[5:])
                      print(nap[2:4]) vagy print[-2:]
                             

                      4. Kedvenc kaják

                      Készíts egy kajak nevű listát legalább 5 étellel.

                      Feladatok:

                      • írasd ki az egész listát
                      • írasd ki a második kedvencedet
                      • írasd ki az első 3 ételt
                      • írasd ki a lista utolsó elemét negatív indexeléssel
                      • írasd ki a lista hosszát

                      Megoldás
                      kajak = [„banán”, „eper”, „csoki”, „sajt”, „croissant”]
                      print(kajak)
                      print(kajak[1])
                      print(kajak[:3])
                      print(kajak[1])
                      print(len(kajak))
                             

                      5. String és lista közti hasonlóság

                      Hozz létre egy változót:

                      szo = „programozas”

                      • írasd ki az első 4 karaktert
                      • írasd ki az utolsó 3 karaktert
                      • írasd ki a 2. karaktertől az 5. karakterig
                      • figyeld meg, hogy ez mennyire hasonlít a listák szeletelésére

                      Megoldás
                      szo = „programozas”
                      print(szo[:4])
                      print(szo[3:])
                      print(szo[1:5])
                             

                      6. Szóbekérős lista

                      Készíts programot, amely szavakat kér be a felhasználótól, és eltárolja őket egy listában.

                      Szabály:

                      • addig kérjen be új szót, amíg a felhasználó nem nyom egy üres Entert

                      A végén:

                      • írasd ki a teljes listát
                      • írasd ki, hány szót adott meg a felhasználó

                        Megoldás
                        szavak = []
                        szo = None

                        while szo != „”:
                            szo = input(„Adj meg egy szót: „)
                            if szo != „”:
                                szavak.append(szo)
                        print(szavak)
                        print(len(szavak))
                               

                        7. Bevásárlólista

                        Kérj be a felhasználótól bevásárlólista-elemeket, és tárold őket listában.

                        A végén:

                        • írasd ki a lista elemeit egy sorban vesszővel elválasztva
                        • írasd ki az első és az utolsó elemet
                        • írasd ki a lista hosszát

                        ➡️ Extra: csak akkor add hozzá a listához az elemet, ha nem üres a megadott szöveg.

                        Megoldás
                        lista = []
                        tetelek = None

                        while tetelek != „”:
                            tetelek = input(„Mit vásárolsz ma? „)
                            if tetelek != „”:
                                lista.append(tetelek)
                        print(„, „.join(lista))


                        if len(lista) > 0:
                            print(lista[0], lista[1])

                        print(len(lista))

                        8. Osztálynévsor

                        Legyen egy lista 5 tanuló nevével.

                        Feladatok:

                        • írasd ki a teljes listát
                        • írasd ki a 3. tanuló nevét
                        • írasd ki az első 2 tanulót
                        • írasd ki az utolsó 3 tanulót
                        • írasd ki a neveket pontosvesszővel elválasztva

                        Megoldás
                        lista = [„Kiss Adam”, „Nagy Géza”, „Kovács Anna”, „Király Elek”, „Zord Bea”]

                        print(lista)
                        print(lista[2])
                        print(lista[:2])
                        print(lista[3:])
                        print(„; „.join(lista))
                               

                        9. Top 3 kedvenc

                        Kérj be a felhasználótól 3 kedvenc filmet vagy zenét, és tárold el listában.

                        A végén:

                        • írasd ki a teljes listát
                        • írasd ki őket | elválasztással
                        • írasd ki az első kedvencet
                        • írasd ki az utolsó kedvencet
                        • írasd ki a lista hosszát

                            Megoldás
                            lista = []

                            while len(lista) < 3:
                                film = input(„Melyik a kedvenc filmed? „)
                                lista.append(film)
                            print(lista)
                            print(” | „.join(lista))
                            print(lista[0])
                            print(lista[1])
                            print(len(lista))
                                   

                            10. Csak rövid szavak

                            Kérj be szavakat a felhasználótól egy listába, üres Enterig.

                            A végén:

                            • írasd ki az összes szót
                            • írasd ki csak az első 3 szót
                            • írasd ki az utolsó 2 szót
                            • írasd ki, hány szó került a listába

                            Megoldás
                            lista = []
                            szavak = None

                            while szavak != „”:
                                szavak = input(„Adj meg egy szót!: „)
                                if szavak !=„”:
                                    lista.append(szavak)

                            print(lista)
                            print(lista[:3])
                            print(lista[2:])
                            print(len(lista))
                                   

                            11. Hónapokból részlista

                            Hozd létre az év 12 hónapját tartalmazó listát.

                            Feladatok:

                            • írasd ki az első félév hónapjait
                            • írasd ki a második félév hónapjait
                            • írasd ki az első 3 hónapot
                            • írasd ki az utolsó 3 hónapot
                            • írasd ki a hónapokat egy sorban, vesszővel elválasztva

                            Megoldás
                            honapok = [„január”, „február”, „március”, „április”, „május”, „június”, „július”, „augusztus”, „szeptember”, „október”, „november”, „december”]

                            print(honapok[:6])
                            print(honapok[6:])
                            print(honapok[:3])
                            print(honapok[3:])
                            print(„, „.join(honapok))
                                   

                            12. Saját listaépítő program

                            Készíts programot, amely:

                            • létrehoz egy üres listát
                            • bekér adatokat a felhasználótól
                            • minden megadott adatot eltárol
                            • üres Enterre leáll

                            A program végén írja ki:

                            • a teljes listát
                            • a lista hosszát
                            • az első elemet, ha van ilyen
                            • az utolsó elemet, ha van ilyen

                              Megoldás
                              lista = []
                              adat = None

                              while adat != „”:
                                  adat = input(„Add meg az adatot: „)
                                  if adat != „”:
                                      lista.append(adat)
                              print(lista)
                              print(len(lista))
                              if lista != > 0:
                                  print(lista[0])
                                  print(lista[1])
                                     

                              13. Vegyes listafigyelés

                              Hozz létre egy ilyen listát:

                              • egy szöveg
                              • egy szám
                              • egy logikai érték

                              Utána:

                              • írasd ki az egész listát
                              • írasd ki külön az első, második és harmadik elemet

                              ➡️ Figyeld meg, hogy a Python ezt simán engedi, még ha nem is mindig ez a legszebb megoldás.

                              Megoldás
                              lista = [„alma”, 2, True]

                              print(lista)
                              print(lista[0])
                              print(lista[1])
                              print(lista[2])
                                     
                              Vidám anime lány számítógépnél grafikát készít, Inkscape alapok tanulása

                              Ha a ciklusok működését a hivatalos leírás alapján is szeretnéd megnézni, olvasd el a Python vezérlési szerkezetekről szóló tutorialját.

                              Ha szeretnél továbbhaladni a Python programozással, lépj a következő leckére:

                              Egymásba ágyazott ciklusok

                              Egymásba ágyazott ciklusok

                              Python

                              Egymásba ágyazott ciklusok

                              Az egymásba ágyazott ciklusok akkor kerülnek elő, amikor egy programnak nem egyetlen elemet kell kezelnie, hanem egy egész rendszert, amely sorokból és oszlopokból, ismétlődő mintákból vagy több szinten szerveződő adatokból áll.
                              Ilyenkor már nem elég egy sima ciklus, mert nemcsak azt kell megadni, hogy hányszor ismétlődjön valami, hanem azt is, hogy egy ismétlésen belül mi történjen újra és újra. .

                              Python while ciklus működése illusztráción

                              Ezért használjuk az egymásba ágyazott ciklusok megoldást például táblázatok, játéktáblák, szöveges alakzatok, képrácsok vagy akár adatpárok összehasonlításának feldolgozására.

                              Pythonban az egymásba ágyazott ciklusok különösen hasznosak, amikor kétdimenziós gondolkodásra van szükség. Ha például egy sakktáblát, egy szorzótáblát, egy pixelekből álló mintát vagy több sorból felépülő alakzatot szeretnénk kirajzolni, akkor a programnak egyszerre kell figyelnie a sorokra és az oszlopokra. Ugyanez igaz akkor is, amikor listák elemeit hasonlítjuk össze egymással, vagy egy nagyobb adathalmaz minden elemét minden másik elemmel összevetjük. Az egymásba ágyazott ciklusok tehát nemcsak iskolai mintarajzolós feladatokhoz kellenek, hanem minden olyan helyzethez, ahol a program egy rácsban, táblázatban vagy többszintű ismétlődésben gondolkodik.

                              Mit jelent az, hogy egymásba ágyazott ciklusok?

                              6Az egymásba ágyazott ciklusok azt jelentik, hogy egy cikluson belül van még egy másik ciklus. Ez akkor kell, amikor nem csak egyetlen sort akarunk kiírni, hanem több sort, és minden sorban több elemet is meg szeretnénk jeleníteni.

                              A legegyszerűbb példa az, amikor egy sorban több azonos jelet írunk ki.

                              Egy sor kirajzolása

                              Ha egyetlen sorban szeretnénk 6 darab X-et megjeleníteni, akkor elég egy ciklus, ami 6-szor lefut.

                              Itt a program egymás mellé írja ki a karaktereket. Az end=” ” azért kell, mert a print() alapból új sort kezdene (a print(„X”) valójában ennek a rövidítése: print(„X”, end=”\n”). Az end azt mondja meg, hogy a print() a kiírás végére mit tegyen. Ha ezt írod: print(„X”, end=” „) akkor azt mondod, hogy a végére egy szóközt tegyen. 

                              Több sor kirajzolása

                              Ha már nem egyetlen sort, hanem egy teljes téglalapot szeretnénk kirajzolni, akkor jönnek a képbe az egymásba ágyazott ciklusok. A külső ciklus kezeli a sorokat, a belső ciklus pedig minden sorban kírja a 6 karaktert:

                              • A külső ciklus eldönti, hogy hány sor legyen.
                              • A belső ciklus minden sorban végigmegy az oszlopokon
                              • A print() üresen új sort kezd

                              Vagyis 6 karakter, soremelés, újra 6 karakter és ez ismétlődik 4 soron keresztül. 

                              Növekvő alakzat rajzolása

                              Az egymásba ágyazott ciklusok nemcsak a téglalapokhoz jók, hanem alakzatokhoz is. Például készíthetünk vele egy lépcsőzetesen növekvő mintát. 

                              Itt minden új sorban eggyel több karakter jelenik meg. Az első sorban 1, a másodikban 2, a harmadikban 3, a negyedikben 4. 

                              Feladatok

                              Ablakkeret

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével kirajzol egy 5×5-ös mezőt az oldalt látható minta szerint. 

                              Megoldás
                              sor = 1
                              while sor <= 5:
                                  oszlop = 1

                                  while oszlop <= 5:
                                      if sor == 1 or sor == 5 or oszlop == 1 or oszlop == 5:
                                          print(„x”, end= ” „)
                                      else:
                                          print(” „, end= ” „)
                                      oszlop += 1
                                  print()
                                  sor += 1

                              Magyarázat:

                              • sor = 1
                              • while sor <= 5:

                              Ez a külső ciklus, a sorokat kezeli. Ez azt jelenti, hogy a program 5 soron megy végig. Tehát:

                              • 1. sor
                              • 2. sor
                              • 3. sor
                              • 4. sor
                              • 5. sor

                              Minden sor elején újraindítjuk az oszlopokat. 

                              • oszlop = 1

                              Ez nagyon fontos. 5 oszlopunk lesz. A belső ciklus az oszlopokat kezeli:

                              • while oszlop <= 5:

                              ez azt jelenti, hogy az adott soron belül a program végigmegy az 5 helyen. Tehát minden sorban megnézi:

                              • mi legyen az első helyen
                              • mi legyen a második helyen
                              • mi legyen a harmadik helyen
                              • mi legyen a negyedik helyen
                              • mi legyen az ötödik helyen

                              Ez a belső ciklus. 

                              Mikor írunk ki x-et?

                              • if sor == 1 or sor == 5 or oszlop == 1 or oszlop == 5:
                              • print(„x”, end=” „)
                              • else: print(” „, end=” „)

                              Tehát akkor kell x, ha az adott hely a kereten van. A keret pedig ez:

                              • legfelső sor -> sor == 1
                              • legalsó sor -> sor == 5
                              • legelső oszlop -> oszlop == 1
                              • legutolsó oszlop -> oszlop == 5

                              Ha ezek közül bármelyik igaz, akkor kereten vagyunk és kell az x. Ha egyik sem igaz, akkor kell a szóköz. 

                              Miért kell a belső ciklus végén a print()? -> itt váltunk sort. Ez a print üresen csak egy új sort kezd. 

                              Miért kell az oszlop +=1 és a sor +=1? -> belső ciklusban ezzel lépünk a következő oszlopra, külső ciklus végén ezzel lépünk a következő sorra. 

                              Átlós minta

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével kirajzol egy 7×7-es mezőben az oldalt látható alakzatot. 

                              Megoldás
                              sor = 1
                              while sor <= 7:

                                  oszlop = 1
                                  while oszlop <= 7:
                                      if sor == oszlop or sor + oszlop == 8:
                                          print(„x”, end= ” „)
                                      else:
                                          print(” „, end=” „)
                                      oszlop += 1
                                  print()
                                  sor += 1

                              Magyarázat

                              Az X két átlóból áll. Az egyik átló bal felülről megy jobb alulra, ott mindig igaz, hogy sor == oszlop, azaz x van az (1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7)-es helyeken.

                              A másik átló, ami jobb felülről megy bal alulra, ott mindig igaz, hogy sor + oszlop == 8
                              Miért 8?
                              Mert (1, 7), (2, 6), (3, 5), (4, 4) stb. mindig 8. Ezekre a helyekre is x kell.
                              Ha az x-ek megvannak, minden más helyre szóköz kerül. 

                              Gyakorlás

                              1. Téglalap csillagokból

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével kirajzol egy 4 sor magas és 6 oszlop széles téglalapot * karakterből.

                              Megoldás
                              sor = 1

                              while sor <= 4:
                                  oszlop = 1

                                  while oszlop <= 6:
                                      if sor == 1 or oszlop == 1 or sor == 4 or oszlop == 6:
                                          print(„*”, end= ” „)
                                      else:
                                          print(” „, end= ” „)
                                      oszlop += 1
                                  print()
                                  sor += 1
                                     

                              2. Fordított lépcső

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével kirajzol egy 4 soros mintát, ahol az első sorban 5 karakter van, a másodikban 4, a harmadikban 3 és így tovább.

                              Megoldás
                              sor = 1
                              darab = 5

                              while sor <= 5:
                                  oszlop = 1
                                 
                                  while oszlop <= darab:
                                      print(„X”, end= ” „)
                                      oszlop +=1
                                     
                                  print()
                                  sor +=1
                                  darab -=1

                              3. Sakktábla minta

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével kirajzol egy 6×6-os mezőben felváltva ír ki X és O karaktereket, sakktáblaszerű elrendezésben

                              Megoldás
                              sor = 1

                              while sor <= 6:
                                  oszlop = 1

                                  while oszlop <= 6:
                                      if sor % 2 == oszlop % 2:
                                          print(„x”, end= ” „)
                                      else:
                                          print(„O”, end= ” „)
                                      oszlop +=1
                                  print()
                                  sor += 1
                                     

                              4. Pluszjel

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével egy 5×5-ös mezőben pluszjelet rajzol ki. A középső sor legyen kitöltve, minden más helyen szóköz jelenjen meg. 

                              Megoldás
                              sor = 1

                              while sor <= 5:
                                  oszlop = 1

                                  while oszlop <=5:
                                      if sor == 3 or oszlop == 3:
                                          print(„+”, end=” „)
                                      else:
                                          print(” „, end= ” „)
                                      oszlop += 1
                                  print()
                                  sor += 1
                                     

                              5. Piramis alap

                              Készíts egy programot, amely egymásba ágyazott ciklusok segítségével egy középre rendezett, 4 soros piramis alapváltozatát rajzolja ki O karakterből. 

                              Megoldás
                              sor = 1

                              while sor <= 4:
                                  oszlop = 1

                                  while oszlop <= 7:
                                      if oszlop >= 5 sor and oszlop <= 3 + sor:
                                          print(„O”, end= ” „)
                                      else:
                                          print(” „, end= ” „)
                                      oszlop += 1
                                  print()
                                  sor += 1
                                     
                              Vidám anime lány számítógépnél grafikát készít, Inkscape alapok tanulása

                              Ha a ciklusok működését a hivatalos leírás alapján is szeretnéd megnézni, olvasd el a Python vezérlési szerkezetekről szóló tutorialját.

                              Ha szeretnél továbbhaladni a Python programozással, lépj a következő leckére:

                              Python gyakorlás

                              Python gyakorlás

                              Python

                              Python gyakorlás

                              (if-elif-else, véletlenszám-generálás, while ciklus)

                              Az eddigi leckékben már megismerkedtünk a feltételes utasításokkal, a véletlenszám-generálással és a while ciklussal. Mielőtt továbblépnénk, érdemes egy kicsit megállni és átismételni ezeket az alapokat. Az alábbi feladatok segítenek abban, hogy magabiztosabban használd az if, elif, else szerkezetet, felismerd, mikor kell több külön if, és gyakorold a ciklusos gondolkodást is.

                              Python while ciklus működése illusztráción

                              Python gyakorlás kezdőknek: 15 feladat lépésről lépésre

                              1. Jelszóbekérés

                              Kérj be egy jelszót a felhasználótól. Amíg nem írja be, hogy python123, addig kérje be újra. Ha eltalálta, írja ki: Sikeres belépés!

                              Megoldás
                              jelszo = input(„Add meg a jelszót: „)

                              while jelszo != „python123”:
                                  jelszo = input(„Add meg a jelszót: „)

                              print(„Sikeres belépés!”)

                              2. Véletlen szám tulajdonságai

                              Generálj egy véletlen számot -10 és 10 között, majd írd ki róla, hogy pozitív-e, páros-e, osztható-e hárommal. 

                              Megoldás
                              import random

                              szam = random.randint(10, 10)
                              print(szam)

                              if szam > 0:
                                  print(„A szám pozitív”)

                              if szam % 2 == 0:
                                  print(„A szám páros”)

                              if szam % 3 == 0:
                                  print(„A szám osztható hárommal”)

                              3. Találd ki, melyik tartományba esik

                              Generálj egy véletlen számot 1 és 100 között, majd írd ki, hogy kicsi, ha 1 és 33 közé esik, közepes, ha 34 és 66 közé esik, nagy, ha 67 és 100 közé esik. 

                              Megoldás
                              import random
                              szam = random.randint(1, 100)
                              print(szam)

                              if 1 <= szam <= 33:
                                  print(„kicsi”)

                              elif szam <= 66:
                                  print(„közepes”)

                              else:
                                  print(„nagy”)

                              4. Számlálás while ciklussal

                              Írj programot, amely while ciklussal kiírja az 1-től 10-ig terjedő számokat. 

                              Megoldás
                              szam = 1

                              while  szam <= 10:
                                  print(szam)
                                  szam += 1

                              5. Addig kérjen be számokat, amíg nullát nem kap

                              Kérj be számokat a felhasználótól egymás után, és a program addig fusson, amíg a felhasználó 0-t nem ír be. Minden nem nulla számnál írd ki, hogy a szám pozitív, negatív vagy páros-e? 

                              Megoldás
                              szam = int(input(„Adj meg egy számot: „))
                              while szam != 0:
                                  if szam > 0:
                                      print(„Pozitív”)
                                  elif szam < 0:
                                      print(„Negatív”)
                                 
                                  if szam % 2 == 0:
                                      print(„Páros”)
                                  szam = int(input(„Adj meg egy másik számot: „))

                              6. Jelszóbekérés

                              Kérj be egy jelszót a felhasználótól. Amíg nem írja be, hogy python123, addig kérje be újra. Ha eltalálta, írja ki: Sikeres belépés!

                              Megoldás
                              jelszo = input(„Írja be a helyes jelszót: „)

                              while jelszo != „python123”:
                                  jelszo = input(„Írja be a helyes jelszót! „)

                              print(„Sikeres belépés!”)

                              7. Szám kitalálása

                              A gép gondoljon egy számra 1 és 10 között a random segítségével. A felhasználó addig tippeljen, amíg el nem találja. Ha kisebb a tipp, írd ki: Nagyobbra gondoltam.
                              Ha a tipp nagyobb, írd ki: Kisebbre gondoltam. Ha eltalálta, írd ki: Eltaláltad!

                              Megoldás
                              import random
                              szam = random.randint(1,10)


                              tipp = int(input(„Gondoltam egy számra 1-10 között. Tippeld meg!: „))

                              while tipp != szam:
                                  if tipp < szam:
                                      print(„Nagyobbra gondoltam!”)
                                  elif tipp > szam:
                                      print(„Kisebbre gondoltam”)
                                 
                                  tipp = int(input(„Tippelj újra: „))
                              else:
                                  print(„Etaláltad!”)

                              8. Menü választással

                              Írd ki ezt a menüt: 
                              1 – Köszönés
                              2 – Vicces üzenet
                              3 – Kilépés. 
                              Kérj be egy választást a felhasználótól. 
                              Ha 1 – akkor írd ki: Szia!
                              Ha 2 – akkor írd ki: A bug nem hiba, hanem meglepetés funkció.
                              Ha 3 . akkor írd ki: Kilépés
                              Minden más esetben: Hibás választás

                              Megoldás
                              print(„1 = Köszönés \n, „2 = Vicces üzenet \n, „3 – Kilépés \n)

                              szam = int(input(„Írd be, mit szeretnél: „))

                              if szam == 1:
                                  print(„Szia!”)
                              elif szam == 2:
                                  print(„A bug nem hiba, hanem meglepetés funkció”)
                              elif szam == 3:
                                  print(„Kilépés”)
                              else:
                                  print(„Hibás választás”)

                              9. Többszöri menü

                              Készíts egy olyan programot, ami újra és újra ezt a menüt jeleníti meg:

                              1 – Dobj egy számot 1 és 6 között
                              2 – Dobj egy számot 1 és 10 között
                              0 – Kilépés

                              A program addig fusson, amíg a felhasználó 0-t nem választ. 
                              1 esetén írjon ki egy véletlen számot 1 és 6 között
                              2 esetén írjon ki egy véletlen számot 1 és 10 között
                              0 esetén álljon le
                              Rossz választásnál írja ki: Nincs ilyen menüpont

                              Megoldás
                              import random

                              szam = „”
                              while szam !=„0”:
                                  print(„1 – Dobj egy számot 1 és 6 között”)
                                  print(„2 – Dobj egy számot 1 és 10 között”)
                                  print(„0 – Kilépés”)


                                  szam = input(„Adj meg egy számot: „)

                                  if szam == „1”:
                                      dobas = random.randint(1, 6)
                                      print(dobas)
                                  elif szam == „2”:
                                      dobas = random.randint(1, 10)
                                      print(dobas)

                                  elif szam == „0”:
                                      print(„Kilépés”)

                                  else:
                                      print(„Nincs ilyen menüpont”)

                              10. Gondoltam egy számra….

                              A gép gondoljon egy számra 1 és 10 között. A játékosnak összesen 3 próbája legyen kitalálni. Minden rossz tipp után írd ki, hogy nagyobbra vagy kisebbre gondoltam. Ha elfogy a 3 próba, írd ki a helyes számot.

                              Megoldás
                              import random

                               

                              szam = random.randint(1, 5)
                              darab = 1
                              tipp = int(input(„Gondoltam egy számra 1 és 5 között. Találd ki! Mi a tipped? „))

                               

                              while szam != tipp and darab < 3:
                                  if szam > tipp:
                                      print(„Nagyobbra gondoltam: „)
                                     
                                  elif szam < tipp:
                                      print(„Kisebbre gondoltam: „)

                               

                                  tipp = int(input(„Tippeld meg újra: „))
                                  darab += 1
                              if szam == tipp:
                                  print(„Eltaláltad!”)
                              else:
                                  print(„Nem találtad el. A helyes szám: „, szam)
                                 

                              11. Páros vagy páratlan játék

                              A gép sorsoljon egy számot 1 és 10 között. A felhasználó tippelje meg, hogy a szám páros vagy páratlan. Ha eltalálta, írd ki: Eltaláltad. Ha nem, írd ki: Nem találtad el. A végén írja ki a gép a helyes számot is.

                              Megoldás
                              import random

                               

                              szam = random.randint(1, 10)
                              if szam % 2 == 0:
                                  tipus = „páros”
                              else:
                                  tipus = „páratlan”

                               

                              tipp = input(„Gondoltam egy számra. Tippeld meg, hogy páros vagy páratlan? „)
                              if tipp == tipus:
                                      print(„Eltaláltad, a szám: „, szam)
                                       
                              else:

                                      print(„Nem találtad el, a szám: „, szam)

                              vagy

                              import random

                              szam = random.randint(1, 10)
                              tipp = input(„Golndoltam egy számra. Tippeld meg, hogy páros vagy páratlan: „)

                              if szam % 2 == 0 and tipp == „páros”:
                                  print(„Eltaláltad! A szám: „, szam)
                              elif szam % 2 != 0 and tipp == („páratlan”):
                                  print(„Eltaláltad! A szám: „, szam)
                              else:
                                  print(„Nem találtad el, a szám: „, szam)

                              12. Három dobás

                              A program dobjon egy számot 1 és 6 között háromszor. Minden dobás után:
                              Ha 6-os, írd ki: Max dobás!
                              Ha 1-es, írd ki: Pech!
                              Egyébként írd ki a dobott számot. 

                              Megoldás
                              import random

                              darab = 0

                              while darab < 3:
                                  dobas = random.randint(1, 6)
                                  if dobas == 6:
                                      print(„Max dobás!”)
                                  elif dobas == 1:
                                      print („Pech”)
                                  else:
                                      print(dobas)
                                  darab += 1

                              13. Titkos szám, kilépési lehetőséggel

                              A gép gondoljon egy számra 1 és 5 között. A felhasználó addig tippeljen, amíg el nem találja vagy be nem írja azt, hogy 0. 
                              Szabályok: 
                              ha 0, akkor írd ki: Kilépés
                              ha kisebb a tipp, írd ki: Nagyobbra gondoltam
                              ha nagyobb a tipp, írd ki: Kisebbre gondoltam
                              ha eltalálta, írd ki: Ügyes!

                              Megoldás
                              import random
                              szam = random.randint(1, 5)
                              tipp = int(input(„Tippeld meg, melyik számra gondoltam, 1-5 között: „))

                              while szam != tipp and tipp !=0:

                                  if szam < tipp:
                                      print(„Kisebbre gondoltam”)
                                     
                                  elif szam > tipp:
                                      print(„Nagyobbra gondoltam”)
                                  tipp = int(input(„Tippeld meg, melyik számra gondoltam, 1-5 között: „))
                                 
                              if tipp == szam:
                                  print(„Ügyes vagy!”)

                              elif tipp == 0:
                                  print(„Kilépés”)

                              14. Menü véletlen üzenettel

                              Készíts menüt:
                              1 = Pozitív üzenet
                              2 = Vicces üzenet
                              3 = Véletlen szám 1 és 10 között
                              0 = Kilépés
                              A program addig fusson, amíg a felhasználó 0-t nem választ. 

                              Megoldás
                              import random

                              print(„1 – Pozitív üzenet”)
                              print(„2 – Vicces üzenet”)
                              print(„3 – véletlen szám 1 és 10 között”)
                              print(„0 – Kilépés”)

                              valasztas = int(input(„Válassz egy számot!: „))

                              while valasztas != 0:
                                  if valasztas == 1:
                                      print(„Jól haladsz!”)
                                  elif valasztas == 2:
                                      print(„Nyugi, a számítógép nálad is jobban össze van zavarodva”)
                                  elif valasztas == 3:
                                      szam = random.randint(1, 10)
                                      print(szam)
                                  else:
                                      print(„Nincs ilyen menüpont”)
                                  valasztas = int(input(„Válassz egy másik számot: „))


                              print(„Kilépés”)

                              15. Két próbás tippelés

                              A gép gondoljon egy számra 1 és 3 között. A felhasználónak 2 próbálkozása legyen. 
                              Ha elsőre eltalálja: Elsőre sikerült!
                              Ha másodikra találja el: Másodikra sikerült!
                              Ha nem találja el: Nem sikerült. A szám: ….

                              Megoldás
                              import random
                              szam = random.randint(1, 3)
                              tipp_darab = 1

                              tipp = int(input(„Gondoltam egy számra 1 és 3 között. Tippeld meg: „))

                              while szam != tipp and tipp_darab < 2:
                                  tipp_darab +=1
                                  tipp = int(input(„Nem talált. Tippelj újra!: „))
                                 
                              if szam == tipp and tipp_darab == 1:
                                  print(„Elsőre eltaláltad!”)

                              elif szam == tipp and tipp_darab == 2:
                                  print(„Másodszorra eltaláltad”)
                              else:
                                  print(„Nem sikerült. A szám:”, szam)

                              Ez a Python gyakorlás lecke akkor a leghasznosabb, ha nemcsak elolvasod a feladatokat, hanem önállóan meg is próbálod megoldani őket. 

                              Ha szeretnél további példákat is nézni, érdemes átolvasni a Python hivatalos dokumentációját.

                              Vidám anime lány számítógépnél grafikát készít, Inkscape alapok tanulása

                              Ha szeretnél továbbhaladni a Python programozással, lépj a következő leckére: