Computer Programming 2026/27 fall

Pythoni põhimõisted

Sissejuhatus

Selles peatükis tutvume Pythoni põhiliste töövahenditega ning anname ülevaate programmeerimise olemusest ja võimalustest.

Kursusel kasutame programmeerimiskeskkonda Thonny. Pythoni programme võiks vabalt kirjutada ka Notepadi või mõne muu üldotstarbelise tekstiredaktoriga, kuid Thonnysse on lisatud mitmeid just algajale programmeerijale mõeldud abivahendeid. Lisaks võimaldab Thonny logida tegevusi, mida ülesannete lahendamise ajal tehakse. Thonny paigaldamisest ja seadistamisest räägib lähemalt eelmine peatükk.

Esimene programm

Alustuseks koostame lihtsa programmi, mis väljastab ekraanile Tervist!.

Thonny esmakordsel avamisel on ees tühi redaktor uue programmi kirjutamiseks. Kui seda ei ole, saab uue faili luua menüüst File -> New. Kirjuta või kopeeri redaktorisse järgnev üherealine programm:

print("Tervist!")

Salvesta fail klahvidega Ctrl+S (või menüüst File -> Save as...), lisades failinime lõppu laiendi .py, näiteks tervist.py. Taolist Pythoni programmi sisaldavat tekstifaili nimetame edaspidi skriptiks.

Programmi käivitamiseks vajuta rohelist noolega nuppu, klahvi F5 või vali menüüst Run -> Run current script. Akna allservas olevasse käsurea paneeli peaks tekkima uus rida tekstiga Tervist!.

Nagu võid järeldada, tähendab print Pythoni jaoks teksti ekraanile kuvamist, mitte printerisse saatmist. Selleks, et Python suudaks teha vahet käskudel ja tavalisel tekstil, kirjutatakse tekst jutumärkide vahele.

NB!

Tee oma programmeerimisharjutuste jaoks kohe eraldi kaust – ülesandeid tuleb semestri jooksul palju.

Pythoni käsurida

Programmeerida saab ka käsureal, ilma et programmi peaks failina salvestama. Selline viis sobib väiksemate ülesannete lahendamiseks ja Pythoni võimaluste katsetamiseks. Kuna käske antakse ühekaupa ja tulemus näidatakse kohe järgmisel real, nimetatakse seda ka interaktiivseks programmeerimiseks.

Thonnys on käsurida alati nähtav. Käsuviip >>> näitab kohta, kuhu saab kirjutada Pythoni käsu – ENTERi vajutamisel see käsk täidetakse. Järgnev näide on kopeeritud käsurealt, kuhu sisestati kaks käsku:

>>> print("Tervist!")
Tervist!
>>> print(23 * 454)
10442

Märkus käsuviibast

Edaspidi tuleb näiteid nii käsurea kui ka skriptide (st faili salvestatud programmide) kohta. Kui näide algab käsuviibaga >>>, siis esitab see käsurea dialoogi; vastasel juhul on tegemist skriptiga.

NB! Käsuviiba märki kasutatakse vaid selleks, et oleks kergem eristada, millistel ridadel on käsud ja millistel vastused. Seda ei kirjutata kunagi ise – ei käsureal ega skriptis.

Sissejuhatav video

Algoritmi video

Vigadest

Veateated on programmeerimises tavapärased. Kuna arvutiga ei saa suhelda nagu inimesega, võib ka kõige väiksem vormistusviga tekitada veateate. See on Pythoni viis öelda, et ta ei saa täpselt aru, mida temast tahetakse.

Alguses tuleb kokku puutuda kahe peamise veatüübiga.

Süntaksiviga

Süntaksiviga (ingl syntax error) tekib siis, kui Python ei saa aru programmi tekstist ja seetõttu programmi käivitama ei hakatagi. Veateade antakse selle rea kohta, kust Python enam edasi lugeda ei osanud, aga tegelik vea põhjus on tihti hoopis eelneval real!

