While ciklus

Emlékezzünk vissza előző előadásról a while ciklusra:

In [ ]:
n = 1000
a = 1
while a ** 3 < n:
    print a ** 3,  # a vessző miatt egy sorba kerülnek
    a = a + 1
print "vege"

Tudunk írni olyan ciklust, mely addig olvas be számokat míg valamilyen kritérium nem teljesül:

In [ ]:
n = 0
a = input()
while a != 5:
    print a
    a = input()

Írjunk most olyan kódot, mely addig olvas be számokat míg egyszer 0-t nem adunk neki, ekkor megáll és kiírja a kapott számok összegét.

In [ ]:
n = 0
a = input()
while a != 0:
    n = n + a
    a = input()
print n

Programozási tételek

Általalánosan megfogalmazott gyakran használt rövid algoritmusok

Összegzés tétele

Bár a név ezt sugallja, de nem feltétlen csak összegzésre használható. Ha van egy szám (vagy bármi más) sorozatunk és valamilyen szempontból összegezni akarjuk őket egy változóba, akkor beszélünk az összegzés tételéről.

In [ ]:
n = 0            # akkumulátor
a = input()      # első beolvasása
while a != 0:    # leállási feltétel
    n = n + a    # összegzés
    a = input()  # későbbiek beolvasása
print n

Nem feltétlen csak szummázni lehet:

In [ ]:
n = 1            # akkumulátor
a = input()      # első beolvasása
while a != 1:    # leállási feltétel
    n = n * a    # összegzés
    a = input()  # későbbiek beolvasása
print n

Számlálás tétele

Adott valahány objektumunk (pl számok) és ezek közül szeretnénk megszámolni az adott tulajdonsággal rendelkezőket (pl páratlanokat).

In [ ]:
db = 0               # számláló
a = input()          # első beolvasása
while a != 0:        # leállási feltétel
    if a % 2 == 1:   # tulajdonság vizsgálata
        db += 1      # számláló növelése
    a = input()      # későbbiek beolvasása
print db

Nézzünk egy bonyolultabb példát stringekkel. Olvassunk be szavakat egészen addig amíg egy üres stringet nem olvasunk be. Számoljuk meg, hogy a beolvasott szavak közül hány darabban található 'e' betű!

In [ ]:
db = 0        
szo = raw_input()        
while szo != "":      
    if "e" in szo:  
        db += 1   
    szo = raw_input()   
print db

Szélsőérték keresése

Adott objektumok egy sorozata, ezeknek a szélsőértékét keressük valamilyen szempontból. Például pozitív valós számok sorozatából a legkisebbet.

In [ ]:
a = input()              # első beolvasása
legnagyobb = a           # az eddig talált legnagyobb szám
while a > 0:             # leállási feltétel
    if legnagyobb < a:   # tulajdonság vizsgálata
        legnagyobb = a   # számláló növelése
    a = input()          # későbbiek beolvasása
print legnagyobb

Eldöntés tétele

Azt vizsgáljuk, hogy adott elemek között szerepel-e egy bizonyos tulajdonságú. Például a prím tesztelésnél a lehetséges osztók voltak a lehetséges elemek és azt vizsgáltuk, hogy valamelyik osztja-e az adott számunkat.

In [ ]:
n = input()                    # a szám beolvasása
a = 2                          # a változó amivel végigfutunk a lehetséges osztókon
talalat = False                # megtaláltuk-e a keresett elemet
while a < n and not talalat:   # leállási feltétel, ha megtaláltuk akkor is leállunk
    if n % a == 0:             # a keresett elem a beolvasott szám osztója
        talalat = True         # ha megtaláltuk akkor a találatot igazra állítjuk
    a += 1                     # vizsgáljuk a következő elemet
print not talalat              # azért a negáltját írjuk ki, mert valójában összetettséget vizsgáltunk

Tételek kombinálása

