9. Listide muteerimine¶

Harjutus. Arvude küsimine¶

Kirjuta eelmises peatükis toodud arvude küsimise näide ümber append-i kasutades.

Harjutus. Täringuvisete statistika¶

Genereeri 100 täringuviske tulemust (kasutades näiteks eelmises peatükis defineeritud funktsiooni juhuslik_järjend) ning salvesta tulemus muutujasse.

Koosta 6-elemendiline järjend statistika, mis sisaldab täringuvisete statistikat – avaldis statistika[0] peaks näitama, mitu korda tuli täringuviske tulemuseks 1, statistika[1] peaks näitama kahtede sagedust jne.

Kuva statistika ekraanile.

from random import randint

def juhuslik_järjend(n, alates, kuni):
    arvud = []

    for i in range(n):
        arvud.append(randint(alates, kuni))

    return arvud

statistika = [0, 0, 0, 0, 0, 0]
visked = juhuslik_järjend(100, 1, 6)

for vise in visked:
    # visked on arvud 1..6
    # listi statistika indeksid on 0..5
    indeks = vise-1
    statistika[indeks] += 1

print(statistika)

Viitamisest täpsemalt¶

Kas selline situatsioon, et erinevad muutujad viitavad samale objektile, on võimalik ainult listide korral? Tehniliselt võttes ei – muutujad ja harilik (=-ga) omistamine toimivad alati samamoodi hoolimata andmetüübist.

Kõik Pythoni väärtused on programmi käimise ajal esitatud mingite objektidena, mis asuvad kusagil arvuti mälus. Kui käivitatakse lause x = 7, siis luuakse mälus objekt, mis tähistab arvu 7 ja muutujasse x salvestatakse tegelikult ainult viide sellele objektile. Kui me järgmisena käivitame lause y = x, siis muutujasse y salvestatakse sama viit, mis on muutujas x, aga uut täisarvu objekti ei looda. Seega nüüd viitavad muutujad x ja y samale objektile.

Erinevus listidest tuleneb aga sellest, et täisarvu objekti ei ole võimalik muuta, seetõttu ei ole ilma pingutamata võimalik isegi aru saada, kas need muutujad viitavad samale objektile, või erinevatele objektidele, mis tähistavad sama arvu. Seetõttu ei pidanud me ei arvude ega sõnede puhul viitamise teema peale mõtlema.

Viitamise teema täpsemal uurimisel on abiks funktsioon id, mis tagastab argumendiks antud väärtuse (e objekti) aadressi arvuti mälus – see ongi see viide, mida muutujad sisaldavad. Järgnevas näites luuakse kaks samaväärset sõneobjekti, mille kummagi viide salvestatakse erinevasse muutujasse:

>>> a = "tere hommikust!"
>>> b = "tere hommikust!"

Veendume id abil, et muutujad viitavad erinevatele objektidele:

>>> id(a)
48829968
>>> id(b)
48830088

Nüüd kopeerime ühe viida uude muutujasse:

>>> c = a
>>> id(c)
48829968

Nagu näha, kopeeriti omistamisel muutujasse olemasoleva objekti viit ja uut objekti ei loodud.

Kui proovisid seda eksperimenti lühemate sõnedega või väikeste arvudega, siis võis juhtuda, et Python vältis juba esimeste omistamiste juures kahe samaväärse objekti loomist ja omistas b-le sama viite nagu a-le. Arvude ja sõnede puhul on tal see vabadus, sest programmi tähendus sellest ei muutu. Listide korral aga on kindel, et järgmised omistamised tekitavad alati kaks uut objekti:

>>> x = [1,2,3]
>>> y = [1,2,3]
>>> id(x)
47840952
>>> id(y)
48787328

Erinev id-väärtus näitab, et tegemist on erinevate objektidega – kui me ühte neist muteerime (näiteks append-iga), siis teine sellest ei muutu. Kui me aga uue listi loomise asemel kopeerime viida, siis teeme sellega lihtsalt samale objektile uue nime:

>>> z = x
>>> id(z)
47840952
>>> z.append(4)
>>> z
[1, 2, 3, 4]
>>> x
[1, 2, 3, 4]
>>> y
[1, 2, 3]

Tuleb panna tähele, et muutuja muutmine ei ole sama, mis objekti muteerimine. Kui me omistame z-le uue väärtuse, siis z lihtsalt kaotab seose eelmise objektiga – algne objekt sellest ei muutu:

>>> z = [6,7,8]
>>> id(z)
48766568
>>> x            # x poolt viidatud objekt on sama, mis enne
[1, 2, 3, 4]
>>> y
[1, 2, 3]