Üks tüüpilisemaid süntaksivigu on puuduv lõpetav sulg. Kuigi iga inimene saab aru, mida on mõeldud lausega x = 3 + (4 * 5, on see Pythoni jaoks arusaamatu tekst, sest ei vasta keele reeglitele. Teisiti öeldes: Python (nagu iga teine programmeerimiskeel) on suur tähenärija ja sellega tuleb arvestada – programmi kirjutamisel tuleb olla täpne, iga sümbol loeb!

Täitmisaegne viga

Täitmisaegne viga (ingl runtime error) tekib siis, kui programm küll käivitati, aga mingi konkreetse käsu täitmine ebaõnnestus. Vigane käsk võib olla näiteks nulliga jagamine, valesti kirjutatud funktsiooninime kasutamine või olematu faili lugemine. Kui sa pole veel ühtki täitmisaegset viga näinud, sisesta käsureale prin("Tere!"). Täitmisaegseid vigu nimetatakse tihti ka erinditeks (ingl exception).

Kuidas veateadet lugeda

Täitmisaegses veateates on tavaliselt mitme rea jagu infot, mis on abiks kogenud programmeerijale, aga võib algajal silme eest kirjuks võtta. Sellest ei tasu end heidutada lasta – enamasti piisab veateate viimase rea lugemisest. Lisaks probleemi kirjeldusele on veateates alati reanumber, mis viitab vea tekitanud reale programmi tekstis. (Käsureal töötades on aktiivse käsu reanumber alati 1.)

Thonnys avaneb vea korral ka paneel Assistant, mis püüab veateate lahti seletada ja tüüpilisemate vigade puhul lahenduse välja pakkuda. Kui see paneel ei ole nähtav, saab selle avada menüüst View -> Assistant.

Paraku tuleb algajal vahel ka viimase rea üle pead murda. Hea näide on see, kui Python vastab käsule cos(pi) teatega NameError: name 'cos' is not defined. Sisuline põhjus ei ole see, et käsk cos oleks vale, vaid see, et funktsioon cos on eelnevalt importimata. See ei ole Pythoni-poolne kiusamine – Python püüab aidata :)

Veateateid näevad programmeerijad palju ja nende lahendamine võib olla aeganõudev. Lähtu sellest, et iga veateade on mõeldud programmeerija abistamiseks: loe teate tekst (või vähemalt viimane rida) alati hoolikalt läbi ja mõtle, milles võiks probleem olla. Sageli aitab ka veateate guugeldamine. Nii muutub Pythoni veateadete salakiri kogemusega arusaadavamaks ja kasulikuks.

Laused ja avaldised

Pythoni programmid koosnevad lausetest, mis on olemuselt sarnased loomuliku keele käskiva kõneviisi lausetega – iga lausega (nt y = 123 või print("Tervist!")) annab programmeerija Pythonile mingi korralduse. Lihtsamate lausete puhul tähendab üks koodirida ühte lauset ja programmi käivitamisel täidab Python laused samas järjekorras, nagu need on programmitekstis. (Edaspidi tutvume ka lausetega, mis võtavad enda alla mitu rida ja võimaldavad keerulisemaid käskude järjestamise skeeme.)

Nii nagu loomulikus keeles moodustatakse laused sõnadest ja fraasidest, pannakse ka Pythoni laused kokku väiksematest keele elementidest, millest kõige olulisemad on avaldised.

Avaldised on näiteks:

• lihtne arvutustehe, nt 2 + 3 või sin(0.5);
• "arvutustehe" teksti ja muutujaga, nt "Tere " + nimi + "!";
• lihtsalt muutuja, nt x või nipitiri;
• lihtsalt arv, nt 123 või 3.987;
• lihtsalt tekst, nt "Tervist!";
• käsk, mis annab mingi tulemuse, nt input("Sisesta mingi täisarv: ");
• ükskõik kui keeruline kombinatsioon eelnevatest, nt sin(int(y) * x / 1.76).

Avaldised esinevad enamasti mingi lause komponendina – näiteks avaldist 2 + 3 võib kasutada lauses x = 2 + 3 või lauses print(2 + 3).

Uue terminoloogia abil saab paljud reeglid kokku võtta väga lühidalt: print-käsu järel olevatesse sulgudesse võib kirjutada suvalise avaldise ning võrdusmärgist paremale võib kirjutada suvalise avaldise.

Iga avaldist, ükskõik kui keerulist, saab kasutada veel keerulisema avaldise moodustamiseks: näiteks avaldistest 1 ja x * 3 saab moodustada avaldise x * 3 - 1. Sama põhimõtet teistpidi vaadates võib öelda, et iga keeruline avaldis koosneb lihtsamatest avaldistest ehk alamavaldistest.

Väärtused

Tähelepanelikul lugejal võib tekkida õigustatud küsimus: miks ilmub lause print(2 + 3) käivitamisel ekraanile 5, mitte 2 + 3? Asi on selles, et avaldist sisaldava lause käivitamisel arvutab Python kõigepealt tulemuse välja ja kasutab siis seda esialgse avaldise asemel. Arvutuse tulemust nimetatakse väärtuseks (ingl value) ning arvutusprotsessi avaldise väärtustamiseks (ingl evaluation).

