Új lapon nyílik meg

5. lecke

Ciklusok: for és while

6 rész14 kódpélda1 ábra
Miről szól ez a lecke?

Ha ugyanazt a műveletet sokszor kell elvégezni, nem írjuk le százszor — ciklust használunk. A lecke bemutatja a for ciklust és a range() függvényt, a listákon és szövegeken való végighaladást, a while ciklust, valamint a break és continue utasítást. A gépi tanulásban a ciklus mindenütt ott van: egy modell tanítása is egy sokszor ismételt lépéssor.

Amit ebben a leckében megtanulsz
  • Miért kell ciklus?
  • A for ciklus és a range()
  • For ciklus listán / szövegen
  • A while ciklus
  • Break és continue
  • Gyakorlati példa — ciklus + feltétel együtt
Tudnivalók
  • Olvasási idő: kb. 5 perc (a kódok kipróbálásával több)
  • 6 rész · 14 kódpélda
  • A végén gyakorló feladatok ellenőrzik a tudásodat
Ciklus: az utasítás ismétlődik, majd kilép
A ciklus ugyanazt a kódot ismétli — vagy adott számszor (for), vagy amíg egy feltétel igaz (while). Így nem kell ezerszer leírnod ugyanazt.

1. Miért kell ciklus?

PYTHON● ● ●
print(1)
print(2)
print(3)
print(4)
print(5)

Miért probléma ez, ha egyszer leírom? 5 sornál nem tűnik nagy tehernek, de gondolj bele: ha 1000 számot kellene kiírni, 1000 sort kellene írnod, és ha menet közben módosítani akarnál valamit (pl. minden számot duplázni), mind az 1000 sort külön kellene átírnod. Ez nem csak fáradságos, hanem hibalehetőség is — könnyű elgépelni valamit egy ilyen hosszú, ismétlődő listában. A ciklus lényege: egyszer leírod a logikát, és a géppel ismételteted meg annyiszor, ahányszor kell.

2. A for ciklus és a range()

PYTHON● ● ●
for szam in range(5):
    print(szam)

Kimenet: 0, 1, 2, 3, 4 (öt szám, 0-tól indulva!)

Miért 0-tól indul, miért nem 1-től? Ez az egyik leggyakoribb kezdő zavar! A válasz technikai gyökerű: a számítógépek világában a "számolás" hagyományosan 0-tól indul, mert amikor egy memóriahelyre "mutatunk", az első elem távolsága a kezdőponttól 0 (hiszen ott van a kezdőpont) — a második elem távolsága 1, és így tovább. Ez a konvenció ("0-indexelés") a legtöbb modern programozási nyelvben (Python, Java, C, JavaScript) elterjedt, mert konzisztensebb a memóriakezelés szintjén. A range(5) tehát nem "5-től számol", hanem "5 darab számot ad, 0-tól kezdve" — ez a különbség kulcsfontosságú.

SzéljegyzetMi az a range() valójában — egy lista?

Meglepő módon nem lista, hanem egy speciális, "lusta" (lazy) objektum — ez azt jelenti, hogy a range(5) nem gyártja le előre az [0, 1, 2, 3, 4] listát a memóriában, hanem csak "megjegyzi" a szabályt (kezdés, vég, lépésköz), és menet közben, egyesével generálja a számokat, ahogy a ciklus kéri őket. Ez azért fontos, mert ha lenne range(10000000) (10 millió), egy sima lista eszi a memóriát, míg a range() gyakorlatilag semmi extra memóriát nem használ — csak a 3 db számot (kezdés, vég, lépés), amiből ki tudja számolni bármelyik elemet.

PYTHON● ● ●
for szam in range(1, 6):
    print(szam)

Kimenet: 1, 2, 3, 4, 5

PYTHON● ● ●
for szam in range(0, 10, 2):
    print(szam)

Kimenet: 0, 2, 4, 6, 8 (kettesével lép)