Kokkuvõttes: omistamisel salvestatakse muutujasse ainult viit paremal pool näidatud väärtusele. Analoogselt toimib Python ka funktsiooni väljakutsel – parameetrisse satub vaid viit argumendile. Päris uusi objekte saab luua literaale kasutades (aga nagu eespool mainitud, võib Python mittemuteeritavate andmetüüpide puhul siin ka objekte jagada) või kasutades mingit operatsiooni, mis teadaolevalt loob uue objekti.

>>> x = [1,2,3]
>>> y = x[:]
>>> id(x)
30988928
>>> id(y)
48829944

>>> a = [1,2,3]
>>> b = a.copy()
>>> c = list(a)
>>> id(a)
47840952
>>> id(b)
47844488
>>> id(c)
48830024

>>> a = [1,2,[3,3]]
>>> b = a.copy()
>>> id(a[2])
47839032
>>> id(b[2])
47839032
>>> a[2].append(4)
>>> a
[1, 2, [3, 3, 4]]
>>> b
[1, 2, [3, 3, 4]]

>>> from copy import deepcopy
>>> a = [1,2,[3,3]]
>>> b = deepcopy(a)
>>> a[2].append(4)
>>> a
[1, 2, [3, 3, 4]]
>>> b
[1, 2, [3, 3]]

1. Tagasivaade¶

Loe läbi selle peatüki lõpus olev Tagasivaade peatükkidele 1-9.

2. Palkade analüüs¶

Antud on tekstifail palgad.txt, kus igal real on töötaja nimi, tema vanus ja kuupalk. Kirjuta programm, mis väljastab antud andmete põhjal:

• kõige suurema palgaga töötaja nime ja palga suuruse (vihje: suurima palga otsimisel jäta meelde, milliselt positsioonilt sa selle leidsid);
• keskmise palga;
• keskmisest palgast rohkem teenijate arvu;
• keskmised vanused eraldi neile, kes teenivad keskmisest palgast vähem (või samapalju), ning neile, kes teenivad keskmisest palgast rohkem.

3. minu_shuffle¶

Pythoni random moodulis on funktsioon shuffle, mis ajab argumendiks antud järjendis elementide järjekorra juhuslikult segamini:

>>> from random import shuffle
>>> a = [1, 3, 3, 4, 5, 5, 5, 6, 6]
>>> shuffle(a)
>>> a
[5, 3, 6, 5, 5, 3, 4, 1, 6]

Kirjuta ise analoogne funktsioon minu_shuffle, mis teeb sama (seejuures pole lubatud kasutada olemasolevat shuffle funktsiooni).

>>> from random import randint
>>> randint(1,4)
1
>>> randint(1,4)
1
>>> randint(1,4)
3
>>> randint(1,4)
2
>>> randint(1,4)
4
>>> randint(1,4)
2
>>> randint(1,4)
2

4. Eesti filmide statistika (raskem)¶

Veebisait http://www.imdb.com kogub ja jagab informatsiooni filmide kohta. Aadressilt ftp://ftp.funet.fi/pub/mirrors/ftp.imdb.com/pub/ saab IMDB poolt kogutud infot alla laadida pakitud tekstifailidena.

Fail filmid.zip (4.5MB) on koostatud faili „countries.list.gz“ põhjal ning see sisaldab filmide (ja telesaadete) loetelu koos riigi nime ning valmimise aastaga. Lae see fail alla ning paki lahti.

Failis filmid.txt on ühe filmi andmed ühel real kujul <nimi><tühik>(<aasta>)<tabulaator><riik>. (Notepad2-s saad tühikuid ja tabulaatoreid eristada, kui märgid menüüs View valiku Show whitespace.)

Ülesanne on kirjutada programm, mis otsib sellest failist üles Eestis valminud filmid/telesaated ning koostab statistika selle kohta, mitu filmi/telesaadet mingil aastal valmis.

Avaldised vs laused¶

Kõik eelpool käsitletud Python keele elemendid saame jaotada kahte suurde gruppi: avaldised ja laused.

Avaldised on näiteks 2, 2 + 3, brutopalk ja sin(0.5) ** (x-1) – kõigil neil on väärtus ja neid saab seetõttu kasutada nt muutujate defineerimisel ja teistes keerulisemates avaldistes.

Laused (ingl statements) on näiteks omistamislause (x = sin(0.5)), tingimus- ja korduslaused (if, while ja for) ja funktsioonide definitsioonid (def). Eri tüüpi lausete ühine omadus on see, et nad teevad midagi (nt muudavad muutuja väärtust, defineerivad uue käsu või teevad midagi tingimuslikult või korduvalt).

