Feltételes utasítások.

Az eddigi programjaink minden sort végrehajtottak, fentről lefelé. A valódi programok viszont döntenek: ha a jelszó helyes, beengednek; ha a pontszám 50 alatti, „elégtelen”-t írnak ki. Az ilyen útelágazást feltételes utasításnak vagy elágazásnak nevezzük.

kor = int(input("Hány éves vagy? "))
if kor >= 18:
    print("Beléphetsz.")
else:
    print("Sajnos még nem léphetsz be.")
print("Viszlát!")

Futtasd többször, különböző életkorral (16, 18, 30), majd kövesd Lépésenként: a Kiértékelés részben látod, hogyan lesz a kor >= 18-ból 16 >= 18, majd False – és hogy emiatt melyik sor marad ki. Az utolsó print nincs beljebb kezdve, ezért az elágazástól függetlenül mindig lefut.

Az összehasonlítás eredménye maga is egy érték, amelyet ki lehet írni vagy változóba lehet tenni:

x = 7
print(x > 5)
print(x == 10)
nagykoru = x >= 18
print(nagykoru, type(nagykoru))
print("alma" == "alma", "alma" == "Alma")

print(5 == 5.0, "5" == 5)

a = 0.1 + 0.2
print(a == 0.3)
print(abs(a - 0.3) < 1e-9)

if feltétel:
    utasítás1    # ezek csak akkor futnak le,
    utasítás2    # ha a feltétel igaz
utasítás3        # ez mindig lefut

• ifkulcsszó: „ha”
• feltételkifejezés, amelyet a Python igaznak vagy hamisnak tekint – jellemzően True vagy False értékű
• :a fejléc végét jelzi – kötelező
• ····4 szóköz behúzás: ezek a sorok alkotják a blokkot

A behúzás a Pythonban a szerkezet része: ami az if alatt beljebb kezdődik, az az if blokkja, és csak igaz feltétel esetén fut. Az első nem behúzott sor már az elágazás után következik. Más nyelvek kapcsos zárójellel jelölik a blokkot – a Python a behúzással.

szam = int(input("Adj meg egy egész számot: "))
if szam < 0:
    print("Negatív számot adtál meg.")
    szam = -szam
print("A szám abszolút értéke:", szam)

Kövesd lépésenként két futással: egyszer negatív, egyszer pozitív számmal. Negatív számnál a blokk mindkét sora lefut, és a szam = -szam előjelet vált. Pozitívnál a teljes blokk kimarad.

Az else („különben”) ág akkor fut le, ha a feltétel hamis. Az else-nek nincs feltétele, és mindig az elágazás utolsó ága. A két ág közül pontosan egy fut le – sosem mindkettő, és sosem egyik sem.

Példa: páros vagy páratlan?

Egy szám akkor páros, ha 2-vel osztva a maradék 0. A szam % 2 a 2-vel vett maradékot adja (0 vagy 1), a feltétel pedig azt vizsgálja, hogy ez a maradék 0-e.

szam = int(input("Adj meg egy egész számot: "))
if szam % 2 == 0:
    print(szam, "páros.")
else:
    print(szam, "páratlan.")

17 = 8 · 2 + 1, a maradék 1, ezért a feltétel hamis, és az else ág fut. Figyeld meg: nem azt vizsgáljuk, hogy „a szám nulla-e”, hanem hogy a maradék nulla-e.

Példa: felhasználónév hossza

felhasznalonev = input("Felhasználónév: ")
if len(felhasznalonev) >= 3:
    print(f"Üdv, {felhasznalonev}!")
else:
    print("Hiba: a név legalább 3 karakter legyen.")

Ha kettőnél több lehetőség van, az elif („különben, ha”) ágakkal bővítjük az elágazást. A Python fentről lefelé vizsgálja a feltételeket, és az első igaz feltételhez tartozó ágat hajtja végre – a többit már meg sem nézi. Ha egyik sem igaz, az else fut (ha van).

pont = int(input("Elért pontszám (0–100): "))
if pont >= 85:
    jegy = 5
elif pont >= 70:
    jegy = 4
elif pont >= 55:
    jegy = 3
elif pont >= 40:
    jegy = 2
else:
    jegy = 1
print("Az érdemjegy:", jegy)

78 pontnál a pont >= 85 hamis, a pont >= 70 igaz – itt a vizsgálat véget ér, a jegy 4. Hogy a pont >= 55 is igaz lenne, már nem számít. Ezért elég az alsó határokat leírni: az elif pont >= 70 ágba csak olyan pontszám juthat el, amely 85 alatti.

pont = int(input("Pontszám: "))
if pont >= 40:
    jegy = 2
elif pont >= 55:
    jegy = 3
elif pont >= 70:
    jegy = 4
elif pont >= 85:
    jegy = 5
else:
    jegy = 1
print("Az érdemjegy:", jegy)

