Vezérlési szerkezetek, kivételek, konverziók

További vezérlési szerkezetek

Ciklus folytatása a következő iterációval: continue

┌─▸ while vannak_elemek:
│       if ez_nem_kell:
└─────────  continue

        ciklustörzs ...

┌─▸ for tároló:
│       if ez_nem_kell:
└─────────  continue

        ciklustörzs ...

A continue utasítás visszaugrik a ciklustörzs elejére, a ciklusfeltétel ellenőrzéséhez. Általában az if utasítással együtt használjuk, a ciklustörzs további részének kihagyásához. Működik while és for ciklus esetén is. Ezzel néha egyszerűbbé, áttekinthetőbbé lehet tenni a vezérlési szerkezetünket.

Példa: elemek kihagyása

szamok = [1, 2, 0, 4]
i = 0
while i < len(szamok):
    if szamok[i] != 0:
        print(1/szamok[i])
    i += 1

szamok = [1, 2, 0, 4]

for x in szamok:
    if x == 0:
        continue
    print(1/x)

for x in szamok:
    if x != 0:
        sok...
        teendő...
        az...
        eltárolt...
        elemekkel...

for x in szamok:
    if x == 0:
        continue
    sok...
    teendő...
    az eltárolt...
    elemekkel...

Ciklus megszakítása: break

    while feltétel:
       ...
       if megvan:
┌───      break
│      ...
│
└─▸ ciklus után...

    for x in tároló:
        ...
        if megvan:
┌───       break
│       ...
│
└─▸ ciklus után...

Feladat: meghatározni, hogy szerepel-e egy adott tulajdonságú elem a listában.

Erre az eldöntés tételét használtuk:

szamok = [1, 2, 3, 4, 5]
vantalalat = False
i = 0
while i < len(szamok) and not vantalalat:
    if szamok[i] % 2 == 0:
        vantalalat = True
    i += 1

if vantalalat:
    print("Van páros szám")
else:
    print("Nincs páros")

vantalalat = False
i = 0
while i < len(szamok):  # egyszerűbb!
    if szamok[i] % 2 == 0:
        vantalalat = True
        break       # ciklus megszakítása
    i += 1

vantalalat = False
for x in szamok:
    if x % 2 == 0:
        vantalalat = True
        break

vantalalat = False
for x in szamok:
    if x % 2 != 0:
        continue
    vantalalat = True
    break

Feladat: meghatározni, hogy hol van az első, adott tulajdonságú elem a listában.

van = False
i = 0
while i < len(szamok) and not van:
    if szamok[i] % 2 == 0:
        van = True
    i += 1

i = 0
while i < len(szamok) and not szamok[i] % 2 == 0:
    i += 1

i = 0
while i < len(szamok) and szamok[i] % 2 != 0:
    i += 1

if i < len(szamok):
    print("Az első páros szám helye:", i)
else:
    print("Nincs páros, végigment a ciklus")

szamok = [1, 7, 5, 4, 5]
i = 0
while i < len(szamok):
    if szamok[i] % 2 == 0:
        break
    i += 1

if i < len(szamok):
    print("Az első páros szám helye:", i)
else:
    print("Nincs páros, végigment a ciklus")

Mi történik, ha a fenti kód kiírásait (üzeneteit) megpróbáljuk beépíteni a találat helyére?

A Python megengedi, hogy a while ciklusnak is legyen else ága:

    szamok = [1, 7, 5, 4, 5]
    i = 0
    while i < len(szamok):        ────────────────┐
        if szamok[i] % 2 == 0:                    │
            print("Az első páros szám helye:", i) │
┌───        break                                 │
│       i += 1                                    │
│   else:                                       ◂─┘
│       print("Nincs páros, végigment a ciklus")
└─▸

A találat helyének kiírását egyértelműen betehetjük a break elé. A „nincs találat” szöveg egy különleges helyre kerülhet, a while ciklus else ágába. Ez akkor fut le, ha nem ugrottunk ki break-kel a ciklusból. (Ez egyben azt jelenti, hogy break nélküli while után else-t írni értelmetlen.)

