Termipankki
  1. A
    1. Absoluuttinen polku
    2. Ajonaikainen
      konseptit
    3. Alkio
      arvot listat
    4. Alustaminen
      muuttujat arvot
    5. Argumentti
      arvot funktiot
    6. Arvo
      arvot
    7. Avain
      sanakirjat arvot
    8. Avainsana
      nimet
    9. Avainsana-argumentti
      funktiot
    10. Avausmoodi
      tiedostot
    11. Aliohjelma
      Funktio
    12. Attribuutti
      Jäsenarvo
    13. 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-luokka
      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. f-merkkijono
      merkkijonot
    7. for
  7. G
    1. Generaattori
      objektit toistorakenteet
    2. Globaali muuttuja
      muuttujat arvot
    3. Globaali näkyvyys
  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. Paikallinen muuttuja
    2. Paikanpidin
      merkkijonot tulostus
    3. Pakeneminen
      merkkijonot
    4. Palauttaminen
      arvot funktiot
    5. Paluuarvo
    6. Parametri
      funktiot
    7. Parametrisaatio
    8. Poikkeus
      try-rakenteet ongelmanratkaisu
    9. Poikkeusten käsittely
      ohjausrakenteet poikkeukset
    10. Polku
    11. Python-konsoli
      työkalut
    12. Python-tulkki
      työkalut
    13. Pääohjelma
      konseptit
    14. Presedenssi
      Sidontajärjestys
  17. R
    1. Rajapinta
      moduulit funktiot konseptit
    2. Ratkaisumalli
      ongelmanratkaisu
    3. Rekursio
      funktiot konseptit
    4. Relatiivinen polku
    5. 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. Suoritusjärjestys
    13. Syntaksi
      konseptit
    14. Syntaksivirhe
      poikkeukset
    15. Syöte
      merkkijonot konseptit
    16. Silmukka
      Toistorakenne
    17. 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ää

2. Harjoitukset: Ehdottoman merkilliset poikkeukset

Tässä harjoituksessa päästään tekemään ohjelmia, jotka ovat muutakin kuin suoraviivaisia laskuautomaatteja. Suorituskerrat voivat olla erilaisia, koska nyt käyttäjälle annetaan mahdollisuus olla suurammassa vuorovaikutuksessa ohjelman kanssa. Viime kerran harjoituksiin nähden näissä tehtävissä on huomattavasti enemmän haastetta, sillä kaikissa joutuu miettimään miten toimitaan erilaisissa tilanteissa. Viikon viimeiset tehtävät antavat myös eväitä lopputyön tekemiseen ja antavat hieman esimakua siitä, millaisia haasteita lopputyön kanssa tulee olemaan.

Osaamistavoitteet

Näiden harjoitusten jälkeen pystyt tekemään ohjelmia, joiden suoritus haarautuu käyttäjän toiveiden mukaan. Lisäksi osaat kommunikoida käyttäjälle tämän virheellisistä
syötteistä
ja ohjelmasi osaavat antaa miellyttävän näköisiä tulosteita. Keskeisenä tekijänä ovat materiaalin kolme konseptia:
merkkijonot
,
poikkeusten
käsittely ja
ehtorakenteet
. Myös
sanakirjoja
käytetään. Kukin tehtävä omalta osaltaan opettaa myös ohjelmien suunnittelua - eipä siltä oikein voi välttyäkään.

Esimerkki

Tehtävänanto

Toteuta ohjelma, joka kysyy käyttäjältä kaksi kokonaislukua ja kertoo, onko toinen niistä toisen tekijä. Virheellisistä syötteistä huomautetaan erikseen. Alla on esimerkkejä ohjelman toiminnasta:
Anna ensimmäinen luku: 5
Anna toinen luku: 10
5 on 10:n tekijä.
Anna ensimmäinen luku: 9
Anna toinen luku: -3
-3 on 9:n tekijä.
Anna ensimmäinen luku: 7
Anna toinen luku: 4
Kumpikaan luvuista ei ole toisen tekijä.
Anna ensimmäinen luku: 2
Anna toinen luku: -2
2 on -2:n tekijä.
Anna ensimmäinen luku: 0
Anna toinen luku: 3
3 on 0:n tekijä.
Anna ensimmäinen luku: 0
Anna toinen luku: 0
0 on 0:n tekijä.
Anna ensimmäinen luku: aasi
Ei näytä luvulta
Anna ensimmäinen luku: 0
Anna toinen luku: aasi
Ei näytä luvulta

Ratkaisu

Lähdetään liikkeelle helpoimmasta, eli lukujen kysymisestä. Tämä menee jo viime kerralla opitulla tavalla, joten ei siitä sen enempää:
luku_1 = int(input("Anna ensimmäinen luku: "))
luku_2 = int(input("Anna toinen luku: "))
Tekijyyttä voi testata jakojäännöksellä. Jos jakojäännös on nolla, jakaja on jaettavan tekijä.
Mietitään sitten miten ohjelma voisi haarautua. Tulostusvaihtoehtoja on kaksi: joko toinen luvuista on toisen tekijä, tai kumpikaan ei ole. Tämä voisi viitata kahteen
haaraan
, alla olevaan tyyliin. Käytetään luonnosteluvaiheessa pass-komentoa korvaamaan
ehtolauseen
sisälle tuleva koodi.
if luku_1 % luku_2 == 0 or luku_2 % luku_1 == 0:
    pass
else:   
    pass
Tästä seuraa kuitenkin ongelma: mistä tiedetään kumpi oli kumman tekijä? Suunnittelemamme ehtolause ei tätä kerro. Pitäisi siis lisätä toinen tarkistus tämän ehtolauseen sisälle, jossa selvitetään kumpi oli kumpi. Tämä onnistuisi katsomalla kumpi luvuista on pienempi, koska suurempi luku ei voi olla pienemmän tekijä. Tämä on kuitenkin tarpeettoman hankalaa. On helpompaa purkaa tämä yksi haara kahdeksi:
if luku_1 % luku_2 == 0:
    pass
elif luku_2 % luku_1 == 0:
    pass
else:
    pass
Nyt 1. haarassa tiedetään, että juuri luku_2 on luku_1:n tekijä, ja vastaavasti 2. haarassa tiedetään, että asia oli toisin päin. Lisätään tehtävänannon mukaiset tulostukset näihin haaroihin. Se kannattaa tehdä kopioimalla teksti tehtävänannon esimerkeistä, ja korvaamalla sitten lukuarvot
aaltosulkupaikanpitimillä
. Huomaa
argumenttien
muuttuva järjestys 1. ja 2. haaran välillä.
if luku_1 % luku_2 == 0:
    print(f"{luku_2} on {luku_1}:n tekijä.")
elif luku_2 % luku_1 == 0:
    print(f"{luku_1} on {luku_2}:n tekijä.")
else:
    print("Kumpikaan luvuista ei ole toisen tekijä.")
Yhdistetään tämä syötteen kysymiseen ja kokeillaan:
Anna ensimmäinen luku: 4
Anna toinen luku: 0
---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
/joku/kansio/tekija.py in ()
      1 luku_1 = int(input("Anna ensimmäinen luku: "))
      2 luku_2 = int(input("Anna toinen luku: "))
