Olemme tähän mennessä ohjelmoineet ohjelmamme siten, että kaikki ohjelman toiminnallisuus tapahtuu yhdessä pääohjelmafunktiossa. Pääohjelmafunktiota on kutsuttu ohjelman lopussa. Funktio on käytännössä koodinpätkä, jota voi kutsua muualta ohjelmakoodista. Pythonin valmiita funktioita on käytetty jo oikeastaan ensimmäisestä ohjelmasta lähtien.
Kirjoitetaan funktiot lähdekoodin yläosaan, ja funktioita itse käyttävä ohjelma funktioiden alapuolelle:
# -*- coding: utf-8 -*-
# ensin funktiomäärittelyt
def main():
print "No heipä hei!"
# ja sitten ohjelma joka käyttää funktioita!
main();
Ylläolevassa esimerkissä on luotu oma funktio nimeltä main. Funktio määritellään komennolla def jonka jälkeen tulee funktion nimi, eli nimi jolla funktiota kutsutaan. Funktion nimen jälkeen tulee sulut ja kaksoispiste. Kaksoispisteen jälkeen alkaa lohko, jonka sisällä määritellään funktion toiminnallisuus.
Ylläolevassa esimerkissä funktio päätetään kun sen sisennys käyttämä sisennys päättyy. Kun esimerkki suoritetaan, tulostuu seuraavanlainen teksti:
No heipä hei!
Lähdekoodin suoritus alkaa funktiomäärittelyiden jälkeen. Ensin suoritetaan funktiokutsu main(), joka siirtää ohjelman suorituksen funktion main alkuun. Tässä tulee vastaan komento print "No heipä hei!", joka oikeasti kutsuu pythonin valmista tulostusfunktiota print. Kun rivi suoritetaan, tulostuu näytölle teksti "No heipä hei!". Tämän jälkeen mennään seuraavalle riville, joka on tyhjä, ja koska funktiossa ei ole muita komentoja, palataan takaisin kohtaan josta funktiota kutsuttiin. Funktiokutsun main() jälkeen ei ole muita komentoja, ja ohjelman suoritus päättyy.
Itsekirjoitetun funktion kutsuminen on helppoa, kirjoitetaan funktion nimi ja perään sulut. Seuraavassa esimerkissä luodaan funktio tervehdi(), jota kutsutaan funktiosta main() ensin kerran ja sen jälkeen useita kertoja.
# -*- coding: utf-8 -*-
# ensin funktiomäärittelyt
def tervehdi():
print "Terveisiä funktiosta tervehdi!"
def main():
print "Kokeillaan onnistuuko funktion kutsuminen:"
tervehdi()
print "Näyttää siltä, kokeillaan vielä:"
tervehdi()
tervehdi()
tervehdi()
# ja sitten ohjelma joka käyttää funktioita!
main()
Ohjelman suoritus saa aikaan seuraavan tulosteen:
Kokeillaan onnistuuko funktion kutsuminen: Terveisiä funktiosta tervehdi! Näyttää siltä, kokeillaan vielä: Terveisiä funktiosta tervehdi! Terveisiä funktiosta tervehdi! Terveisiä funktiosta tervehdi!
Tässä siis huomionarvoista on, että koodin suoritus etenee siten, että pääohjelmafunktion rivit suoritetaan ylhäältä alas yksi kerrallaan. Koodirivin ollessa funktiokutsu, mennään suorittamaan funktion koodirivit jonka jälkeen palataan siihen kohtaan josta kutsu tapahtui, tai tarkemminottaen funktiokutsun jälkeiseen kohtaan.
Jatkossa kun esittelemme funktioita, emme erikseen mainitse että niiden täytyy sijaita omalla paikallaan. Funktioita ei esimerkiksi voi määritellä toisen funktion sisällä.
Funktiosta saa huomattavasti monikäyttöisemmän antamalla sille parametreja. Parametrit ovat muuttujia, jotka määritellään funktion ylimmällä rivillä funktion nimen jälkeen olevien sulkujen sisällä. Kun funktiota kutsutaan, sen parametreille annetaan arvot kutsuvaiheessa.
Seuraavassa esimerkissä määritellään parametrillinen funktio tervehdi, jolla on tekstityyppinen parametri nimi
# -*- coding: utf-8 -*-
def tervehdi(nimi):
print "Hei " + nimi + ", terveiset funktiosta!"
def main():
tervehdi("Emilia")
tervehdi("Matti")
main()
Ohjelmassa kutsutaan funktiota tervehdi siten, että parametrin nimi arvoksi asetetaan ensimmäisellä kutsulla Emilia ja toisella kutsulla Matti.
Hei Emilia, terveiset funktiosta! Hei Matti, terveiset funktiosta!
Aivan kuten kutsuttaessa pythonin valmista print-metodia, voi oman metodin kutsussa parametrina käyttää monimutkaisempaa ilmausta:
# -*- coding: utf-8 -*-
def tervehdi(nimi):
print "Hei " + nimi + ", terveiset funktiosta!"
def main():
nimi1 = "Tero"
nimi2 = "H"
tervehdi( nimi1 + " " + nimi2 )
ika = 21
tervehdi("Matti " + str(ika) + " vuotta")
main()
Hei Tero H, terveiset funktiosta! Hei Matti 21 vuotta, terveiset funktiosta!
Molemmissa tapauksissa funktiolla on edelleen vain 1 parametri. Parametrin arvo lasketaan ennen funktion kutsumista. Ensimmäisessä tapauksessa parametrin arvo saadaan merkkijonoja yhdistäessä nimi1 + " " + nimi2 arvoksi Tero H ja jälkimmäisessä tapauksessa merkkijonoja yhdistettäessä "Matti " + str(ika) + " vuotta" arvoksi Matti 21 vuotta.
Listan käyttö parametrina onnistuu ilman ongelmia:
# -*- coding: utf-8 -*-
def tulostaAlkiot(lista):
for alkio in lista:
print alkio
def main():
luvut = [1, 2, 3, 4, 5]
tulostaAlkiot(luvut)
main()
1 2 3 4 5
Huomaa että parametrin nimi funktion sisällä voi olla aivan vapaasti valittu, nimen ei tarvitse missään tapauksessa olla sama kuin kutsuvassa ohjelmassa. Edellä listaa kutsutaan metodin sisällä nimellä lista, metodin kutsuja taas näkee saman listan luvut-nimisenä.
Funktiolle voidaan määritellä useampia parametreja. Tällöin metodin kutsussa parametrit annetaan samassa järjestyksessä.
# -*- coding: utf-8 -*-
def tervehdi(nimi, mistaTerveiset):
print "Hei " + nimi + ", terveiset " + mistaTerveiset
def main():
kuka = "Matti"
terveiset = "Oulusta"
tervehdi(kuka, terveiset)
tervehdi(kuka, terveiset + " ja Kuopiosta")
main()
Jälkimmäisessä tervehdi-funktion kutsussa toinen parametri muodostetaan yhdistämällä muuttujaan terveiset teksti " ja Kuopiosta". Tämä suoritetaan ennen varsinaista funktion suoritusta.
Hei Matti, terveiset Oulusta Hei Matti, terveiset Oulusta ja Kuopiosta
Pääohjelmafunktiomme, eli main-funktio, ei suinkaan ole ainoa joka voi kutsua funktioita. Funktiot voivat kutsua myös toisiaan. Tehdään funktio tervehdiMontaKertaa, joka tervehtii käyttäjää useasti funktion tervehdi avulla:
# -*- coding: utf-8 -*-
def tervehdi(nimi):
print "Hei " + nimi + ", terveiset funktiosta!"
def tervehdiMontaKertaa(nimi, kerrat):
for i in range(kerrat):
tervehdi(nimi)
def main():
tervehdiMontaKertaa("Emilia", 3)
print "ja"
tervehdiMontaKertaa("Matti", 2)
main()
Tulostuu:
Hei Emilia, terveiset funktiosta! Hei Emilia, terveiset funktiosta! Hei Emilia, terveiset funktiosta! ja Hei Matti, terveiset funktiosta! Hei Matti, terveiset funktiosta!
Funktio voi myös palauttaa arvon. Edellä olevissa esimerkeissä funktiot eivät palauttaneet mitään arvoa. Arvon palauttavaa funktiota määriteltäessä annetaan funktiossa olevalle return-komennolle palautettava muuttuja. Seuraavassa funktio joka palauttaa aina luvun 10.p>
def palautetaanAinaKymppi():
return 10
Jotta funktion kutsuja voisi käyttää paluuarvoa, tulee paluuarvo ottaa talteen muuttujaan:
# -*- coding: utf-8 -*-
def palautetaanAinaKymppi():
return 10
def main():
luku = palautetaanAinaKymppi();
print "metodi palautti luvun " + str(luku)
main()
Funktion paluuarvo siis sijoitetaan muuttujaan aivan kuin mikä tahansa muukin arvo. Seuraavassa esimerkissä määritellään funktio summan laskemiseen. Tämän jälkeen funktiota käytetään laskemaan luvut 2 ja 7 yhteen, funktiokutsusta saatava paluuarvo asetetaan muuttujaan lukujen_summa.
# -*- coding: utf-8 -*-
def summa(eka, toka):
return eka + toka
def main():
lukujen_summa = summa(2, 7);
print "Lukujen 2 ja 7 summa on " + str(lukujen_summa);
main()
Kuten huomataan, funktion paluuarvoa ei tarvitse välttämättä sijoittaa muuttujaan, se voi olla osana tulostuslausetta aivan kuten mikä tahansa muukin arvo. Kannattaa kuitenkin huomata, että merkkijonoon liitettäessä kokonaislukumuuttujat tulee muuttaa myös teksti- tai merkkijonotyyppisiksi funktiokutsulla str.
Seuraava funktio laskee syötteinään saamiensa luvun keskiarvon. Metodi käyttää apumuuttujia summa ja ka. Metodin sisäisen muuttujan määrittely tapahtuu tutulla tavalla.
# -*- coding: utf-8 -*-
def keskiarvo(luku1, luku2, luku3):
summa = luku1 + luku2 + luku3
ka = summa/3.0
return ka
def main():
print keskiarvo(3, 4, 5)
main()
4