1. Johdanto

2. Algoritmi

2.1 Sisällys

• Algoritmin määritelmä.

• Aiheen pariin johdatteleva esimerkki.

• Algoritmista ohjelmaksi.

4. Lausekielinen ohjelmointi

4.1 Konekieli ja symbolinen konekieli

• Aluksi ohjelmoitiin tietokoneiden sellaisenaan ymmärtämällä konekielellä (machine language), jossa suorittimen komennot ja niiden parametrit esitetään binäärilukuina.

  • 10101001 00000001

• Symbolisessa konekielessä (assembly language) komennot on nimetty lyhyesti.

  • LDA #$01

• Koneläheisillä kielillä ohjelmointi on hidasta ja virhealtista, mutta toisaalta täysin ihmisläheinen ohjelmointi luonnollisella kielellä on mahdotonta kieliopin monimutkaisuuden sekä lauseiden ja sanojen moniselitteisyyden vuoksi.

5. Muuttujat ja funktiot

5.1 Sisällys

• Imperatiivinen laskenta.

• Muuttujat.

  • Nimi ja arvo.

  • Muuttujan nimeäminen.

  • Muuttujan tyyppi.

• Operaattorit.

  • Operandit.

  • Arvon sijoitus muuttujaan.

  • Aritmeettiset operaattorit.

• Funktiot.

  • Nimeäminen.

  • Parametrit.

  • Paluuarvo.

• Esimerkkejä.

  • Yksikkömuunnos.

6.2 Muuntaja-ohjelma

• Jaardit metreiksi muuntavan ohjelman muuttaminen Python-ohjelmaksi on helppoa; siinä on vain peräkkäisiä toimintoja.

  • Vuokaavion muuttujilla ja funktioilla kuvatut toiminnot voidaan kopioida lähdekoodiin samaan järjestykseen lauseiksi.

  • Kutakin toimintoa vastaava lause kirjoitetaan omalle rivilleen, koska Pythonissa lause on pääsääntöisesti yhdellä rivillä.

  • Löydät muuntaja.py-tiedoston kurssin kotisivuilta.

  • Komentoikkunassa siirrytään ennen ohjelman suoritusta ohjelmatiedoston sisältävään kansioon.

6.3 Lähdekoodin organisointi

• Kurssin harjoitusten ratkaisut kannattaa organisoida samalla tavoin kuin kurssin esimerkit on organisoitu.

• Tee kurssikansio, jossa on harjoituksille oma alikansio ja tässä kansiossa kullekin harjoitukselle oma alikansio, jonne tallennat kyseisen harjoituksen ohjelmat.

  • Löydät näin nopeasti tietyn tehtävän koodin eivätkä saman ohjelman eri versiot mene helposti sekaisin.

• Älä tallenna koskaan ohjelmiasi Python-tulkin omaan hakemistoon, koska suorituskelpoiset ohjelmat täytyy pitää erillään niiden käsittelemästä datasta.

• Muista tehdä säännöllisesti varmuuskopioita ohjelmistasi.

6.4 Kielioppivirheet

• Ohjelman tulkitseminen pysähtyy, jos siinä havaitaan kielioppivirhe.

• Oheisesta Hello World-ohjelmasta puuttuu sulkeva lainausmerkki.

• Tulkin virheilmoituksesta käy ilmi virheen rivi ja virheen laatu.

• Korjattu ohjelma pitää muistaa tallentaa, koska tulkki lukee lähdekoodin tiedostosta, ei editorista.

7.2 Erikoismerkit

• Erikoismerkkejä (escape characters) käytetään merkkeinä ja merkkijonon osina.

• Koostuvat kahdesta merkistä, mutta ovat kieliopillisesti yksi merkki.

  • Aloitetaan kenoviivalla \, jota seuraa toinen merkki.

• \n rivinvaihto

• \t tabulaattori

• \' yksinkertainen lainausmerkki

• \" lainausmerkki

• \\ kenoviiva

• \a äänimerkki

7.3 Tulostus erikoismerkeillä

• Erikoismerkeillä saadaan aikaan helposti vaikeasti luettavaa koodia.

  # Älä tee näin.
  print("\t\t**********\n\t\t* Python *\n\t\t**********")

  # Tee näin.
  print("\t\t**********")
  print("\t\t* Python *")
  print("\t\t**********")

• Yksinkertaisissa lainausmerkissä oleva lainausmerkki voidaan esittää sellaisenaan ja päinvastoin.

  # Yksinkertaista lainausmerkkiä ei tarvitse esittää
  # alla erikoismerkkinä, koska se on lainattu.
  print("It's just a flesh wound...")

8. Lisää operaattoreista ja tyypeistä

8.1 Sisältö

• Lisää aritmeettisia operaattoreita.

  • Potenssilasku, osamäärä ja jakojäännös.

• Merkkijonojen yhdistäminen eri tavoin.

• Totuusarvo bool.

• Vertailuoperaattorit.

8.2 Aritmetiikkaa

• Potenssilaskulle on pow-funktion lisäksi oma operaattori **.

• pow(2, 3) ja 2 ** 3 ovat molemmat \(2^3\).

• Osamäärän kokonaisosa saadaan selville //-operaattorilla ja jakojäännös %-operaattorilla.

  • Jakojäännösoperaattori on hyödyllinen, kun pitää päätellä onko vasen operandi jaollinen oikealla operandilla.

• 7 // 3 on 2, koska kolme menee kaksi kertaa lukuun seitsemän.

• 7 % 3 on 1, koska 7 - 2 ∙ 3 = 1.

• 3 on pariton luku, koska 3 % 2 on 1.

• 4 on parillinen luku, koska 4 % 2 on 0.

8.3 Merkkijonojen yhdistäminen

• Python yhdistää automaattisesti peräkkäiset merkkijonoliteraalit.

• yhdiste1 = "Spam!" " " "Spam!"

  • Muuttuja saa arvokseen merkkijonon "Spam! Spam!"

• Yhteenlaskuoperaattori on käytettävissä myös merkkijonojen yhdistämiseen.

  • Molempien operandien on oltava merkkijonoja. Tulos merkkijono.

  • Tarvitaan, kun merkkijonoliteraaliin yhdistetään muuttujan arvo, koska automaattinen yhdistäminen on sallittua vain literaaleille.

  etunimi = "Brian"
  # Tulostetaan "The life of Brian."
  print("The life of " + etunimi + ".")

8.4 Totuusarvotyyppi bool

• Totuusarvotyyppinen (Boolean-tyyppi) muuttuja voi olla vain joko tosi (True) tai epätosi (False).

• vaihtoehtoinen_totuus = False

• Pythonissa totuusarvoilla on numeeriset vastineet.

  • Luku 0 vastaa arvoa False.

    • Myös tyhjä merkkijono '' tai "" tulkitaan tarvittaessa epätodeksi.

  • Luku 1 vastaa arvoa True.

8.5 Vertailuoperaattorit

9. Pythonin valintarakenteet

9.1 If-lause

• Merkitään varatulla sanalla if.

• Kuvaa yksisuuntaisen päätöksen: rakenteen lauseet suoritetaan vain ehdon ollessa totta (True).

• Lauseet kiinnitetään rakenteeseen sisentämällä niitä neljällä välilyönnillä.

  • Pythonissa sisennyksellä on kieliopillinen merkitys.

  • Sisennys auttaa ohjelman lukijaa hahmottamaan mitkä lauseet ovat osa rakennetta.

...
# Luetaan luvut.

print("Anna ensimmäinen luku:")
x = int(input())
print("Anna toinen luku:")
y = int(input())

# Vertaillaan lukuja.
if x == y:
# Tulostetaan, jos x ja y ovat yhtä suuret.
print(x, "==", y)
...

9.3 If-else-lause

• Merkitään varatuilla sanoilla if ja else.

• Kuvaa kaksisuuntaisen päätöksen: if-osaan liittyvät lauseet suoritetaan ehdon ollessa totta, muuten suoritetaan else-osaan liittyvät lauseet.

  • Else-osalla ei ole omaa ehtoa.

• Lause kiinnitetään rakenteen osaan neljällä välilyönnillä.

...
# Vertaillaan lukuja.
if x == y:
    # Tulostetaan, jos x ja y ovat yhtä suuret.
    print(x, "==", y)
else:
    # Tulostetaan, jos x ja y ovat erisuuret.
    print(x, "!=", y)
...

9.5 Sisäkkäiset valinnat

• Monisuuntaisten valintojen ilmaisuun.

• Sisennysten merkitys kieliopillisena merkintänä ja ohjelman rakenteen selkeyttäjänä korostuu rakenteiden.

• Sisennysten määrää voidaan vähentää korvaamalla sisäkkäiset rakenteet if-elif-else-lauseella, jossa kukin elif-avainsanalla merkitty osa yhdistää ulomman if-else-lauseen else-osan ja sisemmän if-else-lauseen if-osan.

• Sisäkkäiset valintarakenteet voidaan korvata peräkkäisillä valinnoilla, jos rakenteiden ehdot sulkevat toisensa pois.

  • Sisäkkäisiä valintoja suositellaan, koska ne ovat vähemmän virhealttiita ja tehokkaampia.

9.6 Sisäkkäiset valinnat (vertailija3.py)

...
# Ulompi lause.
if x < y:
    print(x, "<", y)
else:
    # Sisempi lause.
    if x == y:
        print(x, "==", y)
    else:
        # Pakko olla totta, jos ehtolausekkeet
        # ovat epätosia.
        print(x, ">", y)
...

9.7 Sisäkkäiset valinnat (vertailija4.py)

...
if x < y:
    # Tulostetaan, jos x on pienempi kuin y.
    print(x, "<", y)
# "else:" ja "if x == y:" yhdessä.
elif x == y:
    # Tulostetaan, jos x ja y ovat yhtä suuret.
    print(x, "==", y)
else:
    # Pakko olla totta, jos ehtolausekkeet ovat 
    # epätosia.
    print(x, ">", y)
...

9.8 Peräkkäiset valinnat

...
# (x == y) == False ja (x > y) == False
if x < y:
    print(x, "<", y)

# (x < y) == False ja (x > y) == False
if x == y:
    print(x, "==", y)