----> 3 if luku_1 % luku_2 == 0:
      4     print(f"{luku_2} on {luku_1}:n tekijä.")
      5 elif luku_2 % luku_1 == 0:

ZeroDivisionError: integer division or modulo by zero
...
Se nolla. Tekijyydestä tiedetään, että kaikki luvut ovat nollan tekijöitä ja nolla on itsensä tekijä. Eli jos jompi kumpi luvuista on nolla, toinen on sen tekijä. Aiemmasta viisastuneena ei yritetä laittaa tätä yhden
haaran
alle, vaan lisätään kaksi uutta haaraa. Nyt on tärkeää miettiä myös mihin kohtaan uudet haarat sijoitetaan. Mikäli käyttäjä
syöttää
nollan, koodin suoritus ei saa päästä niihin
ehtolauseisiin
joissa suoritetaan jakamista. Niinpä nämä uudet ehdot tulee sijoittaa alkuun. Muistetaan siis, että
ehtorakenteesta
suoritetaan ainoastaan ensimmäinen haara, jonka
ehto
toteutuu - muita haaroja ei edes tutkita. Koko ohjelma tähän asti:
luku_1 = int(input("Anna ensimmäinen luku: "))
luku_2 = int(input("Anna toinen luku: "))
if luku_1 == 0:
    print(f"{luku_2} on {luku_1}:n tekijä.")
elif luku_2 == 0:
    print(f"{luku_1} on {luku_2}:n tekijä.")    
elif luku_1 % luku_2 == 0:
    print(f"{luku_2} on {luku_1}:n tekijä.")
elif luku_2 % luku_1 == 0:
    print(f"{luku_1} on {luku_2}:n tekijä.")
else:
    print("Kumpikaan luvuista ei ole toisen tekijä.")
Kokeillaan uudestaan:
Anna ensimmäinen luku: 4
Anna toinen luku: 0
4 on 0:n tekijä.
Vielä puuttuu virheellisten
syötteiden
käsittely. Tämä onnistuu try-except-rakenteella, jossa otetaan kiinni materiaalissa pariin kertaan pyöritelty ValueError-
poikkeus
:
try:
    luku_1 = int(input("Anna ensimmäinen luku: "))
    luku_2 = int(input("Anna toinen luku: "))
except ValueError:
    print("Ei näytä luvulta")
Tämä on muuten hyvä, mutta jos se lyödään ohjelman alkuun sellaisenaan saadaan vähemmän toivottuja tuloksia.
Anna ensimmäinen luku: aasi
Ei näytä luvulta
---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
/joku/kansio/tekija.py in ()
      4 except ValueError:
      5     print("Ei näytä luvulta")
----> 6 if luku_1 == 0:
      7     print(f"{luku_2} on {luku_1}:n tekijä.")
      8 elif luku_2 == 0:

NameError: name 'luku_1' is not defined
Virheilmoitus kyllä tulostuu, mutta rivin 6 ehtolauseesta saadaankin NameError! On tämä työmaa... Ongelman ydin on siinä, että rivin 2 suoritus loppuu heti kun int-funktiota kutsutaan, joten luku_1 muuttujaa ei koskaan luoda. Tässä tilanteessa olisikin toivottavaa, että ohjelman suoritus ei jatku, jos jompikumpi luvuista on virheellinen - eihän siinä ole edes mitään järkeä jatkaa. Ongelman voi ratkaista lyömällä try-except-rakenteeseen else-osan, ja työntämällä loput koodit sinne:
try:
    luku_1 = int(input("Anna ensimmäinen luku: "))
    luku_2 = int(input("Anna toinen luku: "))
except ValueError:
    print("Ei näytä luvulta")
else:
    if luku_1 == 0:
        print(f"{luku_2} on {luku_1}:n tekijä.")
    elif luku_2 == 0:
        print(f"{luku_1} on {luku_2}:n tekijä.")    
    elif luku_1 % luku_2 == 0:
        print(f"{luku_2} on {luku_1}:n tekijä.")
    elif luku_2 % luku_1 == 0:
        print(f"{luku_1} on {luku_2}:n tekijä.")
    else:
        print("Kumpikaan luvuista ei ole toisen tekijä.")
Tämän rakennelman ymmärtäminen on keskeistä tämän kerran harjoitustehtävien suorittamiselle. Käytä siis hetki sen opiskeluun. Nyt ohjelma toimii oikein:
Anna ensimmäinen luku: aasi 
Ei näytä luvulta

Ohjelmien lopettaminen

Tässä harjoituksessa on tehtäviä, joissa pyydetään päättämään ohjelman suoritus esim. virhetilanteessa. Tämä tarkoittaa aina sitä, että virheestä ilmoittaminen jää ohjelman viimeiseksi suoritettavaksi riviksi siinä haarassa missä se on. Ohjelman rakenne tulee siis suunnitella siten, että kukin virheilmoitus on jonkun rakenteen sisällä siten, ettei sen jälkeen ole enää mitään suoritettavaa. Internetin ihmemaa löytää helposti quit- ja exit-funktiot, joilla ohjelman suorituksen voi lopettaa. Näitä ei kuitenkaan voi kurssilla käyttää. Syitä on kaksi.
Ensimmäinen syy liittyy oppimiseen: tässä harjoituksessa on tarkoitus oppia ohjaamaan ohjelman suorituksen kulkua ohjausrakenteilla - ei käyttämällä oikopolkuja. Oikopolkuja voi käyttää sitten, kun ohjelman suorituksen hallinnan perusteet ovat hallussa. Toinen syy on tekninen: nämä funktiot sammuttavat koko Python-prosessin. Tarkistukset toimivat siten, että tarkistinohjelma lataa palautetun koodin suoritettavaksi osaksi itseään (importilla). Näin ollen em. funktiot sammuttavat siis palauttamasi ohjelman lisäksi myös tarkistimen, ja saat tästä ilmoituksen "Tarkistin kaatui kesken tarkistuksen".

Yhteiset tehtävät

Kaikki nämä tehtävät kuuluvat osaksi kurssisuoritusta.

Lämmittelytehtävä

Poliittiset neliöt

Ajoittain ruudulla tapahtuvassa geometriassa pitää tietää millä puolella jotain akselia tai objektia jokin toinen objekti sijaitsee. Jos esimerkiksi halutaan loihtia ruudulle otus joka liikkuu ruudun lähintä reunaa kohti, pitää ensin selvittää kummassa suunnassa tämä reuna on. Tässä tehtävässä toteutamme yksinkertaisen ehtolauseen, jonka avulla piirretään poliittisesti orientoituneita neliöitä, joiden väri riippuu sijainnista: vasemmalla punaista, oikealla sinistä.
Opittavat asiat: Ohjelman suorituksen ohjaaminen
ehtorakenteen
avulla
. Koordinaatiston puoliskojen tunnistaminen koodissa.
Tavoite: Ohjelma, joka piirtää neliöitä, joiden väri riippuu x-koordinaatista

