Termipankki
  1. A
    1. Ajonaikainen
      konseptit
    2. Alkio
      arvot listat
    3. Alustaminen
      muuttujat arvot
    4. Argumentti
      arvot funktiot
    5. Arvo
      arvot
    6. Avain
      sanakirjat arvot
    7. Avainsana
      nimet
    8. Avainsana-argumentti
      funktiot
    9. Avausmoodi
      tiedostot
    10. Aliohjelma
      Funktio
    11. Attribuutti
      Jäsenarvo
    12. Ajaminen
      Suorittaminen
  2. B
    1. Boolen operaattori
      Looginen operaattori
    2. Bugi
      Ohjelmointivirhe
    3. break
      toistorakenteet avainsanat
  3. C
    1. Carriage return
      pakeneminen merkkijonot tiedostot windows
    2. Ctrl + C
      Näppäimistökeskeytys
    3. Callback
      Takaisinkutsu
    4. continue
      toistorakenteet avainsanat
  4. D
    1. Data
    2. Debuggaus
    3. Dokumenttimerkkijono
      dokumentointi
  5. E
    1. Elementti
      Alkio
    2. Ehto
      ohjausrakenteet
    3. Ehtolause
      ohjausrakenteet
    4. Ehtorakenne
      ehtorakenteet ohjausrakenteet
    5. Epätosi
      arvot
    6. Erotin
      merkkijonot tiedostot listat syöte
    7. Evaluointi
      lausekkeet arvot
    8. Exception
      poikkeukset ohjausrakenteet
    9. enumerate
      listat toistorakenteet
  6. F
    1. False
      Epätosi
    2. Format
      merkkijonot tulostus
    3. Funktio
      funktiot
    4. Funktiokutsu
      funktiot lauseet
    5. Funktiomäärittely
    6. for
  7. G
    1. Generaattori
      objektit toistorakenteet
    2. Globaali muuttuja
      muuttujat arvot
  8. H
    1. Haara
      try-rakenteet ehtorakenteet
    2. Hyppy
      ohjausrakenteet
    3. Hardkoodaus
      Kovakoodaus
  9. I
    1. if-lause
      Ehtolause
    2. if-rakenne
      Ehtorakenne
    3. Ikuinen silmukka
      toistorakenteet
    4. Indeksi
      arvot listat
    5. Indeksiosoitus
      arvot listat
    6. import
      moduulit
  10. J
    1. Jäsenarvo
      objektit
    2. Jäsenfunktio
      Metodi
  11. K
    1. Kutsu
      Funktiokutsu
    2. Kierros
      toistorakenteet
    3. Kirjasto
      moduulit
    4. Komentoriviargumentti
      terminaali
    5. Kommentti
      virheenetsintä dokumentointi
    6. Kooditiedosto
      konseptit
    7. Kovakoodaus
      arvot
    8. Kutsupyyntö
      funktiot
    9. Käsittelijä
      funktiot konseptit
    10. Käyttöliittymä
      konseptit
    11. Käyttöliittymäelementti
    12. Koodilohko
      Lohko
    13. Koodi
      Lähdekoodi
    14. KeyboardInterrupt
      Näppäimistökeskeytys
    15. Komentorivi
      Terminaali
    16. Komentokehote
      Terminaali
    17. Kahva
      Tiedostokahva
  12. L
    1. Lause
      konseptit
    2. Lauseke
      konseptit
    3. Leikkaus
      listat
    4. Lista
    5. Literaaliarvo
      arvot
    6. Liukuluku
      arvot tyypit
    7. Lohko
      ohjausrakenteet funktiot
    8. Looginen operaattori
      ohjausrakenteet operaattorit
    9. Lähdekoodi
      konseptit
  13. M
    1. Muotoilu
      Format
    2. Merkki
    3. Merkkijono
      arvot tyypit
    4. Metodi
      funktiot objektit
    5. Metodikutsu
      lausekkeet objektit
    6. Moduuli
    7. Monikko
      tietorakenteet listat
    8. Muuntumaton
      arvot merkkijonot konseptit
    9. Muuntuva
      arvot konseptit listat
    10. Muuttuja
      arvot konseptit
    11. Määrittely
      konseptit
  14. N
    1. Nimeämätön vakio
      arvot vakiot
    2. Nimi
      muuttujat funktiot
    3. Nimiavaruus
      moduulit funktiot konseptit
    4. Nimikonflikti
    5. Näkyvyysalue
      konseptit lohkot
    6. Näppäimistökeskeytys
      poikkeukset
  15. O
    1. Objekti
      konseptit
    2. Olio
      Objekti
    3. Ohjausrakenne
      try-rakenteet toistorakenteet ehtorakenteet
    4. Ohjelmointiongelma
      ongelmanratkaisu
    5. Ohjelmointityyli
    6. Ohjelmointivirhe
      ongelmanratkaisu
    7. Oletusarvo
      arvot funktiot parametrit
    8. Ominaisuus
      objektit
    9. Operaatio
      lausekkeet
    10. Operaattori
    11. Operandi
  16. P
    1. Paikanpidin
      merkkijonot tulostus
    2. Pakeneminen
      merkkijonot
    3. Palauttaminen
      arvot funktiot
    4. Paluuarvo
    5. Parametri
      funktiot
    6. Poikkeus
      try-rakenteet ongelmanratkaisu
    7. Poikkeusten käsittely
      ohjausrakenteet poikkeukset
    8. Polku
    9. Python-konsoli
      työkalut
    10. Python-tulkki
      työkalut
    11. Pääohjelma
      konseptit
    12. Presedenssi
      Sidontajärjestys
  17. R
    1. Rajapinta
      moduulit funktiot konseptit
    2. Ratkaisumalli
      ongelmanratkaisu
    3. Rekursio
      funktiot konseptit
    4. Rivinvaihtomerkki
      merkkijonot tiedostot
  18. S
    1. Sanakirja
      tietorakenteet
    2. Sapluuna
      merkkijonot konseptit
    3. Sekvenssi
      tietorakenteet konseptit toistorakenteet
    4. Sidontajärjestys
      lausekkeet konseptit
    5. Suoritusjärjestys
      Sidontajärjestys
    6. Sijoittaminen
      muuttujat arvot
    7. Sijoitusoperaattori
      muuttujat arvot operaattorit
    8. Silmukkamuuttuja
      muuttujat toistorakenteet
    9. Sisennys
      konseptit
    10. Sisäänrakennettu funktio
      funktiot
    11. Suorittaminen
      lausekkeet konseptit
    12. Syntaksi
      konseptit
    13. Syntaksivirhe
      poikkeukset
    14. Syöte
      merkkijonot konseptit
    15. Silmukka
      Toistorakenne
    16. Stacktrace
      Traceback
  19. T
    1. Taikaluku
      Nimeämätön vakio
    2. try-rakenne
      Poikkeusten käsittely
    3. Takaisinkutsu
      funktiot
    4. Tallennusformaatti
      merkkijonot tiedostot
    5. Tapahtuma
      konseptit
    6. Tekstitiedosto
      tiedostot
    7. Terminaali
      työkalut
    8. Testaaminen
      ongelmanratkaisu konseptit
    9. Tiedostokahva
      objektit tiedostot
    10. Tiedostonimi
      merkkijonot tiedostot
    11. Tiedostopääte
      tiedostot
    12. Tietorakenne
      sanakirjat konseptit listat
    13. Tila
      konseptit
    14. Toistorakenne
      ohjausrakenteet
    15. Tosi
      arvot
    16. True
      Tosi
    17. Totuusarvo
      ohjausrakenteet
    18. Traceback
      ongelmanratkaisu
    19. Tulostaminen
      merkkijonot konseptit
    20. Tynkäfunktio
      ongelmanratkaisu funktiot
    21. Tyylisääntö
    22. Tyyppi
      arvot konseptit
    23. Tyyppimuunnos
      arvot funktiot tyypit
  20. V
    1. Vakio
      muuttujat arvot
    2. Valinnainen argumentti
      arvot funktiot parametrit
    3. Vertailuarvo
    4. Vertailuoperaattori
      ohjausrakenteet operaattorit
    5. Viittaaminen
      muuttujat arvot objektit
    6. Virheviesti
      ongelmanratkaisu
  21. W
    1. while
      toistorakenteet
    2. with
      tiedostot
Ratkaistu: / tehtävää

1. Materiaali: Kosmisten muuttujien arvoitus

Mitä täällä oikein tapahtuu?

Ohjelmoinnin alkeet kurssin nimenä tarkoittaa, että kurssilla opitaan ohjelmointia ilman minkäänlaisia esitietovaatimuksia. Tie on ajoittain kivinen, mutta suuret saavutukset toivon mukaan kompensoivat nähtyä vaivaa. Viimeistään aloitusviikon harjoitukset antavat riittävät taidot ohjelmoinnin opettelun aloittamiseen. Opit asentamaan ja käynnistämään oikeat sovellukset sekä kirjoittelemaan laskutoimituksia
interaktiiviseen Python-tulkkiin
. Saatpa myös tietää, mikä tuo mystinen tulkki oikein on.
Kooditiedostostakin
muodostuu alustavasti tuttu käsite.
Ohjelmoinnin oppimisen haastavuus riippuu monesta tekijästä, mutta sellaista tekijää ei olekaan, joka estäisi oppimisen. Oppimista tehostaa erityisesti, jos mukana on tiettyä tavoitteellisuutta. Jo tässä vaiheessa onkin siis hyvä miettiä, mihin juuri sinä voisit käyttää ohjelmointia. Jotakuinkin kaikilla aloilla ja jopa monissa harrastuksissa voi jollain tapaa hyödyntää ohjelmointiosaamista. Ohjelmointitaito johtaa yllättäviin mahdollisuuksiin täysin odottamattomissa tilanteissa. Mikään ei kuitenkaan vedä vertoja sille motivaatiolle, mikä syntyy henkilökohtaisista päämääristä. Mitä sinä voisit ohjelmoida?
Kurssin puolesta me voimme vain tarjota kalpean päämäärän varjon: kaikki kurssilla kiteytyy lopputyöhön. Jos muuta tarkoitusta ohjelmoinnille ei juolahda mieleesi, pidä ainakin valitsemasi lopputyöaihe mielessä, kun kohtaat uusia haasteita ja opit uusia asioita. Joku aamu saatat herätä ja kokea mystisen valaistumisen siitä, miten miinaharava toimii konepellin alla, miten RLC-piiriä voidaan ratkoa ohjelmallisesti tai kuinka mittaustulokset taittuvat nätille käyrälle. Sillä hetkellä kannattaa muistaa, mistä olet lähtenyt liikkeelle, ja todeta miten paljon olet saavuttanut tässä lyhyessä ajassa. Aiheisiin kannattaa siis tutustua vaikka heti.

Asia selvä, sensei. Kerrotko jo, mitä se ohjelmointi on?

Kuvalähde 1
Ohjelmointi ei ole pelkkää
koodin
kirjoittamista. Koodin kirjoittaminen on vain helpoiten havaittava ilmentymä ohjelmoinnista. Voit harrastaa erinäisiä ohjelmointiaktiviteetteja täysin salaa. Vasta kun alat kirjoittaa koodia, aiheeseen vihkiytymättömät ihmiset ympärilläsi tajuavat mitä olet tekemässä. Tässä vaiheessa on tietenkin myöhäistä, sillä suunnitelmasi maailmanvalloitukseen on jo täysillä käynnissä.
Mitä muuta ohjelmoija sitten tekee kuin kirjoittaa koodia? Yleisesti voidaan sanoa, että hän ratkaisee
ongelmia
. Ongelma on tässä kontekstissa mikä tahansa tarve, joka voidaan tyydyttää ohjelmoimalla – oli kyseessä sitten komentorivimiinaharavan tarve, tai tarve postailla hassuja kuvia internetiin muiden ihmisten peukutettavaksi. Kumpikaan ei varsinaisesti ole ongelma maailmassa, mutta kun tarve on valittu ohjelmointityön kohteeksi, voidaan sanoa, että siitä tulee ohjelmointiongelma.
Ohjelmointiongelman alustava ratkaisu on puolestaan suunnitelma siitä, mitä varsinaisen koodin tulisi tehdä. Tässä työvaiheessa
ratkaisumalli
saattaa olla olemassa ja työn alla ainoastaan ohjelmoijan päässä ja kenties myös paperilla. Ratkaisumallin tuottaminen on ensimmäinen näkymätön ohjelmointaito.
Ratkaisumallia tuottaessa on keskeistä tietää, mitä koodilla voi tehdä, mutta vielä ei tarvitse tietää tarkkoja yksityiskohtia siitä, miten koodi kirjoitetaan. Sen sijaan on tarpeen ymmärtää ohjelmoinnin käsitteet. Nämä vastaavat kysymyksiin siitä, miten ohjelmien etenemistä yleisesti hallitaan ja miten ohjelmat mallintavat tietoa. Niitä oppiessa on hyvä muistaa, etteivät ne ole pelkästään Pythonin ominaisuuksia. Sen sijaan ne ovat läsnä kaikissa ohjelmointikielissä tavalla tai toisella.
Ratkaisumallin
käsitteellistäminen muodostaa siis toisen näkymättömän ohjelmointitaidon.
Tämän prosessin jälkeen voidaan viimeinkin puhua varsinaisesta näkyvästä taidosta, eli koodin kirjoittamisesta. Koodi itsessään on vain
syntaksia
, jolla ohjelmoija kuvaa kehittämänsä ratkaisumallin yksiselitteisesti tietokoneelle. Kaikkeen muuhun verrattuna se on melkeinpä vain muodollisuus. Pelkästään kirjoittamalla koodia ei siis opi ohjelmoimaan.

Suo, muuttuja ja koodari

Osaamistavoitteet: Tämän osion läpikäytyäsi pitäisi muuttujan olla tuttu käsite. Muuttujien käyttö asioiden muistamiseen koodatessa sisäistyy luontevaksi toiminnaksi. Lisäksi muuttujien syvempi luonne ja liittyminen tietokoneen muistiin alkaa vähitellen avautua. Sijoitusoperaattori tulee tutuksi. Samoin muuttujien nimeämiseen liittyvät säännöt ja suositukset.

Johdatus muuttujien maailmaan

Ensimmäisenä opittavana ohjelmoinnin käsitteenämme on muisti. Asioiden muistaminen useamman kuin yhden operaation jälkeen tulee tarpeeseen heti, kun ratkotaan yhtään mitään monimutkaisempaa ongelmaa. Ohjelmoinnissa tiedon pitämiseen muistissa käytetään
muuttujia
. Muuttujaan sijoitus tapahtuu yhtäsuuruusmerkillä siten, että muuttuja on vasemalla ja sijoitettava arvo oikealla:
x = 1337
Ohjelmoinnissa tallentaminen tapahtuu tietokoneen muistiin. Merkittävä ero ihmisen ja tietokoneen muistissa on se, että ihminen tietää mikä merkitys omassa muistissa olevilla asioilla on, kun taas tietokone ei. 1337 on vain numero jossain muistin syövereissä. Sen tallennettuaan tietokone ei suoraan osaa vastata pyyntöön "anna minulle aiemmin ratkaistu x:n arvo". Se kuitenkin tietää missä 1337 sen muistissa sijaitsee, joten se osaa kyllä kertoa, jos ohjelmoija pyytää tietoa siitä, mitä tiettyyn muistiosoitteeseen on tallennettu. Ohjelmoijan ei sentään tarvitse osata muistiosoitteita ulkoa tiedon muistista noutamista varten. Sitä varten on olemassa muuttujat – tässä tapauksessa siis x.

Muuttujan käsittäminen

Muuttujan
käsitteen voi ymmärtää hyvin monella tavalla. Pohjimmiltaan kyse on ohjelmoijan ja
Python-tulkin
välisestä sopimuksesta siitä, että tietty sana (esim. x)
viittaa
juuri tiettyyn paikkaan tietokoneen muistissa. Sopimuksen tuloksena molemmat osapuolet pystyvät käsittelemään tallennettua tietoa tavalla, joka on luontevaa: ohjelmoija voi kutsua asioita kuvaavilla nimillä, kun taas tietokoneen puolella puhutaan muistiosoitteista. Asian voi myös ilmaista yksinkertaisemmin toteamalla, että esimerkissä x = 1337 x tarkoittaa tämän rivin suorituksen jälkeen arvoa 1337. Pythonille on ominaista, että muuttuja on vain ja ainoastaan nimi, jolla viitataan johonkin arvoon.
Koska ohjelmoidessa usein puhutaan muuttujan sisällöstä, seuraava väite voi olla hieman hämmentävä: muuttuja ei tosiasiallisesti sisällä mitään. "Muuttujan sisältö" on vain arkikielinen tapa puhua siitä
arvosta
, joka on tietokoneen muistissa muuttujan
viittaamassa
paikassa.
Muuttujan
kaltaisia asioita ovatkin vaikkapa kappaleen otsikko kirjan sisällysluettelossa tai kaupungin nimi kartalla. Kumpikaan ei sisällä sitä, mihin ne viittaavat; ne ainoastaan kertovat, mistä se löytyy. Kartta itsessään ei tiedä mitä "Oulu" merkitsee sitä etsivälle. Se tietää vain, että sellainen nimi on annettu tietyissä koordinaateissa olevalle maantieteelliselle alueelle.
Jos siis rivi x = 1337 tarkoittaa, että otetaan käyttöön nimi x viittaamaan muistipaikkaan, johon juuri tallennettiin arvo 1337, mitä seuraavat rivit tarkoittavat?
y = x
x = 4451
Ensimmäisellä rivillä annetaan toinen nimi x:n
viittaamalle
arvolle. Tämän jälkeen sekä x että y viittaavat samaan
arvoon
, joka on siis 1337. Kyseessä ei ole nimen muuttaminen, koska tämän jälkeen molemmat, sekä x että y, ovat olemassa. Toisella rivillä määritellään uusi arvo 4451, joka
sijoitetaan
johonkin uuteen muistipaikkaan. Tämän jälkeen määritetään, että x viittaakin nyt tähän uuteen muistipaikkaan ja sen sisältämään arvoon. Lopputuloksena siis meillä on edelleen x ja y, mutta niiden arvot ovat nyt vastaavasti 4451 ja 1337. Alla oleva animaatio selventää muuttujien ja nimien suhdetta.
Huomioitavaa on, että vaikka
muuttujaan
sijoittaminen tapahtuu =-merkillä, se ei ole sama asia kuin matemaattinen yhtäsuuruus. Erityisen oleellista on se, mitä on merkin vasemmalla ja mitä oikealla puolen. Vasemmalla on siis aina muuttuja (tai vastaava), mihin sijoitetaan, ja oikealla on aina arvo, joka sijoitetaan. Jos yrittää tehdä toisin päin...
1337 = x
...tapahtuu kauheita:
SyntaxError: can't assign to literal
Eli koodissa on
syntaksivirhe
, koska
literaaliarvoon
(esim. kokonaisluku) ei voi sijoittaa mitään. Merkin vasemalla puolella ei voi myöskään suorittaa
operaatioita
...
x + 3 = 5
...koska jälleen tapahtuu kauheita:
SyntaxError: can't assign to operator
Tällä kertaa
virheviesti
on vähän hämmentävämpi, mutta viittaa siis siihen, että Python olettaa, että haluamme sijoittaa x + 3
operaatioon
. Virheviestien tulkintaa harrastetaan tarkemmin seuraavalla viikolla.
Tiivistettynä =-merkin vasemmalle puolelle kelpaavat vain
muuttujien
nimet. Kaiken muun pitäisi tapahtua merkin oikealla puolen.
Siitä, että sijoitusoperaattorin vasemalla puolella on oltava vain ja ainoastaan muuttujanimi, saavutaan myös seuraavaan päätelmään. Jos muuttujan nimi esiintyy missään muualla kuin
sijoitusoperaattorin
vasemmalla puolella, silloin viitataan muuttujan arvoon (eli siihen muistissa olevaan arvoon, johon muuttuja itse viittaa).
Kun seuraavaa
lauseketta
puretaan päässä, voidaan
muuttujan
paikalle kuvitella sen
arvo
. Arvo nimittäin haetaan muistista muuttujan paikalle ennen rivin kuvaaman lauseen suorittamista. Suoritusjärjestyksestä tulee huomioida, että kaikki, mitä on =-operaattorin oikealla puolella, suoritetaan kokonaisuudessaan, ennen kuin muuttujaan vasemmalla puolella sijoitetaan yhtään mitään.
x = y + 4451
Koska y:n
arvoksi
jäi aiemman pyörittelyn ansiosta 1337, x:n arvoksi tulisi 5788. Tässä siis y:n arvo haetaan muistista ja lisätään siihen 4451, minkä jälkeen lopputulos tallennetaan uuteen muistipaikkaan ja sovitaan, että nimi x viittaa sinne. Suoritusjärjestys on asia johon palataan useampaan otteeseen.
Kun nyt näitä
sijoituksia
ja muita operaatioita on tässä muutamaan otteeseen kirjoiteltu, voidaan saman tien sopia niihin liittyvä
tyylisääntö
:
operaattorin
(siis sen merkin) ja
operandien
(tässä tapauksessa nimien tai lukuarvojen) väliin kuuluu aina yksi välilyönti. Tämä sen vuoksi, että muuten koodi näyttää liian tunkkaiselta. Se sattuu olemaan myös linjassa Pythonin virallisen tyylistandardin kanssa. Eli esimerkkien mukaisesti, välilyönti aina ennen operaattoria sekä sen jälkeen.

Pisteitä suoralla

Opittavat asiat: Välitulosten
sijoittaminen
muuttujiin
.
Alustus:
Aloitetaan siitä, että olemme katsoneet origon kautta kulkevalta suoralta yhden pisteen. Pisteen x- ja y-koordinaatit on tallennettu
tulkissa
muuttujiin seuraavasti:
In [1]: x = 4
In [2]: y = 2
Tehtävänä on laskea näitä pisteitä käyttäen suoran kulmakerroin, ja sen avulla vastaavasti arvot y1 (pisteessä x = 7) ja y2 (pisteessä x = 159).
Haettu vastaus:
Syötä kolme Python-kielistä riviä vastauslaatikkoon joilla:
  • lasketaan muuttujan k arvo käyttämällä muuttujia x ja y (jakolasku)
  • lasketaan muuttujan y1 arvo käyttämällä k:ta ja numeroarvoa 7 (kertolasku)
  • lasketaan muuttujan y2 arvo käyttämällä k:ta ja numeroarvoa 159 (kertolasku)