# (x < y) == False ja (x == y) == False
if x > y:
    print(x, ">", y)
...

10. Toisto while-lauseella

10.1 Yleistä

• Algoritmin osien toistuva suoritus ilmaistaan lausekielissä toistorakenteilla, joita kutsutaan lyhyemmin silmukoiksi (loop).

• Pythonissa on käytettävissä while- ja for-rakenteet.

  • For esitellään myöhemmin, koska se on tehty sekvenssien silmukointiin.

• While-rakennetta ohjataan joko lipulla tai laskurilla riippuen siitä onko silmukan kierrosten lukumäärä tuntematon vai tunnettu ennen silmukkaa.

  • While on esiehtoinen silmukka.

  • Silmukka käyttäytyy jälkiehtoisen silmukan tapaan, kun ehdossa käytettävien muuttujien alkuarvot valitaan sitten, että silmukan ensimmäinen kierros suoritetaan aina.

10.2 While-lause

• Aloitetaan varatulla sanalla while.

• Ilmaisee esiehtoisen toistorakenteen, jossa rakenteen lauseita suoritetaan niin kauan kuin ehtolauseke on totta (True).

• Toistettavat lauseet kiinnitetään toistorakenteeseen niitä sisentämällä.

  • Sisennykseen käytetään Pythonin tyyliohjeiden mukaisesti neljää välilyöntiä.

  • Muista edelleen sisennyksen perimmäisin merkitys: koodin muotoilu välilyönnein kertoo lukijalle mitkä lauseet kuuluvat rakenteeseen.

10.4 Liput (lukija1.py)

• Silmukkaa ohjaa lippuarvo "Spam!"

• Syötteen säilövä muuttuja alustetaan siten, että esiehtoinen silmukka suoritetaan aina vähintään kerran.

...
merkit = ""
while merkit != "Spam!":
    print("Sano jotain:")
    merkit = input()
...

10.5 Liput (lukija2.py)

• Silmukkaa ohjaa lippumuuttuja, jonka arvo vaihdetaan silmukan sisällä if-lausetta käyttäen.

• Lippumuuttuja alustetaan siten, että esiehtoinen silmukka suoritetaan aina vähintään kerran.

• Lippumuuttujaa ei tarvitse vertailla erikseen True-arvoon, koska muuttujan arvo on jo sellaisenaan bool-tyyppinen.

...
jatketaan = True
while jatketaan:
    print("Sano jotain:")
    merkit = input()
    if merkit == "Spam!":
        jatketaan = False
...

10.6 Liput (lukija3.py)

• Lippumuuttuja alustetaan käyttäjän syötteen avulla, jolloin joudutaan toistamaan lauseita. Toisto ei ole toivottavaa, koska toistamalla ohjelma monimutkaistuu tarpeettomasti ja sen ylläpito vaikeutuu.

...
# Turhaa toistoa.
print("Sano jotain:")
merkit = input()
jatketaan = True
if merkit == "Spam!":
    jatketaan = False

while jatketaan:
    print("Sano jotain:")
    merkit = input()
    if merkit == "Spam!":
        jatketaan = False
...

10.7 Break-, continue ja ikuinen silmukka

• Break-lause keskeyttää silmukan suorituksen.

  • Käytetään aina ehdollisena, koska silmukka pysähtyy välittömästi.

• Continue-lause pysäyttää silmukan nykyisen kierroksen, mutta silmukan suoritusta jatketaan, mikäli kierroksia on jäljellä.

• Break- ja continue-lauseita lauseita käytetään yleensä yhdessä tarkoituksella tehdyn ikuisen while-silmukan kanssa. Tällä kurssilla näin ei saa tehdä, jotta while-lausetta opittaisiin aluksi käyttämään aidosti ehtolausekkeen kautta.

10.8 Liput (lukija4.py)

• Silmukan ehtolauseke on ilmaistu pelkällä True-literaalilla.

• Silmukka pysäytetään lippuarvon syötön jälkeen break-lauseella.

• Ei näin tällä kurssilla; eräs kurssin oppimistavoite on osata käyttää while-lausetta oikein.

while True:
    print("Sano jotain:")
    merkit = input()
    if merkit == "Spam!":
        break

10.9 While ja else

• While-silmukan yhteydessä voidaan käyttää else-avainsanaa.

• Tätä tekniikkaa ei esitellä tarkemmin muun muassa, koska sitä käytetään harvemmin, hyödyt ovat pieniä ja siitä saattaa olla enemmän haittaa kuin hyötyä ohjelman ymmärrettävyyden kannalta.

• "I would not have the feature at all if I had to do it over."
  - Guido van Rossum, Python-kielen kehittäjä.

10.10 Peli luvun arvaukseen

• Pelin vapaamuotoinen versio voidaan muuttaa melko suoraviivaisesti muuttujia ja Pythonin funktioita käyttäväksi tarkemmaksi algoritmiksi.

  • Otetaan käyttöön muuttujat arvattavalle ja arvatulle luvulle.

  • Arvattava luku alustetaan satunnaisen kokonaisluvun tuottavalla funktiolla väliltä [1, 10].

    • Laajemmalla välillä saataisiin luonnollisesti vaikeampi peli.

  • Arvaus luetaan käyttäjältä input-operaatiolla.

  • Vinkit ja onnittelut viestitään print-operaatiolla.

    • Algoritmin käytettävyyttä parannetaan muutamalla lisätulosteella.

  • Päätökset ilmaistaan vertailuoperaattoreiden avulla.

10.11 Peli luvun arvaukseen esiehdolla

10.12 Laskurit

• While-silmukkaa ohjataan laskurimuuttujan (counter) avulla, kun silmukan toistojen lukumäärä tunnetaan.

• Voidaan nimetä lyhyesti ellei ilmeistä parempaa nimeä löydy.

  • Yleisimmät lyhyet nimet ovat matematiikasta tutut indeksien symbolit i, j, k ja l.

• Laskurina käytetään yleisesti kokonaislukutyyppistä muuttujaa, jonka arvoon lisätään luku yksi jokaisella silmukan kierroksella.

  • Tällainen laskuri pitää kirjaa siitä montako kertaa toistaiseksi on silmukoitu.

  • Yhdellä kasvatettavan laskurin arvoa rajoitetaan kierrosten lukumäärällä, joka voidaan ilmaista literaalina tai muuttujana.

10.13 Laskurit (n_x_hello_world.py)

# Tervehditään käyttäjää ja kerrotaan 
# ohjelmasta.
print("Moi! Sanon monta kertaa moi.")
# Luetaan syöte käyttäjältä.
print("Anna moikkien lukumäärä:")
lkm = int(input())
# Alustetaan silmukan laskuri.
i = 0
# Tulostetaan haluttu määrä 
# tervehdyksiä silmukan avulla.
while i < lkm:
    # Tulostetaan tervehdys.
    print("Hello, World!")
    # Kasvatetaan laskuria.
    i = i + 1

10.14 Keskiarvon laskeminen

• Päätellään tarvittavat muuttujat kaavasta \(\bar{x} = \displaystyle\sum^n_{i=1}\frac{x_i}{n},\quad n \gt 0\)

  • luku on luettu luku (termi \(x_i\)),

  • i on laskuri, josta selviää monesko silmukan kierros on alkamassa (termin indeksi \(i\)),

  • summa vastaa lukujen summaa (\(\sum x_i\)),

  • lkm vastaa lukujen lukumäärää (indeksin yläraja \(n\)) ja

  • ka on lukujen keskiarvo (\(\bar{x}\)).

  • Arvaus luetaan käyttäjältä input-operaatiolla.

• Käyttäjän kanssa kommunikoidaan print- ja input-operaatioilla.

  • Algoritmin käytettävyyttä parannetaan lisätulosteilla.

11. Loogiset operaattorit

11.1 Yleistä

• Operandit ovat totuusarvoiksi käyviä literaaleja tai lausekkeiden tuloksia.

• Tulos on totuusarvoksi käyvä literaali.

• Kurssilla käytetään selvyyden vuoksi loogisten operaattoreiden operandeina vain bool-tyypin arvoja True ja False, vaikka esimerkiksi 1 ja 0 ovat sallittuja.

• Operaattorit määritellään totuustauluina, joissa annetaan operandien arvojen kaikki yhdistelmät ja arvoyhdistelmien tulokset.

11.2 Laskentajärjestys

1. Aritmetiikka.

2. Vertailut.

3. Looginen not.

4. Looginen and.

5. Looginen or.

6. Lopuksi mahdollinen sijoitus.

• Vasemmalta oikealle.

• Laskentajärjestystä voi muuttaa suluilla.

• Sulkuja on joskus syytä käyttää selvyyden vuoksi.

• And- ja Or- operaattorit operaatiot ovat ehdollisia: jos tulos saadaan selville jo ensimmäisestä operandista, niin toista operandia ei arvioida.

11.3 And

• Olkoon A ja B totuusarvoja tai totuusarvoisia lausekkeita.

• Lauseke A and B on tosi vain, kun A ja B ovat tosia.

# Syödään karkkia vain, jos on oikea
# päivä ja hampaat käyttökelpoisia.
if karkkipäivä and reikien_lkm < 2:
    karkkien_lkm = karkkien_lkm - 1

karkkipäivä = True
reikien_lkm = 1
karkkipäivä and reikien_lkm < 2 -->
True and 1 < 2 --> True and True -->
True

karkkipäivä = False
reikien_lkm = 1
karkkipäivä and reikien_lkm < 2 -->
False and 1 < 2 --> False

11.4 Or

• Lauseke A or B on tosi, kun jompikumpi lauseke tai molemmat lausekkeet ovat tosia.

# Syödään karkkia, kun on karkki-
# päivä tai kun hampaat ovat käyttö-
# kunnossa tai karkkipäivänä, kun on
# hampaat ovat kunnossa.
if karkkipäivä or reikien_lkm < 2:
    karkkien_lkm = karkkien_lkm - 1

karkkipäivä = True
reikien_lkm = 1
karkkipäivä or reikien_lkm < 2 -->
True or 1 < 2 --> True