Nii avaldiste kui ka lausete juures on oluline see, et neid saab panna üksteise sisse. Näiteks operaatori + kasutuse üldskeem on <avaldis1> + <avaldis2>, kusjuures nii avaldis1 kui ka avaldis2 võivad olla samuti mingi tehted. if-lause põhiskeem on:

if <avaldis>:
    <laused1>
else:
    <laused2>

kusjuures nii laused1 kui ka laused2 võivad sisaldada suvalisi lauseid, sh if-lauseid, mille sees võib olla omakorda suvalisi lauseid.

Muutujad¶

Muutujad võimaldavad meil tegelda väärtustega ilma et me peaks mainima mingit konkreetset väärtust. Näiteks kui me salvestame kaks kasutaja poolt sisestatud arvu muutujatesse a ja b, siis nende kokku liitmisel ei huvita meid enam, mis on nende muutujate konkreetne väärtus.

Soovitatav on lugeda uuesti läbi 2. peatüki osa Muutujad, tõenäoliselt näed nüüd muutujate olemust juba uue pilguga.

Funktsioonid¶

Kui muutujad võimaldavad meil kasutada mingit väärtust ilma et me peaksime mõtlema mingile konkreetsele väärtusele, siis funktsioonid võimaldavad meil midagi teha või arvutada ilma et me peaksime alati mõtlema selle peale, kuidas see toiming või arvutus täpselt tehakse. Viska pilk peale järgnevale programmile:

def kolmest_suurim(a, b, c):
    if a > b and a > c:
        return a
    elif b > a and b > c:
        return b
    else:
        return c

print(kolmest_suurim(4, 15, 2))

Tõenäoliselt oskad isegi ilma funktsiooni definitsiooni süvenemata arvata, mida taoline programm ekraanile prindib. Põhjus on selles, et antud funktsiooni olemus tuleb välja juba tema nimest ja üldjuhul võime me eeldada, et funktsiooni tegelik definitsioon on tema nimele vastav. Seetõttu, kui meil on sobivad funktsioonid juba defineeritud, siis saame me programmi põhiosas (või järgmiste funktsioonide defineerimisel) töötada kõrgemal tasemel, ilma pisiasjade pärast muretsemata.

Kuna funktsioonide teema on programmeerimise algkursusel tavaliselt tudengitele kõige hägusam, siis on soovitatav lugeda uuesti läbi 5. peatükist vähemalt järgmised osad.

• Parameetrid vs input
• return vs. print
• Milleks funktsioonid?

Tingimuslause¶

Tingimuslause (ehk if-lause ehk hargnemislause) on oma olemuselt küllalt lihtne – teatud tingimusel tuleb täita ühed laused ja vastasel juhul teised. Lisavõimalusena on Pythonis võimalik kirjutada ka üheharulisi (st ilma else-ta) ning mitmeharulisi (elif-iga) tingimuslauseid.

Üks oluline punkt tingimuslause juures on lause päises antud tingimusavaldis. Nagu eelnevalt mainitud, on avaldiste moodustamiseks lõputult võimalusi – võib kasutada konstante, muutujaid, tehteid, funktsiooni väljakutseid või kõigi nende kombinatsioone. Tingimusavaldise juures on oluline, et avaldise tüüp oleks tõeväärtus, st avaldise väärtustamisel saadakse kas True või False.

Mitme tingimuse kombineerimiseks saab kasutada operaatoreid and ja or, tingimuse ümberpööramiseks on operaator not. Ära unusta, et tingimuses saad kasutada ka isetehtud funktsioone, aga need peavad sel juhul tagastama tõeväärtuse.

Korduslaused e tsüklid¶

Pythonis on kaks erinevat korduslauset – while-tsükkel, mis on väga paindlik, ning for-tsükkel, mis on lihtsam, aga mis ei sobi kõigil juhtumitel.

for-tsükli juures on oluline mõista, et tema tööpõhimõte on while’ist kaunis erinev. Kui while-tsükli kordused põhinevad mingil tingimusel, siis for-tsükli kordused põhinevad mingil järjendil (või järjendisarnasel asjal, nt failil või vahemikul).

Järjendid¶

Järjendite abil saame koondada mingi hulga andmeid ühe nime alla.

Järjendid on vajalikud neil juhtudel, kus programmi kirjutades pole võimalik öelda, mitme andmejupiga peab programm töötama (vastasel juhul võiksime iga andmejupi jaoks võtta programmis kasutusele ühe muutuja).

Järjendeid saab programmi sisse kirjutada, koostada teiste järjendite põhjal või lugeda failist. Kui järjendeid on vaja ükshaaval järjest läbi vaadata, siis on selleks kõige mugavam kasutada for-tsüklit, kui on vaja lugeda järjendist mingit konkreetset elementi, siis tuleks kasutada indekseerimist.