Alustus:
Edellisen harjoituksen tapaan tehtävässä on annettu koodipohja. Kaikki kirjoitettava koodi pitäisi jälleen tulla funktion sisälle.
neliot.py
from turtle import *

def piirra_nelio(sivu, x, y):
    # tähän funktio joka piirtää neliön
    # joko punaisena tai sinisenä riippuen
    # siitä onko aloituspisteen x-koordinaatti
    # positiivinen (sininen) vai negativiinen
    # (punainen)
    
piirra_nelio(40, -100, 100)
piirra_nelio(60, 100, -100)
piirra_nelio(100, -50, -20)
piirra_nelio(80, 90, 30)
done()


Toteutettava funktio: piirra_nelio
  • Parametrit
    :
    • neliön sivun pituus (kokonaisluku)
    • alkupisteen x-koordinaatti (kokonaisluku)
    • alkupisteen y-koordinaatti (kokonaisluku)
Funktio piirtää yhden neliön, jonka täyttöväri riippuu siitä onko aloituspisteen x-koordinaatti positiivinen vai negatiivinen. Negatiiviselle x-koordinaatin
arvolle
käytetään väriä "red" ja positiiviselle väriä "blue".

Pääohjelma:
Koodipohjan
pääohjelmassa
olevat rivit piirtävät esimerkkikuvan neliöt, jos funktio on toteutettu oikein. Huom: kääntymissuunta vaikuttaa neliöiden asetteluun, joten tulos ei välttämättä ole täysin sama (kuvan neliöt piirretty kääntymällä oikealle).
Esimerkkineliöitä. Funktiota on kutsuttu neljä kertaa. Kuvaan on lisätty viivat kuvaamaan x- ja y-akseleita.

Käytettävät Turtle-komennot:
Käytössä ovat jo tutut komennot. Kaikkia näistä ei tarvita.
forward(x)   # liikkuu x pikseliä ruudulla eteenpäin. x on kokonaisluku, esim. forward(42)
left(a)      # kääntyy vasemmalle a astetta. a on kokonaisluku, esim. left(40)
right(a)     # kääntyy oikealle a astetta. a on kokonaisluku, esim. right(40)
color(c)     # asettaa värin. c on väriarvo, tässä tehtävässä voit käyttää perusväriarvoja kuten "red", "yellow", "blue", esim. color("red")
begin_fill() # aloittaa täytön; kaikki tämän komennon jälkeiset viivat lasketaan täyttöalueen rajoiksi
end_fill()   # tämä komento lopettaa täytön; tämän ja edellisen välissä piirretty suljettu alue täytetään color-komennon määrittämällä värillä
reset()      # jos teet virheen, tällä komennolla voit pyyhkiä piirroksen pois ja palauttaa nuolen aloituspaikkaan
done()       # jättää piirtoikkunan auki koodin suoritus pääsee tähän kohtaan; ilman tätä komentoa ikkuna sulkeutuu kun koodi on suoritettu
up()         # nostaa kynän jolloin kynää voi liikuttaa piirtämättä mitään
down()       # laskee kynän alas jotta piirtäminen voi jatkua
setx(x)      # asettaa kynän x-koordinaatin annettuun arvoon
sety(y)      # asettaa kynän y-koordinaatin annettuun arvoon
circle(r)    # piirtää ympyrän, jonka säde on r; tämä tapahtuu siten, että kynä liikkuu 360 asteen ympyrän nykyisestä sijainnistaan kaartamalla koko ajan vasemmalle
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Päätehtävät

Poliisista päivää

Poliisin IT-osaaminen on kovaa vauhtia rapisemassa, joten he ovat tehneet sinulle tarjouksen, josta et voi kieltäytyä: tehtävänäsi on ohjelmoida ohjelma, jolla pystyy selvittämään ohi ajaneen auton nopeuden syöttämällä matkan, jonka auto on kulkenut tietyn ajan kuluessa. Käyt tuumasta toimeen koodaamaan innosta puhkuen verratonta nopeuslaskuriasi.
Opittavat asiat: Tulosten ja muiden numeroiden sijoittaminen
merkkijonoihin
käyttämällä hyödyksi
paikanpitimiä
. Pitkän merkkijonon katkominen.
Tavoite: Ohjelma, joka kysyy auton kulkeman matkan sekä tähän kuluneen ajan, ja antaa nopeuden siististi tulostettuna.

Toteutettava pääohjelma:
Ohjelmassa siis kysytään kaksi liukuluku
syötettä
. Poliisien sovellusosaaminen on pahasti rapistunut kännykän räpeltämisen myötä, joten virheellisistä syötteistä on syytä huomauttaa. Jos poliisi sattuu syöttämään ihan oikeita numeroarvoja, tulostetaan sekä annetut arvot että laskettu nopeus kilometreinä tunnissa. Kuten esimerkistä ilmenee, kaikki numerot tulostetaan kahden desimaalin tarkkuudella - tämän aikansaanti vaatii f-merkkijonojen käyttöä! Pelkällä round-funktiolla ei siis tässä tehtävässä pääse oikeastaan edes lähtöviivalle.
Jos saat tyylivaroituksen pitkästä rivistä, merkkijonon voi jakaa usealla riville laittamalla osaset alekkain. Luonnollisesti mahdollinen f pitää laittaa kunkin osasen eteen tarvittaessa:
print(
    "Tässä on merkkijono jossa on paljon paljon paljon tekstiä, "
    "ja jos sinne laitetaan vielä paikanpitimiä pidentämään..."
)
Poikkeusten käsittelyyn virheellisillä syötteillä voit kurkata aika suoraa apua tämän harjoituksen esimerkistä.

Esimerkit toiminnasta:
Anna auton kulkema matka (m): 50.0
Anna matkaan kulunut aika (s): 3.0
50.00 metriä 3.00 sekunnissa kulkeneen auton nopeus on 60.00 km/h.
Anna auton kulkema matka (m): 50.0m
Vähemmän donitseja, enemmän puhtaita numeroita.
Anna auton kulkema matka (m): 50.0
Anna matkaan kulunut aika (s): minuutti
Vähemmän donitseja, enemmän puhtaita numeroita.
Lähetä ohjelmasi poliisien avuksi tästä.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Heksoja mittatilauksena

Tietokoneen muistin sisältöä esitetään usein heksadesimaaliluvuilla, eli 16-kantaisilla luvuilla (kirjaimet a-f kuvaavat numeroja 10-15). Tyypillisesti tällöin halutaan myös sisällyttää lukuun riittävä määrä etunollia, jotta siitä voidaan lukea kuinka monibittinen luku on kyseessä, jolloin yksi heksa vastaa neljää bittiä. Tämä käy vallan hyvin, koska tietokoneen muistipaikkojen koot ovat aina kakkosen potensseja ja pienimmillään kahdeksan, joka esitettäisiin siis kahdella heksalla. Tässä tehtävässä muutetaan kokonaisluku Pythonilla heksadesimaaliksi, jossa on oikea määrä etunollia.
Opittavat asiat: Merkkijono
metodien
etsiminen ja käyttö siten, että käytetään useampaa kuin yhtä metodia yhdelle merkkijonolle.
Tavoite: Ohjelma, joka muuntaa kokonaisluvun määrätyn pituiseksi heksadesimaaliluvuksi etunollilla varustettuna.