A while–else és for–else ciklusok Python különlegességek, más programozási nyelvben nem is nagyon vannak. Vegyük észre, hogy ebből következik is valami: az, hogy minden probléma megoldható enélkül. Semmiképp ne erőltessük a használatát, csak akkor, ha tényleg egyszerűbb kódot kapunk általa!

Feladat: generáljunk lottószámokat!

A programozás nyelvére fordítva: hozzunk létre egy listát, öt különböző számmal 1 és 90 között.

Az első ötlet

import random

huzott = []
i = 1
while i <= 5:
    huzott.append(random.randint(1, 90))
    i += 1

print("Az e heti nyerőszámok:", huzott)

Hol a hiba? Ott, hogy a véletlenszámgenerátor adhatja ugyanazokat a számokat is. Előfordulhat, hogy az öt egymás után sorsolt szám között lesznek egyformák. Így azokat valahogy ki kellene szűrni. Próbálhatjuk úgy, hogy betesszük a számot a listába, aztán kivesszük, ha nem jó – de ilyet úriember nem csinál. Ennél sokkal jobb ötlet eleve be se tenni a számot a listába, ha már volt olyan.

A kérdés tehát ez: benne van a szám a listában? Implementáljuk az eldöntés algoritmusát!

import random

huzott = []
i = 1
while i <= 5:
    sorsolt = random.randint(1, 90)
    # eldöntés
    found = False
    for x in huzott:
        if x == sorsolt:
            found = True
            break
    # ha nincs benne...
    if not found:
        huzott.append(sorsolt)
    i += 1

print("Az e heti nyerőszámok:", huzott)

És most hol a hiba? Ott, hogy mindig 5 számot próbálunk generálni, de nem mindig tesszük be őket a listába. Tehát előfordulhat, hogy 5-nél kevesebb szám lesz a végeredmény! Nem ötször kellene futtatni a ciklust, hanem addig, amíg öt szám nem lett a listában. Az átalakítás érdekessége, hogy az i változótól is meg tudunk szabadulni általa:

import random

huzott = []
while len(huzott) < 5:
    sorsolt = random.randint(1, 90)
    # eldöntés
    found = False
    for x in huzott:
        if x == sorsolt:
            found = True
            break
    # ha nincs benne...
    if not found:
        huzott.append(sorsolt)

print("Az e heti nyerőszámok:", huzott)

Ez már így jó. Már csak egy kicsit szépíteni kellene. Egyik, hogy az eldöntés algoritmusát valójában meg tudjuk spórolni. Pythonban van egy in nevű operátor, amely megadja nekünk, hogy egy elem szerepel-e egy listában:

huzott = [8, 12, 27, 45, 57]
print(57 in huzott)    # True
print(32 in huzott)    # False

huzott = [8, 12, 27, 45, 57]
print(57 not in huzott)    # False
print(32 not in huzott)    # True

import random

huzott = []
while len(huzott) < 5:
    sorsolt = random.randint(1, 90)
    if sorsolt not in huzott:
        huzott.append(sorsolt)

print("Az e heti nyerőszámok:", huzott)

Hogy tudjuk még szépíteni az eredményt? A nyerőszámokat növekvő sorrendben szokás megadni. A rendezést könnyen elvégezhetjük a sorted() nevű függvénnyel. Ez nem változtatja meg a neki paraméterként adott listát, hanem újat hoz létre. Legegyszerűbb felülírni a meglévő listánkat, mert bármit csinálnánk vele később, máskor is a rendezett formával lenne érdemes dolgozni. A végeredmény:

import random

huzott = []
while len(huzott) < 5:
    sorsolt = random.randint(1, 90)
    if sorsolt not in huzott:
        huzott.append(sorsolt)

huzott = sorted(huzott)
print("Az e heti nyerőszámok:", huzott)

Nem véges futási idő?

Vajon hányszor fut le a következő ciklus törzse?

huzott = []
while len(huzott) < 5:
    sorsolt = random.randint(1, 90)
    if sorsolt not in huzott:
        huzott.append(sorsolt)