Syötä rivit alekkain annetussa järjestyksessä.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Muuttujan
arvoa
voi myös niin sanotusti päivittää. Jos esimerkiksi yhdessä muuttujassa on tallessa joukkueen maalit jalkapallo-ottelussa ja joukkue tekee maalin, koodissa voisi olla seuraavanlainen rivi tilanteen käsittelyä varten:
maalit = maalit + 1
Tällä rivillä siis haetaan maalit-muuttujan arvo, lisätään siihen yksi, ja uudelleenmääritellään maalit-muuttuja
viittaamaan
tähän uuteen tulokseen. Tälle
operaatiolle
on olemassa myös lyhennetty
syntaksi
, jossa maalit-nimeä ei tarvitse kirjoittaa kahdesti:
maalit += 1
Sama syntaksilyhennys toimii kaikilla muillakin
operaattoreilla
.

Muuttujien nimeäminen

Muuttujien
nimeämisessä on sääntöjä, joiden suhteen Python on ehdoton. Nimissä saa käyttää ainoastaan kirjaimia, numeroita sekä alaviivaa. Nimi ei kuitenkaan saa alkaa numerolla. Alaviivalla alkavilla nimillä on erityismerkitys, minkä vuoksi niitäkään ei ole suotavaa käyttää alkeiskurssin kontekstissa. Näiden sääntöjen puitteissa voit nimetä muuttujasi miten haluat. Hassunhauskan teekkarihuumorin viljelyä koodiin kannattaa kuitenkin välttää. Alla on esitelty muutamia sallittuja, hyvän nimeämistavan mukaisia muuttujia:
ottelut = 5
pelaaja1 = "Hessu"
pelaajan_pisteet = 4.8
Kuten muistamme, muuttujat ovat sopimuksia ihmisen ja koneen välillä siitä, mitä milläkin muuttujan nimellä tarkoitetaan. Koska tietokone ei juurikaan välitä nimistä, sinulla on mahdollisuus valita nimet siten, että helpotat omaa työtäsi mahdollisimman paljon. Konetta ei kiinnosta mikä on numeron 1337 merkitys, mutta sinua todennäköisesti kiinnostaa. Se kannattaa siis nimetä siten, että myöhemminkin koodia lukiessa on selvää mitä se merkitsee. Jos kyseessä on esimerkiksi matkan pituus, x ei ole kuvaava nimi. Usein myös jonkun muun pitää itsesi lisäksi lukea koodia. Kurssin assistenteilta saa apua nopeammin, jos koodisi muuttujanimet ovat selkeitä.
Muuttujien
nimeäminen on myös hyvä litmustesti sille, oletko itse ymmärtänyt koodiasi. Jos nimittäin et osaa antaa jonkin
lausekkeen
lopputulokselle sopivaa nimeä, on syytä miettiä oletko ymmärtänyt ylipäätään, mitä kyseinen lauseke tekee.
Kuvalähde 2
Tällä kurssilla seurataan Pythonin tyylioppaan mukaisia suosituksia, minkä vuoksi nimille ehdotetaan seuraavaa: muuttujien nimet kirjoitetaan kokonaan pienillä kirjaimilla, ja monisanaisissa nimissä yksittäiset sanat erotetaan toisistaan alaviivalla. Siis tähän tapaan: aasin_korkeus = 100. Poikkeuksena SI-yksiköt – mikäli käytät niitä, on parempi käyttää oikeaa tunnusta, jolloin se saattaa joskus olla iso kirjain pienen sijaan. SI-yksiköistä tietenkin tällä tavoin voi käyttää vain niitä, joiden symboli löytyy englanninkielisistä aakkosista.

Liikettä laudalla

Joku materiaalinsa huonosti lukenut huumoriveikko on nimennyt ohjelmansa muuttujat todella nokkelasti. Ihmiskunta tarvitsee sinua keksimään kuvaavammat nimet alla olevan koodinpätkän muuttujille.
Opittavat asiat:
Muuttujien
nimeäminen.
Alustus:
Alla on lautasankarin kirjoittama koodirivi. Koska käytetyistä nimistä ei voi oikein päätellä mitään, paljastettakoon sen verran, että kyseessä on liike-energian kaava.
dolan = 1 / 2 * spurdo * spardo ** 2
Haettu vastaus:
Kirjoita koodirivi vastauslaatikkoon käyttäen järjellisiä nimiä. Voit käyttää suureiden nimiä tai SI-symboleja - molemmat ovat hyvän tavan mukaisia - mutta ei sekaisin!
Kopioi rivi vastauslaatikkoon ja korvaa muuttujien nimet paremmilla.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Matematiikka laajenee silmissä

Tähän asti esitellyillä eväillä syntyy jo koodia, jolla voi ratkaista yksinkertaisia yhtälöitä ja harrastaa vähän muutakin matematiikkaa. Nelilaskinta vastaavaa toiminnallisuus on jo toki jotain, mutta yksinään sillä ei vielä saa paljoa aikaan. On siis laajennettava tajuntaamme.
Kuvalähde 3
Osaamistavoitteet: Tämän osion jälkeen tunnet matemaattiset perusoperaattorit. Myös koodirivien kirjoitus alkaa saada uusia piirteitä, kun samalla rivillä tehdään useampia asioita. Opimme myös, että koodilla on suoritusjärjestys, joka vastaa jotakuinkin matematiikkaa. Käsitteet kokonaisluku ja liukuluku tulevat tutuiksi, kuin myös niihin liittyvät komplikaatiot.

Operaatio neliöjuuri

Operaattori
on symboli, joka määrittää suoritettavaksi
operaation
(esim. matemaattisen operaation, kuten yhteenlasku, jolloin operaattori on +-merkki). Operaatiossa käytetään
operandeja
, jotka sijoittuvat operaattorin molemmin puolin, ja ovat siis arvoja joille operaatio suoritetaan.
Operaatio ja sen osat.
Yleisimpiä ohjelmoinnissa ovat matemaattiset operaattorit, joita käsitellään tässä materiaalissa, sekä loogiset operaattorit joita puolestaan pyöritellään ensi viikolla. Python tuntee matemaattiset perusoperaattorit tutuilla merkeillä: +, -, * ja / (yhteen-, vähennys-, kerto- ja jakolasku vastaavasti). Uupumaan jää lähinnä potenssiin korotus sekä juuri. Molemmat tehdään itse asiassa samalla operaattorilla: **. Sinänsä loogista, koska juuren ottaminen vastaa potenssiin korotusta luvulla, joka on pienempi kuin yksi:
kuution_tilavuus = sivun_pituus ** 3
sivun_pituus = kuution_tilavuus ** (1 / 3)
Jakolaskuun liittyy vielä pari
operaattoria
, joille on ajoittain tarvetta. Ensinnäkin //-operaattori suorittaa kokonaislukujakolaskun. %-operaattori puolestaan antaa jakojäännöksen. Tutkitaan näitä lyhyesti tehtävän muodossa ja palataan niihin sitten, kun niille on konkreettisempaa tarvetta (spoiler warning: kolmannessa materiaalissa).

Ei mitään jakoa?

Jakolasku on matemaattisista perusoperaatioista monimutkaisin, koska siihen liittyy pelkän tuloksen sijaan kaksi käsitettä: osamäärä ja jakojäännös. Molemmat ovat ohjelmoinninssa merkittäviä, joten tässä vaiheessa on hyvä tulla tietoiseksi siitä, millaisia eri jakolaskuoperaattoreita Pythonista löytyy.
Opittavat asiat: Tutustua Pythonin eri jakolasku
operaattoreihin
.
Alustus:
Laske seuraavat laskut
tulkissa
:
In [1]: 19 / 4
In [2]: 19 // 4
In [3]: 19 % 4
Haettu vaustaus:
Kirjoita vastauslaatikkoon kunkin
operaation
lopputulos, joka
tulostuu
tulkkiin.
Kerro tulokset vastauslaatikkoon samassa järjestyksessä.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Kuten matematiikassa,
operaattoreilla
on myös Pythonissa
suoritusjärjestys
. Matemaattisten operaattoreiden osalta järjestys on tuttu: kerto- ja jakolaskut ensin, sitten yhteen- ja vähennyslaskut, aina vasemmalta oikealle. Suoritusjärjestystä voi muuttaa totuttuun tapaan suluilla, jolloin suluissa olevat kokonaisuudet suoritetaan ensin. Suoritusjärjestystä ja lisätietoa operaattoreista voi tutkailla Pythonin dokumentaatiosta. Dokumentaation lukeminen yleisesti ottaen on yksi keskeinen ohjelmointitaito.

Kahdenlaisia numeroita

Matematiikassa lukuja jaetaan erilaisiin ryhmiin, kuten kokonaislukuihin ja desimaalilukuihin. Tämä jako on myös ohjelmoinnissa tärkeä. Luvut erotetaan toisistaan siten, että desimaaliluvuissa on desimaalipiste. Näinpä siis 5 olisi kokonaisluku, mutta 5.0 olisi desimaaliluku. Suomalaisille tuttu desimaalipilkku ei siis ole käytössä, sillä pilkulla on aivan eri merkitys Pythonissa.
Jos ollaan aivan tarkkoja, tietokoneet eivät käsittele kovinkaan hyvin aitoja desimaalilukuja johtuen siitä, että niiden sielunelämä muodostuu pohjimmiltaan nollista ja ykkösistä. Tästä syystä ei olekaan tapana puhua desimaaliluvuista, vaan
liukuluvuista
(floating point number, float).
87.41871478 # Tässä on liukuluku
Liukuluku on desimaaliluvun approksimaatio. Se ei siis ole täysin tarkka. Tyypillisesti epätarkkuudet ilmenevät niin monen desimaalin jälkeen, että käytännön sovelluksissa liukulukujen tarkkuus on aivan riittävä, koska tuloksia pyöristetään joka tapauksessa.
Kuutiojuuri 64:stä otetaan esimerkiksi lausekkeella 64 ** (1 / 3), ja tuloksen pitäisi olla tasan 4. Liukulukujen epätarkkuus nostaa kuitenkin tässä päätään, ja tulos on (koneella jolla materiaalia kirjoitettiin) 3.9999999999999996. Asiasta voi lukea tarkemman kuvauksen Pythonin omasta tutoriaalista mikäli yksityiskohdat kiinnostavat. Heitto ei ole hälyttävä ottaen huomioon, että pyöristämällä saadaan 4.0, ja virhekin on niin monen desimaalin takana, että laskutoimituksia saa suorittaa melkoisen määrän ennen kuin lopputulos eroaa tarkasta.
On silti yksi tapa saada merkittävä virhe aikaan hyvin nopeasti. Ohjelmoinnissa on ajoittain tarpeellista
muuttaa lukuja
toisen tyyppiseksi. Useammin niin päin, että
liukuluvusta
täytyy saada kokonaisluku johonkin sellaiseen tarkoitukseen, mihin liukuluvut eivät kelpaa.
Havainnollistavana esimerkkinä otettaakoon kuvaruudun koordinaatit. Kuvaruutu muodostuu fyysisesti pikseleistä, joten se on diskreetti koordinaatisto (verrattuna jatkuvaan koordinaatistoon - toinen ero on, että origo sijaitsee vasemmassa yläkulmassa ja y-akselin positiivinen suunta on alaspäin). Esimerkiksi hiiren kursorin kärki osoittaa aina jotain pikseliä, eikä se voi koskaan olla pikselien välissä. Graafisten objektien sijaintia ruudulla ei siis voi käsitellä desimaalilukuina. Kun siis ohjelmakoodi laskee graafisen objektin sijaintia tai kokoa, sen täytyy muuttaa numeroarvot kokonaisluvuiksi ennen objektin piirtämistä.
Muunnos tapahtuu Pythonissa kahdella
funktiolla
: int ja float. Nimensä ne saavat englannin kielen sanoista integer (kokonaisluku) ja floating point number (liukuluku). Palataan kohta siihen, mitä funktiot ovat.
In [1]: float(4)
Out[1]: 4.0
In [2]: int(4.0)
Out[2]: 4
Näyttää aika yksinkertaiselta. Mutta?

Kokonaisuuden äärellä

Muuntaminen kokonaisluvuksi ja pyöristys eivät ole aivan samoja asioita, kuten tästä tehtävästä ilmenee...
Opittavat asiat: Miten int-
funktio
käsittelee desimaaliosaa.
Alustus:
Tässä lyhyessä tehtävässä sinun ei tarvitse tehdä muuta kuin muuttaa aiemmin esillä ollut luku 3.9999999999999996 kokonaisluvuksi. Voit kokeilla tätä
tulkissa
käyttämällä int-funktiota.
Haettu vastaus:
Kopioi
funktiokutsun
tulos vastauslaatikkoon.
Kirjoita saamasi tulos alla olevaan kenttään.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Äärimmäisen tärkeä fakta int-funktion toiminnasta: se palauttaa luvusta sen kokonaislukuosan. Mitään pyöristystä ei tapahdu. Saman tuloksen saa aikaan suorittamalla kokonaislukujakolaskun ykkösellä eli 3.9999999999999996 // 1. Jos siis lähdetään muuttamaan
liukulukuja
tuottavan laskun lopputulosta suoraan kokonaisluvuksi, voidaan saada kertaheitolla aikaan hyvin suuri virhe. Lopputulos pitäisikin pyöristää ensin jollain tapaa, mihin tarvitsemme uusia työkaluja.

Funktiot - uhka vai mahdollisuus?

Seuraavaksi esiintymisvuorossa ovat funktiot (engl. function), joita myös joissain yhteyksissä aliohjelmiksi kutsutaan. Terminä funktio voi olla tuttu matematiikasta. Yleisimpänä ilmentymänä merkintä f(x). Merkintä siis määrittelee lausekkeen, jonka lopputulos riippuu x:n arvosta. Tämä on hyvä lähtökohta ohjelmoinnissa esiintyvien funktioiden ymmärtämiseen.
Osaamistavoitteet: Tämä osio tekee funktion käsitteen tutuksi: mitä funktiot ovat, miksi niitä on, missä niitä on ja miten niitä käytetään. Opimme myös, miten funktio on toisaalta erillinen osa ohjelmaa, mutta toisaalta kommunikoi muun ohjelman kanssa. Lisäksi muutama perusfunktio tehdään tutuksi.

Funktioiden syvin olemus

Funktiot
ovat kierrätystä kauneimmillaan. Jos on jo olemassa koodinpätkä, joka tekee tietyn asian, on turhaa ryhtyä keksimään pyörää uusiksi. Funktioita löytyy Pythonin sisältä ns.
sisäänrakennettuina funktioina
sekä todella lukuisista
moduuleista
ja
kirjastoista
. Funktioita voi tuottaa myös itse, mikä on äärimmäisen hyvä tapa. Niin hyvä, että se kannattaa omaksua heti ohjelmoinnin opettelun alussa. Alla olevaa esimerkkiä ei tarvitse ymmärtää, mutta se antaa esimakua siitä, mitä on pian odotettavissa, kun pääsemme työstämään omia funktioitamme:
def laske_keskiarvo(arvot):
     return sum(arvot) / len(arvot)

keskiarvo = laske_keskiarvo((6, 8, 10, 7, 9, 8, 5, 7))
Ideaalisesti
funktio
muodostaa toiminnallisen, eristetyn kokonaisuuden. Toisin sanoen siis funktion toiminta ei ole riippuvainen sen ulkopuolella olevasta koodista. Tämä tarkoittaa, että funktion voi ottaa käyttöön missä tahansa ja odottaa, että se toimii aina samalla tavalla. Pythonin
sisäänrakennetut funktiot
ovat luonnollisesti juuri tällaisia. Niihin kuuluvat myös aiemmin käytetyt int ja float. Vastaavasti ohjelmoijan ei tarvitse tietää mitään funktion sisäisestä toiminnasta vaan hänelle riittää tietää, miten sitä käytetään. Tässä auttaa yleensä funktion dokumentaatio, jonka tehtävä on kertoa kaikki oleellinen funktion toiminnasta.
Vaikka ideaalinen funktio elääkin eristyksissä, se ei tarkoita, etteikö sillä olisi keinoja viestiä ulkomaailman kanssa. Tämän viestinnän ymmärtäminen on keskeistä funktioiden oppimisessa. Funktio on muun ohjelman näkökulmasta musta laatikko. Sinne menee jotain sisään, ja jotain tulee ulos. Sattumoisin nämä kaksi kanavaa, sisään ja ulos, ovat myös se
rajapinta
, jonka avulla muu koodi kommunikoi funktion kanssa.
Funktioiden kohdalla puhutaan
kutsumisesta
(engl. call). Tässä prosessissa on kaksi osapuolta: kutsuja ja kutsuttava. Kutsuttavalla tarkoitetaan funktiota, jota halutaan käyttää. Kutsuja puolestaan on se osa ohjelmaa, joka funktiota tarvitsee.
Kuvalähde 4
Kutsuttaessa käytetään
funktion
määrittelemää rajapintaa. Tämä määrittää säännöt, millaista tavaraa funktiolle voi antaa, ja myös sen, mitä sieltä voi odottaa saavansa takaisin. Funktion itsensä kannalta tärkeää on se, että kutsuja noudattaa määrittelyjä siitä, millaisten asioiden antaminen sille on sallittua.
Tiedämme toistaiseksi int-funktiosta sen, että sille annetaan lukuarvo, josta se palauttaa sitten takaisin sen kokonaislukuosan. Sovitaan siis, että olemme laskemassa liikkuvan objektin liikettä x-akselilla koordinaatistossa. Tämä tapahtuu kertomalla objektin suuntavektorin x-komponentti (esim. 0.32) objektin nopeudella (esim. 10 yksikköä).
nopeus = 10
suunta_x = 0.32
liike_x = int(suunta_x * nopeus)
Esimerkkiä itsessään ei ole välttämätöntä sisäistää. Kyseessä on vain skenaario, jossa luvun muuttamista kokonaisluvuksi saattaa oikeasti tarvita ja johon törmätään esimerkiksi pelikoodauksessa. Keskeistä on kolmas rivi, jossa esiintyy
funktion
kutsuminen. Sulkujen sisällä oleva osa on siis se, mitä funktiolle annetaan käsiteltäväksi. Huomion arvoista suoritusjärjestyksestä on se, että lauseke suunta_x * nopeus suoritetaan ensin, joten funktio saa käsiteltäväksi kertolaskun tuloksen (eli 3.2). Kun funktio sitten suorittaa työnsä, pölyn laskeuduttua liike_x-muuttujaan jää sijoitettavaksi kokonaislukuarvo 3. Alla oleva animaatio visualisoi funktiokutsun toimintaa.
Funktiolle annetaan siis ikään kuin uhrilahja sulkujen sisällä. Vastalahjaksi sen paikalle jää funktiokutsun lopputulos.

Squareception

Yksi osa ohjelmointia on olla sujut sen sanaston kanssa. Tässä tehtävässä käsittelemme kahta keskeistä käsitettä: argumenttia ja paluuarvoa.
Opittavat asiat: Tässä tehtävässä pääset pohtimaan
argumenttien
ja
paluuarvojen
rooleja
funktiokutsussa
.
Alustus:
Voit kirjoitella seuraavat koodirivit
tulkkiin
tai muuten vain pohdiskella niitä:
In [1]: sivu_pieni = 8
In [2]: sivu_iso = 3493
In [3]: kpl_per_sivu = int(sivu_iso / sivu_pieni)
Koodirivit liittyvät laskentaan, jossa halutaan selvittää kuinka monta kokonaista pienempää neliötä mahtuu suuremman sisään.
Haettu vastaus:
Vastaukseen halutaan kaksi numeroarvoa (alekkain). Ensimmäinen kertoo mitä lukuarvoa int-funktio käsittelee eli mikä on sille annettu argumentti. Toinen kertoo mitä funktio
palauttaa
.
Tehtävänäsi on kertoa, mitä arvoa int-funktio käsittelee, ja mitä se palauttaa. Anna vastaukset numeroina alekkain, mainitussa järjestyksessä.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Mahdollisuuksien maailma

Päädyimme alunperin ihmettelemään funktioita, koska halusimme muuttaa lausekkeen 64 ** (1 / 3) tuloksen kokonaisluvuksi oikein. Pelkkä int(64 ** (1 / 3)) antoi hämmentävästi arvon 3. Syy selvisi, mutta ratkaisu ei.
Funktioita
on Pythonin mukana lukuisia, kuten voimme todentaa esimerkiksi Pythonin dokumentaatiosta. Kurssin alkupuolella leikimme pitkälti tuolta sivulta löytyvillä funktioilla, emmekä niistäkään läheskään kaikilla. Englannin osaamisesta on yleensä hyötyä ohjelmoinnissa. Tälläkin kertaa auttaa, kun tiedämme, että pyöristämistä tarkoittava sana on round.
Seuraavaksi vuorossa on lyhyt opastus siihen, miten funktion kuvauksia luetaan. Otetaan siis malliksi tarkoitukseemme sopiva round.
Kuvassa round-funktion dokumentaatio.
Ensimmäinen rivi, jolla on
funktion
nimi, on tärkeä. Juuri tämä rivi kertoo millä tavalla funktiota voi kutsua. Suluissa olevat sanat, number ja ndigits, ovat nimityksiä funktion vastaanottamille
arvoille
, ja nimitykset tyypillisesti pyrkivät jollain tapaa kuvaamaan sitä, millainen annettavan arvon tulee olla. Funktion vastaanottamista arvoista ensimmäinen on tässä tapauksessa pyöristettävä luku ja toinen desimaalien lukumäärä, jonka tarkkuuteen pyöristetään.
Näitä nimityksiä funktion vastaanottamille arvoille, number ja ndigits, kutsutaan
parametreiksi
. Kun puolestaan käytämme eli kutsumme funktiota ja annamme sille jonkun tietyn pyöristettävän luvun ja tietyn desimaalien lukumäärän (esimerkiksi 3.56 ja 1), kyseisiä arvoja kutsutaan
argumenteiksi
.
In [1]: round(3.56, 1)
Entä nuo hakasulut ndigits-parametrin ympärillä? Kyseessä on dokumentaatiossa käytetty merkintätapa, jolla ilmaistaan, että kyseisen arvon antaminen on vapaaehtoista. Se voidaan siis jättää pois funtkiota kutsuttaessa. Teksti myös kertoo, mitä tapahtuu, jos ndigits-parametria vastaava arvo jää kutsuta pois: funktio pyöristää nollan desimaalin tarkkuuteen. Nämä ovat siis identtisiä:
In [1]: round(4.451, 0)
Out[1]: 4.0
In [2]: round(4.451)
Out[2]: 4.0
Koska ensimmäisen rivin , 0 sulkujen sisällä on käytännössä tarpeetonta merkitä, tapana on jättää se kirjoittamatta. Näin menetellään yleensä aina, jos halutaan
funktion
käyttäytyvän sen omien
oletusarvojen
mukaisesti. Valinnaiset argumentit annetaan siis vain silloin, kun niiden halutaan poikkeavan oletusarvosta:
In [1]: round(4.451, 2)
Out[2]: 4.45
Kun
funktiolle
annetaan useita
argumentteja
, ne erotetaan aina toisistaan pilkulla. Tapana on myös, kuten tekstiäkin kirjoittaessa, laittaa yksi välilyönti jokaisen pilkun jälkeen. Tässä esimerkissä siis number-
parametri
saa arvonsa argumentista 4.451 ja vastaavasti ndigits-parametri saa
arvonsa
argumentista 2. Parametri ja argumentti eivät ole sama asia; niillä ainoastaan viitataan samaan arvoon.