Alustus:
Pythonissa voi muuntaa luvun heksadesimaalia esittäväksi
merkkijonoksi
hex-
funktiolla
:
In [1]: hex(452)
Out[1]: '0x1c4'
Jossa "0x" on heksaluvuille usein käytetty etuliite, josta ilmenee luvun luonne erityisesti niissä tapauksissa, että sinne ei ole eksynyt yhtään numeroa arvolla a-f.

Toteutettava funktio: muotoile_heksaluvuksi
  • Parametrit
    :
    • muutettava kokonaisluku
    • esitettävien bittien lukumäärä
  • Palauttaa
    :
    • merkkijonon joka esittää halutunlaista heksalukua
Funktion tulee muuntaa annettu kokonaisluku heksadesimaaliluvuksi ja sen jälkeen muotoilla se siten, että siinä on oikea määrä heksanumeroita. Koska yksi heksanumero vastaa neljää bittiä, halutun merkkijonon pituus saadaan jakolaskulla. Muotoiluun ei haluta mukaan "0x" etuliitettä, ja sen olemassaolo haittaa etunollien lisäämistä, joten sekin pitäisi ottaa pois.
Tarvitaan siis kaksi asiaa: etuliitteen poisto, ja etunollien lisääminen sen jälkeen. Molempiin operaatioihin löytyy sopiva merkkijonometodi - itse asiassa useampikin. Myös suoritusjärjestystä on syytä miettiä. Luvun ollessa liian suuri bittimäärälle palautetaan kaikki merkit vaikka niitä onkin liikaa. Eli bittien määrää käytetään ainoastaan miniminä. Muista palauttaa lopputulos!.
Merkkijonometodeja ja suoritusjärjestystä kannattaa testata
tulkissa
jolloin on paljon helpompi nähdä mitä kukin merkkijonometodi palauttaa. Tulkissa voit viitata edelliseen tulokseen _-merkillä - jos vaikka yllä annetun esimerkin jälkeisellä rivillä käyttää tätä merkkiä, se sisältäisi arvon "0x1c4".
Jakolaskuun kannattaa käyttää kokonaislukujakolaskua, eli //-
operaattoria
.

Pääohjelma:
Tee pääohjelma joka kysyy käyttäjältä kokonaisluvun sekä esitettävien bittien lukumäärän. Jos jompikumpi syötteistä ei ole kokonaisluku, annetaan virheilmoitus ja ei jatketa suoritusta - eli samalla tavalla kuin esimerkissä ja edellisessä tehtävässä, paitsi nyt muunnos tehdään kokonaisluvuksi liukuluuvun sijaan. Numerot saatuaan pääohjelma
kutsuu
juuri tehtyä funktiota ja tulostaa sen
paluuarvon
. Alta näet esimerkkejä siitä miten ohjelman tulisi toimia sekä kyselyihin käytettävät merkkijonot.

Esimerkit toiminnasta:
Anna kokonaisluku: 5
Anna heksaluvun pituus (bittien lukumäärä): 16
0005
Anna kokonaisluku: 349798384653
Anna heksaluvun pituus (bittien lukumäärä): 64
00000051719bc40d
Anna kokonaisluku: 255
Anna heksaluvun pituus (bittien lukumäärä): 8
ff
Anna kokonaisluku: aasi
Kokonaisluku kiitos
Anna kokonaisluku: 252
Anna heksaluvun pituus (bittien lukumäärä): 2.5
Kokonaisluku kiitos
ja vielä loppuun malli siitä mitä käy jos luku on liian iso bittimäärälle (eli ei mitään erikoista):
Anna kokonaisluku: 4892
Anna heksaluvun pituus (bittien lukumäärä): 4
131c
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Nelilaskin

Tässä tehtävässä koodaamme perinteisen nelilaskimen. Ei mikään maailman jännittävin värkki, mutta sen tekemisessä oppii useita hyödyllisiä asioita niin syötteiden käsittelystä kuin ohjelman rakenteesta.
Opittavat asiat: Sisäkkäisten
ohjausrakenteiden
käyttö siten, että ohjelman kaikki suorituspolut pysyvät ehjinä. Käyttäjän syötteiden tarkastaminen
poikkeusten
käsittelyn avulla.
Tavoite: Koodata nelilaskin, jolle annetaan operaatio ja operandit.

Toteutettava pääohjelma:
Käyttäjä valitsee
operaattorin
syöttämällä
haluaako tehdä yhteen-, vähennys-, kerto- vai jakolaskun. Jos käyttäjä yrittää syöttää jotain muuta, todetaan, että "Operaatiota ei ole olemassa". Tämän jälkeen ohjelma kysyy käyttäjältä kaksi lukua ja antaa tuloksen esimerkkien mukaisesti. Mikäli käyttäjä syöttää virheellisen luvun, ohjelman suoritus loppuu ja näytölle tulostuu "Ei tämä ole mikään luku". Vastaavasti, jos käyttäjä yrittää jakaa nollalla, todetaan "Tällä ohjelmalla ei pääse äärettömyyteen". Koodissa tulee laskea
liukuluvuilla
.
Tässä tehtävässä on erityisen tärkeää pitää mielessä mitä harjoituksen alussa kerrottiin ohjelman lopettamisesta. Älä siis käytä quit- tai exit-funktioita!

Esimerkit toiminnasta:
Valitse operaatio (+, -, *, /): +
Anna luku 1: 12.8
Anna luku 2: enpäs
Ei tämä ole mikään luku
Valitse operaatio (+, -, *, /): +
Anna luku 1: aasisvengaa
Ei tämä ole mikään luku
Valitse operaatio (+, -, *, /): ^
Operaatiota ei ole olemassa
Valitse operaatio (+, -, *, /): *
Anna luku 1: 12
Anna luku 2: 5
Tulos: 60
Valitse operaatio (+, -, *, /): /
Anna luku 1: 52.65
Anna luku 2: 0
Tällä ohjelmalla ei pääse äärettömyyteen
Palauta laskimesi tänne.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Äänestyskone

Oikean maailman äänestyskoneisiin liittyy monenlaisia turvallisuustekijöitä. Onneksi näin peruskurssilla voidaan tehdä vain ohjelma, joka laskee annettuja ääniä ja näyttää tulokset. Tällä ohjelmalla ei taatusti voida suorittaa minkäänlaista vaalivilppiä.
Opittavat asiat:
Sanakirjan
sisällön lukeminen ja päivittäminen.
Funktioiden
käyttö
muuntuvien
arvojen kanssa.
Tavoite: Ohjelma johon käyttäjä(t) syöttävät ääniä, ja joka ilmoittaa tulokset
Ennen kuin aloitat:
Luo ohjelmaasi testausta varten kaksi eri äänestystä kuvaavaa sanakirjaa. Kummassakin on vaihtoehdot "jaa", "ei", "eos" (en osaa sanoa), sekä lisäksi oma avain virheellisiä ääniä varten. Toisessa äänestyksessä on valmiiksi tuloksia.
verouudistus = {
    "jaa": 0,
    "ei": 0,
    "eos": 0,
    "virhe": 0
}
nalle_puh_presidentiksi = {
    "jaa": 12,
    "ei": 0,
    "eos": 5,
    "virhe": 4
}
1. toteutettava funktio: aanesta
  • Parametrit
    :
    • sanakirja, jossa on aiemmat äänet, ja johon uusi ääni talletetaan