Legalább öt lépés, de ez az algoritmus nem véges.

Mit jelent ez? Ha pongyolán fogalmazunk, azt mondjuk, hogy minden iterációban hozzáfűzünk egy számot a listához. Valójában ez nem igaz: minden iterációban legfeljebb egy számot fűzünk a listához. Legtöbbször egyet, de az is lehet, hogy egyet sem. Ha a véletlenszámgenerátor olyan számot sorsol, ami már van, akkor nem történik semmi, hanem újra megpróbáljuk. Általában olyan szám fog jönni, ami még nincs a listában, mert 90 közül 5-öt választunk csak ki. Az első lépés biztosan új számot ad (100% eséllyel). A második már csak 98,9% eséllyel (1/90, hogy rossz), a harmadik 97,8% eséllyel (2/90, hogy már volt), és így tovább.

Az iterációk maximális számát nem tudjuk garantálni, mert előfordulhat, hogy a véletlenszámgenerátor „rakoncátlankodik”, és sokszor ugyanazt a számot adja. Ez persze valójában nem rakoncátlankodás, hiszen teljesen normális az, ha többször ugyanaz a szám jön – mindegyiknek ugyanolyan esélye van, mint az összes többinek. De emiatt az iterációk számának legfeljebb a várható értékét tudjuk megmondani a valószínűségszámítás segítségével.

Lottósorsolás véges lépésszámban?

Van olyan megoldás erre a problémára, ami véges? Ötletek:

1. Sorsoljunk listából, és vegyük ki.
2. Keverjük meg a listát, és aztán az első öt.

Lista a számokkal 1-től 90-ig:

osszes = []
i = 1
while i <= 90:
    osszes.append(i)
    i += 1

Az ilyen számlálásos ciklust egyszerűsíthetjük a range(1, 91) függvénnyel. Ez egy ún. range objektumot ad, amelyik előállítja az [1, 91) számsort (balról zárt, jobbról nyílt intervallumban). Ennek részleteibe nem fogunk belemenni a félévben, a lényeg, hogy úgy viselkedik, mint egy lista (az elemek tényleges előállítása nélkül), és így for ciklusban használható:

osszes = []
for i in range(1, 91):
    osszes.append(i)

De a generátor által adott 1...90 számsor könnyen listává is alakítható:

osszes = list(range(1, 91))

Ebből kivéve a számokat:

osszes = list(range(1, 91))
huzott = []
for i in range(0, 5):
    idx = random.randint(0, len(osszes)-1)
    huzott.append(osszes[idx])
    del osszes[idx]

osszes = list(range(1, 91))
huzott = []
for i in range(0, 5):
    idx = random.randrange(0, len(osszes)) # !
    huzott.append(osszes[idx])
    del osszes[idx]   # elem törlése

import random

osszes = list(range(1, 91))
huzott = random.sample(osszes, 5)

huzott = sorted(huzott)
print("Az e heti nyerőszámok:", huzott)

import random

print("Az e heti nyerőszámok:", sorted(random.sample(range(1, 91), 5)))

A Fisher–Yates algoritmus (Durstenfeld verziója)

start következő folyamatos

CIKLUS i = 0-tól n-2-ig:
    j = véletlenszám i ≤ j < n között
    csere: lista[i] ↔ lista[j]

Pythonban:

for i in range(0, len(lista)-1):
    j = random.randrange(i, len(lista))
    temp = lista[i]
    lista[i] = lista[j]
    lista[j] = temp

Vigyázat: A lista utolsó elemét már nem cseréljük semmivel (ezért volt a pszeudokódban „0-tól n-2-ig”). A cseréhez kiválasztott elem viszont lehet az utolsó elem is, aminek indexe len(lista)-1. De mindezeket a gondolatokat a range() és a random.randrange() függvénnyekkel fogalmazzuk meg, amelyek balról zárt, jobbról nyílt intervallumot várnak. Tehát az i-s ciklus a len(lista)-1 elemmel már éppen nem dolgozik, a j változó viszont még éppen fölveheti a len(lista)-1 értéket. Az i == j eset is lehetséges, hiszen az is a lehetséges keverések között van, hogy egy elem nem mozdul el a helyéről.