Pyöreä nolla

Funktiokutsujen kirjoittaminen on yksi yleisimpiä asioita ohjelmoinnissa. Niitä on siis hyvä harjoitella. Toistuvasti.
Opittavat asiat:
Funktiokutsun
kirjoittaminen käyttäen useaa
argumenttia
.
Haettu vastaus:
Minkälaisella koodirivillä pyöristäisit round-
funktiota
käyttäen luvun 0.123456 neljän desimaalin tarkkuuteen?
Kirjoita käyttämäsi funktiokutsu alle.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Funktiot käytössä

Nyt voimme viimein kirjoittaa koodinpätkän, jolla lausekkeen 64 ** (1 / 3)
arvo
saadaan kokonaislukuna oikein.
tulos = round(64 ** (1 / 3))
tulos = int(tulos)
Sama asia voidaan myös ilmaista yhdellä rivillä, mikä on tässä tapauksessa oikeastaan suotavampaa:
tulos = int(round(64 ** (1 / 3)))
Suoritusjärjestys seuraa edelleen tuttuja periaatteita: sisempi
funktiokutsu
käsitellään ensin. Koska rivillä on jo aika paljon asioita, seuraava animaatio vielä havainnoillistaa suoritusjärjestyksen.
Se, kirjoittaako asioita paljon samalle riville vai jakaako niitä
muuttujien
käytöllä usealle, on pitkälti itsestä kiinni. Tärkeintä on luettavuus, mistä syystä on vältettävä liian pitkiä ja monimutkaisia rivejä. Toisaalta vastaavasti on syytä välttää jatkuvaa muuttujiin sijoittelua, koska tämä vaikeuttaa koodista oleellisen löytämistä.
Nyt tiedämme siis, mitä
funktiot
ovat, mistä niitä löytyy ja vieläpä senkin miten niitä koodissa käytetään. Seuraavaksi tutustutaan tarkemmin funktioiden käyttöön ja esitellään muutamia kurssin kannalta keskeisiä funktioita.
Ensimmäisenä tutkimuskohteena on se, miten
kooditiedostoja
ajattaessa saadaan jotain näkyviin.
Tulkissa
toimiessahan erinäisten
operaatioiden
lopputulokset tulostuvat näkyviin, ellei niitä
tallenna
muuttujiin
. Tulkki siis suorittaa koko lausekkeen, ja lopulta näyttää sen lopputuloksen. Kuten opittiin aloitusviikolla, kooditiedostot puolestaan eivät näytä rivien suorittamisen tuloksia automaattisesti, vaan käytännössä heittävät ne roskiin. Niinpä esimerkiksi kooditiedostossa rivi
4451 + 1337
ei käytännössä tee yhtään mitään. Tuottaahan se tuloksen (5788), mutta sillä ei tehdä mitään, joten se katoaa välittömästi bittiavaruuden syövereihin. Yleensä ohjelmien suorituksesta olisi kuitenkin hyödyllistä nähdä lopputuloksia, joten tarvitaan keino saada niitä näkyviin. Avuksi hätään rientää print-funktio (jos olet aiemmin opiskellut Pythonin kakkosversiota käyttämällä, vieraile täällä). Otetaan yksinkertainen käyttöesimerkki:
tulos = int(round(64 ** (1 / 3)))
print(tulos)
tai ilman muuttujaan sijoitusta välissä:
print(int(round(64 ** (1 / 3))))
Yksinkertaisimmillaan print-funktio on
funktio
, joka tulostaa sille annetun
argumentin
, ja rivinvaihdon perään. Jos koodissa on siis monta print-funktiokutsua, jokainen niistä tulostaa saamansa argumentin eri riville.

Tulostuspalvelu

Toisin kuin tulkissa toimittaessa, kooditiedostoja suoritettaessa näytölle ei automaattisesti tulostu erinäisten operaatioiden lopputuloksia. Tässä tehtävässä opettelemme, miten kooditiedostosta saadan tulosteita näkyviin näytölle suorituksen aikana.
Opittavat asiat: Näytölle tulostaminen kun koodia suoritetaan
kooditiedostosta
.
Tavoite: Saada annettu ohjelma tulostamaan laskemiaan tuloksia.
Ennen kuin aloitat:
Alempana on tiedosto, jossa suoritetaan muutamia perusmekaanikan mukaisia laskutoimituksia. Lataa tiedosto klikkaamalla linkkiä oikealla hiirennäppäimellä ja suorita se. Ongelmana on, että laskutoimituksien tulokset eivät näy.
Voit kerrata Python-tiedostojen suorittamisen täältä.
Muokattava pääohjelma:
Tehtäväsi on nyt lisätä tiedoston kahdelle viimeiselle riville print-
funktiokutsut
siten, että nämä rivit, jotka eivät aiemmin tehneet mitään, tulostetaan.
Resurssit:
kiihtyvyys.py
x_0 = 50
v_0 = 100
a = 10
t = 5

v_0 + a * t
x_0 + v_0 * t + 0.5 * a * t ** 2

Palauta tulostava koodi tänne.

Sallitut tiedostojen nimet

Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Näin alussa, kun käsittelemme pelkkiä numeroita, muut käyttökelpoiset funktiot print-funktion ohella ovat lähinnä matemaattisia. Näitä ovat muun muassa minimin, maksimin sekä itseisarvon ottaminen: min, max ja abs. Pythonin mukana tulee enemmänkin matemaattisia funktioita, mutta ne on niputettu omaan
moduuliinsa
.
Terminaalissa
työskennellessä yksi kätevä funktio on help. Ilman mitään argumentteja se avaa interaktiivisen aputoiminnon. Jos sille taas antaa
argumentiksi
funktion nimen, saa tietoja funktion toiminnasta. Seuraava kutsu tulostaisi tietoa round-funktiosta:
help(round)
Tyypillisesti nämä help-funktion tulosteet ovat lyhyempiä kuin dokumenttisivulla olevat ja sisältävät vähemmän yksityiskohtia. Käyttämällä help-funktiota voi kuitenkin nopeasti muun muassa katsoa, mitkä argumentit funktiolle pitää tai voi antaa. Ohjeista pääsee pois painamalla Q.

Funktioiden salatut elämät

Funktioita
osataan nyt alustavasti käyttää. Seuraavaksi on edessä matka kuun pimeälle puolelle, missä funktioita tehdään itse. Samalla käydään läpi
kooditiedoston
rakennetta.
Osaamistavoitteet: Tämän osion jälkeen tunnet funktion määrittelyyn liittyvän syntaksin ja tiedät, miten funktion sisällä oleva koodi eroaa muusta koodista. Lisäksi muuttujien ja niiden arvojen käyttäytyminen funktiota kirjoittaessa ja kutsuttaessa selkenevät. Lisäbonuksena opit, miten kooditiedosto kannattaa järjestää ja miksi.

Funktion rakennuspalikat

Funktion
sisältö itsessään on aivan tavallista koodia. Funktioiden kirjoittamiseen liittyy kuitenkin kaksi erityistä
lausetta
. Näistä ensimmäinen on def, jolla aloitetaan funktion määrittely. Toinen puolestaan on return, joka määrää sen, mistä kohdasta funktiokoodia palataan takaisin
funktiota kutsuneelle
riville ja mikä
arvo
sinne
palautetaan
. Funktiokoodi erotetaan muusta koodista sisentämällä def-lauseen jälkeen. Otetaan havainnollistava esimerkki avaamaan näitä käsitteitä:
def laske_matka(nopeus, aika):
    return nopeus * aika
Tämä funktio on hyvin yksinkertainen. Sen ensimmäinen rivi kertoo Pythonille
avainsanalla
def (lyhennös sanasta define, määrittää), että tästä kohtaa alkaa funktion määrittely. Seuraava rivi on
sisennetty
, mikä kertoo, että sille kirjoitettu koodi sijaitsee funktion sisällä, eristyksissä muusta koodista. Puretaan kuitenkin def-riviä lisää. Siihen kuuluu kolme merkittävää komponenttia: itse def-sana, funktion nimi ja funktion parametrit.
Funktioiden
nimeämisessä on samat säännöt ja pitkälti samat suositukset kuin
muuttujien
nimissä. Funktioiden nimille on kuitenkin tyypillistä, että ne niissä on verbi. Tämä korostaa sitä, että funktio tekee jotain. Toinen hyvin tyypillinen tapa erottaa, milloin kyseessä on muuttuja ja milloin funktio, on se, että sekä määritellessä että kutsuttaessa funktion nimeä seuraavat välittömästi sulut.
matka = laske_matka(100, 2) # matka on muuttuja, laske_matka puolestaan funktio
Funktion määrittelyrivillä olevat sulut sisältävät funktion parametrien nimet, tässä tapauksessa siis nopeus ja aika, pilkulla erotettuna. Määrittelyrivi päättyy aina kaksoispisteeseen. Kaksoispisteellä on Pythonissa syntaktinen merkitys: sitä seuraava rivi tulee olla
sisennetty
.
Lopuksi funktioon kuuluu yleensä rivi, joka alkaa sanalla return. Tämä rivi merkitsee kohtaa, jossa funktion suorittaminen päättyy. Lisäksi se kertoo, mitä funktio
palauttaa
lopputuloksenaan. Se siis määrittelee funktion toisen liittymäkohdan muuhun ohjelmaan siinä, missä funktion määrittelyrivillä olevat
parametrit
määrittävät ensimmäisen.

Energinen funktio

Omien funktioiden määrittely on keskeinen osa ohjelmointia. Tähän liittyy oikean syntaksin opettelu sekä yksi keskeinen käsite: parametri.
Opittavat asiat:
Funktion
määrittely ja siihen liittyvät termit.
Haettu vastaus:
Kirjoita määrittelyrivi, jolla aloittaisit uuden funktion kirjoittamisen. Funktion nimen tulee olla laske_energia ja sillä tulee olla kaksi pakollista
parametria
: massa ja nopeus (tässä järjestyksessä).
Kirjoita määrittelyrivi kokonaisuudessaan alle.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Parametristä argumentaatiota

Funktioiden kanssa pelatessa keskeiset käsitteet ovat
parametri
ja
argumentit
. Nämä ovat oikeastaan kaksi eri nimitystä samalle
arvolle
. Parametri on paikallinen muuttuja - nimi, jolla kutakin argumenttia kutsutaan funktion sisällä. Argumentti puolestaan on literaaliarvo tai muuttuja, jonka arvon parametri saa.

Paramestari

Alla on esitetty ohjelma, joka laskee lieriön ominaisuuksia. Tehtävänä on tunnistaa mitkä ohjelmassa käytetyt nimet kuuluvat parametreille
PI = 3.1416

def laske_tilavuus(sade, korkeus):
    tilavuus = korkeus * PI * sade ** 2
    return tilavuus

def laske_ala(sade, korkeus):
    ala = 2 * PI * sade ** 2 + 2 * PI * sade * korkeus
    return ala

pituus = 10
sade_paaty = 2
print(laske_tilavuus(sade_paaty, pituus))
print(laske_ala(sade_paaty, pituus))
Valitse vaihtoehdoista nimet jotka kuuluvat parametreille.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Argumenttien
ja
parametrien
järjestys määrää sen, mihin parametriin kunkin argumentin
arvo
sijoitetaan. Huomioitavaa on, ettei arvokaan varsinaisesti siirry mihinkään. Funktion sisällä näihin arvoihin aletaan vain
viitata
käyttämällä parametrien nimiä. Argumenttien ja parametrien käytöstä valaisee seuraava animaatio.

Parametrista diskriminaatiota

Funktiokutsussa arvojen välittyminen parametreille on jälleen yksi prosessi, joka on syytä ymmärtää hyvin. Luonnollisesti pitäisi myös sisäistää mitä nämä arvot ja parametrit ylipäätään ovat... Asiaan perehdytään tässä tehtävässä.
Opittavat asiat: Tutustumme
funktiokutsuun
liittyviin
arvon
ja
parametrin
käsitteisiin sekä niiden suhteeseen.
Alustus:
Alla on esitetty
funktion
määrittely sekä lyhyt koodipätkä, joka kutsuu funktiota. Funktiota voidaan käyttää koodissa, joka selvittää kuinka monta ratkaisua toisen asteen yhtälöllä on.
def laske_diskriminantti(kerroin_1, kerroin_2, vakio):
    diskriminantti = kerroin_2 ** 2 - 4 * kerroin_1 * vakio
    return diskriminantti

print(laske_diskriminantti(5 - 8, 4 * 3, 13))
Haettu vastaus:
Tehtävänäsi on kertoa, mitä
arvoja
funktion
parametrit
saavat. Kirjoita vastauksesi muodossa
kerroin_1 = ?
kerroin_2 = ?
vakio = ?
Eli korvaa kysymysmerkit kunkin parametrin arvolla.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Tärkeä konsepti parametrien ymmärtämisessä on muuttujien paikallisuus. Paikalliset muuttujat eivät näy oman kontekstinsa - tässä tapauksessa funktion - ulkopuolelle. Muun ohjelman näkökulmasta ne eivät ole olemassa. Kahden eri funktion sisällä voi olla saman nimisiä muuttujia eivätkä ne millään tapaa sotke toistensa toimintaa. Pääohjelman muuttujat sen sijaan näkyvät kaikkialle, mutta niihin ei voi kirjoittaa muualla kuin pääohjelmassa. Jos funktion sisällä sijoitetaan muuttujaan, jonka nimi on jo pääohjelmassa käytössä, luodaan itse asiassa vain saman niminen paikallinen muuttuja. Paikalliset muuttujat myös lakkaavat olemasta heti kun funktion suoritus päättyy.

Paikallisen asiantuntija

Tässä yksinkertaisessa tunnistustehtävässä on tarkoitus löytää annetusta kooditiedostosta kaikki paikalliset nimet.
def laske_suuntavektori(x0, y0, x1, y1):
    pituus = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
    ux = (x1 - x0) / pituus
    uy = (y1 - y0) / pituus
    return ux, uy

def laske_sijainti(suunta_x, suunta_y, nopeus):
    x = suunta_x * nopeus
    y = suunta_y * nopeus
    return x, y

liikenopeus = 5
alku_x = 2
alku_y = 6
kohde_x = 10
kohde_y = 12
vektori_x, vektori_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
uusi_x, uusi_y = laske_sijainti(vektori_x, vektori_y, liikenopeus)
print(uusi_x)
print(uusi_y)
Alla on listattu kaikki koodissa olevat nimet. Valitse kaikki paikalliset nimet.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Kuvalähde 5

Paluumatkan vuoro

Siinä missä
funktiokutsussa
funktion sisälle välitetään
dataa
argumenttien
ja
parametrien
avulla, vastaavasti funktiosta saadaan dataa takaisin
paluuarvon
kautta. Paluuarvo määritellään return-
avainsanalla
alkavalla rivillä, kuten ylläolevassa tehtävässä. Tässäkin on oleellista pitää mielessä
muuttujan
ja
arvon
ero: mitään funktion sisällä olevaa muuttujaa ei vapauteta ulkomaailman käsiteltäväksi. Paluun yhteydessä määritetään ainoastaan arvo, jota funktion kutsuja voi käyttää haluamallaan tavalla. Aiempi esimerkki hieman muunneltuna:
def laske_matka(nopeus, aika):
    matka = nopeus * aika
    return matka

v = 100
t = 0.6
s = laske_matka(v, t)
Koodissa
funktio
palauttaa
viittauksen
matka-muuttujan sisältämään
arvoon
(ts. siihen arvoon, johon matka-muuttuja viittaa). Viimeisellä rivillä funktion ulkopuolella tälle viittaukselle annetaan nimi s. Siis matka-muuttuja ei karkaa funktion ulkopuolelta mihinkään, ja itse asiassa se lakkaa olemasta kokonaan funktion suorittamisen jälkeen, koska sitä ei enää tarvita. Sen sijaan viimeisen rivin suorituksen jälkeen on olemassa muuttuja s, joka sisältää saman arvon kuin matka-muuttuja funktion suorituksen päättyessä.
Funktio voi myös palauttaa useita arvoja. Yksi tällainen funktio on divmod, joka suorittaa kokonaislukujakolaskun ja palauttaa sekä osamäärän että jakojäännöksen. Funktion palauttessa useita arvoja ne voidaan sijoittaa useaan muuttujaan kirjoittamalla oikea määrä muuttujia pilkulla erotettuna
sijoitusoperaattorin
vasemmalle puolelle:
In [1]: jaettava = 10
In [2]: jakaja = 3
In [3]: osamaara, jakojaannos = divmod(jaettava, jakaja)
In [4]: print(osamaara)
3
In [5]: print(jakojaannos)
1
Sama temppu nähtiin jo hetki sitten tehtäväesimerkissä kun palautettiin 2-ulotteisen vektorin komponentit funktiosta. Koska sijoituksen oikealla puolen on sijoitusvaiheessa oikeastaan vain kaksi lukuarvoa, loogisesti pitäisi olla myös mahdollista sijoittaa suoraan kahteen muuttujaan kaksi
literaaliarvoa
, ja onkin:
In [1]: jaettava, jakaja = 10, 3
Jos edelleen pidetään mielessä, että funktiokutsu on suorituksen jälkeen pelkkä paluuarvo, funktiota kutsuvalla rivillä voidaan
sijoituksen
sijaan myös luovuttaa yhdeltä funktiolta saatu paluuarvo eteenpäin toiselle funktiolle
argumenttina
, kuten eräässä aiemmassa esimerkissä tehtiin:
tulos = int(round(64 ** (1 / 3)))

Funktioiden kirjoittamisesta

Funktiot
vaikuttavat sisältävän valtavasti ymmärrettävää asiaa. Mikä niistä tekee vaivan arvoisia?
Toivottavasti tämä listauksen seurauksena koet funktioiden hyödyistä vastaavanlaisen ahaa-elämyksen kuin alla.
Kuvalähde 6
Ideaali funktioiden rajaamisessa on se, että funktio tekee yhden asian. Funktion nimestä tulisi myös selkeästi ilmetä mikä tämä yksi asia on. Jos nämä tavoitteet eivät täyty, joko funktio tekee liian paljon asioita tai se on huonosti nimetty.
Toinen ideaali funktioiden kanssa on se, että ne ovat mahdollisimman uusiokäytettäviä. Jos siis ohjelmassa tehdään useassa kohtaa samankaltaisia asioita, ideaalitapauksessa ne kaikki voidaan hoitaa samalla funktiolla. Funktion uusiokäytettävyyteen vaikuttaa erityisesti
parametrien
valinta. Laskutoimituksissa kaikki kaavaan liittyvät tuntemattomat tekijät kannattaakin käsitellä funktion
argumentteina
, kuten laske_matka-esimerkissämme.

Funktioiden sijoittelusta

Funktioiden
sijainnilla koodissa on merkitystä. Funktio luodaan sillä hetkellä, kun sen def-rivi suoritetaan. Funktion def-rivin tulee siis olla ennen koodia, joka funktiota käyttää. Funktioiden keskinäisellä järjestyksellä ei ole merkitystä. Niiden ryhmittelyyn kannattaa valita looginen tapa, joka miellyttää itseä eniten. Yleisesti ottaen funktioiden määrittelylle tulisi olla koodissa oma alueensa, jossa ei tehdä muuta kuin funktioiden määrittelyä.
Kooditiedosto voidaankin jakaa kolmeen lohkoon:
  1. alustuslohko, jossa tehdään erinäisiä valmisteluja
  2. funktiolohko, jossa määritellään funktiot
  3. pääohjelmalohko.
Kooditiedoston kolme osaa. Osien ei tulisi koskaan vuotaa rajojensa yli.
Alustuslohkossa tehdään asioita, joilla on merkitystä koko tiedoston kannalta. Tähän kuuluu lähinnä
vakioarvojen
määrittely ja
moduulien
käyttöönotto, johon perehdymme myöhemmin. Vakioista puhutaan lyhyesti seuraavassa osiossa. Funktiolohkossa määritellään
funktiot
: sinne siis kirjoitetaan def-lauseita ja niitä seuraavia sisennettyjä koodirivejä, jotka määrittävät funktion toiminnan.
Pääohjelmalohko on se, mistä ohjelman suoritus varsinaisesti alkaa. Sitä ennen kaikki funktiot pitäisi olla määritelty.
Pääohjelman
tulisikin lähinnä koostua muiden funktioiden
kutsumisesta
, jotta sen kulku on mahdollisimman selkeä. Joissain ohjelmointikielissä "pääohjelma" sijoitetaan erityiseen main-funktioon, ja ohjelman suoritus alkaa tästä funktiosta.

Kyselytunti

Oppimistavoitteet: Tämä osio tarjoaa eväät yksinkertaisten tulosteiden tekemiseen sekä perusteet kysymyksien esittämiseen käyttäjälle. Keskeinen ongelma on, miten käyttäjän näppäimistöltä saadaan numeroarvo ohjelman käsiteltäväksi.

Lisää vektorigeometriaa