Väärtused (nt arv 5, arv 3.141592653589793, tekst "Tere!") on need päris andmed, mida programm oma töö käigus kasutab, loob, arvutab ja teisendab. Võib öelda, et avaldised tähistavad asju programmi tekstis, aga väärtused on need asjad programmi töötamise ajal. Väärtustamine genereerib avaldisele vastava väärtuse.

Avaldised käsureal

Üldjuhul ei ole eraldiseisev avaldis (nt 2 + 3) Pythoni jaoks mõistlik lause – nii nagu eesti keeles ei saa üksikut fraasi "suur mets" pidada lauseks. Seetõttu on avaldised harilikult mingi lause komponendid (nt vastus = 2 + 3). Pythoni käsurida aga võimaldab avaldisi väärtustada ka ilma neid lause konteksti panemata – see on mugav viis tehete katsetamiseks:

>>> 2 + 3
5

Andmetüübid, tehted ja muutujad

Eelnevatest näidetest tuli välja, et Python oskab kasutada erinevat liiki andmeid ehk väärtusi: teksti, täisarve ja murdarve. Andmete liiki nimetatakse programmeerimisel andmetüübiks või lihtsalt tüübiks.

Iga andmetüübi juures on esimene küsimus, kuidas panna kirja selle tüübi konkreetseid väärtusi. Siin tuleb lihtsalt teada vastavaid reegleid: näiteks kümnendmurru esitamisel tuleb koma asemel kasutada punkti ning tekst tuleb panna ülakomade vahele või jutumärkidesse. Sedasi programmi teksti sisse kirjutatud konkreetseid väärtusi nimetatakse literaalideks ehk konstantideks.

Teine küsimus on, mida antud tüüpi andmetega teha saab. Näiteks arve saab omavahel liita, teksti saab teisendada suurtähtedesse ning kõiki andmetüüpe saab käsuga print ekraanile kuvada. Selliseid toiminguid nimetatakse teheteks ehk operatsioonideks.

Väärtuse tüübi saab alati järele vaadata funktsiooniga type:

>>> type(5)
<class 'int'>
>>> type(5.0)
<class 'float'>
>>> type("5")
<class 'str'>

Pane tähele, et 5 ja "5" on kaks täiesti erinevat asja: esimene on arv, teine on üheteemärgiline tekst.

Muutujad

Tähtis mõiste on veel muutuja. Kerge on seda sassi ajada varasemate matemaatikateadmistega, aga muutuja programmeerimiskeeles on teine asi: muutujaid kasutatakse väärtuste salvestamiseks.

a = 15
b = 13
summa = a + b
print(summa)          # 28

Näites on muutujad a, b ja summa. Nagu näha, võib muutujasse salvestada ka teistest muutujatest arvutatud väärtuse.

Omistamislauset summa = a + b loetakse paremalt vasakule: kõigepealt väärtustatakse võrdusmärgist paremal olev avaldis ja alles siis salvestatakse tulemus vasakul olevasse muutujasse. Sama muutujale võib uue väärtuse anda ükskõik mitu korda – vana väärtus läheb siis kaotsi.

Pythoni jaoks on ükskõik, millise nime sa muutujale valid, aga programmi loetavuse huvides peaks nimi kirjeldama muutuja tähendust antud ülesande kontekstis (nt brutopalk või isikukood). Muutujanimede kohta kehtivad järgmised reeglid:

• nimi võib sisaldada tähti, numbreid ja alakriipse, aga esimene sümbol ei tohi olla number;
• mitmest sõnast koosnevas nimes kasutatakse tühikute asemel alakriipse, nt laste_arv;
• suur ja väike täht on erinevad: vanus ja Vanus on kaks eri muutujat;
• nimeks ei saa võtta Pythoni võtmesõna (nt print, input, if) – muidu läheb algne tähendus kaotsi.

Video. Andmetüübid. Arvud. Sõned. Tõeväärtused

Muutuja video

Aritmeetiliste avaldiste video

Arvud

Pythonis (nagu ka enamikus teistes programmeerimiskeeltes) käsitletakse täisarve ja reaalarve veidi erinevalt.

Täisarvud. Pythoni täisarvu andmetüübi nimi on int (lühend ingliskeelsest sõnast integer). Erinevalt paljudest teistest keeltest ei ole Python 3-s piiratud, kui suuri (või kui väikseid) täisarve saab esitada.

Ujukomaarvud. Reaalarvudele vastavad Pythonis nn ujukomaarvud (ingl floating point number, lühemalt float). Näiteks 3.0 ja 1.653. NB! Koma asemel kasutatakse punkti!