A cserét a háromlépéses csere algoritmussal végezzük. A középső sorban (lista[i] = lista[j]) látszik, hogy szükségünk van egy segédváltozóra. A lista i-edik elemét félre kell tennünk, különben felülírnánk, mindkét elem egyformává változna. Tehát az i-ediket félretesszük; aztán az i-edikbe mehet a másik, és végül a j-edikbe megy a félretett elem.

Mivel a lista ilyenkorra meg van keverve, a lottószámok sorsolása egyszerűen a lista első öt elemének kiválasztása.

import random

osszes = list(range(1, 91))

for i in range(0, len(osszes)-1):
    j = random.randint(i, len(osszes)-1)
    temp = osszes[i]
    osszes[i] = osszes[j]
    osszes[j] = temp

huzott = sorted(osszes[:5])
print("Az e heti nyerőszámok:", huzott)

Egyébként a random.shuffle() függvény pont erre képes: meg tud keverni egy listát. Most már értjük, hogy működik. Ezzel megvalósítva a lottósorsolást:

import random

osszes = list(range(1, 91))
random.shuffle(osszes)

huzott = sorted(osszes[:5])
print("Az e heti nyerőszámok:", huzott)

Kivételek kezelése

Hiba keletkezése

x = int(input("Írj be egy számot: "))
print("Duplája:", 2*x)

Írj be egy számot: alma

Traceback (most recent call last):
  File "q.py", line 1, in <module>
    x = int(input("Írj be egy számot: "))
ValueError: invalid literal for int() with base 10: 'alma'

A szó nem alakítható int-té. Mindenképp megáll a program?

Valahogy kezelni kellene az ilyen hibát – pl. hogy újra meg lehessen próbálni a műveletet. Egy ilyen apróságtól nem kellene összeomlania a programnak!

A hiba keletkezésének pillanatában egy kivétel (exception) típusú objektum jön létre (an exception is raised). Ezt a kivételt el tudjuk kapni (catch), és így a hibát kezelni tudjuk (handling an exception). A kivétel elkapása a try–except kulcsszópárral történik. A try blokkba tesszük azt az utasítássorozatot, ahol probléma lehet. Hiba keletkezése esetén az except kulcsszóval megjelölt blokknál folytatódik a program.

Az alábbi ábrán a nyilak mutatják a lehetséges végrehajtási utakat. Ha sikerül a beolvasás, és a beolvasott adatot sikerül számmá alakítani, akkor a következő sorban folytatódik a végrehajtás, kiíródik a szám kétszerese. Ha nem, akkor viszont a hibaüzenet kiírásánál. Akármelyik is történt a kettő közül, végül a „program vége” szöveg ki fog íródni.

    try:
┌───    x = int(input("Írj be egy számot: "))    ────┐
└─▸     print("Duplája:", 2*x)                       │
    except:                                          │
        print("Nem számot kaptam.")                ◂─┘
    print("Program vége.")

Vagyis az elágazáshoz hasonlóan, a hibakezelés után a blokkok utáni közös résznél folytatódik tovább a végrehajtás. Ez természetesen azt is jelenti, hogy ha van olyan teendő, amit csak akkor szeretnénk végrehajtani, amikor minden rendben volt, az a try blokkban kell legyen. Ez nagyon fontos: épp ezért került a szám dupláját kiíró sor a try blokkba. Arra csak akkor szabad lépni, ha sikerült a beolvasás, és számot írt be a felhasználó.

Lentebb látható a program működése, mint egy nyomkövetőben.

    try:
        x = int(input("Írj be egy számot: "))  
        print("Duplája:", 2 * x)  
    except:
        print("Nem számot kaptam.")  
    print("Program vége.")  

x: 

Látszik, hogy a kivétel elkapásával kezelni tudjuk a hibát. Nem áll le a programunk, hanem megadhatjuk, mi történjen.

try:
    sor = input("Írj be egy számot: ")
    szam = int(sor)
    print("Duplája:", 2*szam)