Lähdetään liikkeelle aiemmasta esimerkistä. Aiemmassa tehtävässä esiteltiin koodinpätkä , jolla laskettiin suuntavektorteita sekä liikettä suuntavektorin ja nopeuden perusteella. Esimerkistä löytyy yksi ilmeinen vika helposti: jotta ohjelma toimisi kunnollisena vektorigeometrialaskimena, sille olisi varmaan hyvä saada syötettyä pisteitä muutenkin kuin muokkaamalla kooditiedostossa olevian muuttujien arvoja. Toiseksi ohjelma ei tällä hetkellä tulosta muuta kuin numeroita ilman mitään selitystä mitä ne ovat.
4.0
3.0
Käyttäjällä ei siis ole mitään käsitystä siitä, mistä nämä luvut tulevat tai mitä ne ovat. Ohjelmassa on siis ainakin kaksi selkeää parannuskohdetta: vektorin alku- ja loppupisteet pitäisi kysyä käyttäjältä, ja ohjelman pitäisi antaa ulos tietoa siitä, mitä sen tulosteet tarkoittavat.
Otetaan toistaiseksi koodista käyttöön pelkästään suuntavektorin laskeminen - sijainnin laskentafunktion voi kuitenkin jättää sinne myöhempää käyttöä varten. Kooditiedosto löytyy alta, jos olet sattunut sen unohtamaan. Siitä on myös poistettu rivit, jotka eivät liity suuntavektorin laskemiseen, ja lisätty suuntavektorin tulostus.
suuntavektori.py
def laske_suuntavektori(x0, y0, x1, y1):
    pituus = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
    ux = (x1 - x0) / pituus
    uy = (y1 - y0) / pituus
    return ux, uy

def laske_sijainti(suunta_x, suunta_y, nopeus):
    x = suunta_x * nopeus
    y = suunta_y * nopeus
    return x, y

alku_x = 2
alku_y = 6
kohde_x = 10
kohde_y = 12
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
print(suunta_x)
print(suunta_y)

Se puhuu!

Aloitetaan ohjelman suoritus siitä, että kerrotaan käyttäjälle seuraavaa: "Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla". Tämä vaatii jotain uutta eli kyvyn käsitellä tekstiä. Tekstin ohjelmointikielinen termi on
merkkijono
, mikä viittaa siihen, että merkkejä on siinä kiltisti peräkkäin. Voisi jopa sanoa, että siinä on merkkejä...
(•_•)
( •_•)>⌐■-■
(⌐■_■)
...jonossa. Englanniksi merkkijono on string ja lyhennetään yleensä str.
Toistaiseksi kirjaimia on käytetty asioiden nimeämiseen. Miten sitten Python erottaa, milloin on kyse nimestä, ja milloin merkkijonosta? Lainausmerkki on hyvin yksiselitteinen ohje Python-tulkille, että tästä kohtaa alkaa merkkijono. Merkkijono myös jatkuu seuraavaan lainausmerkkiin asti. Yksinkertaiset (') ja kaksinkertaiset (") lainausmerkit ovat molemmat käypiä kunhan merkkijono alkaa ja loppuu samalla lainausmerkillä. Lyhyesti koodilla esitettynä:
"merkkijono"
'toinen merkkijono'
muuttuja
Lainausmerkkien valintaan ei ole varsinaisesti mitään muuta sääntöä kuin "valitse yksi". Eli kumpaa tahansa käytätkin, pysy siinä. Me käytämme tässä materiaalissa "-merkkiä, koska se on muissa ohjelmointikielissä yleisempi. Itse asiassa joissain kielissä, kuten C, yksinkertaisilla lainausmerkeillä voidaan merkitä vain yksittäinen merkki ja merkkijono vaatii kaksinkertaiset lainausmerkit.
Merkkijono
on
tietotyyppi
, eli se kuuluu samaan joukkoon kokonaislukujen ja
liukulukujen
kanssa. Merkkijonot ovat siis
arvoja
, ja kaikki, mitä aiemmin todettiin arvoista, pätee ihan samalla tavalla merkkijonoihin kuin numeroihinkin (merkkijonoja tosin ei tietenkään voi esim. pyöristää). Merkkijonoja voi siis sijoittaa
muuttujiin
, ja voipa niille tehdä myös joitain
operaatioita
. Niitä voi myös tulostaa print-
funktiolla
ihan samalla tavalla kuin numeroita. Siispä aiemmin ehdotettu tuloste "Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla" saadaan ulos kun se annetaan print-funktiolle argumentiksi
argumentiksi
:
print("Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla")

Aasibileet

Opittavat asiat: Yksinkertaisen print-
funktiokutsun
kirjoittaminen.
Haettu vastaus:
Kirjoita koodirivi, joka tulostaa seuraavan tekstin: aasisvengaa.
Ai miksi? Koska pystyt siihen!
Syötä koodirivi alle.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Vektoriohjelmamme olisi hyvä kertoa, mitä vektorin komponentteja tulostettavat numerot ovat. Käyttäjälle pitäisi myös informoida, minkä pisteiden välisestä suuntavektorista on kyse, koska tällä hetkellä sitä ei näe mistään. Lisätään sopivat tulostukset
pääohjelmaan
:
print("Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla")
alku_x = 2
alku_y = 6
kohde_x = 10
kohde_y = 12
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
print("Aloituspiste (x y):", alku_x, alku_y)
print("Päätepiste (x y):", kohde_x, kohde_y)
print("Suuntavektori (x y):", suunta_x, suunta_y) 
Tähän esimerkkiin on myös ujutettu uusi tapa käyttää print-fuktiota: sille voidaan itse asiassa antaa enemmän kuin yksi tulostettava argumentti. Tarkalleen ottaen print on funktio, joka tulostaa kaikki argumenttinsa - joiden määrää ei ole mitenkään rajoitettu - välilyönnillä erotettuna yhdelle riville ja rivinvaihdoin loppuun (itse asiassa myös sekä erottimen että lopetusmerkinkin voi vaihtaa, mutta ei mennä sinne nyt). Jos ajamme tämän muokatun ohjelman, saamme jo paljon informatiivisemman tulosteen:
Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla
Aloituspiste (x y): 2 6
Päätepiste (x y): 10 12
Suuntavektori (x y): 0.8 0.6

Syöttäminen 101

Seuraava askel on muuttaa ohjelmaa siten, että alku- ja päätepisteiden toteamisen sijaan se kysyy niitä käyttäjältä. Tällä kurssilla kommunikoimme käyttäjän kanssa pääasiassa
tekstisyötteiden
avulla, koska niiden käyttöön riittää yksi
funktio
: input. Ensimmäinen tehtävä, kun törmätään uuteen funktioon, on tietenkin katsoa, mitä Python itse siitä sanoo:
In [1]: help(input)
Help on built-in function input in module builtins:

input(...)
    input([prompt]) -> string

    Read a string from standard input.  The trailing newline is stripped.
    If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
    On Unix, GNU readline is used if enabled.  The prompt string, if given,
    is printed without a trailing newline before reading.
Perusasiat bongataan nopeasti: funktiolla on yksi valinnainen
argumentti
ja se palauttaa
merkkijonon
.
Funktion
help-teksti kertoo mm. että käyttäjän päättäessä tekstin
syöttämisen
enter-näppäimen painalluksella, syntyvä rivinvaihto jätetään funktion
palauttamasta
merkkijonosta pois. Mikäpä sitten on tuon prompt-
parametrin
rooli? Se merkitsee kysymystä, joka näytetään käyttäjälle. Kysymyksellä on tarkoitus on ohjeistaa, mitä käyttäjän pitäisi syöttää.

Syöttöpeliä

Opittavat asiat: Nähdä mitä input-
funktio
ylipäätään tekee.
Alustus:
Kirjoita
tulkkiin
:
In [1]: input("Kerro nimesi: ")
ja kirjoita myös. Valehtele, että nimesi on aasi.
Haettu vastaus:
Vastauskenttään haetaan riviä, joka tulostuu kun painat enteriä sanan aasi syöttämisen jälkeen.
Kopioi vastauskenttään rivi, jonka Python tulostaa enterin painamisen jälkeen.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Koska input toimii kuten mikä tahansa muukin
funktio
, sen
palauttama
arvo
voidaan tallentaa
muuttujaan
. Ehkä hieman erikoista aiempaan nähden tässä on se, että palautettu arvo ei varsinaisesti mitenkään liity funktiolle annettuun
argumenttiin
. Argumentti toimii vain ohjeena käyttäjälle, ja funktio palauttaa arvon, jonka käyttäjä sille tämän ohjeen perusteella antoi. Alla oleva animaatio esittää miten input-
funktiokutsu
toimii.
Vektorikoodin pääohjelma alkaa tällä hetkellä seuraavasti:
alku_x = 2
alku_y = 6
kohde_x = 10
kohde_y = 12
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
Ensimmäistä neljää riviä muuttamalla saadaan pisteitä kuvaavien
muuttujien
arvot luettua input-
funktiolla
käyttäjältä, joten tehdään niin. Samalla voidaan kaukaa viisaasti poistaa rivit, joilla nämä pisteet tulostetaan. Tämä informaatio näkyy nimittäin käyttäjälle nyt siinä vaiheessa, kun häneltä sitä kysytään. Muutetaan siis
pääohjelma
seuraavan näköiseksi:
print("Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla")
alku_x = input("Anna alkupisteen x-koordinaatti: ")
alku_y = input("Anna alkupisteen y-koordinaatti: ")
kohde_x = input("Anna päätepisteen x-koordinaatti: ")
kohde_y = input("Anna päätepisteen y-koordinaatti: ")
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
print("Suuntavektori (x y):", suunta_x, suunta_y)
Lisäsimme yhden välilyönnin input-funktion
argumentin
loppuun. Tämä vähentää klaustrofobisia tunteita, kun kysymys ja syötekenttä eivät ole aivan kiinni toisissaan:
Anna alkupisteen x-koordinaatti: 2

Tyypillinen virhe

Opittavat asiat: Tässä tehtävässä esittelemme virhetilanteen, joka tulee kurssin aikana useasti eteen: mitä tapahtuu, kun käyttäjän
syötettä
käytetään laskuoperaatioissa sellaisenaan.
Alustus:
Lataa alla annettu koodi koneellesi ja suorita se
terminaalissa
. Anna lukuarvoiksi esimerkissä käytetyt 2, 6, 10 ja 12.
Haettu vastaus:
Vastaukseen halutaan syntyneen
poikkeuksen
nimi. Nimi on virheviestin viimeisellä rivillä ennen kaksoispistettä.
Huom: Jos et saa virheviestiä ja ohjelma toimii odotetulla tavalla, käytössäsi on erittäin todennäköisesti Python 2. Mene välittömästi katsomaan asennusohjeista miten asennat Python 3:n.
Resurssit:
suuntavektori.py
def laske_suuntavektori(x0, y0, x1, y1):
    pituus = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
    ux = (x1 - x0) / pituus
    uy = (y1 - y0) / pituus
    return ux, uy

def laske_sijainti(suunta_x, suunta_y, nopeus):
    x = suunta_x * nopeus
    y = suunta_y * nopeus
    return x, y

print("Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla")
alku_x = input("Anna alkupisteen x-koordinaatti: ")
alku_y = input("Anna alkupisteen y-koordinaatti: ")
kohde_x = input("Anna päätepisteen x-koordinaatti: ")
kohde_y = input("Anna päätepisteen y-koordinaatti: ")
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
print("Suuntavektori (x y):", suunta_x, suunta_y)

Kopioi poikkeuksen nimi laatikkoon.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Ei ole vääriä kysymyksiä, on vain vääriä vastauksia

Edellisessä tehtävässä aikaansaadun tekstitulvan pitäisi näyttää jotakuinkin tältä:
Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla
Anna alkupisteen x-koordinaatti: 2
Anna alkupisteen y-koordinaatti: 6
Anna päätepisteen x-koordinaatti: 10
Anna päätepisteen y-koordinaatti: 12
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
/joku/kansio/suuntavektori.py in ()
     15 kohde_x = input("Anna päätepisteen x-koordinaatti: ")
     16 kohde_y = input("Anna päätepisteen y-koordinaatti: ")
---> 17 suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
     18 print("Suuntavektori (x y):", suunta_x, suunta_y)

/joku/kansio/suuntavektori.py in laske_suuntavektori(x0, y0, x1, y1)
      1 def laske_suuntavektori(x0, y0, x1, y1):
----> 2     pituus = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
      3     ux = (x1 - x0) / pituus
      4     uy = (y1 - y0) / pituus
      5     return ux, uy

TypeError: unsupported operand type(s) for -: 'str' and 'str'
Virheviesti
koostuu kahdesta osasta: pidempi, sisennyksiä sisältävä osa kertoo missä päin ohjelmaa virhe tapahtui. Viimeinen rivi puolestaan kuvaa millaisesta virheestä on kyse. Ensimmäisessä osassa luetellaan
traceback
, eli
virhetilanteeseen
johtaneista
funktiokutsuista
kertynyt pino, joka alkaa
pääohjelmasta
ja loppuu aina siihen kohtaan koodissa, jossa virhe varsinaisesti tapahtui. Lähtöpisteenä on siis pääohjelman (viestissä <module>) rivi 17, jolla kutsutaan laske_sade-
funktiota
.
Varsinainen virhe kohdataan laske_suuntavektori-funktion sisällä rivillä 2. Viestin viimeinen rivi puolestaan kertoo, että kyseessä on TypeError-niminen
poikkeus
. Tämä nimi viittaa siihen, että koodissa esiintyy väärän
tyyppinen
arvo
. Virheen kuvaus kertoo vielä, että rivillä yritetään vähentää kaksi
merkkijonoa
toisistaan.
Koska
virheiden jäljitys
on ehdottomasti yksi tärkeimmistä ohjelmointitaidoista, käydään virheviesti vielä kertaalleen rivi riviltä läpi:

Sherlock de Bug ja mestarietsivän menetelmät

Ongelmatilanteissa on hyvä harrastaa hieman etsiväntyötä. Yksi tärkeä menetelmä on tarkistaa tulkissa tai pienessä testikooditiedostossa, miten jokin osa ohjelmaa tarkalleen ottaen toimii. Esimerkiksi tässä tapauksessa on hyvä tutkia input-funktion toimintaa.
Opittavat asiat: Lisää yksityiskohtia input-
funktion
toiminnasta, eli mitä tapahtuu kun
syöte
on luku.
Alustus:
Kirjoita
tulkkiin
:
In [1]: input(": ")
: 23
Haettu vastaus:
Jälleen kerraan haluamme kopion rivistä, joka tulostuu syötteen antamisen jälkeen. Suosittelemme myös miettimään mitä tämä tuloste tarkoittaa matemaattisten operaatioiden näkökulmasta.
Mitä tulkki näyttää input-funktion paluuarvoksi?
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Kuvalähde 7
Vektorikoodimme ongelmana siis on, että input-
funktio
tuottaa meille
merkkijonon
, ja tarvitsemme kokonaisluvun tai
liukuluvun
. Sattumoisin aiemmin tässä materiaalissa oppimamme int- ja float-funktiot osaavat numeroiden lisäksi muuttaa myös sopivanlaisia merkkijonoja numeroiksi. Vaatimuksena tietenkin on, että merkkijonon sisältö näyttää oikeantyyppiseltä: siis joko kokonaisluvulta tai liukuluvulta. Tässä tapauksessa liukuluku on parempi, koska pisteiden ei ole missään vaiheessa sanottu olevan kokonaislukuja. Muunnos merkkijonosta liukuluvuksi voidaan tehdä vaikkapa input-riviä muokkaamalla:
alku_x = float(input("Anna alkupisteen x-koordinaatti: "))
Tämän jälkeen ohjelma toimii, jos siihen
syöttää
numeroita. Ihan omanlaisensa suo syntyy siitä, jos käyttäjä ei syötäkään numeroa. Tämän materiaalin puitteissa sovitaan kuitenkin, että eihän kukaan nyt tuommoista virhettä tee... Päivitetty kooditiedosto löytyy alta:
suuntavektori.py
def laske_suuntavektori(x0, y0, x1, y1):
    pituus = ((x1 - x0) ** 2 + (y1 - y0) ** 2) ** 0.5
    ux = (x1 - x0) / pituus
    uy = (y1 - y0) / pituus
    return ux, uy

def laske_sijainti(suunta_x, suunta_y, nopeus):
    x = suunta_x * nopeus
    y = suunta_y * nopeus
    return x, y

print("Tämä ohjelma laskee kahden pisteen välisen suuntavektorin 2-ulotteisella tasolla")
alku_x = float(input("Anna alkupisteen x-koordinaatti: "))
alku_y = float(input("Anna alkupisteen y-koordinaatti: "))
kohde_x = float(input("Anna päätepisteen x-koordinaatti: "))
kohde_y = float(input("Anna päätepisteen y-koordinaatti: "))
suunta_x, suunta_y = laske_suuntavektori(alku_x, alku_y, kohde_x, kohde_y)
print("Suuntavektori (x y):", suunta_x, suunta_y)

100 bugia koodissa

Ennen eteenpäin siirtymistä pääset kirjoittamaan oman input-rivin! Tehtävänäsi on kirjoittaa yksi koodirivi, joka esittää käyttäjälle kysymyksen "Montako bugia koodissa? ". Lisäksi voit pysähtyä hetkeksi pohtimaan montako bugia koodiin jää, kun yksi sadasta korjataan...
Opittavat asiat: Kertaamme vielä kerran input-
funktiokutsun
käyttöä.
Alustus:
Kopioi tämä
merkkijono
, jotta voit liittää sen input-funktion
argumentiksi
:
"Montako bugia koodissa? "
Haettu vastaus:
Vastaukseen haetaan input-funktiokutsua, jossa argumenttina on em. merkkijono. Lisäksi funktion
paluuarvo
pitää muuttaa kokonaisluvuksi ja koko komeuden lopputulos
sijoittaa
bugeja-nimiseen
muuttujaan
.
Kaikki tämä siis yhdellä koodirivillä.
Kirjoita koodirivisi tekstilaatikkoon.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Moduulit

Osaamistavoitteet: Tämän osion jälkeen tiedät mitä ovat moduulit ja miten käytetään Pythonin mukana tulevia moduuleja. Tarkemmat yksityiskohdat jätetään myöhemmäksi.

Illan tähtivieraina moduulit

Tässä osiossa käsitellään Pythonin mukana tulevia
moduuleja
. On paljon muitakin moduuleja - mm. kaikki kirjoittamasi kooditiedostot - mutta niihin ei ole tarpeen paneutua tässä vaiheessa kurssia. Olet jo käyttänytkin yhtä Pythonin moduulia: esitehtäväsivun piirtelytehtävät käyttivät Turtle-nimistä palikkaa. Käyttöönotto hoidettiin maagisella rivillä, jota ei sen enempää selitelty: from turtle import *. Mystiikka ei ole hyväksi ohjelmoinnin oppimiselle, joten pureudutaan siihen mitä tässä tapahtuu. Meidän näkökulmastamme Turtle on kokoelma
funktioita
- ihan samanlaisia funktioita kuin ne joita tässä materiaalissa on käsitelty. Nämä funktiot siis tulevat Pythonin mukana, mutta ne on paketoitu erilliseen moduuliin. Useimmissa ohjelmissa kun ei tarvita Turtlen kaltaista piirtelylelua, joten sen kymmenet funktiot olisivat turhaa painolastia.
Koska moduuleihin paketoidut funktiot eivät ole suoraan käytössä kaikissa Python-ohjelmissa, tarvitaan jokin keino ilmaista Pythonille milloin haluamme niitä käyttää. Tätä tarkoitusta palvelee
import-lause
. Esitehtävissä käytetty import-lause on itse asiassa harvinaisempi tapa käyttää moduuleja. Nyt esitellään se tavallisempi tapa, joka saattaa tässä vaiheessa tuntua hölmömmältä, mutta pitää koodin huomattavasti selkeämpänä projektien laajetessa. Jotta sitä voidaan kunnolla käsitellä, täytyy tietää hieman nimiavaruuksista.

Nimiä avaruudessa

Kuten tässä materiaalissa on koitettu teroittaa, funktion sisällä määritellyt nimet ovat olemassa vain funktion sisällä. Moduuleihin pätee samanlainen periaate, eli moduulin määrittelemät nimet ovat lähtökohtaisesti käytössä vain moduulin sisällä - näitä nimiä kutsutaan moduulin
nimiavaruudeksi
. Toisin kuin funktioiden kohdalla, moduulien tapauksessa on kuitenkin mahdollista päästä käsiksi näihin nimiin käyttämällä import-lausetta. Yksinkertaisimmillaan import-lause kirjoitetaan import moduulin_nimi, eli esimerkiksi Turtlen kohdalla import turtle. Ero aiemmin käytettyyn tapaan on se, että turtle-moduulista ei oteta käyttöön kaikkia nimiä kuten esitehtävissä. Sen sijaan käyttöön tulee vain yksi nimi: turtle.
Ohjelman ja moduulin nimiavaruudet import turtle komennnon jälkeen
Miten funktioihin sitten pääsee käsiksi, jos käytössä on pelkkä turtle? Muut nimet ovat turtle-moduulin ominaisuuksia, ja Pythonissa tapa jolla näihin päästään kiinni on liittää ominaisuus sen omistajan perään pisteellä erotettuna. Näin esim viivan piirto eteenpäin olisi: turtle.forward(50). Tämä tapa vaatii enemmän kirjoittamista, mutta siinä on selkeä etu: yhdellä vilkaisulla nähdään, että forward on nimenomaan turtle-moduuliin kuuluva funktio. Jos taas on tehty kuin esitehtävissä, kaikki nimet on kaadettu samaan laariin ja koodin lukijan pitää selvittää pidemmän kaavan kautta mitkä funktiot on määritelty auki olevassa kooditiedostossa ja mitkä on tuotu muualta.
Ympyrän piirto käyttämällä import turtle tehtäisiin siis:
In [1]: import turtle
In [2]: turtle.circle(30)
Tällä kurssilla esimerkit ja tehtävät käyttävät suomenkielisiä nimiä funktioille yms. joten
nimikonfliktit
ovat harvinaisempia. Jos sen sijaan puhutaan ns. tosielämän ohjelmista, ne ovat itsessään todella laajoja ja käyttävät lukuisia moduuleja. Jos kaikkien moduulien nimet kaadettaisiin samaan laariin, todennäköisyys nimikonflikteille kasvaa merkittävästi. Tyypillisesti tästä seuraa se, että ohjelma ei käynnisty, koska jokin muuttuja on uudelleenmääritelty täysin odottamattomaan arvoon, joka on usein vieläpä eri tyyppiä.
On myös tilanteita, missä käy työlääksi kirjoittaa koko ajan moduulin nimi funktion nimen eteen, koska samaa funktiota käytetään jatkuvasti ohjelmassa. Tähän on kuitenkin olemassa parempi keino kuin esitehtävien from turtle import *. Tuossa rivissä nimittäin * on lyhenne sille, että otetaan kaikki nimet (ns. wildcard) - sen tilalla voidaan myös listata mitkä nimet halutaan tuoda. Tämä tehdään pilkulla erotettuna. Näinpä siis jos halutaan vaikka pelkästään neliön piirtämiseen tarvittavat funktiot turtlesta, ne voitaisiin ottaa käyttöön myös näin:
from turtle import begin_fill, color, done, end_fill, forward, left
Tämän tavan etuna on se, että yhdeltä riviltä voidaan helposti lukea mitkä koodissa käytetyt funktiot on tuotu Turtlesta. Moduulille voidaan myös antaa uusi nimi importin yhteydessä, mikä on käytännöllistä erityisesti pitkien ja usein käytettävien moduulien nimien kanssa. Tällöin rivi kirjoitetaan seuraavanlaiseen muotoon: import turtle as t, jossa siis as-operaattorin oikealla puolella on uusi nimi.

Matikkaa moduulista

Kuten todettua, tässä vaiheessa kurssia käytetään vain Pythonin mukana tulevia moduuleja. Niitäkin on tosin aika monta. Sivun taulukosta voi lyhyiden kuvausten sekä moduulien nimien perusteella kohtalaisesti päätellä mihin moduulia voisi tarvita. Useimpia ei kuitenkaan välttämättä tarvitse koskaan. Itse asiassa juuri tällä hetkellä et tarvitse kuin jo käytössä olleen Turtlen, ja uutena tulokkaana math-moduulin. Sieltä löytyvät useimmat matemaattiset operaatiot, jotka eivät ole riittävän yleisiä ollakseen suoraan
sisäänrakennettujen funktioiden
joukossa.

Mistä löytyy matikkaa?

Otsikon kysymys saattaa tulla vastaan vaikka supermarketin kalaosastolla, mutta sattuu olemaan myös relevantti ohjelmointihommissa. Matemaattisia funktioita on sen verran paljon, ettei niitä ole koottu samaan paikkaan. Aivan perusfunktiot löytyvät suoraan sisäänrakennettuna, mutta vähän eksoottisempia pitääkin jo hakea math-moduulista. Sieltä löytyvät ainakin useimmat lukiomatikasta tutut kaverit. Raskaampaan matikan nälkään täytyykin sitten mennä jo merta edemmäs kalaan...
Opittavat asiat: Tutkitaan math-
moduulin
sisältöä ja opetellaan mitä operaatioita varten tarvitaan siellä olevia funktiota, ja mistä selvitään ilman.
Alustus:
Avaa selaimeen seuraavat sivut:
Haettu vastaus:
Alla on listattu erinäisiä matemaattisia operaatioita. Tehtäväsi on selvittää mitkä niistä onnistuvat Pythonin
sisäänrakennetuilla funktioilla
tai
operaattoreilla
, ja mihin tarvitaan math-moduulista löytyviä funktioita. Tässä tehtävässä operaatio vaatii math-moduulia, jos sitä ei pysty tekemään yhdellä operaatorilla tai funktiolla muuten. Tämä siis tarkoittaa, että vaikka jokin asia onnistuisi perusoperaattoreita ja/tai funktioita yhdistelemällä, siihen haetaan funktiota joka tekee koko operaation kerralla - pitää vain selvittää mistä tämä löytyy.
Valitse operaatiot, jotka vaativat funktion math-moduulista. (4 kpl)
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Funktioiden lisäksi moduuleista löytyy myös vakioita, joita käsitellään seuraavassa osiossa tarkemmin. Vakioita haetaan moduulista samalla tavalla kuin funktioita, eli moduulin nimi eteen, piste väliin ja vakion nii perään. Esim math-moduulista löytyvät yleiset vakiot pi ja e, joiden arvot saadaan siis seuraavasti:
In [1]: import math
In [2]: math.pi
Out[2]: 3.141592653589793
In [3]: math.e
Out[3]: 2.718281828459045
Moduulin sisältämät arvot näille vakioille ovat tarkimpia mahdollisia -
Python-tulkki
ei vain oletuksena näytä enempää desimaaleja kuin yllä. Math-moduulilla päästään leikkimään lisää harjoituksissa.

Vakiot

Osaamistavoitteet: Tämän osion jälkeen tiedät mitä ovat vakiot, mihin niitä käytetään ja miten ne vaikuttavat muun koodin sielunelämään.

Vakio on valetta

Pythonissa ei oikeasti ole
vakioita
. Vakiot ovat ihan tavallisia
muuttujia
, jotka erottuvat muista muuttujista ainoastaan käyttötarkoituksensa perusteella. Vakio on käytännössä nimetty
arvo
, jota käytetään ohjelmakoodissa usein ja muuttumattomana. Ne ovat sukua matemaattisille ja luonnontieteellisille vakioille. Niitä voidaan käyttää muun muassa kaavojen selventämiseen: kun numeron sijaan käytetään vakion nimeä, tiedetään heti, että kyseessä ei ole mikä tahansa numero, vaan juuri tietty vakio. Näin tekemällä koodi on luettavampaa ja ymmärrettävämpää: lukijan ei tarvitse omatoimisesti koittaa keksiä
mystisen luvun
merkitystä. Toiseksi, voi olla myös sellaisia tilanteita, joissa esimerkiksi sama luku esiintyy useaan kertaan ohjelmassa, mutta ohjelmoija joutuu testaamaan, mikä tarkalleen olisi sopiva sen lopulliseksi arvoksi. Tällöin on edullista käyttää vakiota, koska arvoa ei tällöin tarvitse vaihtaa kuin yhdessä kohtaa ohjelmaa.
Vakiot määritellään kooditiedoston valmistelulohkossa. Tämä tapahtuu juuri samalla tavalla kuin arvojen
sijoittaminen
muuttujiin muualla koodissa. Tapana on kuitenkin kirjoittaa vakioiden nimet kokonaan isoilla kirjaimilla, mikä korostaa niiden luonnetta.
VALON_NOPEUS = 299_792_458
Tässä nähdään myös Python 3.6 versiossa tullut ominaisuus: isojen lukujen kirjoituksessa voi käyttää alaviivaa tuhaterottimena, joka tekee niistä helpompia lukea.

Kerroin, kerroin, kuvastin

Vakioiden avulla koodista voidaan tehdä huomattavasti muokkausystävällisempää. Peliohjelmoinnissa skaalausta voidaan tarvita esimerkiksi siihen, että pelihahmon leveys, liikkumisnopeus ja kaikki muu suhteutetaan kuvaruudun kokoon. Tässä esimerkissä määrittelemme yksinkertaisen pelihahmon, jonka ominaisuuksia täytyy skaalata.
Opittavat asiat:
Vakioiden
käyttö usein toistuvien
literaaliarvojen
tilalla.
Alustus:
Pelihahmon kolme ominaisuutta on määritelty seuraavilla koodiriveillä:
koko = 40 * 0.8
nopeus = 10 * 0.8
kantama = 200 * 0.8
Tässä esiintyvä luku 0.8 on skaalauskerroin, jolla säädetään pelin yleistä geometriaa (käytännössä siis kaikki
arvot
jotka liittyvät mittoihin kerrotaan sillä). Arvoja ei ole laskettu valmiiksi, koska mukavia tasalukuja on helpompi ajatella. Nyt kuitenkin, jos arvoa pitäisi muuttaa joksikin muuksi, jouduttaisiin edelleen käymään kaikki ohjelman rivit läpi.
Ongelman välttämiseksi asiansa osaava ohjelmoija määritteleekin
kooditiedoston
alkuun vakion:
SKAALAUS = 0.8
Haettu vastaus:
Kirjoita esimerkin kolme hahmon ominaisuutta määrittelevää riviä uudestaan siten, että niissä käytetään literaaliarvon 0.8 sijaan esimerkissä määritettyä vakiota. Muutoksen jälkeen siis pitäisi käydä niin, että jos SKAALAUS-vakion arvoa muutetaan, kaikkien ominaisuuksien skaalauskerroin muuttuu sen seurauksena. Tämä on äärimmäisen kätevää, jos arvoa päätetään muuttaa.
Kirjoita muutetut rivit laatikkoon, alkuperäisessä järjestyksessä.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
Kun
vakiot
määritellään koodin alussa, ne ovat
käytössä
kaikkialla – myös
funktioiden
sisällä. Funktiot osaavat nimittäin lukea
pääohjelman
määrittelemiä muuttujia, mikä mahdollistaa vakioiden käytön. Muista kuitenkin tämä: funktion sisällä ei koskaan saa käyttää mitään ulkopuolista tietoa joka ei ole a)
parametri
tai b) vakio. Tämän käytännön rikkominen johtaa funktioihin, joita ei voi uusiokäyttää, sekä lisäksi odottamattomiin
bugeihin
. Funktio ei siis saa olla riippuvainen muun koodin toiminnasta vaan ainoastaan vakioista.