karkkipäivä = False
reikien_lkm = 1
karkkipäivä or reikien_lkm < 2 -->
False or 1 < 2 --> False or True --> True

11.5 Not

• Lauseke not A on tosi silloin, kun lauseke A on epätosi.

• Lauseke not A on epätosi silloin, kun lauseke A on tosi.

# Syödään karkkia vain, jos ei ole
# oikea päivä ja hampaat ovat
# käyttökelpoisia.
if not karkkipäivä and reikien_lkm < 2:
    karkkien_lkm = karkkien_lkm - 1

karkkipäivä = True
reikien_lkm = 1
not karkkipäivä and reikien_lkm < 2 -->
not True and 1 < 2 --> not True and True --> False and True --> False

karkkipäivä = False
reikien_lkm = 1
not karkkipäivä and reikien_lkm < 2 -->
not False and 1 < 2 --> not False and True --> True and True --> True

11.6 Ohjausrakenteissa

• Loogisilla operaatioilla yhdistetyistä lausekkeista voidaan muodostaa monimutkaisempia ehtoja, joiden avulla voidaan puolestaan vähentää sisäkkäisiä rakenteita.

...
# Sisäkkäiset rakenteet.
if viikonpäivä == "ma":
    if monesko == 13:
        print("2 x huono päivä.")

# Ehdot yhdistämällä voidaan poistaa
# sisempi if-lause.
if viikonpäivä == "ma" and monesko == 13:
    print("2 x huono päivä.")
...

...
# Sisäkkäiset rakenteet.
if viikonpäivä == "ma":
    print("Huono päivä.")
elif monesko == 13:
    print("Huono päivä.")

# Ehdot yhdistämällä voidaan poistaa
# elif-osa.
if viikonpäivä == "ma" or monesko == 13:
    print("Huono päivä.")
...

...
if (viikonpäivä == "ma") and (monesko == 13):
    print("2 x huono päivä.")
if (viikonpäivä == "ma") or (monesko == 13):
    print("Huono päivä.")
...

• Älä käytä ylimääräisiä sulkeita tarpeettomasi muissa yhteyksissä. Ne vain hämäävät ohjelmasi lukijaa.

# Tästä suljeparista on lähinnä haittaa lukijalle. Älä tee näin!
i = (i + 1)

11.7 Bittioperaatorit

• Myös Python-kielessä on and-, or ja not-operaattorit (&, | ja ~) kokonaislukujen käsittelyyn bittien tasolla.

• Näitä operaattoreita on syytä välttää, vaikka ne toimivat True- ja False-arvojen kokonaislukuvastineiden 1 ja 0 ansiosta loogisesti oikein, koska Pythonissa on omat operaattorit logiikalle.

• Biteittäinen xor (^) on poikkeus, koska poissulkevan disjunktion looginen versio puuttuu Pythonista.

  • Xor voidaan esittää myös erisuuruusoperaattorin avulla.

12. Hyvä ohjelmointitapa

12.1 Yleistä

• Ohjelman elinkaari ei tyypillisesti pääty sen toteuttamiseen; ohjelmaa voidaan käyttää ja ylläpitää jopa vuosikymmeniä.

• Jotta koodin muuttaminen on mahdollista, sen on oltava muidenkin kuin tekijänsä ymmärrettävissä.

• Hyvää ohjelmointitapaa noudattamalla saadaan aikaiseksi ymmärrettäviä ja hallittavia ohjelmia.

• Perusasioita:

  • Nimeä muuttujat järkevästi.

  • Kommentoi riittävästi ja oikeissa paikoissa.

  • Sisennä koodia.

  • Rivitys: vältä liian pitkiä rivejä, käytä välirivejä ja käytä välilyöntejä riveillä.

  • Käytä vakioita.

12.2 Nimeä järkevästi

• Tunnusten (nimien) tulee olla järkeviä.

• Nimestä tulisi voida päätellä muuttujan tehtävä ohjelmassa ja muuttujan sisältämän tiedon luonne.

• Usein hyvä nimi on yhtä kuin riittävän pitkä nimi.

  • Laskurit saa nimetä lyhyemmin, kun ilmeistä hyvää nimeä on vaikea keksiä.

• Noudata kielen nimeämiskäytäntöjä johdonmukaisesti.

  • Pythonissa muuttujien nimet annetaan pienin kirjaimin.

  • Sanat erotetaan toisistaan alaviivoilla.

    • Yhdyssanat kirjoitetaan yhteen samoin kuin luonnollisessa kielessä.

• Käytä tunnuksissa mahdollisimman pitkälti vain yhtä kieltä.

  • Tunnusten on oltava käytännössä joko suomeksi tai englanniksi.

  • Luentomateriaalissa pyritään yhtenäisesti suomenkielisiin tunnuksiin. Annetut ohjelmatiedostot nimetään siten ettei niissä ole å-, ä- tai ö-kirjaimia, jotta niitä on helppo siirtää järjestelmien välillä.

• Ohjelman muuttujat ja kommentit saa kirjoittaa suomenkielellä, vaikka ohjelman käyttöliittymässä käytettäisiin englannin kieltä.

• Kirjoita ohjelmasi täysin englanniksi (tunnukset, kommentit ja käyttöliittymä), jos on mahdollista, että siihen on kansainvälistä kiinnostusta.

12.3 Kommentoi

• Kommentit kannattaa kohdistaa erityisesti koodin keskeisiin osiin ja vaikeasti ymmärrettäviin osiin.

  • Varsinkin pitemmässä ohjelmassa ei tarvitse kommentoida kaikkea.

  • Harva laajempi ohjelma on niin selkeä, että kommentteja ei tarvita. Kommentit puuttuvat yleensä siksi ettei niille ole aikaa tai kirjoittaja on vain laiska.

  • Kurssin materiaalissa on kommentteja, jotka ovat käytännössä turhia, jotta koodi olisi aloittelijalle selkeämpää.

• Ohjelman alkuun kannattaa kirjoittaa kommentti, josta käy ilmi mitä ohjelma tekee, kuka ohjelman teki ja yhteystietoja esimerkiksi sähköpostin muodossa.

• Muista päivittää kommentit ohjelman muuttuessa.

12.4 Sisennä

• Sisennys auttaa hahmottamaan kokonaisuuksia.

• Sisennyksellä osoitetaan Pythonissa lauseiden looginen ja kieliopillinen yhteenkuuluvuus.

• Sisennä Python-lähdekoodi välilyönnein.

  • Kukin sisennyksen taso on neljä välilyöntiä.

  • Sekä tavalliset lauseet että kommentit samalle tasolle.

• Ole tarkkana valintarakenteissa: muista sisentää esimerkiksi if- ja else-osiin kuuluvat kommentit ja lauseet samalle tasolle.

12.5 Rivitys

• Osoita lauseiden "teemoittainenˮ yhteen-kuuluvuus kootun lauseen sisällä välirivejä käyttämällä.

  • Erota teemat yhdellä välirivillä.

  • Pythonin tyyliopas ohjeistaa käyttämään välirivejä säästeliääsi.

    • Esimerkeissä ja mallivastauksissa on selkeyden vuoksi normaalia enemmän erottavia rivejä.

...
# Tulostussilmukan laskuri.
rivi = 0
    
# Tulostetaan rivit.
while rivi < korkeus:
   # Muodostetaan rivi ja
   # tulostetaan se.
   print(leveys * piirtomerkki)
   # Kasvatetaan laskuria.
   rivi = rivi + 1

# Jatkokyselyä ohjaava lippu.
väärä_vastaus = True
...

• Pitkät rivit ovat vaikeaselkoisia ja näkyvät vain osin pienessä ikkunassa.

• Jaa liian pitkä rivi kahdeksi lauseeksi kahdelle riville tai katkaise rivi, jolloin yksi lause on kahdella rivillä.

  • Pythonin tyylioppaassa rivin maksimimitaksi annetaan 79 merkkiä.

    • Kurssilla yli 100 merkin mittaiset ovat liian pitkiä.

  • Rivien katkonnasta kerrotaan myöhemmin.

• Paranna yksittäisten rivien luettavuutta käyttämällä välilyöntejä.

  • Yksi välilyönti ennen ja jälkeen operaattorin.

  • Ei välilyöntiä avaavan sulkeen jälkeen eikä ennen sulkevaa suljetta.

# Ei näin...
i=1
i=(j+1)*2
    
# ...vaan näin...
i = 1
i = (j + 1) * 2

# ...tai näin, jos halutaan
# ilmaista, että yhteenlasku
# on kertolaskua heikompi
# operaattori.
i = 1
i = (j+1) * 2

12.6 Vakiot

• Vakiot (constant) ovat muuttujia, joiden arvo ei ole tarkoitettu muutettavaksi alustamisen jälkeen.

• Vakioiden tunnus kirjoitetaan ISOIN KIRJAIMIN, jotta ne erottuvat paremmin muuttujista.

  • Pythonissa ei ole valitettavasti määrettä, jolla arvon myöhempi muutos voitaisiin estää. Isoin kirjaimin annetut muuttujat on siksi vain muistettava jättää rauhaan.

• PII = 3.14

• LOPETUSKOMENTO = "e"

• LYHYET_JÄÄHYVÄISET = "Ohjelma lopetettu."

• Vakiot määritellään yleensä ohjelman alussa ennen muita lauseita.

• Helpottavat ohjelmien ylläpitoa.

  • Luonnollisesti hyödyllisiä, kun muuttujan arvo on suojattava muutoksilta ylipäätänsä.

  • Vakiolla voi korvata monessa kohtaa lähdekoodissa esiintyvän literaalin, jolloin literaalin voi muuttaa kätevästi vain muuttamalla vakion alustuslausetta.

  • Ohjelman käyttöliittymän muokkaaminen on helpompaa, kun ohjelman tuntemat komennot samoin kuin sen tulostamat viestit vakioidaan .

• Osa hyvää ohjelmointitapaa.

• Oheisessa esimerkissä vakion ansiosta piin likiarvon muuttuessa tarvitsee muuttaa vain yhtä lausetta.

...
// 3.14 literaalina.
ympyrän_ala = 3.14 * r ** 2
ympyrän_keha = 2 * 3.14 * r
pallon_ala = 4 * 3.14 * r ** 2
...

