Ciklusok.

Írd ki a számokat 1-től 5-ig. Ez még megy öt print-tel. És 1-től 1000-ig? Vagy annyiszor, ahányat a felhasználó kér? Az ilyen feladatokhoz ciklus kell: egy utasításcsoport, amelyet a program többször egymás után végrehajt.

for i in range(1, 6):
    print(i, "a négyzete:", i * i)
print("Kész.")

Kövesd Lépésenként. A Memória részben figyeld az i változót: minden körben a következő értéket kapja. A „Kész.” sor nincs beljebb kezdve, ezért a ciklus után, egyszer fut le.

for valtozo in sorozat:
    ciklusmag   # minden elemre egyszer lefut

• forkulcsszó: „minden … -ra/-re”
• valtozoa ciklusváltozó: körönként a sorozat következő eleme
• in sorozatamin végighaladunk: range(), szöveg, lista…
• : + behúzásutána jön a ciklusmag

A for annyiszor futtatja le a magot, ahány eleme a sorozatnak van, és minden körben a ciklusváltozóba teszi a soron következő elemet. A sorozat lehet például egy szöveg – ilyenkor a karaktereken megy végig:

szo = input("Adj meg egy szót: ")
for betu in szo:
    print(betu)

…vagy egy lista (a listákról a 4. modulban lesz bővebben szó; itt elég annyi, hogy szögletes zárójelben, vesszővel felsorolt értékek):

for gyumolcs in ["alma", "körte", "szilva"]:
    print("Kosárba tettem:", gyumolcs)

A leggyakoribb sorozat egy számtartomány. A range() függvény egy, két vagy három egész számot kap:

for mp in range(10, 0, -1):
    print(mp, end=" ")
print("Start!")

for i in range(2, 11, 3):
    print(i, end=" ")

A ciklusos feladatok nagy része néhány visszatérő mintára épül. Ha ezeket felismered, a legtöbb feladat megoldása már csak összerakás.

Összegzés

Egy gyűjtőváltozó a ciklus előtt 0-t kap, és a ciklusmagban minden körben hozzáadjuk az aktuális értéket. A osszeg += szam az osszeg = osszeg + szam rövidítése. Ugyanígy működik a -=, *=, /=, //= és %= is: például az x //= 10 jelentése x = x // 10.

n = int(input("Meddig adjam össze a számokat? "))
osszeg = 0
for szam in range(1, n + 1):
    osszeg += szam
print(f"1 + 2 + … + {n} = {osszeg}")

Kövesd lépésenként n = 5-tel: az osszeg értéke 0 → 1 → 3 → 6 → 10 → 15. Figyeld meg a range(1, n + 1)-et: azért kell a + 1, mert a stop nem része a sorozatnak, mi pedig az n-et is össze akarjuk adni.

Számlálás

A számláló is a ciklus előtt kap 0-t, és csak akkor nő eggyel, ha az elem megfelel a feltételnek – ehhez a ciklusmagban egy if kell.

szoveg = input("Írj egy mondatot: ")
db = 0
for betu in szoveg.lower():
    if betu in "aáeéiíoóöőuúüű":
        db += 1
print("Magánhangzók száma:", db)

Két új apróság a példában: a szoveg.lower() a szöveg kisbetűs változatát adja (így a nagy kezdőbetű is magánhangzónak számít), a betu in "aáeé…" pedig igaz, ha a karakter szerepel a felsorolt szövegben – szövegnél az in azt vizsgálja, hogy a bal oldal része-e a jobb oldalnak.

Szélsőérték (legnagyobb, legkisebb)

A legnagyobb érték kereséséhez az első elemet tekintjük kezdetben a legnagyobbnak, majd minden további elemet összevetünk vele. Ha nagyobbat találunk, az lesz az új „eddigi legnagyobb”.

db = int(input("Hány számot adsz meg? "))
legnagyobb = int(input("1. szám: "))
for i in range(2, db + 1):
    szam = int(input(f"{i}. szám: "))
    if szam > legnagyobb:
        legnagyobb = szam
print("A legnagyobb:", legnagyobb)

while feltétel:
    ciklusmag   # addig ismétlődik, amíg a feltétel igaz

A while minden kör előtt kiértékeli a feltételt: ha igaz, lefut a mag, és utána újra a feltétel következik; ha hamis, a ciklus véget ér. Ha a feltétel már az elején hamis, a mag egyszer sem fut le. Akkor használjuk, amikor nem tudjuk előre, hány kör kell – például addig kérdezünk, amíg jó választ nem kapunk.

szam = 1
while szam <= 5:
    print(szam)
    szam += 1