Loppusanat

Tässä luvussa on käyty läpi ohjelmoinnin aloittamisen kannalta keskeisiä perusteita.
Muuttujien
kohdalla teroitettiin useaan otteeseen, että muuttuja ja sen
arvo
ovat erillisiä asioita: muuttuja ainoastaan
viittaa
olemassaolevaan arvoon. Silti puhutaan usein kuin muuttuja sisältäisi arvon, ja erityisesti termi "muuttujan sisältö" toistuu usein.
Kävimme myös läpi toisen keskeisen käsitteen eli
funktiot
. Funktiot ovat tapa jakaa ohjelmaa osiin, joita voidaan uusiokäyttää. Uusiokäyttöä tärkeämpi etu funktioissa on kuitenkin ohjelmakoodin jäsentäminen. Pienet kokonaisuudet ovat aina helpommin hallittavia kuin suuret ja rajaamattomat. Ohjelman rakentaminen funktioiden avulla antaa mahdollisuuden vastata pieniin ongelmiin ja käsitellä niitä yksi kerrallaan sen sijaan, että pyrkii suoraan ratkaisemaan yhden mammuttiongelman, josta on lähdetty liikkeelle. Funktiot ovat siis ohjelmien työnjakoa.
Ensi viikon harjoituksissa pääset kokeilemaan näitä asioita käytännössä, minkä jälkeen niiden pitäisi selkeytyä. Omaksumalla alussa vahvan perustan yksinkertaisten tehtävien parissa teet itsellesi palveluksen. Myöhemmin, tehtävien vaikeutuessa, hyvät käytännöt tulevat selkärangasta ja tuotat koodia, jota on sekä itsesi että muiden merkittävästi helpompi ymmärtää ja korjata.

Kuvalähteet

  1. Ruutukaappaus History Channelin sarjasta Ancient Aliens, teksti lisätty.
  2. alkuperäinen lisenssi: CC-BY 2.0 (teksti lisätty)
  3. Ruutukaappaus elokuvasta Inception, teksti lisätty.
  4. alkuperäinen lisenssi: CC-BY 2.0 (teksti lisätty)
  5. alkuperäinen lisenssi: CC-BY 2.0 (teksti lisätty)
  6. alkuperäinen lisenssi: CC-BY 2.0 (teksti lisätty)
  7. alkuperäinen lisenssi: CC-BY 2.0 (teksti lisätty)
?
Ajonaikaisesta (engl. run time) puhuttaessa määreenä on se aikaväli, kun ohjelma on käynnissä. Esimerkiksi Pythonissa virheet (syntaksivirheitä lukuun ottamatta) tarkastetaan ajonaikaisesti. Ohjelma saattaa siis olla käynnissä ja toimia tiettyyn pisteeseen saakka, kunnes törmätään käsittelemättömään poikkeukseen – ajonaikaiseen virheeseen (engl. run time error).
  1. Kuvaus
  2. Esimerkit
Alkio (engl. item, element) on listan tai muun tietorakenteen sisältämä yksittäinen arvo. Useimmiten alkioista puhutaan juuri listojen yhteydessä. Tällöin alkiolla on arvon lisäksi paikka eli indeksi, joka kertoo sen sijainnin listassa etäisyytenä listan alusta. Niinpä siis listan ensimmäisen alkion indeksi on 0.
  1. Kuvaus
  2. Esimerkit
Alustamisella (engl. initialize) tarkoitetaan yleisesti jonkin arvon asettamista muuttujalle muuttujan luonnin yhteydessä. Pythonissa ei ole mahdollista luoda muuttujaa, jolla ei ole myös jotain arvoa. Niinpä tyypillisesti käytetäänkin sanamuotoa ”muuttuja alustetaan arvolla x”, millä tarkoitetaan sitä, että muuttuja, joka luodaan, saa luomisen yhteydessä (eikä vasta joskus myöhemmin) arvon x.
  1. Kuvaus
  2. Esimerkit
Argumentti (engl. argument) on funktiokutsussa käytettävä arvo, joka välitetään kutsuttavalle funktiolle. Funktiokutsun alkaessa argumentit sijoitetaan parametreiksi kutsuttuihin muuttujiin, joiden kautta arvoihin pääsee funktion sisällä käsiksi.
Arvo (engl. value) on konkreettista, tietokoneen muistissa sijaitsevaa tietoa, jota käytetään ohjelman suorituksen aikana. Arvoilla on tyyppi ja sisältö; esimerkiksi numero 5 on tyypiltään kokonaisluku, jonka sisältö on 5. Useimmiten arvot liitetään muuttujiin, mutta myös operaatioiden ja funktiokutsujen paluuarvot sekä koodissa sellaisenaan esiintyvät arvot ovat arvoja. Käytännössä siis kaikkea konkreettista mitä ohjelma käsittelee voidaan kutsua arvoiksi.
  1. Kuvaus
  2. Esimerkit
Avain (engl. key) on ikään kuin sanakirjan ”indeksi”, eli sillä valitaan yksittäinen arvo tietorakenteen sisältä. Kutakin avainta vastaa yksi arvo. Avaimina käytetään yleensä merkkijonoja, mutta ne voivat olla mitä tahansa muuntumattomia tietotyyppejä, kuten lukuja tai monikkoja.
  1. Kuvaus
  2. Kurssin avainsanat
Avainsanat (engl. keyword) ovat ohjelmointikielessä kielen käyttöön varattuja sanoja, joilla on erityinen merkitys. Hyvät tekstieditorit tyypillisesti merkitsevät avainsanat muista nimistä eroavalla tavalla (esimerkiksi lihavoinnilla tai tietyllä värillä). Avainsanat ovat yleensä suojattuja, eli samannimisiä muuttujia ei voi luoda. Yleisiä avainsanoja Pythonissa ovat esimerkiksi funktioihin liittyvät def ja return. Avainsanat ovat siis osa ohjelmointikielen kielioppia.
  1. Kuvaus
  2. Esimerkit
Avainsana-argumentti-termiä (engl. keyword argument, lyh. kwarg) käytetään, kun funktio- tai metodikutsussa argumentteja annetaan sijoittamalla niitä parametrien nimiin. Tätä käytetään erityisesti format-metodin yhteydessä: "Hei {nimi}".format(nimi="hemuli"). Toinen yleinen käyttötapaus on silloin, kun kutsutulla funktiolla on paljon valinnaisia argumentteja ja näistä vain osa halutaan määrittää. Avainsana-argumentin käyttö voi myös selkeyttää koodia, erityisesti sellaisten argumenttien kohdalla joille annetaan arvoksi True tai False.
  1. Kuvaus
  2. Esimerkit
Avausmoodilla kerrotaan Pythonille (ja käyttöjärjestelmälle) millä tavalla tiedosto avataan. Tiedosto voidaan avata lukemista tai kirjoittamista varten. Oletuksena, eli jos avausmoodia ei erikseen määritellä, tiedosto avataan lukumoodissa ("r"). Kirjoitusmoodeja on kaksi:
  • "w", eli write, joka kirjoittaa tiedoston sisällön puhtaalta pöydältä hävittäen mahdollisesti aiemmin olemassa olleen saman nimisen tiedoston.
  • "a", eli append puolestaan kirjoittaa olemassaolevan tiedoston loppuun.