...
// Arvo 3.14 vakiona.
PII = 3.14
ala = PII * r * r
keha = 2 * PII * r
pallon_ala = 4 * PII * r ** 2
...

13. Pythonin tietorakenteita

13.1 Yleistä

• Tietorakenne (data structure) on järjestelmällinen esitysmuoto, joka mahdollistaa tietoalkioiden tehokkaan saannin ja muuttamisen.

• Eräs Pythonin vahvuus ovat useat kieleen sisäänrakennetut tietorakenteet.

  • Esimerkiksi Javassa voi käyttää suoraan vain taulukoita.

• Tällä kurssilla käsitellään joitakin sekvenssejä (sequence) ja sanakirjaa (dictionary).

• Sekvenssi on peräkkäisten alkioiden kokoelma.

  • Sekvenssit luokitellaan muuttumattomiksi (immutable) ja muuttuviksi (mutable) sen mukaan voidaanko sekvenssin alkioita muuttaa sekvenssin luomisen jälkeen.

13.2 Lukujono

• Lukujono (range) on kokonaislukujen äärellinen aritmeettinen jono.

  • Peräkkäisen alkioiden väli \(d = a_{i+1} - a_i\) on vakio, missä \(i = 0, 1, ...\)

  • Alkio \(a_i = a_0 + d \cdot (i - 1)\)

  • Esimerkiksi jonossa 2, 4, 6, 8 väli \(d\) on 2.

• Muodostetaan kolmeparametrisella range-funktiolla.

  • start: jonon ensimmäinen alkio \(a_0\). Nolla, jos määrittelemättä.

  • stop: jonon viimeisen alkion päättelyyn käytettävä arvo.

  • step: väli \(d\). Jos \(d > 0\), \(a_i = a_0 + d \cdot i\), missä \(i \geq 0\) ja \(a_i <\) stop. Jos \(d < 0\), \(a_i = a_0 + d \cdot i\), missä \(i \geq 0\) ja \(a_i >\) stop. Lukujono on tyhjä, jos \(a_0\) ei täytä epäyhtälöä. Väli on yksi, jos se jätetään määrittelemättä. Väli ei voi olla nolla.

• Funktion peruskäyttötapaus on yksiparametrinen kutsu, jolloin jono alkaa nollasta ja koostuu peräkkäistä kokonaisluvuista parametriarvo pois lukien.

  • Esimerkiksi range(5) tuottaa jonon 0, 1, 2, 3, 4.

# 1, 2, 3, 4, 5
range(1, 6)
# 2, 4, 6, 8
range(2, 9, 2)
# 7, 20, 33, 46, 59, 72, 85, 98
range(7, 100, 13)
# -3, -2, -1, 0, 1
range(-3, 2)
# 5, 4, 3, 2, 1
range(5, 0, -1)
# 1, -1, -3
range(1, -5, -2)
# Tyhjä väli.
range(1, 1)
range(7, 3)
# Ajonaikainen virhe ValueError
range(1, 10, 0)

• Vaikka lukujono itsessään on muuttumaton sekvenssi, sitä käytetään harvoin pääasiallisena tietorakenteena.

• Lukujonoja käytetään tyypillisimmin silmukoinnin yhteydessä.

  • Jonon alkiot voivat toimia laskurin tapaan ja jonolla voidaan tuottaa tietorakenteen alkioita yksilöiviä indeksiarvoja.

    • Lukujono on näissä tehtävissä tehokas, koska se ei säilö alkioitaan, vaan laskee aina tarvittaessa uuden alkion arvon yhtälön avulla.

13.3 For-silmukka

• Pythonin for-silmukka on tehty sekvenssien tapaisten iteroitavien rakenteiden käsittelyyn.

• Silmukan otsikkorivillä esitellään muuttuja, johon sijoitetaan automaattisesti otsikkorivillä määritellyn sekvenssin seuraava alkio.

  • Lippua tai laskuria ei voi käyttää ehdossa; ehto-lauseke annetaan aina avainsanaa in käyttäen.

for muuttuja in sekvenssi:
   ...

• Toistettavat lauseet sidotaan rakenteeseen sisentämällä.

  • Muista neljä välilyöntiä.

• Pysäytettävä break-lauseella, jos kaikkia alkioita ei haluta käsitellä.

  • Continue aloittaa välittömästi seuraavan alkion käsittelevän kierroksen

13.4 Karkausvuodet1.py ja karkausvuodet2.py

...
vuosi = eka_vuosi
...
while vuosi <= vika_vuosi:
    if ...:
        print(vuosi)
    vuosi = vuosi + 1

...
for vuosi in range(eka_vuosi, vika_vuosi + 1):
    if ...:
        print(vuosi)

13.5 Merkkijonot

• Muuttumattomia sekvenssejä, joista opitaan seuraavaksi erityisesti kuinka merkkijonosta voidaan valita yksittäisiä merkkejä ja osia []-notaatiolla ja indeksiarvoilla.

  • Valinta ja merkkijonojen yhteydessä esitellyt funktiot toimivat myös lukujonojen ja myöhemmin esiteltävien sekvenssien yhteydessä.

• Python indeksoi sekvenssit nollasta alkavin kokonaisluvuin.

  • Viimeinen indeksiarvo on \(n- 1\), kun sekvenssissä on \(n\) kappaletta tietoalkioita.

  • Sekvenssin pituus voidaan selvittää len-funktiolla.

  • Myös negatiiviset (\(< 0\)) indeksiarvot ovat mahdollisia; Python lisää niihin automaattisesti sekvenssin pituuden.