except ValueError as e:     # volt adat, de nem értelmezhető
    print("Hiba:", e)
except EOFError:            # nem volt adat
    print("Fájl vége jel.")

Írj be egy számot: almafa
Hiba: invalid literal for int() with base 10: 'almafa'

Írj be egy számot: 
Fájl vége jel.

try:
    x = int(input("Írj be egy számot: "))
    print("Duplája:", 2*x)
except Exception as e:
    print("Hiba:", e)

Futási idejű hibák (általában)

• ValueError: konverziók esetén, pl. int("almafa")
• TypeError: hibás adatok a művelethez, pl. "alma" * "körte"
• ZeroDivisionError: nullával osztás, pl. 1/0
• IndexError: túlindexelés
• EOFError: fájl vége
• ...

Programozási hibák (általában)

• ModuleNotFoundError: import nemlétezőmodul esetén
• NameError: nem létező változó esetén
• ...

A hibák kapcsán gyakran megkülönböztetjük a futási idejű hibákat és a programozási hibákat. A futási idejű hibák legtöbbször helytelen bemenet hatására keletkeznek, és a programkóddal nincsen baj. A programozási hibák pedig olyanok, amelyeket valahol a kódban javítani kellene. Ez persze csak pongyola definíció, és nem választható el a kettő egymástól élesen: beírhatjuk a programunkba, hogy print(1/0), és bár a nullával osztást általában futási idejű hibának tekintjük, ez a programsor mégsem lehet helyes soha.

Hibatípusból egyébként rengeteg van: csak a Python nyelv kb. 60-at határoz meg, de mi magunk is definiálhatunk újat. Mindenesetre legalább a fentieket érdemes fejből tudni. A további típusokról és azok kategorizálásáról itt lehet olvasni: Exception hierarchy.

Feladat: adott egy sztring. Szám van benne?

szoveg = input("Írj be valamit: ")

try:
    int(szoveg)     # az eredmény nem érdekes
    szam_volt = True
except:
    szam_volt = False

if szam_volt:
    print("Egész számként értelmezhető.")
else:
    print("Nem értelmezhető egész számként.")

x = int(input())
try:
    1/x
    print("A szám nem nulla.")
except:
    print("A szám nulla.")

x = int(input())

if x != 0:
    print("A szám nem nulla.")
else:
    print("A szám nulla.")

szamok = [65, 98, 13, 27, 35]

i = 0
while True:
    try:
        print(szamok[i])
        i += 1
    except IndexError:
        break

szamok = [65, 98, 13, 27, 35]

i = 0
while i < len(szamok):
    print(szamok[i])
    i += 1

Feladat: olvassunk be számokat, amíg sikerül!

Ez pont egy olyan helyzet, amikor várjuk, hogy a művelet előbb-utóbb sikertelen lesz. Nem tudjuk, hogy fog-e sikerülni a szám beolvasása, amíg meg nem próbáljuk. Vagyis a számsor beolvasása egy végtelen ciklusba kerül, amelyből azonban előbb-utóbb kiugrunk sikertelenség esetén:

    print("Írj be egész számokat, soronként egyet:")

    szamok = []
    try:
    ┌─▸  while True:
    │        szam = int(input())     ────┐
    └──────  szamok.append(szam)         │
    except (ValueError, EOFError):     ◂─┘
┌──      pass
│
└─▸ print(f"A beírt számok: {szamok}.")

Írj be egész számokat, soronként egyet:
1
2
x
A beírt számok: [1, 2].

print("Írj be egész számokat, soronként egyet:")

szamok = []
try:
    while True:
        szam = int(input())
        szamok.append(szam)
except (ValueError, EOFError):
    pass

print(f"A beírt számok: {szamok}.")

Feladat: kérjünk egy számot. Ha nem szám, próbáljuk újra!

    while True:                                ◂──┐
        try:                                      │
            sor = input("Írj be egy számot: ")    │
            szam = int(sor)    ───┐               │