Miért áll meg a range(0, 10, 2) a 8-nál, és nem éri el a 10-et? Ez ugyanaz a "0-indexelés"-hez hasonló konvenció: a range() a végértéket soha nem éri el, csak közelít feléje — ez a "felső határ kizárt" (exclusive upper bound) elv. Ennek gyakorlati előnye van: ha két range()-et szeretnél összefűzni (pl. range(0, 5) és range(5, 10)), ezzel a szabállyal nem lesz átfedés vagy hiányzó szám — az 5 pontosan egyszer szerepelne, a második range() elején.

3. for ciklus listán / szövegen

PYTHON● ● ●
nevek = ["Anna", "Béla", "Csilla"]
PYTHON● ● ●
for nev in nevek:
    print("Szia,", nev, "!")

Ez most más, mint a range()? Hogyan 'tudja' a for, hogyan menjen végig egy listán? A Python-ban minden, ami "végigjárható" (listák, szövegek, range, és sok más), rendelkezik egy beépített képességgel, amit "iterálhatóságnak" hívnak — ez azt jelenti, hogy az adott dolog tudja, hogyan adja ki magát "egyesével, sorban". A for ciklus valójában ezt kérdezi meg: "add nekem a következő elemet" — és ezt ismétli, amíg van még elem, majd automatikusan leáll, amikor elfogynak. Ez az oka, hogy ugyanazzal a for szerkezettel tudsz végigmenni számokon (range), listákon, sőt akár szövegen is (lásd alább) — mindegyik "tudja", hogyan adja ki magát elemenként.

SzéljegyzetHogyan kapom meg egyszerre az elem sorszámát és az elemet magát egy listán végigmenve?

Erre való az enumerate() beépített függvény: for i, nev in enumerate(nevek): — így egyszerre kapod meg a sorszámot (i, 0-tól indulva) és magát az elemet (nev), anélkül hogy külön számlálót kellene kézzel vezetned.

PYTHON● ● ●
for betu in "Python":
    print(betu)

Hogyan lehet egy szón 'végigmenni', mintha lista lenne? Mert egy szöveg (string) a Python szemében valójában egy karakterek sorozata — nagyon hasonlóan viselkedik, mint egy lista, csak listaelemek helyett egyedi betűket tartalmaz. Ezért a for ciklus ugyanúgy tudja "egyesével kiadni" a betűket, mint ahogy egy listánál az elemeket.

4. A while ciklus

PYTHON● ● ●
szamlalo = 1
PYTHON● ● ●
while szamlalo <= 5:
    print("Számláló:", szamlalo)
    szamlalo = szamlalo + 1   # enélkül a ciklus SOSEM állna le!
PYTHON● ● ●
print("Kész a ciklus.")

Mi a különbség a for és a while között — mikor melyiket használjam? A for akkor ideális, ha előre tudod, hányszor kell ismételni (pl. "menj végig ezen a listán", "számolj 1-től 10-ig") — van egy véges, ismert "gyűjtemény", amin végigmész. A while akkor ideális, ha nem tudod előre, hányszor kell ismételni, csak azt tudod, milyen feltétel mellett kell folytatni — pl. "addig kérdezz be adatot, amíg a felhasználó ki nem lép" — itt nem tudhatod előre, hányszor fog gépelni valamit a felhasználó.

Miért 'sosem állna le' a ciklus a szamlalo = szamlalo + 1 sor nélkül? A while minden egyes körben újra megvizsgálja a feltételt (szamlalo <= 5). Ha a szamlalo értéke soha nem változna (mert elfelejtenéd növelni), a feltétel mindig igaz maradna (hiszen 1 <= 5 örökre igaz lenne), és a program végtelen ciklusba ragadna — a program szó szerint soha nem lépne tovább, "lefagyna". Ez az egyik leggyakoribb kezdő hiba while-nál — mindig ellenőrizd, hogy a ciklusban valami ténylegesen közelebb visz a feltétel megszűnéséhez.