Ujukomaarvude ligikaudsus

Proovi läbi järgnev lihtne näide:

>>> 0.1 * 3.0
0.30000000000000004

Ootuspärane vastus oleks 0.3, kuid Python tagastas midagi muud. Asi on selles, et arvutis esitatakse ujukomaarvud kahendkujul, kasutades piiratud arvu bitte, ja seetõttu polegi võimalik teatud kümnendmurde (nende hulgas 0.1) täpselt esitada – analoogiliselt pole kümnendmurruna võimalik täpselt esitada näiteks 10 / 3. Taolistel juhtudel ümardatakse sisestatud arv lähima võimaliku kahendmurruni ja see ongi ebatäpsuse põhjus.

Kui ujukomaarvu on tarvis esitada kümnendmurruna (nt ekraanile kuvamisel), toimub jälle ümardamine – seepärast antakse käsureale 0.1 sisestades vastuseks tagasi 0.1, kuigi Python sisimas ei suuda seda arvu täpselt esitada. Kui korrutasime 0.1 kolmega, muutus viga juba piisavalt suureks, et tulemusele lähim võimalik kümnendmurd oli 0.30000000000000004, mitte 0.3.

Tegelikult tekitab ujukomaarvude ligikaudsus probleeme vaid siis, kui eeldame reaalarvude absoluutselt täpset esitamist (nt kümnendmurruna esitatud rahasummad, kus murdosa tähistab sente). Praktikas kasutatakse ujukomaarve peamiselt mõõtmistulemuste esitamiseks ja selle jaoks on float-tüübi ulatus ning täpsus enam kui piisav.

Aritmeetilised tehted

Tehete järjekord on sama nagu matemaatikas: kõigepealt astendamine, siis korrutamine ja jagamine, seejärel liitmine ja lahutamine. Järjekorra muutmiseks kasutatakse sulge.

Märkus

Kui avaldis on keeruline, tasub kaaluda sulgude kasutamist ka seal, kus Python neid ei nõua – nii on lugemine lihtsam. Loetavuse huvides on siin ja edaspidistes näidetes pandud tehtemärkide ümber tühikud, aga need võib ka ära jätta.

Sõned

Teksti nimetatakse programmeerimises sõneks (ingl string, tüübi nimi str). Sõne kirjutatakse kas jutumärkide või ülakomade vahele – Pythoni jaoks on need samaväärsed, oluline on ainult, et sõne algaks ja lõpeks sama märgiga:

>>> "Tere"
'Tere'
>>> 'Tere'
'Tere'

Ka sõnedega saab teha tehteid, kuigi tähendus on teine kui arvude puhul:

>>> "Tere " + "maailm!"      # liitmine ühendab sõned
'Tere maailm!'
>>> "ha" * 3                 # korrutamine kordab sõnet
'hahaha'
>>> len("Tere")              # sõne pikkus
4

Tõeväärtused

Kolmas oluline andmetüüp on tõeväärtus (ingl boolean, tüübi nimi bool), millel on ainult kaks võimalikku väärtust: True ja False. Neid kirjutatakse alati suure algustähega. Tõeväärtused tekivad näiteks võrdlemisel:

>>> 3 < 5
True
>>> 3 == 5
False

Tõeväärtustest ja tingimustest tuleb pikemalt juttu järgmisel nädalal.

Tüübiteisendused

Väärtusi saab ühest tüübist teise teisendada. Kõige olulisemad teisendusfunktsioonid on:

• int(...) – teeb väärtusest täisarvu;
• float(...) – teeb väärtusest ujukomaarvu;
• str(...) – teeb väärtusest sõne.

>>> int("42") + 1
43
>>> float("3.14")
3.14
>>> str(21) + "!"
'21!'

Teisendamine on vajalik seepärast, et Python ei liida omavahel eri tüüpi väärtusi:

>>> "Vanus: " + 21
TypeError: can only concatenate str (not "int") to str

Kui teisendada ei õnnestu, tuleb täitmisaegne viga:

>>> int("kolm")
ValueError: invalid literal for int() with base 10: 'kolm'

Sisend ja väljund

Programm saab andmeid välismaailmast sisendina ja annab tulemused välja väljundina. Kasutajalt sisendi küsimiseks on käsk input:

nimi = input("Palun sisesta oma nimi ja vajuta ENTER: ")
print("Tere " + nimi + "!")

Salvesta ja käivita programm. Enne oma nime kirjutamist proovi ennustada, milline tekst ekraanile ilmub. Katseta! Kui arvasid õigesti, vaata programmi tekst veel kord üle ja mõtle, milline otstarve on igal programmielemendil:

• käsk input võimaldab kasutajal midagi sisestada ning edastab saadud teksti Pythonile;
• konstruktsioon nimi = ... salvestab selle teksti mällu, edaspidi saab sellele viidata, kirjutades lihtsalt nimi;
• konstruktsioon "Tere " + nimi + "!" kombineerib etteantud tekstijupid ja kasutaja nime uueks sõneks.

NB! input tagastab alati sõne

Ka siis, kui kasutaja sisestab arvu, saab programm selle tekstina. Seetõttu tuleb arvuna kasutamiseks sisend teisendada:

vanus = int(input("Kui vana sa oled? "))
print(f"Aasta pärast oled {vanus + 1}.")

Ilma teisenduseta annaks vanus + 1 vea TypeError, sest sõnele ei saa arvu liita. Kui oodata on komakohtadega arvu, kasutatakse int asemel float-i.

Väljastamine

Väljundi andmiseks kasutame juba tuttavat käsku print. Käsule võib anda ka mitu argumenti – sel juhul trükitakse samale reale mitu asja järjest, tühikutega eraldatuna.

Järgnev näide demonstreerib kolme samaväärset viisi, kuidas trükkida ekraanile mitu infokildu korraga:

>>> eesnimi = "Peeter"
>>> perenimi = "Paan"
>>> vanus = 21
>>> print(eesnimi + " " + perenimi + " vanus: " + str(vanus))
Peeter Paan vanus: 21
>>> print(eesnimi, perenimi, "vanus:", vanus)
Peeter Paan vanus: 21
>>> print(f"{eesnimi} {perenimi} vanus: {vanus}")
Peeter Paan vanus: 21

1. Esimene variant kombineerib komponendid kõigepealt üheks sõneks ja kasutab seda print-i argumendina. Muutuja vanus tuleb siin teisendada sõneks, muidu tuleb TypeError.
2. Teine variant annab kõik komponendid eraldi argumentidena. Teisendama ei pea, sest print oskab ise iga argumendi tekstiks muuta. Argumentide vahele tuleb automaatselt tühik.
3. Kolmas variant kasutab f-stringi ehk sõnede interpolatsiooni: jutumärkide ette kirjutatakse f-täht ja muutujate väärtused paigutatakse teksti sisse loogeliste sulgude vahele. See on kolmest kõige loetavam ja edaspidi kasutamegi enamasti seda.

Vihje

Loogelised sulud { ja } saab eestikeelsel klaviatuuril klahvikombinatsioonidega AltGr+7 ja AltGr+0.

Kommenteerimine

Lisaks Pythoni jaoks mõeldud käskudele saab programmi kirjutada kommentaare, mis on mõeldud vaid programmi lugemise hõlbustamiseks. Kommentaar algab sümboliga # – Python ignoreerib kogu teksti sellest sümbolist kuni rea lõpuni.

# Küsin kasutaja nime
nimi = input("Kuidas on sinu nimi? ")

# Tervitan kasutajat
print("No tere " + nimi)
print("Kuidas läheb?")

# Praktikas keegi nii lihtsa programmi puhul
# tegelikult kommentaare ei kasutaks

Kommentaari abil saab ka mõne koodirea ajutiselt "kahjutuks" teha. Thonnys saab valitud read korraga kommentaariks muuta klahvidega Ctrl+3 ja samamoodi ka tagasi.

Kokkuvõte

• Programm koosneb lausetest; laused pannakse kokku avaldistest. Avaldise arvutamist nimetatakse väärtustamiseks ja tulemust väärtuseks.
• Põhilised andmetüübid on int (täisarv), float (ujukomaarv), str (sõne) ja bool (tõeväärtus). Tüüpi saab vaadata funktsiooniga type.
• Ujukomaarvud on ligikaudsed – 0.1 * 3.0 ei anna täpselt 0.3.
• / annab alati ujukomaarvu, // täisosa ja % jäägi.
• Muutujasse salvestatakse väärtusi. Omistamine toimub paremalt vasakule; nimi algab tähega ja kirjeldab sisu.
• input tagastab alati sõne – arvuna kasutamiseks tuleb see teisendada int-i või float-iga.
• Väljastamiseks on kolm viisi, millest loetavaim on f-string: print(f"{nimi} on {vanus}").
• Süntaksiviga tähendab, et programmi ei saadudki käivitada; täitmisaegne viga tekib töö käigus. Loe veateate viimast rida.

from turtle import *

forward(100)
right(90)
forward(100)

from turtle import *

color("red")
forward(100)