homerseklet = 30
if homerseklet > 25:
    print("Meleg van.")
if homerseklet > 15:
    print("Kellemes idő van.")
if homerseklet > 5:
    print("Nem fagy.")

kor = int(input("Életkor: "))
jogsi = input("Van jogosítványod? (igen/nem) ")
van_jogsi = jogsi == "igen"
if kor >= 18 and van_jogsi:
    print("Vezethetsz.")
else:
    print("Nem vezethetsz.")

Intervallum vizsgálata

Azt, hogy egy szám két határ közé esik-e, írhatjuk két összehasonlítással és and-del, vagy a Pythonban megengedett láncolt alakban:

pont = 73
print(0 <= pont and pont <= 100)
print(0 <= pont <= 100)
print(not (0 <= pont <= 100))

Példa: szerkeszthető-e a háromszög?

Három szakaszból akkor szerkeszthető háromszög, ha bármely két oldal összege nagyobb a harmadiknál (háromszög-egyenlőtlenség). Ha igen, a kerületet és – Hérón képletével – a területet is kiszámoljuk. A négyzetgyökhöz a math modul sqrt() függvényét használjuk; az import math sor teszi elérhetővé (a modulokról az 5. modulban lesz részletesen szó).

import math

a = float(input("a = "))
b = float(input("b = "))
c = float(input("c = "))
if a + b > c and a + c > b and b + c > a:
    kerulet = a + b + c
    s = kerulet / 2
    terulet = math.sqrt(s * (s - a) * (s - b) * (s - c))
    print(f"Szerkeszthető. Kerület: {kerulet:.2f}, terület: {terulet:.2f}")
else:
    print("Ebből a három szakaszból nem szerkeszthető háromszög.")

Próbáld ki az 1, 2, 3 bemenettel is: 1 + 2 nem nagyobb 3-nál, csak egyenlő – a három szakasz egy egyenesre esne.

Tartalmazás: in

Ha egy értéket több lehetőséggel kell összevetni, a hosszú or-lánc helyett az in művelet tömörebb: honap in (12, 1, 2) igaz, ha a hónap a felsorolt értékek egyike. (A zárójeles, vesszős felsorolás egy tuple – a 4. modulban lesz róla szó.) A not in az ellenkezőjét vizsgálja. Szövegnél az in részszöveget keres: "ma" in "alma" igaz.

honap = int(input("Hónap (1–12): "))
if honap in (12, 1, 2):
    print("Tél")
elif honap in (3, 4, 5):
    print("Tavasz")
elif honap in (6, 7, 8):
    print("Nyár")
elif honap in (9, 10, 11):
    print("Ősz")
else:
    print("Nincs ilyen hónap.")

x = 15
if x % 3 == 0 and x % 5 == 0:
    print("A")
elif x % 3 == 0:
    print("B")
if x > 10 or x < 0:
    print("C")

Egy ág blokkjában újabb elágazás is állhat – ilyenkor a belső if sorai még egy szinttel (újabb 4 szóközzel) beljebb kezdődnek. Akkor használjuk, ha a második kérdésnek csak az első válasz ismeretében van értelme.

Példa: egyszerű számológép

Az osztásnál külön meg kell vizsgálni, hogy az osztó nem nulla-e – ez a belső elágazás.

a = float(input("Első szám: "))
muvelet = input("Művelet (+, -, *, /): ")
b = float(input("Második szám: "))
if muvelet == "+":
    print("Eredmény:", a + b)
elif muvelet == "-":
    print("Eredmény:", a - b)
elif muvelet == "*":
    print("Eredmény:", a * b)
elif muvelet == "/":
    if b != 0:
        print("Eredmény:", a / b)
    else:
        print("Nullával nem lehet osztani!")
else:
    print("Ismeretlen művelet.")

Példa: bankautomata

Ez a program egyetlen tranzakciót kezel: előbb a PIN-kódot ellenőrzi, és csak helyes PIN esetén kérdez rá a műveletre, kivétnél pedig a fedezetre is. A három szint pontosan a döntések sorrendjét követi.

PIN = "1234"
egyenleg = 100000

pin = input("PIN-kód: ")
if pin == PIN:
    print("1 – Készpénzfelvétel")
    print("2 – Egyenleg lekérdezése")
    valasztas = input("Választás: ")
    if valasztas == "1":
        osszeg = int(input("Összeg (Ft): "))
        if osszeg <= 0:
            print("Az összegnek pozitívnak kell lennie.")
        elif osszeg > egyenleg:
            print("Nincs elegendő fedezet.")
        else:
            egyenleg = egyenleg - osszeg
            print(f"Vegye el a pénzt! Új egyenleg: {egyenleg} Ft")
    elif valasztas == "2":
        print(f"Egyenleg: {egyenleg} Ft")
    else:
        print("Érvénytelen választás.")
else:
    print("Hibás PIN-kód.")