Ezeket a tételeket általában kombinálni kell, hogy a bonyolultabb feladatokat meg tudjuk oldani. Természetesen nem csak ezek használatával lehet megoldani feladatokat, de kiindulásnak jó velük megismerkedni.

Számoljuk most meg, hogy hány prím van 2-től 1000-ig! Ehhez az eldöntés tételét ágyazzuk be a számlálás tételébe.

In [ ]:
szam = 2                                     # az első elem amit a számlálás tételénél vizsgálunk
primek_db = 0                                # a számlálás tételének számlálója
while szam < 1000:                           # itt kezdődik a számlálás tétele
    oszto = 2                                # ez már a beágyazott eldöntés tételének a kezdeti eleme
    osszetett = False                        # ez pedig a találatot jelző változója
    while oszto < szam and not osszetett:    # az eldöntés tételének ciklusa
        if szam % oszto == 0:
            osszetett = True
        oszto += 1                           # az eldöntés tételében lépünk a következő elemre
    if not osszetett:                        # itt már befejeződött a beágyazott eldöntés tétele
        primek_db += 1                       # ez a számlálás tételének a feltétele és növelése
    szam += 1                                # a számlálás tételében lépünk a következő elemre
print primek_db

Listák

A listákra gondolhatunk úgy, mint tárolókra, melyek több objektumot képesek tárolni, például számokat:

In [ ]:
lista = [1, 2, 5]

A listák elemeit szögletes zárójelbe tesszük és vesszővel választjuk el egymástól. Egy listának akárhány eleme lehet (akár 0 is), ezek az elemek akármilyen típusúak lehetnek (akár másik listák is):

In [ ]:
lista = [1, 5.3, "kutya", [1, 2, 5], 12, "macska"]

Listák elemeinek elérése, részlisták

Lista egy adott elemét elérhetjük az indexe segítségével:

In [ ]:
lista = ["a", "b", "c"]
print lista[0]
print lista[1]
print lista[2]

Amint látható az indexek számozása 0-tól kezdődik, így az első elemet a 0 indexszel érhetjük el. Míg az utolsó elemet az n - 1 indexszel érjük el, ahol n a lista hossza.

Egy lista részlistáját is lekérhetjük:

In [ ]:
lista = ["a", "b", "c", "d", "e", "f"]
print lista[1:3]       # az 1-es indextől a 3-asig kérjük le az elemeket, de a 3-as már nem lesz benne
print lista[2:]        # a 2-es indextől a lista végéig
print lista[:3]        # a lista elejétől a 3-as indexig, a 3-as indexű elem nem lesz benne
print lista[0:4:2]     # az első elemtől a 4-es indexűig kérjük le kettesével
print lista[-1::-1]    # az utolsó elemtől (negatív index visszafelé lépked -1-től kezdve) az elejéig -1-esével

Listákat ugyanúgy lehet összefűzni mint stringeket:

In [ ]:
print [1, 2, 5] + [8, 5, 3]

Minden eddigi művelet működik stringekkel is:

In [ ]:
s = "kutya"
print s[2]
print s[1:4]
print s[-1::-1]

Annyi különbség viszont van, hogy míg a listák változtatható (mutable) adattípusok, a stringek nem változtathatók (immutable). Tehát listának megváltoztathatjuk az elemeit:

In [ ]:
lista = [1, 2, 5]
lista[2] = 3
print lista

Viszont ugyanezt stringekkel nem tehetjük meg:

In [ ]:
s = "kutya"
s[1] = "a"
print s

Lista kezelés metódusai

A listák kényelmes kezeléséhez tanuljuk meg néhány alapvető függényt / metódust.

Range

A range függvénnyel listát hozhatunk létre. Általában számsorozatok létrehozására hasznos:

In [ ]:
print range(4)
In [ ]:
print range(4, 10)
In [ ]:
print range(3, 15, 3)