┌───        break                 │               │
│       except ValueError:     ◂──┘               │
│           print("Nem szám. Próbáld újra!")    ──┘
│   
└─▸ print(f"A beírt szám: {szam}.")

Írj be egy számot: alma
Nem szám. Próbáld újra!
Írj be egy számot: 5
A beírt szám: 5.

while True:
    try:
        sor = input("Írj be egy számot: ")
        szam = int(sor)
        break
    except ValueError:
        print(f"Nem szám: {sor}. Próbáld újra!")

print(f"A beírt szám: {szam}.")

Összetett példa

Az M7 autópályán traffipax méri az autók sebességét. Minden mérésről három adatot ad: óra:perc sebesség. Pl. 9:39 125 jelentése az, hogy 9:39-kor egy autó 125 km/h-val ment:

9:39 125

A 140 km/h feletti sebességért 30.000 Ft a bírság, a 180 km/h felettiért 100.000 Ft. Az adatsor több nap adatait tartalmazza, és a végét üres sor zárja.

Olvassa be a program ezeket az adatokat, és írja ki, hogy a nap mely órájában mennyi az összes kirótt bírság! Példa kimenet:

12:00-12:59, 60000 Ft
13:00-13:59, 230000 Ft

Hogyan olvassuk be az adatokat? Hát, nem így:

ora, perc, sebesseg = int(input())

9:39 125
ValueError: invalid literal for int() with base 10: '9:39 125'

Az így beolvasott sort nem konvertálhatjuk egész számmá. Pedig az int() konverzió csak ennyit tudna. Először is, nem egy szám van a beolvasott sztringben, hanem három, hiszen a teljes sort megkapjuk az input() függvénytől. Másodszor pedig, az elválasztó karakter hol kettőspont, hol meg szóköz. Nem véletlen, hogy ez a konverzió kivételt dob. De ugyanez történne az üres sor esetén is, ami a bemenet végén van: az üres sztringre hívott int() konverzióra is kivétel a jutalmunk.

Tehát előbb meg kellene néznünk, hogy üres sort kaptunk-e, és csak utána értelmezni a benne lévő adatokat. És az adatokat is úgy kell feldolgoznunk, hogy előbb feldaraboljuk a sztringet három darabra (óra, perc, sebesség), és csak az így kapott darabokat próbáljuk egész számmá konvertálni.

Beolvasás üres sorig:

  print("Írd be az adatokat, üres sorig: ")
  while True:            ◂──┐
      sor = input()         │
      if sor == "":         │
┌───      break             │
│     ... feldolgozás ... ──┘
└─▸ 

A .split() függvény

A beolvasott sztringet a .split() függvénnyel törhetjük darabokra. Ez egy sztringből listát csinál, felvagdalva a megadott karakter mentén a sztringet:

sor = "alma körte barack"

szavak = sor.split()    # ["alma", "körte", "barack"]

print(szavak[0], szavak[1], szavak[2])

A jelenlegi formátumban viszont az egyik helyen kettőspont, a másik helyen szóköz választja el az adatokat. Ezért egymás után két .split()-et fogunk használni. Az egyik a szóköz mentén kettétöri a bemeneti sztringet, így megkapjuk külön az időpontot és a sebességet. A másik pedig az időpontot töri ketté órára és percre.

sor = "9:39 125"

idopont_sebesseg = sor.split()  # ["9:39", "125"]

idopont_sebesseg[0]             # "9:39"

ora_perc = idopont_sebesseg[0].split(":")   # ["9", "39"]

A teljes beolvasás, kiegészítve hibakezeléssel:

    print("Írd be az adatokat, üres sorig: ")
    while True:                                    ◂──┐
        sor = input()                                 │
        if sor == "":                                 │
┌───        break                                     │
│       try:                                          │
│           idopont_sebesseg = sor.split()            │
│           ora_perc = idopont_sebesseg[0].split(":") │
│           ora = int(ora_perc[0])                    │
│           perc = int(ora_perc[1])                   │
│           sebesseg = int(idopont_sebesseg[1])       │
│       except:                                       │
│           print("Hibás bemenet:", sor)              │
│           continue                                ──│
│                                                     │
│       ... feldolgozás ...                         ──┘
└─▸ print("Összes adat beolvasva.")