Funktio esittää äänestyksen vaihtoehdot sekä pyytää käyttäjää syöttämään yhden niistä. Syöte kannattaa muuttaa pieniksi kirjaimiksi. Tämän jälkeen funktio lisää käyttäjän valitseman vaihtoehdon äänten lukumäärään yhden. Tämä tulee tehdä siis siten, että vanha arvo haetaan sanakirjasta annetulla
avaimella
, ja
tallennetaan
myös sinne takaisin. Mikäli käyttäjän valitsema avain ei ole sanakirjassa, lisätään ykkönen "virhe"-avaimen arvoon. Huomaa, että funktion ei kuulu
palauttaa
mitään, koska se muokkaa muuntuvaa arvoa.
2. toteutettava funktion: nayta_tulokset
  • Parametrit
    :
    • sanakirja, jossa on äänestystulokset
Funktio
tulostaa
äänestyksen tulokset siten, että kunkin vaihtoehdon saamat äänet esitetään #-merkeistä muodostuvilla palkeilla, kukin omalla rivillään. Esim:
Jaa  : #####
Ei   : ######
Eos  : #
Virhe: ###
Kaksoispisteiden ja palkkien tasaaminen ei ole pakollista tehtävän läpäisyn kannalta.
Toteutettava
pääohjelma
:
Pääohjelmassa on tarkoitus kutsua tehtyjä funktioita kummallekin sanakirjalle. Kummankin sanakirjan kohdalla voit tehdä seuraavat asiat:
  1. tulosta käyttäjälle tieto siitä mistä äänestetään
  2. kutsu aanesta-funktiota
  3. kutsu nayta_tulokset-funktiota
Koodissa tulee olla siis vain kaksi funktiota, mutta niitä kutsutaan eri
argumenteilla
. Pääohjelman tarkistus olettaa, että olet käyttänyt annettuja sanakirjoja sellaisenaan, ja verouudistus äänestetään ensin.
Esimerkit toiminnasta:
Alla on kutsuttu aanesta-funktiota kertaalleen per äänestys.
Suoritetaanko verouudistus?
Anna äänesi, vaihtoehdot ovat:
jaa, ei, eos
> ööö

Jaa  : 
Ei   : 
Eos  : 
Virhe: #

Nalle Puh presidentiksi?
Anna äänesi, vaihtoehdot ovat:
jaa, ei, eos
> jaa

Jaa  : #############
Ei   : 
Eos  : #####
Virhe: ####
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Lopputyötehtävät

Seuraavista tehtävästi tulee tehdä yksi. Valinta kannattaa tehdä sen perusteella minkä lopputyöaiheen olet valinnut. Nämä tehtävät eivät ole pakollisia minimikurssisuoritukseen.

Miinatehtävä: Äärirajoilla

Tämän tehtävän on tarkoitus antaa valmiuksia Miinantallaaja-lopputyötä varten. Tehtävässä opit joitain perustotuuksia siitä, miten 2-ulotteinen ruudukko toimii ohjelmakoodissa. Lisäksi opit muutamia ohjelmointiperiaatteita, kuten sanakirjojen käyttöä kun halutaan tulostaa jotain tiettyä arvoa vastaava viesti. Viestien hakeminen sanakirjoista on myös hyvin yleistä mm. tämän kurssin tarkistimissa.
Opittavat asiat: Lukujen suuruksien tarkastelu
ehtorakenteilla
. Tehtävässä opitaan, että N-pituisen sarjan viimeinen arvo ei ole N, jos ensimmäinen on 0. Ongelman hahmottelu paperille. Lisäksi opitaan miten ohjelman sisällä kannattaa käyttää data-arvoja, ja pyöritellä pitkiä
merkkijonoja
vasta tulostaessa.
Tavoite: Ohjelma, joka kysyy käyttäjältä kentän mitat sekä ruudun, ja kertoo miten ruutu sijoittuu kentällä.

Alustus:
Lisätään ohjelmaan
sanakirja
, josta lyötyy eri sijainteja vastaavat tulostettavat viestit. Sanakirjan tulee olla koodissasi juuri tällä nimellä:
TULOSTUKSET = {
    "ulkona": "Antamasi ruutu on kentän ulkopuolella.",
    "nurkassa": "Antamasi ruutu on kentän nurkassa.",
    "laidalla": "Antamasi ruutu on kentän laidalla.",
    "keskellä": "Antamasi ruutu on keskikentällä."
}

1. toteutettava funktio: sijainti_kentalla
  • Parametrit
    :
    • ruudun x-koordinaatti (kokonaisluku)
    • ruudun y-koordinaatti (kokonaisluku)
    • kentän leveys (kokonaisluku)
    • kentän korkeus (kokonaisluku)
  • Palauttaa
    :
    • sijaintia kuvaavan avainsanan (
      merkkijono
      )
Tämä funktio palauttaa yhden em. sanakirjan avaimista riippuen siitä missä kohtaa x- ja y-koordinaateilla määritetty ruutu on kentällä, jonka leveys ja korkeus on annettu funktiolle. Funktion tulisi siis tutkia onko ruutu ulkona, nurkassa vai laidassa - jos ei ole mistään näistä, se on keskikentällä. Funktio siis palauttaa yhden sanakirjan
avaimista
, esim jos koordinaatit olivat ulkopuolella tulisi palautusrivin olla: return "ulkona".
Huom! Tehtävässä koordinaattien origo on ruudussa (0, 0). Katso tarkasti alla olevista esimerkeistä, kuinka tämä vaikuttaa tulostuksiin. Kannattaa myös pitää mielessä, että koordinaatit osoittavat kokonaisia ruutuja! Piirtele siis ruudukko paperille ja kirjoittele reunoihin numerot niin voit helposti katsoa milloin ollaan missäkin päin kenttää.

2. toteutettava funktio: tulosta_sijainti
  • Parametrit:
    • sijaintia kuvaava avainsana (merkkijono)
Funktio tulostaa valitun ruudun sijainnin, eli onko se ulkona, nurkassa, laidalla vai keskellä. Viesti tulee hakea tehtävänannossa määritetystä sanakirjasta käyttäen funktion
parametria
avaimena
. Tähän pitäisi tulla aika lailla siis yksi rivi koodia ainakin jos muistaa, että sanakirjan avaimena voi käyttää
muuttujaa
. Kannattaa ottaa ohjeet tosissaan, sillä tarkistin muuttelee sanakirjaan tallennettuja viestejä...
Tämä funktio ei saa kutsua edellistä funktiota!