print("A ciklus után szam =", szam)

Kövesd lépésenként: a Kiértékelés minden körben megmutatja a feltétel aktuális értékét. A ciklus utáni sorban a szam már 6 – éppen ez tette hamissá a feltételt.

n = 0
db = 0
while n < 10:
    n += 3
    db += 1
print(n, db)

Példa: jelszó

jelszo = ""
while jelszo != "titok":
    jelszo = input("Jelszó: ")
print("Beléptél.")

Példa: végjelig olvasás

Gyakori feladat, hogy a felhasználó tetszőleges számú adatot ad meg, a végét pedig egy megbeszélt végjel (pl. 0) jelzi. A végjelet már nem dolgozzuk fel – ezért a beolvasás a ciklus előtt és a mag végén áll:

osszeg = 0
db = 0
szam = int(input("Szám (0 = vége): "))
while szam != 0:
    osszeg += szam
    db += 1
    szam = int(input("Szám (0 = vége): "))
print(f"{db} számot adtál meg, az összegük {osszeg}.")

szam = 1
while szam <= 5:
    print(szam)

A break azonnal kilép a ciklusból (a legbelsőből), a continue pedig a mag hátralévő részét kihagyja, és a következő körrel folytatja. Mindkettő általában egy if belsejében áll.

for i in range(1, 11):
    if i % 3 == 0:
        continue
    if i > 7:
        break
    print(i, end=" ")
print()

A 3, 6 kimarad (continue), a 8-nál pedig a ciklus véget ér (break), így a 9 és a 10 már nem kerül sorra.

A while True + break minta

Bemenet ellenőrzésénél kényelmes, ha a ciklus „örökké” fut, és a jó adat beolvasása után break-kel lépünk ki. Így a beolvasás csak egyszer szerepel a kódban:

while True:
    jegy = int(input("Érdemjegy (1–5): "))
    if 1 <= jegy <= 5:
        break
    print("Hibás érték, próbáld újra!")
print("Rögzítve:", jegy)

Egy ciklus magjában újabb ciklus is állhat. A belső ciklus a külső minden egyes körében végigfut. Táblázatokhoz, rácsokhoz, alakzatok rajzolásához használjuk.

for sor in range(1, 6):
    for oszlop in range(1, 6):
        print(f"{sor * oszlop:4}", end="")
    print()

A belső ciklus egy sort ír ki egymás mellé (end=""), a sor végén a külső ciklus print()-je kezd új sort. A {…:4} formázás minden számot 4 karakter szélesre igazít, így az oszlopok egymás alá kerülnek. Összesen 5 · 5 = 25-ször fut le a belső mag.

Alakzatok: háromszög és fenyőfa

A "*" * db szövegismétlés sokszor kiváltja a belső ciklust. A fenyőfa i-edik sorában (az i 0-tól indul) magassag - i - 1 szóköz és 2 * i + 1 csillag áll – rajzold le papíron egy 4 magas fára, és ellenőrizd a képletet.

magassag = int(input("A fa magassága: "))
for i in range(magassag):
    print(" " * (magassag - i - 1) + "*" * (2 * i + 1))
for i in range(2):
    print(" " * (magassag - 2) + "|||")

db = 0
for i in range(3):
    for j in range(4):
        db += 1
print(db)

A gép gondol egy számra 1 és 100 között, a játékos legfeljebb 7-szer tippelhet, és minden tipp után megtudja, hogy a gondolt szám kisebb vagy nagyobb. A véletlenszámot a random modul randint() függvénye adja – a modult az 5. modulban részletesen megismered.

import random

gondolt = random.randint(1, 100)
max_tipp = 7
tippek = 0
eltalalta = False

print("Gondoltam egy számra 1 és 100 között.")
while tippek < max_tipp and not eltalalta:
    tipp = int(input(f"{tippek + 1}. tipp: "))
    tippek += 1
    if tipp == gondolt:
        eltalalta = True
    elif tipp < gondolt:
        print("A gondolt szám nagyobb.")
    else:
        print("A gondolt szám kisebb.")

if eltalalta:
    print(f"Eltaláltad {tippek} tippből!")
else:
    print(f"Elfogytak a tippek. A szám {gondolt} volt.")

A ciklusnak két kilépési oka lehet: elfogytak a tippek, vagy eltalálta. Az eltalalta logikai változó (más néven jelző) őrzi meg, melyik történt – a ciklus után ennek alapján írjuk ki az eredményt. Ha ügyesen felezed a tartományt (50, 25 vagy 75, …), 7 tipp mindig elég – miért?