A try–except blokk ebben az esetben minden olyan hibát elkap, ami a sor darabolása vagy a konverziók közben történik. Például ha nincs elegendő sztring, a bejövő adat nem tartalmazott kettőspontot vagy szóközt: "9 39 125"; ebben az esetben a túlindexelések miatt, mert a .split()-ek által adott listák túl rövidek lesznek. De akkor is, ha a konverzió sikertelen: "alma:körte barack" ugyan a megfelelő helyeken darabolható, de az eredmény sztringekből nem lesz szám.

        if len(idopont_sebesseg) != 2 or len(ora_perc) != 2:
            raise ValueError()

Lássuk újra a feladat szövegét!

[...] A 140 km/h feletti sebességért 30.000 Ft a bírság, a 180 km/h felettiért 100.000 Ft. [...]
[...] írja ki, hogy a nap mely órájában mennyi az összes kirótt bírság [...]

12:00-12:59, 60000 Ft
13:00-13:59, 230000 Ft

Mire utal ez? Az első fontos dolog, amit észre kell vennünk, hogy egy összegzést kell csinálni. A kimeneten csak a bírságok összegére vagyunk kíváncsiak, ezért a bemenő adatsort nem fogjuk eltárolni. Másik pedig, hogy a bírságokat óránként, vagyis órás bontásban kell meghatároznunk. Méghozzá a nap 24 órájában; ugyan az nincs odaírva, hogy a nap 24 órából áll, de ezt mindenki tudja.

Az adatszerkezetünk egy olyan tömb lesz (fix méretű lista), amelyet kezdetben 24 darab nullával töltünk fel.

A leképezés módja ebben az esetben egyszerű: az óra adja a tömbindexet. Vagyis a birsagok[ora] kifejezéssel érjük majd el a keresett adatot.

birsagok = [0] * 24

while True:
    ... adatok beolvasása ...
    
    if sebesseg >= 180:
        birsagok[ora] += 100000
    elif sebesseg >= 140:
        birsagok[ora] += 30000
    else:
        pass

for ora in range(0, 24):
    print(f"{ora:02}:00-{ora:02}:59, {birsagok[ora]} Ft")

12:00-12:59, 60000 Ft
13:00-13:59, 230000 Ft

Néhány megjegyzés a kóddal kapcsolatban:

Mit jelent a pass utasítás?

Ez az ún. „üres utasítás”, amelyik nem csinál semmit. Az egész else ág elhagyható lenne, mivel tulajdonképp üres. Most csak azért van ott, mert így kicsit szebb a kód: egyértelműsítve van, hogy átgondoltuk azt az esetet is, amikor 140-nél kisebb a sebesség, csak olyankor nincs teendő.

Kell az elif a 140-nél, vagy mindegy?

Fontos, hogy ez a 180-as elágazásnak a hamis ágába kerüljön. Mert különben pl. egy 190-es sebességnél kirónánk a 180 felettieknek járó 100 ezer forintot, és a 140 felettieknek járó 30 ezret, vagyis összesen ilyenkor 130 ezer adódna. A feladat pedig nem ezt kérte.

Mit csinál a {ora:02}az f sztringben?

Ez teszi ki az ún. vezető nullákat a formázásnál: f"{23:05}" értéke "00023". Összesen 5 karakter, és az üres helyek nullákkal vannak kitöltve.

Ami nincs odaírva: hol használjuk fel a perc adatot?

Sehol. Van ez így, hogy nincs minden ismert adatra szükség. Viszont a sztring darabolásakor foglalkoznunk kell vele, hiszen a bemeneten mindenképp ott lesz.

A teljes program letölthető innen: autopalya.py.

Az előadáson megismertek alapján tudni kell:

• Ciklusokban a break és continue szerkezetet használni.
• Lineáris kereső algoritmust használni.
• Egy sorozat permutációját előállítani.
• Kivételeket elkapni.
• Sztringek feldolgozásával összetett adatszerkezetet tartalmazó programokat írni.