Kust saab rohkem infot?¶

Kes soovib läbitud teemade kohta rohkem detaile või lihtsalt teist vaatenurka, siis soovitame lugeda läbi Pythoni ametliku juhendi: http://docs.python.org/3/tutorial/.

Pööratud Poola notatsioon¶

Tänapäeval oleme harjunud kirjutama matemaatilisi avaldisi nõndanimetatud infiksnotatsioonis, kus tehtemärk on nende kahe arvu vahel, millega ta töötab. See tekitab tegelikult aga igasuguseid probleeme seoses sellega, et vahel on raske öelda, mis järjestuses tehteid tegema peab. Koolis õpetatakse meile, et kõigepealt tuleb teha astendamised, siis korrutamised ja jagamised ning alles siis liitmised ja lahutamised. Kui tehteid tuleb mingis muus järjestuses teha, saab kasutada sulge.

Tegelikult on aga juba ammusest olnud tuntud viise avaldiste kirjutamiseks nii, et sulge pole vaja, kuid kõik tehete tegemise järjestused on ometi kirjeldatavad. Ehk tuntuim neist on nõndanimetatud postfiksnotatsioon ehk pööratud Poola notatsioon (Poola notatsioon on nii nimetatud, sest selle põhiline propageerija oli poola matemaatik Jan Łukasiewicz ja ta pakkus selle välja 1920. aastal; pööratud Poola notatsiooni pakkusid välja F. L. Bauer ja E. W. Dijkstra kuuekümnendatel).

Selles ei kirjutata tehe mitte argumentide vahele, vaid järele. Nii teisendatakse näiteks 2 + 3 avaldiseks 2 3 +. Kui üks neist argumentidest juhtub aga olema juba mõne eelneva tehte tulemus, siis tähistabki vastavat tulemust see tehtemärk. Nii saab näiteks 2 + 3 – 1 teisendada kujule 2 3 + 1 -. See tähendab seda, et kõigepealt tehakse liitmine 2 ja 3 vahel ning seejärel lahutamine selle liitmise tulemuse ja 1 vahel. Selline kirjutamisviis kaotab igasuguse vajaduse sulgude jaoks: (2 + 7) * 3 saab kirjutada ju lihtsalt kui 2 7 + 3 * kusjuures on üheselt selge, et kõigepealt tehakse 2 ja 7 liitmine ning alles siis korrutatakse selle tulemus ja kolm omavahel. Muuseas võib juhtuda, et järjest on ka kaks või kolm või isegi enam tehtemärki. Näiteks teiseneb 3 + 2 * (4 - 1) kujule 3 2 4 1 - * +.

Selle kirjapildi teine tõsine eelis on see, et see muudab aritmeetiliste avaldiste töötlemise arvuti jaoks kõvasti lihtsaks. Tuleb vaid meeles pidada, mis arvud parasjagu loetud on, tehtemärki kohates kaks viimati lisatud arvu välja võtta, neile see tehe rakendada ning siis see tulemus uuesti meeles peetud arvude nimekirja lõppu lisada. Seega on väga lihtne koostada programm, mis antud avaldise tulemuse välja arvutab. Toomegi siinkohal programmi, mis seda teeb:

rida = input("Sisesta avaldis: ")
kasud = rida.split()

# töötle avaldis
loend = []

for kask in kasud :
    # liitmine
    if kask == "+" :
        # asenda viimane element tulemusega
        loend[-1] = loend[-2] + loend[-1]
        # eemalda eelviimane element
        loend.pop(-2)

    # lahutamine
    elif kask == "-" :
        loend[-1] = loend[-2] - loend[-1]
        loend.pop(-2)

    # korrutamine
    elif kask == "*" :
        loend[-1] = loend[-2] * loend[-1]
        loend.pop(-2)

    # jagamine
    elif kask == "/" :
        loend[-1] = loend[-2] / loend[-1]
        loend.pop(-2)
    else :
        # polegi käsk, seega loodetavasti hoopis number
        loend.append(float(kask))

print("Tulemus on: " + str(loend[-1]))

Tegu on ka asjaga, mis on praktikas täiesti kasutust leidnud. Oma töötlemise lihtsuse tõttu ehitati selline arvutamise süsteem sisse mõningatesse võimsamatesse kalkulaatoritesse, mida kunagi müüdi. Viimase 15 aasta jooksul on see aga arvutusvõimsuse kasvu tõttu vaikselt kalkulaatorites asendunud meile loomulikuma koolis õpitud infiksnotatsiooniga.