Amint látható, a részlisták lekéréséhez hasonlóan működik. Ha csak egy paramétert adunk meg, akkor 0-tól indulva hozza létre a listát a megadott számig (a szám már nem lesz benne). Létrehozhatunk adott számtól listát, és adott lépésközzel is.

Természetesen ugyanúgy manipulálható, mint a manuálisan létrehozott lista:

In [ ]:
lista = range(1, 4)
lista[2] = 5
print lista

Új elemek felvétele / törlése

Az append metódussal új elemet fűzhetünk egy létező lista végére:

In [ ]:
lista = [1, 2, 5]
lista.append(4)
print lista

Az insert metódussal adott indexre illeszthetünk be új elemet:

In [ ]:
lista = [1, 2, 5]
lista.insert(1, 1.5)
print lista

A pop metódussal adott indexű elemet törölhetünk a listából:

In [ ]:
lista = [1, 2, 5]
lista.pop(2)
print lista

A remove metódussal adott elemet törölhetünk a listából:

In [ ]:
lista = [1, 2, 5]
lista.remove(2)
print lista

Egyéb műveletek listákkal

A len függvénnyel lekérhetjük egy lista hosszát:

In [ ]:
lista = [1, 2, 5]
print len(lista)

A count metódussal lekérhetjük, hogy egy adott elemből hány darab van a listában:

In [ ]:
lista = [1, 2, 3, 4, 1, 2, 1, 4, 5, 1, 3, 2, 4]
print lista.count(1)
print lista.count(4)
print lista.count(15)

A sort metódussal rendezhetjük a listát:

In [ ]:
lista = [1, 2, 3, 4, 1, 2, 1, 4, 5, 1, 3, 2, 4]
lista.sort()
print lista

For ciklus

Pythonban a for ciklus és a listák erősen összefüggnek. A for ciklus listán (és egyéb bejárható objektumokon) fut végig:

In [ ]:
lista = [1, 2, 5, "kutya"]
for elem in lista:
    print elem

Ha az indexekkel szeretnénk végigmenni a listán, akkor használhatjuk a range metódust:

In [ ]:
lista = [1, 2, 5, "kutya"]
for i in range(len(lista)):
    print lista[i]

Miért is működik ez? Gondoljuk végig, hogy a range(len(lista)) pont a lista indexeinek a listáját hozza létre és a for ciklus ezeken megy végig:

In [ ]:
lista = [1, 2, 5, "kutya"]
for i in range(len(lista)):
    print "index: ", i, " elem: ", lista[i]

Programozási tételek listákkal

Összegzés tétele

In [ ]:
lista = [1, 2, 5]
n = 0
for e in lista:
    n += e
print n

Számlálás tétele

In [ ]:
lista = [1, 2, 5, 6, 4, 6, 7, 8]
db = 0
for e in lista:
    if e % 3 == 0:
        db += 1
print db

Szélsőérték keresése

In [ ]:
lista = [1, 2, 5, 6, 15, 4, 6, 7, 8]
legnagyobb = lista[0]
for e in lista:
    if legnagyobb < e:
        legnagyobb = e
print legnagyobb

Eldöntés tétele

In [ ]:
szam = input()
osszetett = False
for oszto in range(2, szam):
    if szam % oszto == 0:
        osszetett = True
        break
print not osszetett

Tételek kombinációja

Számoljuk meg, hogy adott szavak közül, melyekben van 'a' betű, azokban hány darab 'e' betű van!

In [ ]:
szavak = ["kiskutya", "nagyeger", "szekesfehervar", "kiseger"]
db = 0
for szo in szavak:
    if "a" in szo:
        for i in range(len(szo)):
            if szo[i] == "e":
                db += 1
print db

A count metódussal egyszerűbben is meg lehet oldani (ez jóformán egy beépített számlálás tétele egyszerűbb esetekre):

In [ ]:
szavak = ["kiskutya", "nagyeger", "szekesfehervar", "kiseger"]
db = 0
for szo in szavak:
    if "a" in szo:
        db += szo.count("e")
print db