Molemmat kirjoitusmoodit luovat tiedoston, jos sitä ei vielä ole olemassa.
Siinä missä UNIX-pohjaiset järjestelmät tuottavat \n-merkkejä rivinvaihdoiksi, Windows tuottaa \r\n-rivinvaihtoja, joissa r on carriage return -merkki. Se on kirjoituskoneiden peruja ja tarkoittaa toimenpidettä, jossa kirjoituspää siirretään takaisin rivin alkuun. Yleisesti ottaen tämä on lähinnä asia, joka on hyvä tietää – Python käsittelee molempia rivinvaihtoja kiltisti.
Data (engl. data) on ohjelmoinnin asiayhteydessä mitä vaan tietoa, joka ei kuitenkaan yleisesti kata itse ohjelmakoodia. Yleensä datasta puhuttaessa tarkoitetaan yksittäisiä literaaliarvoja, muuttujien sisältämää tietoa tai jostain tietolähteestä (kuten tiedostosta tai verkko-osoitteesta) luettua tai sinne kirjoitettua tietoa. Nyrkkisääntönä voi kuitenkin pitää sitä, että koodi ja data ovat eri asioita, ja koodi käsittelee dataa. (Joissain yhteyksissä koodikin lasketaan dataksi, mutta näihin ei tällä kurssilla syvennytä.)
Debuggaus (engl. debugging) tarkoittaa ohjelmointivirheiden – bugien – jäljittämistä ja korjaamista. Bugien jäljille pääsemiseen on monia eri tapoja, joista ehkä hyödyllisimpänä Python tarjoaa ohjelman kaatumisen yhteydessä näytettävät virheviestit. Myös debug-printit ovat tavanomainen keino virheiden paikantamiseen; kyseessä on print-komentojen ripottelu koodiin väliaikaisesti esimerkiksi sen selvittämiseen, mihin asti koodin suoritus pääsee, tai muuttujien arvojen tutkimiseen ajonaikaisesti. Debuggaus on niin oleellinen osa ohjelmointia, että sitä varten on kehitetty myös erikseen työkaluja, joita kutsutaan debuggereiksi. Debuggereihin emme kuitenkaan tällä kurssilla koske.
Pythonissa dokumenttimerkkijono (engl. docstring) on kommentin kaltainen merkintä, mutta sillä on oma erityistarkoituksensa. Dokumenttimerkkijono merkitään yleensä kolmella lainausmerkillä (eli '''dokumentti''' tai """dokumentti""". Jos dokumenttimerkkijono on sijoitettu funktion def-rivin alapuolelle (sisennettynä), siitä tulee funktion dokumentaatio, jonka saa esiin help-funktiolla tulkissa. Samoin kooditiedoston alkuun sijoitettu dokumenttimerkkijono muuttuu moduuliin dokumentaatioksi. Dokumenttimerkkijonossa on hyvä kertoa funktion toimintaperiaate sekä selittää mitä sen parametrit ja paluuarvot ovat.
Dokumenttimerkkijonoja ei tule käyttää kommenttien sijasta! Muualla kuin edellä mainituissa paikoissa kommentointiin tulee käyttää kommentteja (eli #-merkillä alkavia rivejä)
  1. Kuvaus
  2. Esimerkit
Ehto-nimitystä (engl. condition) käytetään tällä kurssilla ehtolauseiden ja while-silmukoiden siitä osasta, joka määrittelee milloin lause on tosi ja milloin epätosi. Ehtoa on siis kaikki joka on ehtolauseen aloittavan avainsanan (if tai elif) ja sen päättävän kaksoispisteen välissä.
  1. Kuvaus
  2. Esimerkit
Ehtolause (engl. conditional statement) on yksittäisen ehdon määrittelevä rivi koodissa, jota seuraa sisennetty koodilohko, joka määrittää miten ehdon toteutuessa tulee toimia. Varsinaisia ehtolauseita ovat if- ja elif-lauseet, joista jälkimmäinen ei voi esiintyä ilman ensimmäistä. Toisiinsa liitetyt ehtolauseet muodostavat ehtorakenteita. Ehtolause päättyy aina kaksoispisteeseen, ja tämän kaksoispisteen jälkeen on seurattava vähintään yksi sisennetty koodirivi.
  1. Kuvaus
  2. Esimerkit
Ehtorakenne (engl. conditional structure) on yhdestä tai useammasta toisiinsa liitetystä ehtolauseesta muodostuva rakenne, joka haarauttaa ohjelman suoritusta. Useimmissa ehtorakenteissa on vähintään kaksi haaraa: if ja else. Näiden välissä voi olla myös mielivaltainen määrä elif-lauseilla aloitettuja haaroja. On myös mahdollista, että ehtorakenteessa on pelkkä if-lause. Ehtorakenteessa kussakin haarassa on suoritettavaa koodia, joka kuvaa miten ohjelman tulee ehdon määrittelemässä tilanteessa toimia.
Kokonaisuudessaan ehtorakenne käydään läpi siten, että ensin tarkistetaan järjestyksessä ensimmäisen, eli if-lauseen, ehdon paikkansapitävyys. Jos ehto evaluoitui totuusarvoon True, ohjelman suoritus jatkuu kyseisen if-lauseen lohkosta, jonka suorituksen jälkeen siirrytään koko lopun ehtorakenteen ohi. Jos ehto taas evaluoitui Falseksi, käydään järjestyksessä ehtolauseita läpi toistaen samaa kuin ensimmäisen if-lauseen kohdalla, ja jos mikään ehto ei ollut paikkansapitävä, suoritetaan else-lauseen lohko.
Epätosi (engl. false) on toinen kahdesta mahdollisesta totuusarvosta ja toisen, eli toden, vastakohta. Sitä voidaan pitää lopputuloksena loogisissa ja vertailuoperaatorioissa, jotka eivät pidä paikkansa. Esimerkiksi vertailuoperaatio 5 < 4 ei pidä paikkansa, joten kyseinen operaatio evaluoituu epätodeksi. Pythonissa epätotta merkitään avainsanalla False.
  1. Kuvaus
  2. Esimerkit
Erotin (engl. separator) on merkkijonoihin ja tekstitiedostoihin liittyvä termi. Sillä tarkoitetaan tiettyä merkkiä, joiden kohdilta merkkijono on tarkoitus katkaista, kun se luetaan koodiin. Esimerkiksi, jos merkkijono sisältää tietoja, jotka on tarkoitus lukea listaan, erotin erottelee merkkijonon osat alkioiksi. Koodissa käytetään usein merkkijonojen split-metodia näissä tilanteissa – metodilla voidaan siis pätkiä erottimien kohdilta merkkijono listaksi.
Evaluointi (engl. evaluation) tarkoittaa lausekkeen tai muuttujan arvon lopputuloksen määrittämistä. Suoritettaessa lauseet evaluoituvat joksikin tietyksi arvoksi.
Exception on yleisimpien poikkeusten pääluokka. Kutsumme sitä Pokémon-poikkeukseksi, koska jos sitä käyttää try-except-rakenteessa, except ottaa kiinni kaikki poikkeukset. Tämä ei ole hyvä asia, koska se tekee vikatilanteiden tulkitsemisen vaikeammaksi sekä ohjelman käyttäjälle, että koodarille itselleen – se ottaa nimittäin kiinni myös ohjelmointivirheet, jolloin et saa mitään hyödyllistä tietoa ohjelman kaatuessa.
  1. Kuvaus
  2. Esimerkit
Merkkijonojen format-metodi on Pythonissa tehokas tapa sisällyttää muuttujien arvoja tulostettavaan tai tallennettavaan tekstiin. Merkkijonoon määritetään paikanpitimiä (esim: {:.2f}) joihin sijoitetaan format-metodin argumentit. Esimerkki: "Aasin korvien väli on {:.2f} tuumaa".format(mittaus).
  1. Kuvaus
  2. Esimerkit
Funktio (engl. function) on ohjelmassa oleva itsenäinen kokonaisuus, joka muodostuu määrittelyrivistä (def-lauseella) sekä funktion suoritettavista koodiriveistä. Funktioita käytetään selkeyttämään ohjelman rakennetta sekä koodin toiston välttämiseen. Funktiot kommunikoivat keskenään ja pääohjelman kanssa funktion parametrien sekä paluuarvojen välityksellä. Funktion sisällä määritetyt muuttujat (ml. parametrit) ja muut nimet ovat olemassa ainoastaan funktion sisällä. Vastaavasti funktioiden ei pitäisi lukea arvoja itsensä ulkopuolelta.
  1. Kuvaus
  2. Esimerkit
Funktiokutsu (engl. function call) on menetelmä, jonka seurauksena ohjelman suoritus ”hyppää” toiseen kohtaan koodia – sen funktion alkuun, jota kutsutaan. Funktiota kutsuttaessa sillä annetaan sulkeissa argumentit, joihin funktiolohkon koodista käsin pääsee käsiksi funktiomäärittelyn vastaavista kohdista löytyvien parametrien kautta. Funktion suoritus päättyy, kun törmätään funktion loppuun tai return-lauseeseen. Tällöin ohjelmakoodin suoritus palaa takaisin edelliseen kohtaan, eli sinne, mistä funktiota kutsuttiin, ja funktiokutsu korvautuu funktion paluuarvolla.
Toisin sanoen kutsumalla saadaan yksi ohjelman osa käyttämään toista – esimerkiksi pääohjelma funktiota tai funktio toista funktiota.
  1. Kuvaus
  2. Esimerkit
Funktioiden määrittely tapahtuu def-lauseella, jonka yhteydessä annetaan nimi funktiolle sekä sen parametreille. Kaikkien näiden valinta on oleellinen osa hyvän ja yleiskäyttöisin funktion kirjoittamista. Nimi tulisi valita siten, että se kuvaa mahdollisimman hyvin mitä funktio tekee - vastaavasti parametrien nimien tulisi olla sellaisia, että niistä voi helposti päätellä millaiset argumentit funktiolle pitää antaa. Funktion varsinainen koodi määritetään sisennettynä def-rivin alle. Funktion koodi voi ja usein sisältääkin useita rivejä - se voi myös sisältää muita sisennyksiä (esim. ohjausrakenteita).
  1. Kuvaus
  2. Esimerkit
Generaattori (engl. generator) on erityinen objektityyppi, joka toimii esimerkiksi for-silmukassa listan tavoin. Generaattori ei kuitenkaan ole muistissa oleva kokoelma arvoja, vaan erityinen funktio, joka tuottaa arvoja laiskasti, eli sitä mukaa kuin sitä käydään läpi. Tästä johtuen generaattorin ”sisältöä” ei ole mahdollista tulostaa, eikä siitä voida valita alkioita indeksiosoituksella. Generaattorit eivät kuulu alkeiskurssin aihepiiriin.
  1. Kuvaus
  2. Esimerkit
  3. Tilasanakirjat
Globaali muuttuja (engl. global variable) on pääohjelman tasolla esitelty muuttuja, jota muokataan suoraan funktiossa tuomatta sitä funktion nimiavaruuteen parametrin kautta. Globaalien muuttujien käyttö on huonoa ohjelmointityyliä, ja niiden sijaan tietoa kuuluisikin kuljettaa funktioille argumentteina ja ottaa funktiolta vastaan paluuarvoina muutettuja arvoja. Näin tekemällä välttää niin kutsutun globaalin tilan, joka huonontaa koodin ymmärrettävyyttä.
Haara (engl. branch) on yksi keskenään vaihtoisista reiteistä, joita pitkin ohjelman suoritus voi tietystä pisteestä lähtien edetä. Esimerkiksi ehtorakenteissa jokainen if-, elif- ja else-lohko haarauttaa ohjelman suorituksen.
  1. Kuvaus
  2. Esimerkit
Hypystä (engl. jump) puhuttaessa tarkoitetaan ohjausrakenteen aiheuttamaa siirtymistä, jonka jälkeen ohjelman suoritus jatkuukin jostain muualta kuin seuraavalta koodiriviltä.
  1. Kuvaus
  2. Esimerkki
Ikuinen silmukka tai ikisilmukka (engl. infinite loop) on silmukka, joka ei pääty ikinä – silmukan alaisuuteen kuuluvaa koodia siis toistetaan ”ikuisesti”. Ikisilmukoilla on ohjelmoinnissa käyttötarkoituksensa, mutta silloin tällöin tahattomasti syntynyt ikisilmukka voi myös olla ohjelman jumiutumisen aiheuttava bugi. Pythonissa ikuiset silmukat onnistuvat pääasiassa while-silmukoilla.
  1. Kuvaus
  2. Esimerkit
Indeksi (engl. index) on kokonaislukuarvo, joka osoittaa alkion sijainnin järjestetyssä tietorakenteessa (lista, monikko, mutta myös merkkijono!). Indeksit alkavat nollasta, joten viimeinen indeksi on (rakenteen pituus - 1). Tätä voi ajatella etäisyytenä rakenteen alusta. Python tuntee myös negatiiviset indeksit, jolloin indeksi -1 viittaa aina viimeiseen alkioon, -2 toiseksi viimeiseen jne. Kun rakenteesta otetaan alkio indeksin perusteella, puhutaan usein osoittamisesta.
  1. Kuvaus
  2. Esimerkit
Kun käytetään tietorakenteen, esimerkiksi listan, indeksiä, puhutaan (indeksi)osoittamisesta. Tämä osoittaminen merkitään hakasuluilla, esim. arvosanat[0]. Indeksiosoitus palauttaa alkion. Osoitus listan ulkopuolelle aiheuttaa IndexError-poikkeuksen, ja on hyvä pitää mielessä että listan viimeinen indeksi on sen pituus - 1 (koska indeksointi alkaa nollasta). Indeksi voi olla myös negatiivinen, jolloin laskenta alkaa listan lopusta (eli -1 on listan viimeinen alkio).
Katso myö: leikkaus.
Jäsenarvo (engl. attribute) on objektille kuuluva arvo, eli ominaisuus eli attribuutti. Se on siis nimi, joka kuuluu objektin sisäiseen nimiavaruuteen, ja siihen päästään käsiksi objektin kautta: aika.tm_hour joka antaisi aika-objektista tunnit.
Kierros (engl. iteration) on toistorakenteiden eli silmukoiden yhteydessä käytetty sana. Kierroksella viitataan siihen, kun silmukan alla sijaitseva koodi suoritetaan kertaalleen alusta loppuun – tämä on siis yksi kierros.
Kirjasto (engl. library) tai moduuli (engl. module) (kuten niitä Pythonissa virallisesti kutsutaan) on valmiiksi kirjoitettua koodia, jolla on oma rajattu tarkoituksensa. Tyypillisesti kirjasto sisältää ainakin nipun aihepiiriinsä kuuluvia funktioita, mutta voi sisältää muutakin (esim. luokkia tai vakioita). Esimerkiksi Turtle on kirjasto, jonka tarkoitus on tarjota helposti käytettäviä piirtofunktioita.
  1. Kuvaus
  2. Materiaaliesimerkki
  3. Peruskäyttö
Komentoriviargumentti (engl. command line argument) tai -parametri on nimitys lisätiedolle, joka annetaan komennon yhteydessä kun ohjemaa käynnistetään komentoriviltä. Komentoriviargumentit erotetaan toisistaan tyypillisesti välilyönnillä. Esimerkiksi komennossa python koodi.py koodi.py on itse asiassa komentoriviargumentti. Komentoriviargumentteja voi käsitellä Python-koodissa sys-moduulin argv-muuttujan kautta.
  1. Kuvaus
  2. Esimerkit
Kommentti (engl. comment) on kooditiedostossa olevaa tekstiä, joka ohitetaan kun koodia suoritetaan. Kussakin kielessä on oma tapansa sille miten rivi merkitään kommentiksi. Pythonissa se on #- eli risuaitamerkki (engl. hash character), jonka jälkeen riviltä löytyvän tekstin Python-tulkki ohittaa kokonaan. Kommenteilla voi selventää koodin lukijalle (tai itselleen) mitä koodissa tapahtuu. Yleensä kommentit on hyvä laittaa omille riveilleen kommentoitavan koodin yläpuolelle.
Ohjelman ja sen funktioiden toiminta kuvataan yleensä mieluiten dokumenttimerkkijonossa. Kommentteja käytetään enemmänkin välihuomioiden tekemiseen.
Toinen tapa käyttää kommentteja on tilapäisesti kommentoida rivejä pois esimerkiksi vaihtoehtoisen koodin testaamiseksi. Tällöin aiempaa koodia ei tarvitse poistaa – kätevää, jos myöhemmin osoittautuu, että sitä tarvitaan sittenkin.
Kooditiedosto (engl. code file) on tekstimuotoinen tiedosto, joka sisältää suoritettavaa koodia. Python-kooditiedosto suoritetaan komentokehotteesta kirjoittamalla python koodi.py, jossa koodi.py on tiedoston nimi. Kooditiedostoa suorittaessa yksittäisten rivien paluuarvot eivät tule näkyviin – ainoastaan print-funktiolla tulostettavat tiedot näkyvät käyttäjälle.
Ohjelman käyttämät arvot ovat kovakoodattuja (engl. hard coded) silloin, kun ne esiintyvät literaaliarvoina – eli semmoisenaan – ohjelman lähdekoodissa sen sijaan, että ne selvitettäisiin ajonaikaisesti esimerkiksi kysymällä käyttäjältä tai lukemalla tiedostosta.
Kutsupyyntö (eng. callback) on erityisesti nykyaikaisessa ohjelmoinnissa yleinen mekanismi, jossa toiselle - usein jonkun muun tekemälle - ohjelman osalle annetaan funktio, jota sen tulee kutsua toimintansa aikana. Jos tavallinen funktiokutsu vastaa puhelinsoittoa, kutsupyyntö on loogisesti soittopyyntö. Jos ohjelman osa käyttää kutsupyyntöä, sen dokumentaatio tyypillisesti kertoo, millaisen funktion sille voi antaa - erityisesti mitä parametreja funktiolla voi olla ja millainen arvo sen tulee palauttaa.
Käsittelijä(funktio) (engl. handler) on funktio, joka on kiinnitetty tapahtumaan siten, että sitä kutsutaan kun tarkkailtu tapahtuma havaitaan. Tämä johtaa siihen, että yleensä käsittelijää ei kutsuta samassa koodissa missä se on määritelty, vaan se toimii takaisinkutsuna. Käsittelijät liittyvät yleensä käyttöliittymä- ja pelikirjastoihin, joissa ohjelman pääsilmukka pyörii kirjaston sisällä ja tarkkailee tapahtumia. Käsittelijät ovat varsinaisen sovelluksen tapa toteuttaa omat toimintonsa tapahtumien kautta. Koska sovelluksen kirjoittaja ei voi vaikuttaa siihen miten käsittelijäfunktiota kutsutaan, sen parametrien ja paluuarvojen tulee vastata kirjaston antamia määrityksiä.
Käyttöliittymä (engl. User Interface, lyh. UI) on rajapinta ohjelman ja ohjelman käyttäjän – tyypillisesti ihmisen – välillä. Yksinkertaisessa tekstipohjaisessa käyttöliittymässä käyttäjältä voidaan pyytää ohjelman suoritusta varten tietoa input-funktiokutsujen avulla. print-funktiolla voidaan puolestaan esittää käyttäjälle tietoa ja lopputuloksia.
Monet loppukäyttäjälle interaktiiviseen käyttöön tarkoitetut ohjelmat toimivat jonkinlaisen graafisen käyttöliittymän (engl. Graphical User Interface, lyh. GUI) kautta. Näihin sisältyy yleensä ikoneita, painikkeita, avattavia valikoita ynnä muita hiirellä tai kosketusnäytöllä tökittäväksi tarkoitettuja käyttöliittymäelementtejä. Tällä kurssilla tutustumme lopputyön yhteydessä pintaa raapaisemalla graafisten käyttöliittymien sielunelämään.
Käyttöliittymäelementti (engl. UI element, widget) on jokin (yleensä graafiselle) käyttöliittymälle ominainen komponentti, jonka kautta käyttäjän vuorovaikutus ohjelman kanssa on mahdollista. Tällaisia ovat esimerkiksi napit, valikot, liukusäätimet ynnä muut.
Lause (engl. statement) on ohjelmointikielessä nimitys yksittäiselle suoritettavalle asialle, joka on yleensä yksi koodirivi.
Lauseke (engl. expression) tarkoittaa ohjelmoinnissa evaluoitavaa yksikköä. Esimerkiksi 5 + 5 ja "aasi" != "apina" ovat lausekkeita, jotka evaluoituvat arvoiksi 10 ja True. Lauseke yksin ei muuta ohjelman tilaa mitenkään, ellei sillä ole sivuvaikutuksia. Sen sijaan lauseke vaikuttaa osana lausetta.
  1. Kuvaus
  2. Esimerkit
Leikkaamisella (engl. slice) tarkoitetaan sitä, kun sekvenssistä (yleensä listasta, mutta myös merkkijonoista) otetaan osasekvenssi. Lopputuloksena on samaa tyyppiä oleva arvo, joka on kopio valitusta alueesta. Valinnassa merkitään aloitus- ja lopetusindeksit. Molemmat ovat tosin valinnaisia. Leikkaus merkitään sivu = kokoelma[5:10] joka ottaisi siis alkiot indekseistä 5…9. Kaksoispisteen jälkeinen luku on ensimmäinen indeksi jota ei oteta mukaan!
Leikkaaminen ei koskaan aiheuta IndexErroria!
  1. Kuvaus
  2. Esimerkit
Lista (engl. list) on järjestetty kokoelma arvoja, joka on Python-ohjelmoinnissa todellinen monitoimikone. Lista voi sisältää mitä tahansa arvoja, eikä sen kokoa tarvitse tuntea ennalta.
Listassa olevia arvoja kutsutaan alkioiksi. Jokaisella alkiolla on listassa paikka, jota kutsutaan indeksiksi. Indeksit alkavat nollasta! Kaiken tämän lisäksi lista on luonteeltaan muuntuva tietotyyppi. Kaikesta tästä on kerrottu hyvin paljon kolmosmateriaalissa.
Lista voi myös sisältää muita listoja. Tällä tavalla muodostettua tietorakennetta kutsutaan kaksiulotteiseksi listaksi (engl. two-dimensional list). Tietenkin sisäkkäisiä listoja (engl. nested list) voi olla kahtakin tasoa syvemmälle, jolloin ulottuvuuksien lukumäärä kasvaa vastaavasti. Tällöin puhutaan moniulotteisista listoista (engl. multidimensional list).
Literaaliarvo (engl. literal) on yleisnimitys arvoille jotka esiintyvät koodissa sellaisenaan. Arvo ei siis ole muuttujassa, vaan se on kirjoitettu koodiin. Esimerkiksi lauseissa x = 5 ja print("aasi"), 5 ja "aasi" ovat literaaliarvoja. Termiä käytetään pääasiassa yksinkertaisten muuttujatyyppien eli lukujen, totuusarvojen ja merkkijonojen kanssa.
  1. Kuvaus
  2. Muunnokset
Liukuluku (engl. floating point number, lyh. float) on tietokoneiden käyttämä desimaaliluvun approksimaatio. Tietokoneet eivät arkkitehtuurinsa vuoksi pysty käsittelemään oikeita desimaalilukuja, joten niiden tilalla käytetään liukulukuja. Liukuluvut saattavat aiheuttaa pyöristysvirheitä - tämä on hyvä pitää mielessä niitä käyttäessä. Pythonissa on olemassa decimal-moduuli, joka pystyy käsittelemään desimaalilukuja tarkasti.
Lohko (engl. block) on nimitys joukolle koodirivejä jotka kuuluvat yhteen. Lohkoa yhdistää se, että rivit ovat samalla sisennystasolla (tosin lohko voi sisältää myös muita lohkoja). Tyypillisiä lohkoja ovat esim. ehtorakenteiden suoritettavat osat, eli ne sisennyt koodirivit jotka seuraavat ehtoa / elseä. Lohko tulkitaan päättyneeksi kun vastaan tulee rivi, jonka sisennystaso on pienempi kuin lohkoon kuuluvien rivien.
  1. Kuvaus
  2. Lisätietoa
Looginen operaattori (engl. boolean operator) viittaa Boolen algebran operaatiohin, joissa käsitellään totuusarvoja. Tyypillisiä loogisia operaatioita ovat ehtolauseista tutut and, not ja or. Näistä and on tosi jos ja vain jos molemmat operandit ovat tosia; or on tosi jos ainakin toinen operandeista on tosi; ja not on tosi, jos sen ainoa operandi on epätosi.
Lähdekoodi – lyhemmin koodi – (engl. source code, code; alan slangi sorsa) tarkoittaa tekstiä, joka on kirjoitettu ohjelmointikielellä.
Merkillä (engl. character) tarkoitetaan ohjelmoinnissa yksittäistä datana esiintyvää kirjainta, numeroa, välimerkkiä tai muuta vastaavaa symbolia. Pythonissa merkki edustaa pienintä merkkijonon yksittäistä palasta.
  1. Kuvaus
  2. Esimerkit
Merkkijono (engl. string) on tietotyyppi, joka sisältää tekstiä. Sitä käytetään erityisesti käyttäjän kanssa viestimiseen. Merkkijonojen sisältöä voidaan myös tallentaa tiedostoihin. Pythonissa merkkijono merkitään lainaus- tai heittomerkillä (esimerkiksi "aasi" tai 'aasi'). Suosimme ensimmäistä. Merkkijono voidaan merkitä myös kolmella merkillä jolloin se voi olla monirivinen – tätä käytetään erityisesti dokumenttimerkkijonojen (docstring) kanssa. Merkkijono on muuntumaton tietotyyppi – kaikki, mikä näennäisesti muokkaa merkkijonoa, tosiasiassa luo (ja palauttaa) siitä muutetun kopion.
  1. Kuvaus
  2. Esimerkit
Metodi (engl. method) on funktio, joka on osa objektia eli objektin ominaisuus, jolla objekti usein muuttaa omaa tilaansa. Metodia kutsuttaessa käsiteltävä objekti tulee kutsun eteen: valinta.lower(). Metodeita kutsutaan myös joskus jäsenfunktioiksi (engl. member function).
Metodikutsu (engl. method call) vastaa toiminnaltaan funktiokutsua. Merkittävänä erona kuitenkin käsiteltävä objekti on metodikutsun edessä siinä missä funktiokutsussa se annettaisiin argumenttina. Metodikutsussa siis objekti tyypillisesti käsittelee itseään. Esimerkiksi sana.upper() on metodikutsu, jossa käsitellään sana-muuttujan viittaamaa objektia.
Moduuli (engl. module) on periaatteessa mikä tahansa Python-kooditiedosto. Yleisemmin kuitenkin moduulista puhutaan kirjaston synonyymina. Tyypillinen moduuli sisältää yhteen asiaan keskittyviä funktioita ja mahdollisesti muutakin (esimerkiksi vakioita ja luokkia). Laajat ohjelmat on usein myös jaettu useisiin moduuleihin siten että kukin moduuli keskittyy ohjelman toiminnan tiettyyn osa-alueeseen.
  1. Kuvaus
  2. Esimerkit
Monikko (engl. tuple) on ns. jäädytetty lista. Se on siis järjestetty kokoelma arvoja kuten listakin, mutta se on muuntumaton objekti - sen sisältöä ei siis voi muuttaa muuten kuin luomalla uuden kopion. Monikkoja voidaan siis ainoastaan luoda uusia ja lukea. Monikko merkitään yleensä kaarisulkeilla: (1, 2, 3), mutta myös pelkkä 1, 2, 3 on monikko.
Toisin kuin lista, monikko voi toimia sanakirjan avaimena.
  1. Kuvaus
  2. Esimerkit
Pythonissa objektit erotellaan muuntuviin ja muuntumattomiin. Muuntumaton (engl. immutable) arvo on sellainen, jonka sisältö ei voi muuttua - kaikki operaatiot jotka näennäisesti muuttavat arvoa tosiasiassa luovat siitä uuden kopion, joka yleensä sijaitsee uudessa muistipaikassa. Esimerkiksi merkkijonot ovat tyypillinen muuntumaton tyyppi Pythonissa. Siksi merkkijonojen kanssa näkee yleensä jotain tällaista: valinta = valinta.lower()
  1. Kuvaus
  2. Esimerkit
Pythonin objekteissa on kahta tyyppiä: muuntuvia ja muuntumattomia. Muuntuvat (engl. mutable) objektit ovat sellaisia, joiden arvo voi muuttua suorituksen aikana esim. metodikutsun seurauksena. Yleisin esimerkki muuntuvista objekteista on lista: muumilaakso.append("Hemuli") muuttaa muumilaakso-nimistä listaa pysyvästi lisäämällä siihen uuden arvon. Kaikki listaan viittaavat lauseet ohjelmassa käsittelevät tästä eteenpäin listaa, johon "Hemuli" on lisätty.
Yksinkertaistettu tapa käsittää muuttuja (engl. variable) on ajatella sitä tietovarastona – muuttuja sisältää jotain. Tätä ilmaisua käytetään usein puheessa, mutta se ei ole täysin tarkka. Tarkempi kuvaus on, että Python-muuttuja on viittaus arvoon. Se on siis yhteys muuttujan nimen ja tietokoneen muistissa olevan arvon välillä. Muuttuja ei siis varsinaisesti sisällä arvoa – se ainoastaan sisältää tiedon siitä mistä arvo löytyy.
Ohjelmointikielissä on oleellista ymmärtää määrittelyn (engl. definition) ero suorittamiseen. Määrittelemällä luodaan kuvauksia funktioista, muuttujista ja erilaisista tietorakenteista – tavallaan siis kerrotaan ohjelmointikieltä käyttäen, minkälainen jokin edellä mainituista asioista on, tai mitä sen kuuluisi tehdä. Pythonissa määrittelyn ja suorittamisen ero on helpoin ymmärtää funktioiden avulla. Funktiomäärittelyssä funktio vasta luodaan – ikään kuin tehtaalla koottu laite. Funktiota varsinaisesti käytetään – eli sen toiminnallisuus hyödynnetään funktiota varten määriteltyä koodia ajamalla – vasta funktiokutsun yhteydessä. Samaa vertausta käyttäen funktiokutsu vastaa siis sitä hetkeä, kun tehtaalta saapunut laite käynnistetään.
  1. Kuvaus
  2. Esimerkit
Nimeämätön vakio tai taikaluku (engl. magic number) on koodissa esiintyvä literaaliarvo, jota ei selitetä millään tavalla. Hyvään ohjelmointityyliin kuuluu taikalukujen välttäminen. Oikea – itsedokumentoiva – tapa on nimetä koodissa esiintyvät vakiot muuttujiin, jolloin niiden muuttaminen onnistuu tarpeen tullen yhdestä paikasta yhdellä muutoksella, ja koodin lukijan on helpompi ymmärtää koodia.
  1. Kuvaus
  2. Nimeämiskäytännöt
Muuttujilla, funktioilla, vakioilla, moduuleilla ja muilla vastaavilla on kullakin nimi (engl. identifier) – se osa lähdekoodia, joka tarkoittaa kyseistä asiaa. Esimerkiksi, jos ohjelmoija määrittelee koodin alussa muuttujan leveys arvolla 15, kyseisellä leveys-nimellä voidaan myöhemmin käyttää kyseistä muuttujaa. Nimen voidaan siis ajatella olevan ohjelmoijan ja koodia lukevan tulkin yhteinen ymmärrys siitä, mihin asioihin lähdekoodissa esiintyvät sanat viittaavat. Nimet kuuluvat aina johonkin nimiavaruuteen.
Nimiavaruus (engl. namespace) on joukko nimiä (muuttujia, vakioita, funktioita jne.) jotka kuuluvat samaan kontekstiin. Esimerkiksi funktion sisällä, eli funktiomääritelmän lohkossa on oma nimiavaruus: funktion sisällä määritetyt nimet ovat käytössä ainoastaan sen sisällä. Ohjelmalla on myös aina päänimiavaruus (engl. global namespace), jossa kaikki pääohjelmassa määritetyt nimet sijaitsevat. Tavallista import-lausetta käytettäessä saadaan niin ikään erillinen nimiavaruus, johon päästään käsiksi moduulin nimen kautta – moduulin sisäiset nimet ovat siis tällöin erillisessä avaruudessa. Katso myös näkyvyysalue.
Nimikonflikti syntyy, jos useammalle kuin yhdelle arvolle koitetaan antaa sama nimi. Tällöin tapahtuu niin, että tuoreempi sijoitus jåä voimaan. Tästä seuraa yleensä ohjelman kaatavia virheitä, koska usein arvot ovat eri tyyppiä. Voi jopa käydä niin, että epämääräisesti nimetyn funktion päälle tallennetaan vahingossa saman niminen muuttuja.
  1. Kuvaus
  2. Esimerkit
Näkyvyysalue (engl. scope) määrittää sen, onko jokin tietty nimi (muuttuja, funktio tms.) käytettävissä tietyssä kohdassa ohjelmaa. Esimerkiksi funktiomääritelmän lohkossa voidaan viitata funktiossa määriteltyihin muuttujiin, koska ne ovat funktion näkyvyysalueella. Sen sijaan muut funktiot eivät voi viitata näihin muuttujiin, koska ne kuuluvat eri näkyvyysalueelle. Globaalin (ts. pääohjelman) näkyvyysalueen nimet ovat luettavissa kaikkialla koodissa.
  1. Kuvaus
  2. Syventävää nippelitietoa
Näppäimistökeskeytyksellä (engl. keyboard interruption) voi pakottaa jumiin jääneen ohjelman sammumaan. Sen saa aikaan painamalla Ctrl+C sen terminaalin ollessa auki, jossa ohjelma pyörii. Pythonissa näppäimistökeskeytyksen saa käsiteltyä kaappaamalla KeyboardInterrupt-poikkeuksen try-except-rakenteella.
Objekti (engl. object), joskus myös olio, on Pythonissa yleistä terminologiaa. Kutsumme objekteja pääasiassa arvoiksi alkeiskurssilla, mutta Pythonissa kaikkea voi käsitellä objekteina. Tämä tarkoittaa, että mihin tahansa voidaan viitata muuttujilla (esimerkiksi funktion voi sijoittaa muuttujaan). Tämän kurssin puitteissa objekti-termiä käytetään sellaisista arvoista joilla on metodeja.
Objektit nousevat merkittävämpään rooliin alkeista eteenpäin, erityisesti koodissa jossa käytetään luokkia.
Ohjausrakenne (engl. control structure) on yleisnimitys ohjelmointikielen sallimista keinoista, jotka hallitsevat jollain tavalla ohjelman suorituksen kulkua. Näihin rakenteisiin lukeutuvat kurssin puitteissa ehtorakenteet, toistorakenteet sekä poikkeusten käsittely.
Ohjelmointiongelma on ohjelmointityön kohde. Se on siis jokin todettu tarve, jota varten ohjelmaa koodataan. Tarve voi olla jonkin tietokoneella tehtävän asian automatisointi, verkkosivun pystyttäminen tai ihan vain hauskan pelin tekeminen.
Ohjelmointityyli (engl. programming style) on joukko ohjeita tai tapoja, joita ohjelmoija noudattaa koodia kirjoittaessaan. Näihin tapoihin lasketaan muun muassa sisennyksen syvyys, muuttujien ja funktioiden nimeämiskäytännöt, välilyöntien käyttö lauseissa sekä monet muut tyyliseikat. Ohjelmointityylejä on useita erilaisia, ja tällä kurssilla opetetaan noudattamaan tiettyjä tyyliin liittyviä sääntöjä.
Ohjelmointivirhe eli bugi (engl. bug) on virhe ohjelman lähdekoodissa. Bugien seurauksena ohjelma ei välttämättä käynnisty ollenkaan, kaatuu, voi joissain tilanteissa toimia väärin ja joskus aiheuttaa jopa erittäin vakavia tietoturvaongelmia. Huolellinen ohjelmointi ja testaaminen – myös harvinaisilla nurkkatapauksilla – vähentää bugien todennäköisyyttä. Ohjelman havaitun virheellisen toiminnan aiheuttavan koodin etsimistä ja korjaamista kutsutaan debuggaukseksi.
Oletusarvo (engl. default value) on arvo, joka annetaan funktion valinnaisella parametrille mikäli sitä vastaavaa argumenttia ei annettu funktiota kutsuttaessa. Esimerkiksi def kysy_pituus(kysymys, maksimi=10): -määrittelyrivillä maksimi on valinnainen parametri, jonka oletusarvo on 10.
Ominaisuus (attribute) liittyy objekteihin siten, että objekteilla voidaan sanoa olevan ominaisuuksia. Tällä kurssilla useimmat näistä ominaisuuksista ovat metodeja, mutta ne voivat olla myös arvoja. Objektin ominaisuutta käsitellään notaatiolla, jossa objektin nimen ja ominaisuuden nimen väliin tulee piste, esim: valinta.lower()-metodikutsussa valinta on objekti ja lower on ominaisuus.
  1. Kuvaus
  2. Esimerkit
Operaatio-nimitystä (engl. operation) käytetään esimerkiksi matemaattisille operaatioille. Yleisesti ottaen puhutaan operaatiosta, kun koodirivillä esiintyy operaattori ja operandeja. Esimerkiksi 5 + 5 on operaatio.
Operaattori (engl. operator) on matematiikassa ja ohjelmoinnissa nimitys symboleille, jotka kuvaavat jotain operaatiota. Operaattorilla on aina vähintään yksi operandi, mutta useimmilla kaksi. Esimerkiksi +-merkki on yhteenlaskuoperaattori.
Operandi (engl. operand) on hieno matematiikassa ja ohjelmoinnissa käytössä oleva nimitys arvoille joita käytetään operaatiossa. Esimerkiksi 5 + 8 on yhteenlaskuoperaatio, jonka operandit ovat 5 ja 8. Operandien voidaan siis sanoa olevan operaatioiden kohteita.
  1. Kuvaus
  2. Parametrien valinta
  3. Lisämuotoilu
Paikanpidin (engl. placeholder) on yleisesti tilapäinen merkintä, joka on tarkoitus korvata toisella. Tällä kurssilla sitä käytetään lähinnä merkkijonojen muotoilun yhteydessä. Paikanpidin merkkijonon sisällä merkitään aaltosulkeilla ("Hei {}".format(nimi)). Merkkijonojen paikanpitimissä voi olla lisämäärityksiä kuten näytettävien desimaalien lukumäärä ("Aaseilla on keskimäärin {:.2f} jalkaa".format(keskiarvo)). Paikanpitimien tilalle sijoitetaan format-metodikutsun argumentit, normaalisti esiintymisjärjestyksessä. Ne voidaan kuitenkin myös numeroida tai käyttää avainsanoja.
Pakeneminen (engl. escape) tarkoittaa ohjelmoinnissa sitä, että jokin merkki tulkitaan eri tavalla kuin normaalisti. Esimerkiksi "n" on vain n-kirjain, mutta "\n" on rivinvaihto – tässä siis \-merkki (kenoviiva, engl. backslash) aiheuttaa sen, että n-merkin normaali merkitys paetaan ja korvataan toisella merkityksellä; kenoviiva toimii siis koodinvaihtomerkkinä (engl. escape character). Yksi tyypillinen käyttö on sisällyttää "-merkki merkkijonoon, joka on rajattu "-merkeillä: "aasin korvien väli on 14\""
  1. Kuvaus
  2. Esimerkit
Palauttaminen (engl. return) tapahtuu aina kun funktion suoritus päättyy. Tyypillisesti funktion palauttama(t) arvo(t) määritellään funktion sisällä return-lauseella. Funktiota kutsuvassa koodissa paluuarvo näkyy funktiokutsun paikalla, jolloin se voidaan esimerkiksi tallentaa muuttujaan tai laittaa eteenpäin toiselle funktiolle.
Paluuarvo (engl. return value) on nimitys arvolle tai arvoille, jotka funktio palauttaa, kun sen suoritus päättyy - eli siis funktion tulos. Pythonissa funktiolla voi olla useita paluuarvoja. Koodia lukiessa paluuarvoa voi käsitellä päässään siten, että funktiokutsun paikalle sijoitetaan funktion paluuarvo sen jälkeen kun funktio on suoritettu. Paluuarvo löytyy funktion sisältä return-lauseen yhteydestä. return True -rivillä on yksi paluuarvo – totuusarvo True.
Parametri (engl. parameter) on funktion määrittelyssä nimetty muuttuja. Parametreihin sijoitetaan funktion saamien argumenttien arvot silloin, kun funktiota kutsutaan. Parametri on siis nimitys jota käytetään, kun puhutaan arvojen siirtymisestä funktion näkökulmasta. def kysy_syote(kysymys, virheviesti): -rivillä siis kysymys ja virheviesti ovat parametreja. Parametrille voidaan määrittää oletusarvo jonka se saa, jos sitä vastaavaa argumenttia ei anneta kutsuttaeassa – tämä tekee kyseisestä argumentista valinnaisen.
  1. Kuvaus
  2. Esimerkit
Poikkeus (engl. exception) on ohjelmointikielessä määritelty virhetilanne. Poikkeuksella on tyyppi (esimerkiksi TypeError), jota voi käyttää poikkeuksen käsittelyssä ohjelman sisällä sekä myös apuna virhetilanteen ratkaisussa. Tyypillisesti poikkeukseen liitetään myös viesti, joka kertoo mistä ongelmassa on kyse. Pythonissa poikkeuksia käsitellään try-except-rakenteilla.
  1. Kuvaus
  2. try-except-else-finally
Poikkeusten käsittely (engl. exception handling) on ohjelmointikieleen sisäänrakennettu keino ohjelmoijalle reagoida poikkeuksiin. Pythonissa poikkeusten käsittely onnistuu try-except-rakenteella, jossa sekä try: että except: aloittavat omat lohkonsa; try-lohkon alle kirjoitetaan se koodi, joka mahdollisesti aiheuttaa jonkun tietyn poikkeuksen ja except-lohkon alle taas se koodi, joka suoritetaan siinä tapauksessa, että kyseinen poikkeus tapahtuu. Joissain muissa ohjelmointikielissä except-avainsanan sijaan käytetään avainsanaa catch, minkä takia yleisesti puhutaan poikkeusten kiinni ottamisesta.
  1. Kuvaus
  2. Esimerkit
Polku (engl. path) on tiedoston tai kansion sijainti kiintolevyllä. Polku voi olla absoluuttinen tai relatiivinen. Absoluuttinen polku sisältää kaikki kansiot aina juureen asti (esim. Windowsissa asemakirjain kuten C:), kun taas relatiivinen sisältää kansiot aktiiviseen kansioon asti (ts. siihen kansioon mistä ohjelma käynnistettiin). Polku esitetään ohjelmointikielissä yleensä merkkijonona, ja polun osat erotetaan kauttaviivalla /. Useimmiten polkuja muodostaessa kannattaa käyttää os.path-moduulin join-funktiota.
  1. Kuvaus
  2. Esimerkit
Interaktiivinen Python-tulkki (engl. interactive Python interpreter) tai Python-konsoli (engl. Python console) on ohjelma, johon voi kirjoittaa Python-koodirivejä. Nimitys ”interaktiivinen” tulee siitä, että koodirivi suoritetaan välittömästi sen syöttämisen jälkeen, ja ohjelma näyttää käyttäjälle koodirivin tuottaman paluuarvon (esimerkiksi matemaattisen operaation tuloksen). Kurssilla suositellaan IPython-tulkkia, joka käynnistetään asennuksen jälkeen komennolla ipython.
Python-tulkki (engl. Python interpreter) on ohjelma, joka muuttaa Python-koodin tietokoneelle annettaviksi ohjeiksi. Se vastaa niin kooditiedostojen kuin myös interaktiiviseen Python-tulkkiin kirjoitettujen komentojen suorittamisesta. Tällä kurssilla sanalla tulkki viitataan kuitenkin useimmiten nimenomaan interaktiiviseen Python-tulkkiin.
Pythonissa pääohjelma (engl. main program) on se osa koodia, joka suoritetaan, kun ohjelma käynnistetään. Nyrkkisääntönä pääohjelma sisältää kaikki lauseet sekä ohjausrakenteet jotka ovat kiinni koodin vasemmassa laidassa. Pääohjelma sijaitsee tyypillisesti koodin lopussa, ja useimmiten if __name__ == "__main__":-lauseen alla. Älä kuitenkaan käytä tätä lausetta alkupään harjoitustehtävissä, koska tarkistin ei pysty tällöin suorittamaan koodisi pääohjelmaa.
  1. Kuvaus
  2. Esimerkit
Rajapinta (engl. interface) viittaa yleisesti kahden eri asian välimaastoon, ja ohjelmoinnissa sillä tarkoitetaan erityisesti tapaa, jolla ohjelman eri osat voivat liittyä toisiinsa. Esimerkiksi funktion rajapinnasta puhuttaessa tarkoitetaan sitä muotoa, jossa funktio vastaanottaa tietoa ja suoriutumisen jälkeen antaa käsiteltyä tietoa tai jonkun lopputuloksen ulos. Kirjastoilla on yleensä olemassa jonkinlainen niin kutsuttu API, eli Application Programming Interface, joka kertoo sen, kuinka kirjaston toiminnallisuuksia käytetään. Ihmiset taas ovat ohjelmiin kytköksissä käyttöliittymän (engl. User Interface, lyh. UI) kautta, joka sekin on tietynlainen rajapinta.
Ratkaisumalli on ohjelmoijan muodostama abstrakti ajatus siitä miten ohjelmointiongelman ratkaisu etenee. Ratkaisumalli ei ole vielä koodia, mutta sen tulisi olla yksiselitteinen sekä selkeisiin välivaiheisiin jakaantuva, jotta sen pohjalta voidaan kirjoittaa ohjelma. Ratkaisumallia voi hahmotella päänsisäisesti, käyttämällä avuksi paperia sekä kokeilemalla asioita Python-tulkissa.
  1. Kuvaus
  2. Esimerkit
Rekursio (engl. recursion) on yleinen ohjelmointitermi, joka viittaa siihen, kun funktio kutsuu itseään. Rekursio on siis funktiopohjainen tapa luoda toistorakenne, jossa funktio välittää itselleen uusia argumentteja ja käsittelee omia paluuarvojaan. Rekursio on kätevä esimerkiksi puumaisia rakenteita käsitellessä – käsitellään yksi ”oksa” jollain tavalla, ja sitten rekursion avulla käsitellään tästä oksasta lähtevät oksat ja niin edelleen. Pythonissa rekursiota käytetään aika vähän. Osasyynä on sisäänrakennettu rekursiorajoitus, joka asettaa katon sille, kuinka monta kertaa funktio saa kutsua itseään.
Rivinvaihtomerkki (engl. newline, line break, end of line; lyh. EOL) eli "\n" on merkki, joka tulostettaessa tai tiedostoon kirjoitettaessa saa aikaan rivinvaihdon. Jos merkkijonoa tarkastellaan ilman printtausta esim. konsolissa, rivinvaihdot näkyvät "\n"-merkkeinä.
  1. Kuvaus
  2. Määrittely
  3. Arvojen haku
  4. Sanakirjan muuttaminen
Sanakirja (engl. dictionary) on tietorakenne, jossa arvoille annetaan avaimet (yleensä merkkijono). Sanakirjan merkittävin etu on se, että selkeästi nimetyt avaimet tekevät tietorakennetta käsittelevästä koodista huomattavasti selkeämpää luettavaa. Python 3.7:sta lähtien sanakirjan avaimet ja arvot ovat siinä järjestyksessä missä ne on lisätty.
Sapluuna (engl. template) on muotti esimerkiksi tekstille, joka käyttäjälle halutaan näyttää, mutta joka ei semmoisenaan ole vielä valmis. Sapluunasta siis puuttuu tietoa, joka on tarkoitus saada sapluunan paikanpitimien tilalle.
Kurssilla yleisin sapluuna on merkkijono, jossa on paikanpitimiä format-metodia varten.
Sekvenssi (engl. sequence) on mikä tahansa arvo Pythonissa, jossa on tavaraa peräkkäin – esimerkiksi merkkijono, lista ja monikko kuuluvat näihin.
Matematiikasta tuttu sidontajärjestys (engl. precedence) määrittää sen, missä järjestyksessä lausekkeen operaatiot suoritetaan.
lopputulos = 10 + 2 * (2 + 3)
Yllä olevan koodin lopputulos on 20, sillä ensin lasketaan yhteen luvut 2 ja 3, joiden summa kerrotaan kahdella, ja johon lopuksi lasketaan vielä yhteen luku 10. Esimerkissä korkein presedenssi on siis sulkeilla, toisiksi korkein kertolaskulla ja matalin yhteenlaskulla.
Sijoittaminen (engl. assignment) liittyy muuttujiin ja arvoihin. Tyypillinen ilmaisu on ”muuttujaan sijoittaminen”, joka yksinkertaistettuna tarkoittaa sitä, että tietty arvo annetaan muuttujalle (x = 5). Tarkennettuna muuttujaan sijoittaminen kuitenkin tarkoittaa Pythonissa sitä, että muuttujan ja arvon välille luodaan viittaus – muuttuja tietää mistä arvo löytyy.
Samaa tarkoittavia ilmaisuja ovat mm. muuttujaan tallentaminen, arvon ottaminen ylös muuttujaan, arvoon viittaminen muuttujalla, arvon tunkeminen muuttujaan... jne.
Sijoitusoperaattoria (engl. assignment operator) eli =-merkkiä käytetään muuttujaan sijoituksessa. Operaattoria käytettäessä kohteena olevan muuttujan tulee aina olla sen vasemmalla puolen ja sijoitettavan arvon (tai lausekkeen, joka tuottaa sijoitettavan arvon) sen oikealla puolen.
Silmukkamuuttuja (engl. loop variable) on for-silmukan määrittelrivillä esitelty muuttuja, joka saa yksitellen kaikki läpikäytävän sekvenssin (esim. lista) arvot. Sen arvo siis vaihtuu jokaisella silmukan kierroksella. Yksinkertainen esimerkki materiaalista: for elain in elukoita:, jossa siis elain on silmukkamuuttuja. Mikäli läpikäytävä sekvenssi sisältää monikoita (tai listoja), silmukkamuuttujia voi olla myös useita: for opiskelija, arvosana in arvostelu:. Silmukkamuuttujat eivät ole erillisessä nimiavaruudessa, joten niiden tulee erota muista funktion/pääohjelman muuttujista.
Sisennetyn (engl. indented) koodirivin edessä on tyhjää eli välilyöntejä tai sarkainmerkkejä. Sisennyksen tehtävä on parantaa koodin luettavuutta yleisesti. Pythonissa sisennys myös erottaa koodilohkot toisistaan - kaikki samalla sisennystasolla olevat rivit ovat samaa lohkoa. Tällä kurssilla käytetään välilyöntejä, ja yksi sisennys on 4 välilyöntiä. Kaikki järkevät tekstieditorit saa syöttämään sarkainmerkin sijaan halutun määrän välejä.
Sisäänrakennetut funktiot (engl. builtin functions) ovat funktioita, jotka tulevat Pythonin mukana, ja niitä käyttääkseen ei tarvitse erikseen ottaa käyttöön mitään moduulia/kirjastoa.
Suorittaminen (engl. execution) tai ajaminen (engl. running) tarkoittaa ohjelman tai koodinpätkän koneistettua läpi käymistä, jolloin ohjelmassa tai koodissa määritellyt asiat tapahtuvat. Python-tulkki suorittaa sille annettua koodia lause kerrallaan – tällöin ohjelman sanotaan olevan käynnissä. Kun enempää suoritettavaa koodia ei ole, törmätään käsittelemättömään virheeseen tai koodissa erikseen niin määrätään, ohjelman suorittaminen päättyy.
Syntaksi (engl. syntax) on koodin kielioppi. Esimerkiksi Pythonin syntaksi määrittää, millainen teksti on tulkittavissa Python-koodiksi. Jos teksti ei noudata koodin syntaksia, sitä ei voida suorittaa. Syntaksi antaa myös koodaajalle tietoa siitä, missä muodossa halutunlainen ohje tulee antaa.
Syntaksivirhe (engl. syntax error) on poikkeus, joka syntyy, kun Python-tulkki tutkii kooditiedostoa ennen sen suorittamista ja havaitsee siellä rikkinäistä – eli jollain tapaa väärin kirjoitettua – koodia. Syntaksivirhe estää koodin suorittamisen.
Yksi hyvin yleinen syntaksivirhe on sulkujen auki jääminen. Tällöin syntaksivirheilmoitus näyttää poikkeuksen tapahtuneen vasta virheellistä riviä seuraavalla rivillä! Muista siis mystisen syntaksivirheviestin äärellä katsoa myös edeltäviä rivejä.
  1. Kuvaus
  2. Esimerkit
Syöte (engl. input) on tämän kurssin puitteissa käyttäjältä pyydetty tekstimuotoinen komento tai vastaus kysymykseen. Syöte kysytään input-funktiolla, ja se on aina merkkijono. Aina, kun ohjelma kysyy syötettä, sen suoritus pysähtyy, kunnes käyttäjä on antanut syötteen.
Takaisinkutsu (engl. callback) on yleinen ohjelmoinnissa käytetty menetelmä, jossa funktio ottaa parametrin kautta vastaan funktion kutsuttavakseen heti (synkroniset takaisinkutsut) tai joskus tulevaisuudessa (asynkroniset takaisinkutsut). Nimensä menetelmä on saanut soittopyynnöstä: kutsuttavaa funktiota, jolle jokin funktio välitetään argumenttina, ”pyydetään” kutsumaan tätä annettua funktiota. Pythonissa listojen sort()-metodin key-parametri on esimerkki callback-funktioiden käytöstä. Usein käyttöliittymiä toteutettaessa käyttöliittymäelementteihin kytketään callback-funktioita.
Tallennusformaatti on tiedoston "syntaksi", joka siis kertoo miten data on tiedostoon tallennettu. Tallennusformaatti asettaa rajat sille millaista dataa tiedostossa voidaan esittää. Sen perusajatus on se, että koodissa olevat tietorakenteet voidaan tallentaa tiedostoon jossain muodossa, ja myöhemmin ladata sieltä uudelleen. Tallennusformaatti voi seurata jotain alan standardia (esim. JSON), mutta lopullisesti on ohjelman tekijän vastuulla päättää mitkä tiedot ovat ohjelman kannalta relevantteja ja miten ne on paras esittää.
Tapahtuma (engl. event) on ohjelmointikäsite, jota käytetään yleisesti interaktiivisten sovellusten, jotka pyörivät reaaliajassa, yhteydessä. Näissä sovelluksissa on yleensä pääsilmukka, joka tarkkailee tapahtumia, joita voivat olla esimerkiksi: käyttäjä klikkaa hiirellä, käyttäjä painaa näppäimistön nappia, tietty aika on kulunut jne. Tapahtumiin voidaan kiinnittää käsittelijäfunktioita, jolloin funktiota kutsutaan aina kun tapahtuma havaitaan. Tällä tavalla helpotetaan merkittävästi interaktiivisten sovellusten ohjelmointia, koska itse sovellusta kirjoittaessa ei tarvitse huolehtia siitä miten ruudun tapahtumat tunnistetaan.
Periaatteessa tekstitiedosto (engl. text file) on mikä tahansa tiedosto, jonka sisältö voidaan lukea nätisti tekstieditorilla. Tämän kurssin kontekstissa kuitenkin tekstitiedosto on erityisesti sellainen tiedosto, jonka sisältöä käsitellään tekstinä Pythonissa. Eli siinä missä kooditiedostoja suoritetaan, tekstitiedostoja käytetään datan varastoimiseen ohjelman ajojen välillä.
Terminaali (engl. terminal), komentokehote (engl. prompt) ja komentorivi (engl. command line) ovat eri nimiä käyttöjärjestelmän tekstipohjaiselle käyttöikkunalle. Komentorivillä annetaan tekstikomentoja käyttöjärjestelmälle. Tällä kurssilla pääasiassa siirrytään cd- eli change directory -komennolla hakemistosta toiseen ja käytetään ipython-komentoa kooditiedostojen suorittamiseen sekä interaktiivisen tulkin avaamiseen.
  • Windowsissa komentoriville pääsee kirjoittamalla käynnistä-valikon hakuun cmd
  • Mac OS X -käyttöjärjestelmässä komentorivin saa auki kirjoittamalla Finderiin pääte (suomen kielisissä versioissa) tai terminal (englannin kielisissä versioissa)
  • Linux-työpöytäympäristöistä voit painaa Ctrl + Alt + T työpöydällä tai kirjoittaa hakuun {{terminal}}}
Testaamalla eli kokeilemalla (engl. test) selvitetään, toimivatko hartaasti näppäillyt koodirivit halutulla tavalla. Testejä suorittamalla siis etsitään koodista mahdollisia ohjelmointivirheitä. Ohjelmien testaaminen on jopa niin olennaista, että joidenkin alan työntekijöiden tehtävänä on ainoastaan automatisoitujen testien ohjelmointi. Lovelace-järjestelmän tarkistimet testaavat järjestelmään lähetetyt koodit.
Tiedostokahva (engl. file handle) on erityinen objekti, jota Pythonissa käytetään avattuun tiedostoon viittaamiseen. Huomattavaa on, että kahva ei ole sama asia kuin tiedoston sisältö, mutta sen kautta voidaan lukea tiedoston sisältö tai kirjoittaa tiedostoon. Tiedostokahva saadaan käyttöön open-funktiolla, jolle määritetään avattavan tiedoston sijainti sekä avausmoodi, jossa se avataan, esim: with open("aasi.txt", "r") as tiedosto: avaa aasi.txt-tiedoston with-lauseessa (jossa tiedostot tulee yleensä avata) siten, että muuttujasta nimeltä tiedosto löytyy tiedostokahva.
Tiedostonimi (engl. filename) on tiedoston koko nimi, joka sisältää varsinaisen tiedostolle annetun nimen sekä tiedostopäätteen. Esimerkiksi aasisvengaa.py on kokonainen tiedoston nimi, jossa varsinainen annettu nimi on aasisvengaa ja pääte on .py.
Koodin sisällä tiedostojen nimet esitetään merkkijonoina.
Tiedostopääte (engl. filename extension) on se osa tiedoston nimestä, joka on viimeisen pisteen oikealle puolen. Tiedostopäätteet ovat yleisesti käytetty tapa tiedostojen sisällön tunnistamiseen, eli ne ovat keino ilmaista tiedoston tyyppiä. Esimerkiksi kuvatiedostoilla voi olla vaikkapa .png- tai .jpg-pääte, kun taas Python-kooditiedoston pääte on yleensä .py, kuten nimessä aasisvengaa.py.
Tietorakenne (engl. data structure) on yleisnimitys kokoelmille, jotka sisältävät useita arvoja. Tietorakenteen tarkoitus on siis säilöä useammasta kuin yhdestä arvosta koostuvaa tietoa jollain lukuisista eri tavoista, joille kullekin yleensä on olemassa tietorakenteen helpon hyödyntämisen mahdollistavat ohjelmointikeinot, kuten arvojen lisääminen, poistaminen ja muokkaaminen tietorakenteesta. Tietorakenne on siis ohjelman sisäinen tapa käsitellä dataa siten, että varsinaiset yksityiskohdat on piilotettu ohjelmoijalta, joka käyttää tietorakenteita koodissaan.
Omissa ohjelmissa käytettävät tietorakenteet tulisikin valita siten, että niitä on helppo käsitellä koodissa, ja että ne palvelevat hyvin ohjelman tarkoitusta. Pythonissa yleisimmät tietorakenteet ovat lista, monikko ja sanakirja. Myös set – eli joukko-opillinen joukko, joka ei sisällä duplikaattiarvoja – on käytännöllinen tietorakenne. Sisäänrakennettujen lisäksi lukuisia käytänöllisiä tietorakenteita löytyy collections-moduulista.
Myöhemmillä kursseilla tutuksi tulevat myös muun muassa tärkeät tietorakenteet puu (engl. tree) ja graafi (engl. graph).
Tila (engl. state) viittaa sananmukaisesti ohjelman tilanteeseen. Käytännössä ohjelman tila kattaa kaikki sen tila-avaruuteen (engl. state space) kuuluvat asiat, kuten muuttujien arvot, tiedostoissa olevan datan ja sen, mitä kohtaa koodista sillä hetkellä ollaan suorittamassa. Taattu keino saada aikaiseksi korjauskelvotonta spagettikoodia on käyttää niin kutsuttua globaalia tilaa (engl. global state) – rikos, johon syyllistyvät epäpuhtaat globaaleja muuttujia hyödyntävät funktiot.
Myöhemmillä, ohjelmoinnin käsitteitä formaalimmin tutkivilla kursseilla tutuksi tulevat muun muassa tilakoneet (engl. state machine) sekä tilattomat (engl. stateless) että tilalliset (engl. stateful) ohjelmat.
Toistorakenne tai silmukka (engl. loop) on ohjausrakenne, jonka alaisuuteen kirjoitettua koodia toistetaan joko tietty lukumäärä toistoja tai kunnes jokin ehto lakkaa toteutumasta. Toistorakenteiden avulla ohjelmat pystyvät jouhevasti palaamaan aiempaan kohtaan suoritusta ja niillä voidaan myös helposti käsitellä suuria määriä arvoja. Toistorakenteita ovat Pythonissa for- ja while-silmukat.
Tosi (engl. true) on toinen kahdesta mahdollisesta totuusarvosta ja toisen, eli epätoden, vastakohta. Sitä voidaan pitää lopputuloksena loogisissa ja vertailuoperaatorioissa, jotka pitävät paikkansa. Esimerkiksi vertailuoperaatio 5 > 4 pitää paikkansa, joten kyseinen operaatio evaluoituu todeksi. Pythonissa totta merkitään avainsanalla True.
Totuusarvo (engl. boolean) on yleensä ohjelmointikielien yksinkertaisin tietotyyppi, jolla on vain kaksi arvoa: tosi (Pythonissa True) ja epätosi (Pythonissa False). Vertailuoperaattorit tuottavat totuusarvoja, ja niitä käytetään yleisimmin ehtolauseiden ja while-silmukoiden yhteydessä. Pythonissa kaikki arvot vastaavat jompaa kumpaa totuusarvoa. Yleisesti ns. tyhjät arvot (0, "", None jne.) ovat sama kuin False, ja loput sama kuin True.
  1. Kuvaus
  2. Esimerkit
Traceback – taaksepäin jäljittäminen – viittaa yleiseen tapaan tutkia virhetilanteen syntymistä sen juurilta alkaen. Python-tulkki tulostaa virhetilanteessa virheviestin, johon olennaisesti kuuluu traceback. Traceback esitetään purkamalla ohjelman funktiokutsuista syntynyt pino, jonka viimeisimmässä osassa varsinainen virhe tapahtui. Tästä syystä tracebackeja kutsutaan myös nimellä stacktrace, eli pinon jäljittäminen. Jos esimerkiksi pääohjelmassa kutsutaan funktiota f, josta käsin kutsutaan funktiota g, jossa virhe tapahtuu, funktiokutsujen pino on muotoa pääohjelmafg.
  1. Kuvaus
  2. Esimerkit
Tulostaminen (engl. print) onkin ohjelmoinnissa jotain muuta – joskaan ei lopulta periaatteiltaan kovin erilaista – kuin paperin ja musteen yhdistämistä halutunlaisiksi sivuiksi. Tietokoneohjelmien yhteydessä tulostamisella tarkoitetaan tekstin tuottamista esiin näytölle, erityisesti terminaaliin. Pythonissa tätä varten on oma funktio, print(...), joka tulostaa sille annetun argumentin terminaaliin.
  1. Kuvaus
  2. Esimerkit
Tynkäfunktio (engl. stub function) on funktio, jolle on kirjoitettu oikeanlainen määrittelyrivi parametreineen, mutta ei oikeaa sisältöä. Niitä yleensä kirjoitetaan koodiin ohjelman rakennetta suunniteltaessa sekä mahdollistamaan funktioiden kutsuminen muualle ohjelmassa siten, että sitä voidaan testata ennen kuin funktioiden toteutus on valmis. Tynkäfunktion sisältönä on usein pelkkä pass, joku informatiivinen tulostus tai jonkin oletusarvon palautus. Isommissa Python-ohjelmissa tynkäfunktioissa on tapana aiheuttaa NotImplementedError-poikkeus, jolloin reitti toteuttamattoman funktion kutsuun on helppo löytää tracebackistä.
Tyylisäännöt ovat kokoelma suosituksia, joiden mukaan koodia tulisi kirjoittaa. Kullakin kielellä on yleensä omansa. Tyylisääntöjen rikkominen ei varsinaisesti riko ohjelmaa, mutta tyylisääntöjen mukainen koodi on miellyttävämpää lukea ja usein tästä johtuen myös helpompi korjata. Tällä kurssilla seurataan Pythonin virallista tyylistandardia erityisesti tekstikenttätehtävissä. Myös tiedostotehtävissä on koodin laadun tarkistus, jossa käytetään PyLint-ohjelmaa.
  1. Kuvaus
  2. Esimerkit
Tyyppi (engl. type) on arvon ominaisuus – jokainen arvo edustaa aina jotain tiettyä tyyppiä. Tyypin tarkoitus on siis kertoa, minkälaisesta arvosta on kyse. Käytännössä tästä seuraa myös se, mitä operaatioita arvoilla voi tehdä, ja mitä metodeja niiltä löytyy. Funktiot on myös miltei aina toteutettu siten, että niille syötettävien argumenttien täytyy olla tietyntyyppisiä, jotta funktio voisi toimia. Tyypit ovat yksi ohjelmoinnin keskeisimmistä käsitteistä.
Pythonissa arvojen sopiminen koodista löytyviin operaatioihin tarkistetaan tilannekohtaisesti näiden arvon ominaisuuksien perusteella – ei siis suoraan itse tyyppiä tarkastamalla. Esimerkiksi useimmissa tapauksissa kokonaisluku ja liukuluku kelpaavat molemmat, mutta on myös tapauksia, joissa näin ei ole (esimerkiksi merkkijonoa ei voi kertoa liukuluvulla).
Tällä kurssilla tyypillisiä tyyppejä ovat kokonaisluku (int), liukuluku (float), merkkijono (str), lista (list), totuusarvo (bool) ja monikko (tuple). Myös funktioilla on oma tyyppinsä!
  1. Kuvaus
  2. Esimerkit
Tyyppimuunnos (engl. type casting, type conversion, type coercion) tarkoittaa sananmukaisesti jonkin koodissa esiintyvän muuttujan tai literaaliarvon tyypin muuntamista toiseksi. Pythonissa tähän törmää usein, kun käyttäjältä on saatu merkkijonona luku, jota halutaan käsitellä esimerkiksi kokonais- tai liukulukuna. Käytännössä tämä onnistuu esimerkiksi lauseilla int("123") tai float("3.14"). Joissain tilanteissa Python-tulkki suorittaa tyyppimuunnoksen automaattisesti, kuten laskettaessa yhteen kokonais- ja liukulukuja.
  1. Kuvaus
  2. Esimerkit
Vakio (engl. constant) on nimetty literaaliarvo. Niitä käytetään erityisesti silloin kun sama literaaliarvo esiintyy koodissa useasti. Yleisesti ottaen nimetty vakio on käytännöllisempi kuin koodissa oleva literaaliarvo, koska sen nimestä voi päätellä mitä se tekee. Samaten jos arvoa tarvitsee muuttaa, vakioita käyttäessä tarvitsee muuttaa vain kohtaa jossa se määritellään. Pythonissa ei ole erillistä tapaa luoda vakioita vaan ne ovat periaatteessa ihan vain muuttujia. Vakioiden nimet kirjoitetaan isolla. Esimerkiksi VASTAUS = 42.
Funktiota kutsuttaessa argumentti on valinnainen (engl. optional argument), jos funktiossa sitä vastaavalle parametrille on määritetty oletusarvo. Tällöin kyseistä argumenttia ei ole pakollista antaa funktiokutsussa. Jos valinnaisia argumentteja on useita, ne annetaan tyypillisesti avainsana-argumentteina.
Vertailuarvoa käytetään esim. listojen järjestämisessä. Vertailuarvo on listan alkiosta johdettu arvo, jota käytetään järjestämisperusteena. Esimerkiksi jos lista sisältää listoja, vertailuarvo voi olla jostain tietystä indeksistä otettu alkio. Se voi olla myös monimutkaisempi johdannainen, kuten listan alkioiden summa tai keskiarvo.
Vertailuoperaattoreita (engl. comparison operators) käytetään, kun verrataan arvoja toisiinsa. Ne ovat matematiikasta tuttuja ja niillä voidaan verrata suuruksia. Vertailuoperaattorit palauttavat totuusarvon True tai False riippuen vertailun lopputuloksesta. Vertailuoperaattoreita ovat <, <=, >, >=, == ja !=.
Ohjelmoinnin asiayhteydessä viittaaminen (engl. reference) tarkoittaa tapaa, jolla muuttuja liittyy arvoonsa. Viittauksen kohde on tietokoneen muisti, ja muuttuja itsessään – konepellin alla – sisältää osoitteen, mistä kohdasta tietokoneen muistia siihen liitetty arvo löytyy.
  1. Kuvaus
  2. Esimerkit
Virheviesti (engl. error message) on Python-tulkin tapa ilmoittaa koodissa tapahtuneesta poikkeuksesta. Virheviestiin kuuluu tieto siitä missä kohdassa koodin suoritusta se tapahtui, mikä rivi kooditiedostossa aiheutti poikkeuksen, poikkeuksen tyyppi (esimerkiksi SyntaxError) sekä lyhyt sanallinen kuvaus. Virheviestit ovat ohjelmoijan paras ystävä, ja niiden lukeminen on erittäin oleellinen ohjelmointitaito. Niitä ei siis ole syytä säikähtää, sillä ne auttavat selvittämään, mikä ohjelman koodissa on pielessä!
  1. Kuvaus
  2. Esimerkit
Avainsana break on erityinen komento, jota käytetään toistorakenteissa. Se päättää silmukan suorituksen välittömästi, ja koodin suoritus jatkuu ensimmäiseltä silmukan jälkeiseltä riviltä. Jos silmukassa oli else-osa, siihen ei mennä.
  1. Kuvaus
  2. Esimerkit
continue on toinen toistorakenteisiin liittyvä avainsana (toisen ollessa break). Toisin kuin break, joka lopettaa koko silmukan suorituksen, continue keskeyttää ainoastaan meneillään olevan kierroksen suorituksen – suoritus jatkuu siis seuraavasta kierroksesta. Huomaa, että tätä avainsanaa tarvitaan vain tilanteissa, joissa halutaan jättää osa kierroksesta suorittamatta, eli silmukan kierroksen loppuun ei ole tarpeen laittaa continue-avainsanaa.
  1. Kuvaus
  2. Esimerkit
enumerate on Pythonissa sisäänrakennettu funktion kaltainen erityisobjekti, joka tuottaa generaattoriobjektin. Sitä käytetään pääasiassa for-silmukoissa silloin, kun on tarpeen saada läpi käytävän listan alkioiden indeksit käyttöön silmukan sisällä. enumerate-objekti tuottaa monikkoja, joissa ensimmäisenä on alkion indeksi ja toisena itse alkio. Käyttöesimerkki: for i, hahmo in enumerate(muumilaakso):.
  1. Kuvaus
  2. Esimerkit
Pythonissa for on toinen silmukkatyyppi. Sen käyttötarkoitus on tietorakenteiden läpikäyminen – iterointi. Sitä käytetään erityisesti listojen kanssa. Yleisesti ottaen for-silmukkaa käytetään silloin, kun pystytään ennalta määrittämään montako kierrosta silmukkaa tulee pyörittää. Tietorakenteiden läpikäynnin lisäksi näihin lukeutuu tietyn toistomäärän tekeminen (esimerkiksi kymmenen toistoa). Silmukan määrittelyrivi on muotoa: for alkio in lista:, jossa alkion paikalle tulee silmukkamuuttujan nimi ja listan paikalla ilmoitetaan läpikäytävä tietorakenne.
  1. Kuvaus
  2. Esimerkit
Pythonissa moduuleja otetaan käyttöön import-lauseella. Normaalikäytössä (esim. import math) lause tuo ohjelmaan uuden nimiavaruuden, joka on sama kuin moduulin nimi. Tämän nimen kautta päästään käsiksi moduulin funktioihin. Nimistä voi myös tuoda ainoastaan osan from-import-lauseella: from math import ceil. Moduulille voidaan myös antaa eri nimi as-avainsanalla: import math as m.
  1. Kuvaus
  2. Esimerkit
Silmukoista while pohjautuu toistoon ehdon tarkastelun kautta - silmukan sisällä olevaa koodilohkoa suoritetaan niin kauan kuin silmukalle annettu ehto on tosi. Ehto määritetään samalla tavalla kuin ehtolauseissa, esim: while summa < 21. While-silmukat soveltuvat parhaiten sellaisiin tilanteisiin, joissa ei voida etukäteen selvittää montako toistoa tarvitaan - erityisesti syötteiden kysyminen käyttäjältä on tällainen tilanne.
  1. Kuvaus
  2. Esimerkit
Pythonissa with on hieman muista poikkeava avainsana, sillä se ei ole varsinaisesti ohjausrakenne tai uuden asian määrittely. Tällä kurssilla sitä käytetään pääasiassa tiedostojen avaamisessa, tyyliin with open("aasi.txt") as tiedosto:. Tiedoston luku- tai kirjoitusoperaatiot suoritetaan with-lauseen alla. Kun with-lohko päättyy, Python huolehtii automaattisesti with-lauseessa avattujen tiedostojen yms. sulkemisesta.