Pääohjelma:
Kirjoita ohjelma, joka kysyy käyttäjältä kentän leveyden ja pituuden ja näiden jälkeen koordinaatit vaaka- ja pystysuunnissa (eli x- ja y-koordinaatit). Liian pienien leveyden ja pituuden antamisen jälkeen annetaan alla olevien esimerkkien mukainen virheilmoitus ja lopetetaan ohjelman suoritus (kuten laskintehtävässä). Koordinaattien
syöttämisen
jälkeen ohjelman täytyy ilmoittaa, osuiko annettu koordinaatti kentän nurkkaan, reunalle, keskikentällä vai ulkopuolelle. Tämä onnistunee parhaiten juuri tehdyillä funktioilla: ensimmäinen palauttaa sijaintia vastaavan avainsanan ja toinen tulostaa sitä vastaavan viestin.
Kaikki
merkkijonot
kyselyihin ja tulostuksiin löydät suoritusesimerkeistä.

Esimerkit toiminnasta:
Anna kentän leveys: 0
Anna kentän korkeus: 0

Noin pienelle kentälle ei mahdu ainuttakaan ruutua!
Anna kentän leveys: -6
Anna kentän korkeus: 999

Noin pienelle kentälle ei mahdu ainuttakaan ruutua!
Anna kentän leveys: 1
Anna kentän korkeus: 1
Anna x-koordinaatti: 0
Anna y-koordinaatti: 0

Antamasi ruutu on kentän nurkassa.
Anna kentän leveys: 5
Anna kentän korkeus: 8
Anna x-koordinaatti: 4
Anna y-koordinaatti: 3

Antamasi ruutu on kentän laidalla.
Anna kentän leveys: 13
Anna kentän korkeus: 7
Anna x-koordinaatti: 2
Anna y-koordinaatti: 2

Antamasi ruutu on keskikentällä.
Anna kentän leveys: 4
Anna kentän korkeus: 4
Anna x-koordinaatti: 4
Anna y-koordinaatti: 4

Antamasi ruutu on kentän ulkopuolella.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Spektritehtävä: Kulmikasta koodia

Tämän ongelman ratkaisusta on hyötyä Spektriä pukkaa lopputyössä. Kirjoitetaan ohjelma, joka laskee ja tulostaa kahden pisteen välisen suoran yhtälön, huomioiden kaikki rajatapaukset.
Opittavat asiat: Lukujen suuruksien tarkastelu
ehtorakenteilla
. Ohjelman ohjaaminen siten, että laskujen lopputuloksista tehdään oikeat toteamukset. Suoran yhtälön laskeminen.
Tavoite: Ohjelma, joka laskee suoran yhtälön ja tulostaa sen.

Toteutettava funktio: laske_parametrit
  • Parametrit
    :
    • ensimmäisen pisteen x-koordinaatti (liukuluku)
    • ensimmäisen pisteen y-koordinaatti (liukuluku)
    • toisen pisteen x-koordinaatti (liukuluku)
    • toisen pisteen y-koordinaatti (liukuluku)
  • Palauttaa
    :
    • suoran kulmakerroin (liukuluku)
    • suoran vakiotermi (liukuluku)
Käytä kulmakertoimelle ja vakiotermille seuraavia kaavoja:
k = \dfrac{y_2-y_1}{x_2-x_1}
ja
b = \dfrac{x_2 \cdot y_1 - x_1 \cdot y_2}{x_2 - x_1}

Toteutettava
pääohjelma
:
Haluamme, että ohjelmamme
ottaa vastaan käyttäjältä
kahden pisteen x- ja y-koordinaatit ja kertoo
mikä on suoran yhtälö mikäli se vain suinkin voidaan laskea. Lisäksi haluamme ohjelman kykenevän erottamaan toisistaan tilanteet joissa käyttäjä syöttää saman pisteen kahdesti, ja joissa suora on pystysuora. Päätämme, ettemme tarkista käyttäjän syötteitä erikseen, mutta ohjelman pitää osata kuitenkin käsitellä myös
liukulukuja
ja pyöristää kaikki tulosteensa täsmälleen kolmen desimaalin tarkkuuteen.
Ohjelman tekemisessä kannattaa käyttää sisäkkäisiä try- ja if-rakenteita. Helpoin tapa tietää voiko yhtälön laskea on tietenkin kutsua juuri tehtyä funktiota try:n sisällä. Joku
poikkeus
sieltä saadaan, jos yhtälöä ei voi laskea. Kannattaa myös huomata, että vakiotermin ollessa negatiivinen ohjelmasi tulee tulostaa yhtälöön miinusmerkki - eli ihan suoraan ei vakiotermiä voi heittää samaan muotoilumerkkijonoon! Sitä ei myöskään pitäisi laittaa mukaan jos se on nolla (kulmakerroin tulostetaan kuitenkin aina).
Kyselyissä ja tulostuksissa käytettävät
merkkijonot
löydät alta.