SzéljegyzetVan olyan minta, amikor szándékosan végtelen a while feltétele?

Igen, ez egy gyakori, hasznos minta: while True: egy örökké futó ciklust indít, amit belül egy if és egy break állít meg, amikor a kívánt feltétel teljesül. Ez akkor kényelmes, ha a leállási feltételt csak a ciklus közepén, egy lépés után lehet eldönteni.

5. break és continue

PYTHON● ● ●
for szam in range(1, 11):
    if szam == 5:
        break  # amint eléri az 5-öt, teljesen leáll a ciklus
    print("break példa:", szam)
PYTHON● ● ●
print("---")
PYTHON● ● ●
for szam in range(1, 6):
    if szam == 3:
        continue  # a 3-at kihagyja, de a ciklus folytatódik
    print("continue példa:", szam)

Mi történik pontosan a break/continue hívásakor, mi a különbség? A break egy azonnali "vészleállító gomb" — amint a Python ehhez a sorhoz ér, teljesen kilép a ciklusból, mintha az soha nem is futott volna tovább, és folytatja a kódot a ciklus utáni első sorral. A continue viszont "finomabb" — nem lép ki a teljes ciklusból, csak az aktuális kört szakítja meg azonnal, és ugrik a következő körre (a for esetén: veszi a következő listaelemet / számot; while esetén: visszaugrik a feltétel újra-ellenőrzéséhez). Ez olyan, mintha a break azt mondaná "elég volt, kilépek az egész boltból", a continue pedig azt, "ezt a polcot kihagyom, de tovább nézelődöm a boltban."

6. Gyakorlati példa — ciklus + feltétel együtt

PYTHON● ● ●
for szam in range(1, 11):
    if szam % 2 == 0:
        print(szam, "- páros")
    else:
        print(szam, "- páratlan")

Mit csinál pontosan a % (modulo) operátor? A % (modulo, vagyis "maradékos osztás") az osztás maradékát adja vissza, nem az osztás eredményét. Pl. 10 % 3 az nem 3.33, hanem 1 — mert 10-et 3-mal osztva 3 a hányados, de marad még 1 (3*3=9, és 10-9=1). Azért hasznos ez párosság-vizsgálatra, mert egy páros szám mindig pontosan osztható 2-vel, azaz a maradék 0 lesz (pl. 10 % 2 = 0), míg egy páratlan számnál a maradék mindig 1 lesz (pl. 7 % 2 = 1). Ez egy nagyon elterjedt trükk programozásban, nem csak párosságra, hanem pl. "minden 3. elem" kiválogatására is (szam % 3 == 0).

SzéljegyzetVan rövidebb módja is annak, hogy egy for ciklussal listát építsek?

Igen, ezt hívják listaértelmezésnek (list comprehension): [x for x in range(1, 11) if x % 2 == 0] egy sorban létrehozza a párosak listáját, ugyanazt az eredményt adva, mint egy több soros for ciklus. Kezdőként nyugodt szívvel maradhatsz a hagyományos for ciklusnál is, ez csak egy tömörebb alternatíva.

Gyakorlás
  1. Írasd ki for ciklussal az 1-től 20-ig terjedő számok közül csak a 3-mal oszthatókat.
  2. Írj egy while ciklust, ami addig kér be számokat input()-tal, amíg a felhasználó a "kilep" szót nem írja be.
  3. Írj egy for ciklust, ami összeadja az 1-től 100-ig terjedő számokat, és a végén kiírja az összeget.
  4. Új gyakorlat: írj egy while ciklust szándékosan úgy, hogy elfelejted növelni a számlálót — figyelem: ha lefuttatod, végtelen ciklust kapsz! Ha kipróbálod, készülj fel, hogy le kell állítanod (Ctrl+C a terminálban, vagy a stop gomb VS Code-ban) — ez segít megérteni, milyen érzés, amikor ez véletlenül megtörténik, hogy felismerd, ha egyszer élesben csinálod végig.