• Indeksointia havainnollistaa oheinen taulukko, jossa on annettu merkkijonon "Python" merkkien indeksit.

  • Ensimmäisen merkin indeksi on 0 tai -6, koska len(\"Python\") + (-6) = 6 - 6 = 0.

  • Viimeisen merkin indeksi on 5 tai -1, koska len(\"Python\") + (-1) = 6 - 1 = 5.

• Sekvenssistä poimitaan yksittäinen alkio lisäämällä sekvenssin nimen perään hakasuljepari ja yksilöimällä alkio indeksiarvolla, joka sijoitetaan parametrin tapaan sulkeiden väliin.

  • Virheellinen indeksiarvo aiheuttaa ajonaikaisen virheen IndexError.

• Merkkijonon merkkejä ei voi muuttaa.

merkit = "Python"
# "P"
print(merkit[0])
# vika = "n"
vika = merkit[-1]
print(vika)
# Indeksiarvo 6: IndexError
merkit[len(merkit)]
# Indeksiarvo -7: IndexError
merkit[-len(merkit) - 1]
# TypeError: 'str' object does
# not support item assignment
merkit[0] = "T"

• Sekvenssistä poimitaan useampia tietoalkioita kerrallaan [::]-notaatiolla "viipaloimalla" (slicing).

  • Valitut alkiot ovat peräkkäin tai seuraavat toisiaan tasavälein.

• Indeksiarvoja käytetään viipaloinnissa pitkälti range-funktion parametrien tapaan: [start:stop:step].

  1. start: ensimmäisen viipaleeseen kuuluvan tietoalkion indeksi. Nolla, jos ei määritellä. Sekvenssin pituus \(n\), jos suurempi kuin \(n\) ja nolla, jos pienempi kuin \(-n - 1\).

  2. stop: ensimmäisen viipaleesta pois jäävän tietoalkion indeksi. \(n\), jos ei määritellä tai suurempi kuin \(n\). Nolla, jos pienempi kuin \(-n - 1\).

  3. step: viipaleeseen valittavien tietoalkioiden väli. Yksi, jos määrittelemättä.

• Koko sekvenssin viipalointi kopioi sekvenssin.

merkit = "Python"
# "tho"
merkit[2:5]
merkit[-4:-1]
# "P"
merkit[0:1]
merkit[-6:-5]
# Valitaan 3. merkkiin saakka:
# "Pyt"
merkit[:3]
merkit[:-3]
# Valitaan 4. merkistä alkaen:
# "hon"
merkit[3:]
merkit[-3:]
# Valitaan kaikki: "Python"
merkit[:]

# Valitaan parillisissa 
# paikoissa olevat merkit: "Pto"
merkit[::2]
# Kääntäen: "nohtyP"
merkit[::-1]
# 2.-4. merkit kääntäen: "oht"
merkit[4:1:-1]
# Tyhjä merkkijono "".
merkit[4:1]
# Liian pieni tai suuri indeksi 
# ei kaada ohjelmaa, vaan niille
# annetaan arvot 0 ja 6: "Python"
merkit[-100:100]

• In-avainsanalla saadaan myös selville onko tietty alkio sekvenssissä.

  • Toisin kuin useimmissa sekvensseissä, merkkijonoista voidaan hakea osia (osamerkki-jonoja).

• Min- ja max-funktiot palauttavat vastaavasti sekvenssin pienimmän ja suurimman alkion.

merkit = "Python"
# True ja False
"P" in "Python"
"P" not in "Python"
# Pieni ja suuri kirjain ovat 
# eri merkit: False
"p" in "Python"
# True
"on" in "Python"
# Merkkijonon min-funktio 
# palauttaa pienimmän Unicode-
# koodin omaavan merkin: "P"
min("Python")
# Merkkijonon max-funktio 
# palauttaa suurimman Unicode-
# koodin omaavan merkin: "y"
max("Python")

13.6 Listat

• Lista (list) on muuttuva sekvenssi, joka luomiseen on eri tapoja:

  • Tyhjä hakasulkeiden pari [] luo tyhjän listan.

  • Hakasulkeissa oleva yksittäinen tietoalkio tai hakasulkeissa olevat pilkulla toisistaan erotetut tiedot ovat lista.

  • Parametriton list-funktion kutsu luo ja palauttaa tyhjän listan.

  • List-funktio luo parametrinaan saamastaan iteroitavasta rakenteesta listan ja palauttaa sen.

lista1 = []
lista2 = list()
alkuaineita = ["kupari", "hopea", "kulta", "rauta"]
# [1, 3, 5, 7, 9]
parittomia_luonnollisia_lukuja = list(range(1, 10, 2))
# ["P", "y", "t", "h", "o", "n"]
merkit_listana = list("Python")

• Lista on tarkoitettu homogeenisten alkioiden säilömiseen.

  • Pythonin dokumentaatiossa homogeenisuutta ei määritellä, vaan todetaan, että tehtävä määrää samankaltaisuuden asteen.

  • Kurssilla alkioiden samankaltaisuutta mitataan tyypillä.

  • Listoja saatetaan hyödyntää toisin kuin alunperin on ajateltu, koska erityyppisten alkioiden käyttöön ei ole teknisiä esteitä.

• Kaikki merkkijonojen yhteydessä esitellyt sekvenssien yhteiset operaattorit, avainsanat ja notaatiot ovat saatavilla.

  • Valinnat []- ja [::]-notaatioilla palauttavat vastaavasti listan alkio arvon ja listan.

• Ilmeisin ero aiemmin esiteltyihin sekvensseihin on se, että listaa voidaan muuttaa korvaamalla valitut alkiot sijoitusoperaattorilla.

• []-notaatiolla korvattavaksi valitun alkion paikalle sijoitetaan yksittäinen arvo.

• Viipaloimalla määriteltyjä alkioita korvattaessa sijoitus-operaattorin toiseksi operandiksi annetaan korvaavat alkiot sisältävä iteroitava rakenne, joka on tällä kurssilla aina lista.

  • Korvaavalla listalla voi olla eri määrä alkioita kuin viipaleessa, paitsi kun viipale on määritelty väliä käyttäen.

# Korvataan viimeinen alkio.
# ["kupari", "hopea", "kulta", "platina"]
alkuaineita[-1] = "platina"
# Korvataan 2. ja 3. alkio eli "hopea" ja "kulta" tiedolla 
# "vety". ["kupari", "vety", "platina"]
alkuaineita[1:3] = ["vety"]

• Tiedot lisätään sijoitettaessa listalle alkioita korvaamatta, kun viipale määritellään siten, että ensimmäisellä ja toisella parametrilla on sama arvo.

  • Tieto lisätään loppuun, kun arvot ovat n, missä n on listan pituus.

# Lisätään kaksi uutta alkiota listan alkuun.
# ["kalsium", "argon", "kupari", "vety", "platina"]
alkuaineita[0:0] = ["kalsium", "argon"]
# Lisätään uusi alkio listan keskimmäiseen paikkaan. Lisäys-
# paikassa oleva alkio ja sitä seuraavat alkiot seuraavat
# lisättyä alkiota. ["kalsium", "argon", "sinkki",
# "kupari", "vety", "platina"]
alkuaineita[2:2] = ["sinkki"]
# Lisätään uusi tieto listan viimeiseksi alkioksi.
alkuaineita[len(alkuaineita):len(alkuaineita)] = ["alumiini"]

• Yhteenlasku- ja kerto-operaattorit + ja * toimivat samoin kuin merkkijonojen yhteydessä.

  • Operaattorin paluuarvo on sijoitettava muuttujaan, jos uutta listaa tarvitaan myöhemmin.

    • Lisäykset voidaan tehdä vaihtoehtoisesti lisäysoperaattorilla, joka on kätevämpi listan alkuun ja loppuun lisättäessä.

    • Myöhemmin olioita tarkasteltaessa nähdään tarkemmin mitä tapahtuu, kun sijoitusoperaattoria käytetään sekvenssien ja muiden kurssilla esiteltyjen tyyppien kanssa.

• Del-lause poistaa []- ja [::]-notaatiolla määritellyt alkiot.

  • Viipaloimalla valitut alkiot voidaan poistaa myös sijoittamalla viipaleeseen tyhjä lista [].

# Alustetaan listatyyppinen muuttuja. Lista on homogeeninen;
# se sisältää samantyyppisiä alkioita Huomaa, että tarkasti ottaen 
# kyseessä on sekvenssien sekvenssi.
kieliä = ["Java", "Python", "C"]
# Korvataan viimeinen alkio: ["Java", "Python", "C++"]
kieliä[-1] = "C++"
# Korvataan 1. ja 2. alkio: ["Python", "Java", "C++"]
kieliä[:2] = ["Python", "Java"]
# Lisätään listan loppuun uusi alkio. Uusi lista sijoitetaan
# samaan muuttujaan, jonon vanha lista liittyi, jotta esimerkissä
# voidaan jatkaa saman muuttujan käyttöä. Uuden listan alkiot:
# ["Python", "Java", "C++", "Haskell"]
kieliä = kieliä + ["Haskell"]
# Alkion lisääminen epäonnistuu, koska 2. operandi ei ole lista.
# Sekvenssien yhteenlaskussa operandien on oltava samantyyppistä. 
kieliä = kieliä + "JavaScript"

# 2. ja 4. alkion korvaaminen epäonnistuu, koska väliä käytettäessä 
# korvattavia ja korvaavia alkioita on oltava sama määrä.
kieliä[1:4:2] = ["Scala"]
# Lisätään listan toiseksi viimeiseksi alkioksi "Perl".
# ["Python", "Java", "C++", "Perl", "Haskell"]
kieliä[len(kieliä) - 1:len(kieliä) - 1] = ["Perl"]
# Korvataan kaikki alkiot yhdellä uudella alkiolla: ["JavaScript"]
kieliä[:] = ["JavaScript"]
# Samanarvoinen alkio voi esiintyä listalla useasti:
# ["JavaScript", "JavaScript", "JavaScript"]
kieliä = 3 * kieliä
# Poistetaan listan ensimmäinen alkio: ["JavaScript", "JavaScript"]
del kieliä[0]
# Tyhjennetään lista. Myös: del kieliä[:].
kieliä[:] = []

13.7 Tuplat

• Tupla (tuple) on listan muuttumaton versio.

  • Tuplan alkioita ei voida korvata eikä alkioita lisätä tai poistaa.

  • Valitsemalla ja yhteenlaskuoperaattorilla laskettaessa muodostuu uusi tupla toisin kuin listojen yhteydessä.

  • Tuplan alkiot voivat olla muuttuvia.

• Tupla on ajateltu heterogeenisten alkioiden tallentamiseen.

  • Tuplaa käytetään myös, kun tarvitaan muuttumaton heterogeenisten alkioiden sekvenssi.

  • Teknisesti lista ja tupla eroavat toisistaan muuttuvuuden osalta.

• Tupla luodaan samoin periaattein kuin lista.

  • Tyhjä kaarisulkeiden pari () luo tyhjän listan.

  • Pilkulla toisistaan erotetut tiedot ovat lista.

    • Kaarisulkeita voidaan käyttää selvyyden vuoksi.

    • Yhden alkion mittainen tupla luodaan antamalla tieto ja pilkku.

  • Parametriton tuple-funktion kutsu luo ja palauttaa tyhjän listan.

  • Tuple-funktio luo parametrinaan saamastaan iteroitavasta rakenteesta tuplan ja palauttaa sen.

# ("one",)
ainokainen = "one",
# (13, 42, 3.14). Myös: lukuja = (13, 42, 3.14)
lukuja = 13, 42, 3.14
# ("ni", -1, 1.23, ["yes", "way"])
sekalaista = "ni", -1, 1.23, ["yes", "way"]

alkuaineita = ("kupari", "hopea", "kulta", "rauta")
# Valitaan toinen alkio eli "hopea".
toinen = alkuaineita[1]
# Muodostetaan uusi tupla, jolta puuttuu "hopea"-alkio ja liitetään 
# uusi tupla muuttujaan. []-notaatiolla valittu yksittäinen alkio
# on muutettava tuplaksi, jotta +-operaattorin operandit ovat
# samaa tyyppiä. Tuple-funktio ei sovellu tähän tehtävään, koska se
# muuntaisi ensimmäisen alkion merkit alkioiksi.
alkuaineita = (alkuaineita[0],) + alkuaineita[2:]
# False. Alkio "hopea" ei ole uudella listalla.
"hopea" in alkuaineita
# Tuplan alkioita ei voi korvata: TypeError: 'tuple' object does 
# not support item assignment
alkuaineita[1] = "alumiini"

• Sekvenssin purkaminen (unpacking) tarkoittaa sijoitusta, jossa operaattorin vasemmalla puolella on yhtä monta pilkulla erotettua muuttujaa kuin oikealla puolella olevassa sekvenssissä on alkioita.

  • Pythonin monisijoitus on tuplan purkamista muuttujiin.

# Tuplan (1, 2) ensimmäinen alkio 1 sijoitetaan muuttujaan eka
# ja toinen alkio 2 muuttujaan toka.
eka, toka = 1, 2
print(eka)  # 1
print(toka) # 2
# Monisijoituksella on helppo vaihtaa kahden muuttujan arvot
# päikseen.
toka, eka = eka, toka
print(eka)  # 2
print(toka) # 1

13.8 Sanakirjat

• Sanakirjan (dict) alkiot ovat avain--arvo-pareja.

  • Sanakirja ei ole peräkkäisten alkioiden sekvenssi, vaan assosiatiivinen rakenne, jossa järjestyksellä ei ole juuri merkitystä.

• Sana kirja on muuttuva rakenne.

• Avainten on oltava muuttumattomia.

  • Tuplaa voidaan käyttää avaimena, mutta sen alkioiden on oltava muuttumattomia.

  • Avainten ei tarvitse olla samaa tyyppiä. Myös arvot voivat olla keskenään erityyppisiä.

• Avain--arvo-pari on muotoa avain:arvo.

• Sanakirjojen luomiseen on useita menetelmiä. Esimerkiksi:

  • Aaltosulkeiden pari {} tai parametriton dict-funktion kutsu luo tyhjän sanakirjan.

  • Aaltosulkeissa oleva yksittäinen avain--arvo-pari tai aaltosulkeissa olevat pilkulla toisistaan erotetut parit muodostavat sanakirjan.

  • Dict-funktiolle voidaan antaa parit määrittelevien tuplien sekvenssi.

lukusanat = { 1: "yksi", 2: "kaksi", 3: "kolme" }
# Luodaan sanakirja tuplista ("hei", "hi") ja ("moi", "hi").
# {"hei": "hi", "moi": "hi"}
suomi_englanti_sanakirja = dict((("hei", "hi"), ("moi", "hi")))

• Pari lisätään sanakirjaan []-notaatiolla ja sijoittamalla: hakasulkeiden sisään annetaan avain ja sitten sijoitetaan arvo.

  • Samalla menetelmällä päivitetään arvo.

• Sanakirjasta haetaan tietoa []-notaatiolla sijoittamalla hakasulkeiden sisään annetaan avain.

  • Avaimen puuttuessa sanakirjasta tapahtuu ajonaikainen virhe KeyError, joka voidaan välttää avainsanalla in.

• Pari poistetaan del-lauseella ja []-notaatiolla.

  • KeyError, jos avain puuttuu.

# Lisätään kaksi luku - sana -paria.
lukusanat[4] = "nelja"
lukusanat[5] = "viisi"
# Lasketaan parien määrä.
len(lukusanat) # 5
# {1: "yksi", 2: "kaksi", 3: "kolme", 4: "neljä", 5: "viisi"}
print(lukusanat)
# Korjataan typo.
lukusanat[4] = "neljä"
# Haetaan päivitetty arvo.
print(lukusanat[4]) # neljä
# Poistetaan pari.
del lukusanat[5]
# Avain ja sen arvo on poistunut.
5 in lukusanat # False
len(lukusanat) # 4

14. Oliot

14.1 Yleistä

• Python esittää kaikki tiedot olioina (object).

• Oliot ovat luokkansa (class) ilmentymiä.

  • Luokka mallintaa käsitettä, jollaisia ovat muun muassa kissa, koira tai sekvenssi.

  • Luokka on ohjelmointikielen tietotyyppi, joka määrittelee mitä tietoja (muuttujia) ja toimintoja (funktioita) luokan olioilla on.

  • Esimerkiksi kissaa mallintavalla luokalla voisi olla muuttuja painolle ja funktio, joka tulostaa näytölle naukumista, jolloin kaikilla kissaolioilla on oma paino ja kaikki kissaoliot osaavat naukua.

• Python-luokkien muuttujia kutsutaan attribuuteiksi ja funktioita metodeiksi (method).

• Kurssin jatkon kannalta olio-ohjelmoinnista on tarpeen tietää lähinnä vain,

  • että erityisesti muuttujien arvot ovat olioita,

  • muuttujien nimet (tunnukset) ovat olioihin sijoituksella liitettäviä viitteitä (reference), joita voi liittyä yhteen olioon useampia ja

  • kuinka olion metodeja voidaan kutsua pistenotaatiolla olion kautta.

# Liitetään olioon 42 viite 
# sijoittamalla. Olio on 
# int-tyyppinen.
luku = 42
# Olion tyyppi voidaan
# selvittää type-funktiolla.
# <class 'int'>
type(luku)

14.2 Sijoitus

• Muuttujaa toiseen sijoitettaessa sijoitus-operaattorin ensimmäinen operandi liitetään olioon, johon toinen operandi liittyy.

  • Sijoitettaessa olion sisältöä ei kopioida toiseen olioon; vain viiteen kohde vaihtuu.

  • Sijoitus irrottaa ensimmäisen operandin oliostaan, jos operandiin liittyy sellainen.

# Olioon 42 liitetään toinen
# viite.
kaiken_tarkoitus = luku

# Viitteet liittyvät samaan olioon. 
id(luku) # 1633773376
id(kaiken_tarkoitus) # 1633773376
luku is kaiken_tarkoitus # True
luku is not kaiken_tarkoitus # False

• Olioiden identiteetti ja sisältö ovat eri asia.

  • Esimerkiksi samanpainoiset kissat ovat eri olioita.

• Vertailuoperaattorit, erityisesti ==, vertailevat olioiden sisältöä.

  • Python optimoi ohjelman muistinkäyttöä siten, että se liittää viitteitä samoihin pieniarvoisiin muuttumattomiin olioihin automaattisesti ilman sijoitusta.

luku1 = 42
luku2 = 42
# Viitteet liittyvät samaan 
# olioon, vaikka muuttujia
# ei ole sijoitettu 
# keskenään.
luku1 is luku2 # True
luku1 == luku2 # True
luku1 = 2147483647
luku2 = 2147483647 
# Viitteet liittyvät eri 
# olioihin, joiden sisältö 
# on sama.
luku1 is luku2 # False
luku1 == luku2 # True

14.4 Muuttuvat oliot ja sijoitus

• Kokonaislukujen kaltaisia muuttumattomia olioita voidaan käsitellä huoletta minkä tahansa siihen liittyvän viitteen kautta.

• Muuttuvien olioiden kanssa toimittaessa on muistettava, että olion sisältö muuttuu myös muidenkin kuin olioon alun perin liittyneen viitteen kautta.

# Liitetään viite muuttuvaan
# olioon.
eka = [1, 3, 4]
# Liitetään toka-viite eka-
# viitteen olioon.
toka = eka
# Viitteiden jakamaa muuttuvaa 
# oliota voidaan muuttaa minkä
# tahansa siihen liittyvää 
# viitettä käyttäen.
toka[-1] = 5
# [1, 3, 5]
print(eka)
# [1, 3, 5]
print(toka)

14.5 Yhteenlaskuoperaattori

• Yhteenlasku luo uuden olion ja palauttaa siihen liittyvän viitteen.

• Tulosolioon on sijoitettava viite, jos oliota halutaan käyttää myöhemmin.

# a)
luku1 = 1000
# b)
luku2 = 1
# c) luku1 + luku2
# d) summa = c)
summa = luku1 + luku2

14.6 Metodit

• Luokassa määriteltyjä metodeja voidaan kutsua viitteellä yksilöidyn olion kautta pistenotaatiolla.

  • Metodin kutsu on muodoltaan erilainen kuin funktion kutsu, mutta molemmissa kutsutavoissa toiminto kohdistuu olioon.

  • Metodia kutsuttaessa on muistettava edelleen antaa oikea määrä oikeantyyppisiä parametriarvoja järjestys huomioiden.

  • Funktion tapaan metodi voi palauttaa arvon.

# Kutsutaan metodia, joka luo kohteestaan uuden merkkijono-
# olion, joka kirjainmerkit on muutettu isoiksi kirjaimiksi.
# Uuteen olioon liitetään uusi viite.
kirjaimia = "abc"
isoja_kirjaimia = kirjaimia.upper()
print(isoja_kirjaimia) # "ABC"

• Kaikilla sekvensseillä on index- ja count-metodit.

  • Index-metodi hakee parametrinsa ensimmäistä esiintymää sekvenssissä. Hakualueen alku ja loppu voidaan määritellä indeksiarvoilla. Tuottaa ajonaikaisen ValueError-virheen, jos parametrilla ei ole esiintymiä.

  • Count laskee parametrinsa esiintymien lukumäärän.

  • https://docs.python.org/3/library/stdtypes.html#common-sequence-operations

kieli = "Java"
haettava = "a"
# Vältetään ohjelman pysäyttävä virhe tehottomalla tavalla.
if kieli.count(haettava) > 0:
    eka_ind = kieli.index(haettava)
    print(eka_ind) # 1

• Merkkijonoilla (str) on paljon omia metodeja.

  • https://docs.python.org/3/library/stdtypes.html#string-methods

# Haetaan merkkijono-oliosta "abbababba" ensimmäinen parametrin 
# esiintymän indeksiarvo. Hakualuetta voidaan tarketaan 
# lisäparametreilla.
"abbababba".find("ba") # 2
"abbababba".find("B") # -1
# Korvataan ensimmäisenä parametrina annetun osajonon 
# esiintymät toisena parametrina annetulla merkkijonolla.
# Korvausten määrää voidaan rajoittaa.
"abbababba".replace("ba", "-") # "ab--b-"
# Pilkotaan merkkijono osiin käyttäen erottimena annettua
# merkkijonoa. Osien määrälle voidaan antaa yläraja.
osat = "1; Brian; Cohen".split("; ") # ["1", "Brian", "Cohen"]

• Listalla (list) on lähinnä muuttuvien sekvenssien yhteiset metodit, joista pop on erityisen hyödyllinen, koska se palauttaa viitteen poistamaansa alkioon.

  • https://docs.python.org/3/library/stdtypes.html#common-sequence-operations

alkuaineita = ["kupari", "hopea", "kulta", "rauta"]
# Poistetaan listan toinen alkio ja sijoitetaan se muuttujaan.
toinen_alkio = alkuaineita.pop(1)
print(alkuaineita) # ["kupari", "kulta", "rauta"]
print(toinen_alkio) # "hopea"
# IndexError: pop index out of range
alkuaineita.pop(3)

• Sanakirjasta (dict) voidaan muun muassa lukea avaimet, arvot ja parit.

  • https://docs.python.org/3/library/stdtypes.html#mapping-types-dict

tunnuksia = {"cu": "kupari", "au": "kulta", "fe": "rauta"}
# Luetaan avaimet ja arvot ja tehdään metodien palauttamista
# näkymäolioista tuttuja sekvenssejä.
avaimet = list(tunnuksia.keys()) # ["cu", "au", "fe"]
arvot = list(tunnuksia.values()) # ["kupari", "kulta", "rauta"]
parit = list(tunnuksia.items())
# Tulostetaan avaimet ja arvot:
# ("cu", "kupari")
# ("au", "kulta")
# ("fe", "rauta")
for pari in parit:
    print(pari)

15. Omat funktiot

15.1 Yleistä

• Funktio on nimetty ohjelman osa (aliohjelma), jolle on voidaan välittää tietoja ja joka voi myös palauttaa tietoja.

  • Toistaiseksi on hyödynnetty valmiita funktioita. Nyt opitaan kirjoittamaan omia funktioita.

• Funktioilla pitkä ohjelma voidaan jakaa "palasiin", jolloin koodia on helpompi hallita, ymmärtää ja ylläpitää.

  • Monimutkaisuuden hallinta modulaarisella ohjelmoinnilla.

• Ohjelman eri kohdissa samana toistuva osa voidaan sijoittaa fuktioon, jolloin koodia ei tarvitse "monistaa" eri kohtiin, vaan pelkkä operaation kutsu riittää ohjelman osan suoritukseen.

  • Ohjelman ylläpito helpottuu.

• Funktiot nimetään samoin periaattein kuin muuttujat.

  • Nimet ovat yleensä muuttujien nimiä pitempiä.

  • Funktiot kuvaavat toimintoja -- nimessä on usein käskymuotoinen verbi.

• Hyvä ohjelmointitapa koskee myös funktioita.

  • Funktion yleinen kommentti kertoo vähintään funktion tarkoituksen.

• Python-lähdekooditiedosto on niin sanottu skripti (script), jos se on tarkoitettu suoritettavaksi.

• Moduuli (module) on funktioita ja muita määrittelyjä sisältävä Python-lähdekooditiedosto, jonka sisältö voidaan ottaa käyttöön muissa lähdekooditiedostoissa import-lauseella.

  • Moduuli on eräänlainen kirjasto.

• Ohjelmat kirjoitetaan kurssilla jatkossa Pythonille tyypilliseen tapaan siten, että niitä voi käyttää sekä skripteinä että moduleina, vaikka ohjelma onkin edelleen yhdessä tiedostossa.

• Ohjelmiin tehdään myös niin sanottu pääohjelma, joka on main-niminen funktio, joka on ensimmäinen kutsuttava funktio, kun ohjelma suoritetaan skriptinä.

  • Pääohjelma ei ole pakollinen, mutta se kirjoitetaan, koska jatkossa opiskellaan kieliä, joissa suorituskelpoisessa ohjelmassa täytyy olla pääohjelma.

  • Pääohjelmasta kutsutaan muita omia funktioita, jotka puolestaan voivat kutsua muita omia funktioita.

15.2 Pääohjelma

• Pääohjelma määritellään muiden funktioiden tapaan avainsanalla def, joka aloittaa metodin otsikon (header). Otsikkorivillä annetaan funktion nimi ja parametrilista ennen rivin päättävää kaksoispistettä.

• Parametrilista voi olla tyhjä () tai se voi sisältää yhden tai useamman parametrin tunnuksen kaarisulkeiden sisällä.

  • Parametrit nimetään kuten muuttujat ja erotetaan toisistaan pilkulla. Pääohjelman parametrilista on tällä kurssilla tyhjä.

• Funktioon liittyviä lauseita kutsutaan funktion rungoksi (body).

  • Lauseet sisennetään neljällä välilyönnillä.

def funktion_nimi(parametrilista):
    ...

def main():
    ...

• Jaetaan merkkijonon kehystettynä tulostava ohjelma (kehystaja1.py) pääohjelmaksi main ja kehystäväksi funktioksi.

• Aloitetaan pääohjelmasta, jonne sijoitetaan tervehdyksen tulostaminen ja syötteiden luku.

• Pääohjelma on perinteisesti tiedoston viimeinen funktio, jotta sitä kutsuttaessa on varmaa, että kaikki muut funktiot on määritelty.

def main():
    # Tervehditään käyttäjää ja kerrotaan ohjelmasta.
    print("Moi! Tulostan merkkijonon merkillä kehystettynä.")
    # Luetaan syötteet.
    print("Anna merkkijono:")
    merkit = input()
    print("Anna merkki:")
    merkki = input()

• Pääohjelman käynnistämiseen tarvitaan funktiokutsu, joka tulee suorittaa vain kun ohjelmaa käytetään skriptinä eli ajetaan.

  • Kutsu voidaan muotoilla ehdollisena Python-tulkin sisäisen muuttujan __name__ avulla, jolla on arvo "__main__", kun ohjelma on käynnistetty tulkkiin. Muuttujan arvo on tiedoston nimi, kun ohjelmaa ei ajeta, vaan käytetään moduulina.

  • Pääohjelma on määriteltävä ennen kutsua.

def main():
    # Tervehditään käyttäjää ja kerrotaan ohjelmasta.
    print("Moi! Tulostan merkkijonon merkillä kehystettynä.")
    ...
# Kutsutaan pääohjelmaa, jos ohjelmaa ajetaan.
if __name__ == "__main__":
    main()

15.3 Kehystävä funktio

• Kirjoitetaan seuraavaksi kehystävä funktio, jolle välitetään parametreina käyttäjän antamat tiedot.

• Parametrien tunnuksiksi valitaan selvyyden vuoksi tunnukset, joita käytetään pääohjelmassa syötteiden säilömiseen.

  • Parametrien tunnuksina voidaan käyttää mitä tahansa hyviä tunnuksia, koska yhdessä funktiossa käytetyt tunnukset eivät näy yhdestä funktiosta toiseen funktioon.

  • Parametrit toimivat funktion sisällä samoin kuin muuttujat.

• Ohjelmissa ei käytetä jatkossa funktioiden ulkopuolella määriteltyjä niin sanottuja globaaleja muuttujia ellei kyseessä ole useassa funktiossa tarvittava vakio, koska tällaiset muuttujat rikkovat modulaarisuusperiaatetta.

• Funktioon kirjoitetaan yleinen kommentti, jossa kerrotaan mitä funktiossa tehdään ja mitä tietoja parametreilla välitetään funktioon.

  • Kommenteissa kerrotaan myös paluuarvosta, jos funktiolla on sellainen.

  • Monesta kielestä poiketen funktion yleinen kommentti kirjoitetaan funktion sisään.

    • Kommentti on heti otsikon jälkeen. Kommentin jälkeen ei tule väliriviä.

• Yleiset kommentit esitetään kolminkertaisiin lainausmerkkeihin """ suljettuna merkkijonona (docstring), joka on varattu funktioiden ja sitä laajempien kokonaisuuksien dokumentointiin.

• Funktioiden rungoissa kommentoidaan normaaliin tapaan.

def tulosta_kehystettynä(merkit, merkki):
    """Tulostetaan viesti kehystettynä.
    merkit -- kehystettävä viesti, jossa on oltava vähintään yksi merkki.
    merkki -- yhden merkin mittainen merkkijono, jolla viesti kehystetään.
    """
    # Koodia selventävä ja kutsuja vähentävä apumuuttuja.
    merkkien_lkm = len(merkit)
    
    # Tulostetaan vain, jos parametrit ovat järkeviä
    if merkkien_lkm > 0 and len(merkki) == 1:
        # Luodaan ylä- ja alarivi.
        reunarivi = (merkkien_lkm + 4) * merkki

        # Tulostetaan.
        print(reunarivi)
        print(merkki + " " + merkit + " " + merkki)
        print(reunarivi)

• Myös pääohjelmassa on tehtävä funktiokutsu, jotta kehystävä funktio saadaan suoritettua.

  • Funktio sijoitetaan ennen pääohjelmaa, jotta se on määritelty ennen kutsua.

  • Uusi ohjelma on kokonaisuudessaan kehystaja2.py-tiedostossa.

def main():
    # Tervehditään käyttäjää ja kerrotaan ohjelmasta.
    print("Moi! Tulostan merkkijonon merkillä kehystettynä.")
    ...
    # Kutsutaan tulostavaa funktiota antamalla syötteet
    # sisältävien muuttujien arvot parametrien arvoiksi
    # oikea järjestys huomioiden.
    tulosta_kehystettynä(merkit, merkki)
# Kutsutaan pääohjelmaa, jos ohjelmaa ajetaan.
if __name__ == "__main__":
    main()

15.4 Funktioiden kutsut

• Funktiot on järjestettävä lähdekoodi-tiedostossa siten, että kutsuttavan funktion määrittely on ennen funktioiden ulkopuolella tehtävää kutsua.

  • Pääohjelman on oltava muiden funktioiden jälkeen, jotta on varmaa, että kaikki tarpeellinen on määritelty ennen pääohjelman käynnistystä.

  • Python sallii funktioille järjestykset, joiden virheellisyys ilmenee vasta ohjelmaa ajettaessa.

  • Metodien määrittelyjärjestyksellä ei ole kieliopillista merkitystä.

• Yhteenkuuluvia funktioita kannattaa sijoitella lähelle toisiaan ellei kutsujärjestys ole esteenä.

• Parametrien tunnukset ovat muuttujien tapaan viitteitä. Ne saavat arvonsa (olionsa) funktiota kutsuttaessa.

  • Funktiokutsussa parametrin tunnus liitetään parametrin arvoksi annettuun viitteeseen liittyvään olioon.

  • Voidaan ajatella, että parametriarvoksi saadaan nimetön viite, kun funktion kutsussa käytetään literaalia.

• Kutsu siirtää ohjelman suorituksen funktioon, josta palataan automaattisesti kutsupaikkaan ellei funktiossa käytetä ohjelmoijan toimesta return-lausetta.

• Ennen kehystävän funktion kutsua ja funktion kutsun jälkeen olioihin liittyvät vain pääohjelman muuttujat.

# main
merkit = input() # "Python"
merkki = input() # "+"

• Kehystävässä funktiossa olioihin liittyvät pääohjelman muuttujien lisäksi kehystävän funktion parametrit.

def tulosta_kehystettynä(merkit, merkki):

15.5 Parametrien oletusarvot

• Parametrille voidaan määritellä funktion otsikossa oletusarvo, joka otetaan käyttöön, kun parametrille ei anneta arvoa kutsussa.

  • Oletusarvoisten parametrit määritellään muiden parametrien jälkeen.

  • Oletusarvoisia parametreja voidaan käyttää kutsussa avainsanaparametreina.

  • Kutsussa ei voi käyttää avainsanaparametreja ennen normaaleja parametreja.

• Määritellään kehystävän funktion reunamerkin parametrille oletusarvo. Lisätään samalla oletusarvoinen parametri reunan kulmamerkille.

15.6 Kehystävä funktio (kehystaja3.py)

def tulosta_kehystettynä(merkit, reuna = "-", kulma = "+"):
    """Tulostetaan viesti kehystettynä.
    merkit -- kehystettävä viesti, jossa on oltava vähintään yksi merkki.
    reuna -- yhden merkin mittainen merkkijono, jolla viesti kehystetään.
    Oletusarvo on miinusmerkki.
    kulma -- yhden merkin mittainen merkkijono, joka tulostetaan kehyksen
    kulmiin. Oletusarvo on plusmerkki.
    """
    # Koodia selventävä ja kutsuja vähentävä apumuuttuja.
    merkkien_lkm = len(merkit)
    # Tulostetaan vain, jos parametrit ovat järkeviä
    if merkkien_lkm > 0 and len(reuna) == 1 and len(kulma) == 1:
        # Luodaan ylä- ja alarivi.
        reunarivi = kulma + (merkkien_lkm + 2) * reuna + kulma
        # Tulostetaan.
        print(reunarivi)
        print(reuna + " " + merkit + " " + reuna)
        print(reunarivi)
        
        
merkkijono = input() # "Python"
reunamerkki = input() # "."
kulmamerkki = input() # "#"
# Kutsutaan tulostavaa funktiota antamalla syötteet sisältävien
# muuttujien arvot parametrien arvoiksi oikea järjestys huomioiden.
tulosta_kehystettynä(merkkijono, reunamerkki, kulmamerkki)
#........#
. Python .
#........#
# Kutsutaan tulostavaa funktiota välittämällä sille vain 
# kehystettävä merkkijono. Muut parametrit saavat oletusarvonsa.
tulosta_kehystettynä(merkkijono)
+--------+
- Python -
+--------+


# Kutsutaan tulostavaa funktiota välittämällä sille kehystettävä
# merkkijono ja reunamerkki. Kulmamerkki saa oletusarvonsa.
tulosta_kehystettynä(merkkijono, reunamerkki)
+........+
. Python .
+........+
# Kutsutaan tulostavaa funktiota välittämällä sille reunamerkki
# avainsanaparametrina. Reunamerkki saa oletusarvonsa.
tulosta_kehystettynä(merkkijono, kulma = kulmamerkki)
#--------#
- Python -
#--------#
# Kutsu ei ole mahdollinen, koska avainsanaparametrin arvo on
# annettu ennen normaalia parametriarvoa.
# SyntaxError: positional argument follows keyword argument
tulosta_kehystettynä(reuna = kulmamerkki, merkkijono)

15.7 Paluuarvo

• Funktiosta palautetaan arvo return-lauseella.

  • Parametriton return-lause keskeyttää funktion suorituksen siten, että paluuarvo on automaattisesti None-vakio.

• Python ei vaadi return-lauseen yhtenäistä käyttöä: funktiosta on mahdollista palata sekä ohjelmoijan toimesta että automaattisesti.

• Paluuarvoja voi olla useita, jos ne palautetaan esimerkiksi listana tai tuplana.

• Paluuarvo voidaan sijoittaa kutsupaikassa muuttujaan.

• Paluuarvo muodostaa yhdessä parametrilistan kanssa funktion liittymän, jonka kautta funktio kommunikoi muiden funktioiden kanssa.

15.8 Kehystävä funktio (kehystaja4.py)

def tulosta_kehystettynä(merkit, reuna = "-", kulma = "+"):
    """Tulostetaan viesti kehystettynä.
    ...
    Paluuarvo on True, jos parametriarvot ovat sellaiset, että voitiin
    viesti voitiin tulostaa kehystettynä. Muuten palautetaan False.
    """
    ...    
    # Tulostetaan vain, jos parametrit ovat järkeviä
    if merkkien_lkm > 0 and len(reuna) == 1 and len(kulma) == 1:
        ...        
        # Viestitään, että tulostus onnistui.
        return True
    # Yksi tai useampi parametriarvo on virheellinen.
    else:
        # Viestitään, että tulostus epäonnistui.
        return False

def main():
    ...

    # Kutsutaan tulostavaa funktiota antamalla syötteet sisältävien
    # muuttujien arvot parametrien arvoiksi oikea järjestys huomioiden.
    # Paluuarvo sijoitetaan muuttujaan.
    syötteet_ok = tulosta_kehystettynä(merkkijono, reunamerkki, kulmamerkki)
    
    # Kerrotaan virheestä käyttäjälle.
    if not syötteet_ok:
        print("Virheellisiä syötteitä!")

15.9 Näkyvyys

• Tunnuksen näkyvyysalue (scope, visibility) on joko globaali tai paikallinen.

  • Näkyvyyttä pohditaan kurssilla hyvin rajatusti funktioiden näkökulmasta: globaalit tunnukset ovat funktioiden ulkopuolella määriteltyjä muuttujia tai vakioita, kun taas funktion parametrit, muuttujat ja vakiot ovat paikallisia.

• Globaalit tunnukset näkyvät kaikkiin funktioihin.

  • Globaaleja tunnuksia on vältettävä, koska niillä ohitetaan funktioiden liittymät. Seurauksena on funktioiden välisiä riippuvuuksia, jotka vaikeuttavat ohjelman ymmärtämistä ja ylläpitoa.

  • Funktioihin jaettavissa harjoitustehtävissä ei saa käyttää globaaleja muuttujia ellei kyseessä ole vakio.

• Globaalit vakiot esitellään ohjelman alussa ennen funktioita.

• Paikalliset tunnukset näkyvät vain funktionsa sisällä ja ovat siten käytettävissä vain, kun funktiota suoritetaan.

  • Tähän poikkeuksena funktiossa global-lauseella globaaleiksi esitellyt tunnukset, joita ei pitäisi käyttää ylipäätänsä, koska ne vaikeuttavat ohjelman ymmärtämistä huomattavasti.

  • Älä käytä global-lausetta tällä kurssilla.

  • Funktioiden kesken ei voi välittää tietoa käyttämällä saman-nimisiä tunnuksia.

    • Funktiossa voidaan esitellä huoletta samannimisiä tunnuksia, koska ne eivät näy muihin funktioihin.

• Tiedonvälitykseen tarvitaan paluuarvo tai muuttuvia parametreja.

15.10 Sähköpostiosoitteen muutos (posti.py)

def vaihda_etu_ja_suku_ver1(sähköpostiosoite):
    """Vaihtaa nimimuotoisen sähköpostiosoitteen etu- ja sukunimen
    keskenään. Muutos ei heijastu kutsupaikkaan, koska muutos
    on paikallisen eli voimassa vain funktiossa.
    sähköpostiosoite - osoite, jonka alun oletetaan olevan
    "etunimi.sukunimi@" tai "sukunimi.etunimi@".
    """
    # Katkaistaan osoite @-merkin kohdalta.
    alku, loppu = sähköpostiosoite.split("@")
    # Katkaistaan alku pisteen kohdalta.
    eka_nimi, toka_nimi = alku.split(".")
    # Kootaan uusi osoite.
    sähköpostiosoite = toka_nimi + "." + eka_nimi + "@" + loppu
    
    
def vaihda_etu_ja_suku_ver2(sähköpostiosoite):
    """Vaihtaa nimimuotoisen sähköpostiosoitteen etu- ja sukunimen
    keskenään. Muutos heijastuu kutsupaikkaan, koska paikallinen
    muutos välitetään takaisin paluuarvoa käyttäen.
    sähköpostiosoite - osoite, jonka alun oletetaan olevan
    "etunimi.sukunimi@" tai "sukunimi.etunimi@".
    """
    # Katkaistaan osoite @-merkin kohdalta.
    alku, loppu = sähköpostiosoite.split("@")
    # Katkaistaan alku pisteen kohdalta.
    eka_nimi, toka_nimi = alku.split(".")
    # Kootaan uusi osoite.
    sähköpostiosoite = toka_nimi + "." + eka_nimi + "@" + loppu
    # Palautetaan muutettu osoite.
    return sähköpostiosoite


def main():
    # Tervehditään käyttäjää ja kerrotaan ohjelmasta.
    print("Moi! Muutan sähköpostisoitteita.")
    # Luetaan syöte.
    print("Anna osoite:")
    sähköpostiosoite = input()
    # Kutsutaan muunnosfunktion ensimmäistä versiota
    # ja tarkistetaan, että muuttujan arvo ei ole muuttunut.
    vaihda_etu_ja_suku_ver1(sähköpostiosoite)
    print(sähköpostiosoite)
    # Kutsutaan muunnosfunktion toista versiota
    # ja tarkistetaan, että muuttuja on saanut uuden arvon.
    sähköpostiosoite = vaihda_etu_ja_suku_ver2(sähköpostiosoite)
    print(sähköpostiosoite)

15.10.1 Sähköpostiosoitteen muutos (versio 1)

1. Pääohjelma ennen funktion kutsua.

1. Pääohjelma ennen funktion kutsua.

• Moduuli tai sen osa otetaan käyttöön import-lauseella.

  • Nämä ovat ohjelman alussa ennen muita lauseita.

  • Ohjelman kommentit edeltävät import-lauseita.

  • Lauseella on useita muotoja.

# Otetaan käyttöön random-moduuli.
import random
...
# Kutsutaan moduulin funktiota.
arvattava = random.randint(ALARAJA, YLÄRAJA)

# Otetaan käyttöön tietty random-moduulin funktio.
from random import randint
...
# Funktiota voidaan nyt kutsua helpommin. 
arvattava = randint(ALARAJA, YLÄRAJA)

# Otetaan käyttöön random-moduulin kaikki funktiot.
from random import *
...
# Funktiota voidaan nyt kutsua helpommin. 
arvattava = randint(ALARAJA, YLÄRAJA)

15.13 Pitkien rivien katkaisemien

• Monimutkaisen funktion otsikko voi olla tarpeen jatkaa usealle riville mittansa vuoksi.

• Pythonin tyyliopas https://www.python.org/dev/peps/pep-0008/ antaa vaihtoehtoisia tapoja katkaista pitkiä funktion otsikoita, funktiokutsuja ja if-elif-else-lauseen aloittavia rivejä.

• Kurssin materiaalissa funktioiden otsikot katkaistaan alla annetun esimerkin mukaisesti.

# Ensimmäinen otsikkorivi päättyy avaavaan sulkeeseen.
# Muut otsikkorivit sisennetään kahdeksalla välilyönnillä.
def pitkän_pitkän_pitkä_funktion_nimi(
        ensimmäinen_parametri, toinen_parametri,
        kolmas_parametri, neljäs_parametri):
    # Rungon rivit sisennetään neljällä välilyönnillä.

16. Testiosio