Esimerkit toiminnasta:
Anna ensimmäisen pisteen x-koordinaatti: 0
Anna ensimmäisen pisteen y-koordinaatti: 0
Anna toisen pisteen x-koordinaatti: 0
Anna toisen pisteen y-koordinaatti: 0
Nämähän ovat yksi ja sama piste!
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: -1
Anna ensimmäisen pisteen y-koordinaatti: 100
Anna toisen pisteen x-koordinaatti: -1
Anna toisen pisteen y-koordinaatti: -100
Suora on pystysuora, yhtälöä ei voida laskea.
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: 2
Anna ensimmäisen pisteen y-koordinaatti: 3.1
Anna toisen pisteen x-koordinaatti: 6.7
Anna toisen pisteen y-koordinaatti: 8.51
Suoran yhtälö: y = 1.151x + 0.798
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: -8
Anna ensimmäisen pisteen y-koordinaatti: 4.5
Anna toisen pisteen x-koordinaatti: -5
Anna toisen pisteen y-koordinaatti: 4.5
Suoran yhtälö: y = 0.000x + 4.500
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: 3.141457
Anna ensimmäisen pisteen y-koordinaatti: -6.12433
Anna toisen pisteen x-koordinaatti: 0
Anna toisen pisteen y-koordinaatti: 50
Suoran yhtälö: y = -17.866x + 50.000
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: 5.76        
Anna ensimmäisen pisteen y-koordinaatti: 4.6
Anna toisen pisteen x-koordinaatti: 2
Anna toisen pisteen y-koordinaatti: -5
Suoran yhtälö: y = 2.553x - 10.106
}}}
{{{
Anna ensimmäisen pisteen x-koordinaatti: 2
Anna ensimmäisen pisteen y-koordinaatti: 2
Anna toisen pisteen x-koordinaatti: 4
Anna toisen pisteen y-koordinaatti: 4
Suoran yhtälö: y = 1.000x
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Piiritehtävä: Mittauspuuhia

Tämä harjoitus saattaa osoittautua hyödylliseksi erityisesti Piiri pieni pyörii -lopputyötä ajatellen. Tehtävänäsi on koodata ohjelma, joka kysyy käyttäjältä komponentin tyypin sekä komponentin arvon ja laskee näiden pohjalta komponentin impedanssin sekä esittää sen osoitinmuodossa.
Opittavat asiat: Käyttäjän valintojen tunnistaminen
syötteistä
ja niihin reagointi
ehtorakenteessa
. Lisäksi tutustutaan hieman komponenttien impedanssien laskukaavoihin ja osoitinmuotoon.
Tavoite: Ohjelma, joka kysyy komponentin tyypin ja arvon, ja kertoo sen impedanssin osoitinmuodossa.

Toteutettava funktio: laske_osoitinmuoto
  • Parametrit
    :
    • komponentin tyyppi (merkkijono huom. pieni kirjain)
    • komponentin arvo (liukuluku)
    • jännitelähteen taajuus (liukuluku) -
      valinnainen
      ,
      oletusarvo
      0
  • Palauttaa
    :
    • osoittimen pituus (liukuluku)
    • osoittimen kulma radiaaneina (liukuluku)
Funktio laskee siis komponentin impedanssin arvon alla olevilla kaavoilla riippuen komponentin tyypistä, joka on joko r, l tai c. Kompleksiluvun voi syöttää Pythoniin ihan vain muodossa 1j ja Python käsittelee kompleksilukuja ihan mielissään.
Vastus:
Z = R
Kela:
Z = 2pi * f * L * 1j
Kondensaattori:
Z = 1 / (2pi * f * C * 1j)
Impedanssin laskun jälkeen se pitäisi palauttaa osoitinmuodossa. Tähän tarkoitukseen löytyy cmath-
moduulista
funktio nimeltä polar.

Toteutettava
pääohjelma
:
Pääohjelma kysyy käyttäjältä yhden komponentin tyypin (R = vastus, L = kela, C = kondensaattori) ja sen arvon (vastukselle resistanssi, kelalle induktanssi ja kondensaattorille kapasitanssi). Kelan ja kondensaattorin tapauksessa kysytään myös erikseen komponentin taajuus. Siitä että jekkuileva käyttäjä saattaa
syöttää
jotain muuta kuin numeroita ei tarvi välittää, mutta komponentin tyypistä tulee tarkistaa onko se sallittujen joukossa. Ohjelman pitäisi myös toimia riippumatta siitä syöttääkö käyttäjä kirjaintunnukset pieninä tai isoina.
Ohjelma tulostaa komponentin impedanssin osoitinmuodossa siten, että osoittimen pituus jätetään pyöristämättä, mutta kulma tulostetaan asteina ja kolmen desimaaliin tarkkuuteen pyöristettynä.
Kysymys
merkkijonot
ja muut tulosteet löydät esimerkeistä.

Esimerkit toiminnasta:
Anna komponentin tyyppi (R, L, C): xD
Sallittuja komponentteja ovat R, L ja C!
Anna komponentin tyyppi (R, L, C): r
Anna komponentin arvo: 10.5
Komponentin impedanssi osoitinmuodossa: 10.5 < 0.000°
Anna komponentin tyyppi (R, L, C): L
Anna komponentin arvo: 0.855
Anna komponentin taajuus: 10 
Komponentin impedanssi osoitinmuodossa: 53.72123437638546 < 90.000°
Anna komponentin tyyppi (R, L, C): c
Anna komponentin arvo: 0.000003
Anna komponentin taajuus: 250.751
Komponentin impedanssi osoitinmuodossa: 211.57103141083562 < -90.000°
Palauta komponenttimittarisi tänne.
Varoitus: Et ole kirjautunut sisään. Et voi vastata.

Sorsatehtävä: Liikkeen hallintaa

Edellisellä harjoituskerralla tehtiin funktio, joka muuntaa napakoordinaatit (x, y)-koordinaattipariksi ja todettiin, että tätä käytetään usein ruudulla liikkuvien objektien kanssa. Tällä kertaa menemme hieman lähemmäs käytäntöä. Harjoituksessa opetellaan päivittämään (x, y)-tasolla liikkuvan pistemäisen objektin sijainti perustuen sen suuntaan ja nopeuteen. Objektin, jolla on useita ominaisuuksia, pystyy näppärästi kuvaamaan sanakirjalla. Ihan peliksi asti tästä harjoitustehtävästä ei vielä ole, mutta ainakin kyseessä on hyvin usein toistuva mekanismi.
Opittavat asiat:
Sanakirjan
sisällön lukeminen ja päivittäminen.
Funktioiden
käyttö
muuntuvien
arvojen kanssa.
Tavoite: Joukko funktioita, jotka pyytävät käyttäjältä liikkeen suunnan ja nopeuden, sekä päivittävät objektin sijainnin näitä käyttäen.

Alustus:
Nouda edelliseltä harjoituskerralta Sininen funktio -tehtävän ratkaisu ja kopioi siitä muunna_xy_koordinaateiksi-funktio. Älä muuta tätä funktiota! Voit tehdä myös valmiiksi
pääohjelmaan
sanakirjoja, jossa on toteutettavien funktioiden vaatimat
avain
-
arvo
-parit, esim.
hahmo_1 = {
    "x": 0,
    "y": 0,
    "suunta": 0,
    "nopeus": 0
}

hahmo_2 = {
    "x": 50,
    "y": 50,
    "suunta": 0,
    "nopeus": 0
}

1. toteutettava funktio: kysy_liike
  • Parametrit
    :
    • sanakirja, josta löytyy yllä kuvatut avain-arvo-parit
Funktio tulostaa hahmon sijainnin ja
pyytää
sen jälkeen käyttäjältä liikkeen suunnan asteina sekä nopeuden. Tulosteen ja pyynnön käyttämät
merkkijonot
löydät tehtävänannon lopun esimerkistä. Molemmat syötteet otetaan liukulukuina ja sijoitetaan sanakirjan vastaavien avainten arvoiksi. Huomaa, että funktio ei
palauta
mitään, koska se päivittää
muuntuvaa
objektia. Muista viitata sanakirjaan funktion parametrin nimellä!

2. toteutettava fuktio: paivita_sijainti
  • Parametrit
    :
    • sanakirja, josta löytyy yllä kuvatut avain-arvo-parit
Tämä funktio laskee hahmon uuden sijainnin perustuen sanakirjasta löytyvään suuntaan ja nopeuteen. Nämä kaksi arvoa muodostavat itse asiassa napakoordinaattiosoittimen. Olisikohan joku funktio, jolla saisi tästä laskettua paljonko (x, y)-koordinaatit muuttuvat...? Saattaa myös olla, että tällainen funktio ottaa kulman vastaan radiaaneina, kun taas sanakirjassa kulma on asteina. Kuulemma math-moodulissa voisi olla jotain apua tähän..
Huomaa, että testauksessa hahmon aloituspiste ei suinkaa ole aina (0, 0). Funktion tulee siis toimia myös silloin kun hahmon alkusijainti on jossain muussa pisteessä. Huomaa myös, että em. apufunktio palauttaa koordinaattien muutokset - nämä arvot tulee siis summata sanakirjassa oleviin sijaintikoordinaatteihin (eli sijoittaa alkuperäisten päälle uudet arvot). Tämäkin funktio muokkaa muuntuvia objekteja, joten mitään ei tule palauttaa.

Pääohjelma:
Tee pääohjelma joka kysyy siirron kahdelta pelaajalta, joilla kummallakin on kentällä oma hahmo. Se ilmoittaa kumman pelaajan vuoro on, ja kutsuu sitten molempia funktiota käsittelemään tämän pelaajan hahmosanakirjaa, ja lopuksi tulostaa hahmon uuden sijainnin, esimerkkien mukaisesti. Sama toistetaan toiselle pelaajalle. Näin toimimalla varmistetaan, että molemmat funktiot käsittelevät argumenttina annettua sanakirjaa, eivät suoraan pääohjelmassa olevia.

Esimerkit toiminnasta:
Pelaajan 1 vuoro
Hahmo on sijainnissa (0, 0)
Anna liikkumissuunta asteina: 180
Anna liikenopeus: 10
Uusi sijainti: (-10, 0)
Pelaajan 2 vuoro
Hahmo on sijainnissa (50, 50)
Anna liikkumissuunta asteina: 45
Anna liikenopeus: 5
Uusi sijainti: (54, 54)
Pelaajan 1 vuoro
Hahmo on sijainnissa (0, 0)
Anna liikkumissuunta asteina: 30
Anna liikenopeus: -4
Uusi sijainti: (-3, -2)
Pelaajan 2 vuoro
Hahmo on sijainnissa (50, 50)
Anna liikkumissuunta asteina: 210
Anna liikenopeus: 4
Uusi sijainti: (47, 48)
Varoitus: Et ole kirjautunut sisään. Et voi vastata.
?
  1. Kuvaus
  2. Esimerkit
Absoluuttinen polku (absolute path) on käyttöjärjestelmäkäsite, joka kertoo hakemiston "koko osoitteen". Absoluuttinen polku ilmaistaan levyaseman juuresta lähtien joten se ei ole riippuvainen siitä mikä on aktiivinen hakemisto. Absoluuttisia polkuja pyritään yleensä välttämään koodissa, erityisesti jos tarkoitus on tehdä koodia jota joku muukin saattaa käyttää. Toinen käyttäjä ei välttämättä sijoita tiedostoja juuri täsmälleen samanlaiseen hakemistorakenteeseen kuin olet omalla koneellasi tehnyt. Erityisesti jos tiedostosi yleensä asuvat kotihakemistossa, pelkästään absoluuttisessa polussa oleva eri käyttäjänimi sotkee kaiken jonkun muun koneella.
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
  3. Parametrien valinta
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).
Huom: format on vanhentunut tapa yleiseen merkkijonojen muotoiluun, nykyisin käytetään enemmän f-merkkijonoja. Vanhemmalla formatilla on kuitenkin edelleen käyttönsä.
  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ä.
Globaali näkyvyys koskee kaikkia nimiä (muuttujat, funktiot jne.) jotka on määritelty pääohjelman tasolla. Kaikki nimet jotka kuuluvat globaalin näkyvyyden piiriin ovat luettavissa mistä tahansa ohjelmakoodissa. Niihin ei voi kuitenkaan sijoittaa uusia arvoja muualla kuin pääohjelmatasolla. Yleisesti ottaen globaalilta näkyvyysalueelta tulisi käyttää funktioiden sisällä vain vakioita ja muita funktioita. Varsinaiset pääohjelman muuttujat pitäisi aina siirtää funktioihin parametrien kautta.
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.
Paikallinen muuttuja (eng. local variable) on muuttuja, joka on määritelty vain yhdessä kontekstissa, tyypillisesti - ja erityisesti tällä kurssilla - funktion sisällä (ml. funktion parametrit). Paikalliseen muuttujaan ei voi koskea ulkopuolelta, minkä lisäksi se lakkaa olemasta kun ohjelman suoritus poistuu sen kontekstista - eli yleensä kun funktion suoritus päättyy.
  1. Kuvaus
  2. 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 (f"Hei {nimi}"). Merkkijonojen paikanpitimissä voi olla lisämäärityksiä kuten näytettävien desimaalien lukumäärä (f"Aaseilla on keskimäärin {keskiarvo:.2f} jalkaa"). Paikanpitimien tilalle sijoitetaan sisällä olevan muuttujan tai lausekkeen arvo.
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.
Parametrisaatio tarkoittaa jonkin prosessin käyttötarkoitusten laajentamista siten, että osa sen kiinteistä arvoista muutetaan muuttujiksi jolloin sama prosessi voidaan suorittaa eri arvoilla ja saada eri tulos. Esim. matemaattiset yhtälöt ovat eräänlaista parametrisaatiota: kaikki yhtälön kuvaavat pisteet tuotetaan samalla kaavalla vaihtamalla muuttujan (esim. x) arvoa. Ohjelmoinnissa parametrisaatio on hyvin konkreettista: tyypillisesti prosessi irrotetaan omaan funktioonsa jonka parametrit määrittävät mitkä arvot eivät ole kiinnitettyjä jolloin funktio toimii eri tavalla eri parametreilla, antaen esim. eri tuloksen.
  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.
Relatiivinen polku (relative path) on käyttöjärjestelmäkäsite, joka kertoo hakemiston tai tiedoston osoitteen suhteessa aktiiviseen hakemistoon (eli siihen missä komento suoritetaan). Relatiivinen polku ei välitä siitä millainen hakemistoviidakko on levyaseman juuren ja aktiivisen hakemiston välissä. Tästä johtuen relatiivista polkua käytetään yleensä ohjelman omiin alikansioihin viittaamiseen. Tällöin ohjelma alikansioineen voidaan siirtää toiseen paikkaan ilman, että polkuja tarvii muuttaa.
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.
Suoritusjärjestys (eng. presedence) määrittää missä järjestyksessä koodirivillä olevat lauseet suoritetaan. Eri tyyppisillä operaatioilla on eri prioriteetti suoritusjärjestyksesä. Ne löytyvät alla olevasta linkistä. Samantasoiset operaatiot suoritetaan vasemmalta oikealle. Kuten matematiikassa, suoritusjärjestykseen voi vaikuttaa suluilla.
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):.
f(ormat)-merkkijono on erityinen merkkijono, jota käytetään, kun halutaan tuottaa tekstiä jonka sisään on sijoitettu muuttujien tai yksinkertaisten lausekkeiden arvoja. Tällainen merkkijono merkitään laittamalla sen eteen pieni f-kirjain. Merkkijonon sisällä voidaan käyttää aaltosulkeilla merkittyjä paikanpitimiä, joiden sisälle voidaan kirjoittaa muuttujien nimiä tai lausekkeita.
Esimerkki: f"Aasin korvien väli on {mittaus:.2f} tuumaa" (olettaen että mittaus-niminen muuttuja on aikaisemmin määritelty).
  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.