Oppaat: Python-opas: Johdatus Python-ohjelmointiin

Tämän oppaan on korvannut Ohjelmointiputkan uusi Python-opassarja.

Python on tulkattava ohjelmointikieli, joka on saatavilla ilmaiseksi usealle alustalle. Python muistuttaa paljon yleisimpiä ohjelmointikieliä, mutta kielessä on lukuisia omintakeisia – monesti kekseliäitä ja nerokkaitakin – piirteitä. Suomenkielisestä materiaalista on kuitenkin syystä tai toisesta Internetissä huutava pula. Tämä opas pyrkii osaltaan parantamaan asiaa toimimalla johdatuksena Python-ohjelmointiin. Aikaisempi ohjelmointikokemus on välttämätön oppaan ymmärtämiseksi kunnolla.

Ensimmäinen Python-ohjelma

Osoitteessa http://www.python.org/ on Pythonin virallinen kotisivu. Valitse yläreunasta Download, ja kopioi Pythonin versio oman käyttöjärjestelmäsi mukaan. Lisäksi Documentation-linkistä löytyy kattava englanninkielinen dokumentaatio, jota kannattaa ruveta käyttämään viimeistään sitten, kun kielen perusteet ovat hallinnassa.

Python-tulkkia voi käyttää kahdella tavalla. Ensimmäinen tapa on kirjoittaa komentorivillä python, jonka jälkeen tulkkia voi käskyttää kirjoittamalla komento riville >>>-merkinnän jälkeen. Aivan ensiksi kokeilemme print-komentoa.

>>> print 'Toimiiko tämä?'
Toimiiko tämä?

Tuntui toimivan. Tällä tavalla Pythonia on helppo oppia, koska komennon vaikutuksen näkee välittömästi näytöllä.

Jos ohjelma on vähänkin pidempi, se kannattaa tietenkin tallentaa tiedostoon. Python-ohjelman tallennusmuoto on tavallinen tekstitiedosto, jonka pääte on yleensä .py. Kun ohjelma on valmis, sen voi käynnistää komennolla python ohjelma.py. Seuraavassa on ensimmäinen esimerkkiohjelma, eka.py, joka tulostaa rivin tekstiä näytölle ja esittelee samalla kommenttimerkinnän käyttöä.

# eka.py
# näytetään viesti käyttäjälle
print 'Python-aika on alkanut!'

Esimerkkiohjelmassa tulee ilmi ainakin se, että Python-ohjelmat tapaavat olla melko lyhyitä. Lauseen lopussa ei ole myöskään mitään lopetusmerkintää, vaan tähän tarkoitukseen käytetään rivinvaihtoa.

Muuttujat

Pythonissa muuttujien tyypistä ei tarvitse huolehtia itse, vaan tulkki päättelee sen muuttujaan asetetusta arvosta. Muuttujan tyyppi voi siis vaihdella ohjelman edetessä. Muuttujia ei myöskään tarvitse määritellä ennen niiden käyttöä. Kuitenkaan muuttujia ei voi käyttää, ennen kuin niihin on sijoitettu jokin arvo.

Sijoituslause näyttää tältä:

muuttuja = arvo

Samalla kertaa voi sijoittaa useamman muuttujaan arvon:

muuttuja1, muuttuja2 = arvo1, arvo2
# muuttuja1 = arvo1
# muuttuja2 = arvo2

Muuttujien arvon voi myös määrätä ketjussa:

muuttuja1 = muuttuja2 = muuttuja3 = arvo
# muuttuja1 = arvo
# muuttuja2 = arvo
# muuttuja3 = arvo

Luvut

Luvut merkitään tavalliseen tapaan, desimaalierotin on piste. Peruslaskutoimitukset ovat samat kuin esim. C-kielessä (+, -, *, / ja % (jakojäännös)), minkä lisäksi ** merkitsee potenssilaskua. Laskujärjestyssäännöt ovat voimassa ja sulut toimivat odotetusti.

>>> 3 + 4
7
>>> 9 * 7
63
>>> 2 ** 3
8
>>> 3 * (2 + 5)
21

Jos luvussa ei ole desimaaliosaa, Python tulkitsee sen olevan kokonaisluku. Ja jos kaikki laskutoimituksen luvut ovat kokonaislukuja, vastaus ilmoitetaan myös kokonaislukuna. Tämän vuoksi 3 / 2 on 1, mutta 3.0 / 2 on 1.5.

Merkkijonot

Merkkijonot ympäröidään heitto- tai lainausmerkeillä. Jos heittomerkkien sisällä on heittomerkki tai lainausmerkkien sisällä on lainausmerkki, merkin eteen täytyy laittaa kenoviiva. Muita erikoismerkintöjä ovat \\ (kenoviiva), \n (uusi rivi) ja \t (sarkain).

>>> print 'merkkijono'
merkkijono
>>> print "\"lainausmerkit\""
"lainausmerkit"
>>> print 'Rivi1\nRivi2\nRivi3'
Rivi1
Rivi2
Rivi3

Listat

Pythonissa taulukoita vastaavat listat. Lista määritellään ilmoittamalla alkiot hakasulkeissa pilkuilla erotettuina.

>>> autot = ['Audi', 'BMW', 'Cadillac', 'Daihatsu']

Lista on objekti, johon liittyy suoraan useita metodeja:

Seuraavassa ohjelmassa ohjelmointikielten listaan lisätään Python, minkä jälkeen lista järjestellään aakkosjärjestykseen. Lopuksi lista tulostetaan näytölle.

# lista.py
kielet = ['Basic', 'C', 'Pascal', 'Smalltalk']
kielet.append('Python')
kielet.sort()
print kielet

Listan kaltainen tietotyyppi on "sanakirja", jossa tunnuksena voi olla numeron lisäksi myös merkkijono.

>>> sanat = {'puu':'der Baum', 'joki':'der Fluss', 'taivas':'der Himmel'}
>>> sanat['joki']
'der Fluss'

Lisää merkkijonoista ja listoista

Merkkijonoissa ja listoissa on suuri määrä samankaltaisuuksia. Usein voisi jopa ajatella niin, että merkkijono on lista, jonka jokainen alkio on yksi merkki. Sen vuoksi tässä kappaleessa käsitellään samanaikaisesti merkkijonoihin ja listoihin liittyviä asioita.

Merkkijonon pituus tai listan alkioiden määrä selviää len-funktiolla.

>>> len('testi')
5
>>> len([1, 2, 3])
3

Kaksi merkkijonoa tai listaa voi yhdistää toisiinsa +-merkin avulla. Merkkijonoa tai listaa voi myös "monistaa" *-merkin avulla.

>>> 'esi' + 'merkki'
'esimerkki'
>>> [1, 2, 3] + [4, 5]
[1, 2, 3, 4, 5]
>>> 'testi' * 3
'testitestitesti'
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

Pienempien osien erottaminen merkkijonoista ja listoista on varsin näppärää hakasulkujen avulla. Jos hakasulkujen sisällä on yksi numero, palautusarvo on merkkijonon niin mones merkki tai listan niin mones alkio. Ensimmäisen merkin ja alkion numero on 0.

>>> 'testi'[2]
's'
>>> [1, 2, 3][1]
2

Jos numero on negatiivinen, lukeminen aloitetaan merkkijonon tai listan lopusta lähtien. Viimeisen merkin ja alkion numero on -1.

>>> 'testi'[-2]
't'
>>> [1, 2, 3][-1]
3

Suurempien kokonaisuuksien erottaminen on myös mahdollista. Tämän ymmärtämiseksi kannattaa merkkijonokin kuvitella pilkuilla jaetuksi jokaisen merkin kohdalta.

'testi'   => t, e, s, t, i
[1, 2, 3] => 1, 2, 3

Nyt hakasulkujen sisällä on kaksi numeroa, joiden välissä on kaksoispiste. Numerot määrittävät erotettavan alueen "rajat": Ensimmäinen numero osoittaa pilkun, jonka oikealla puolella on ensimmäinen erotettavaan osuuteen kuuluva merkki tai alkio. Toinen numero taas osoittaa pilkun, jonka vasemmalla puolella oleva merkki tai alkio on viimeinen erotettava. Merkkijonon tai listan alkuun ja loppuun voi myös kuvitella pilkun.

Eli siis:

>>> 'testi'[0:1]
't'
>>> 'testi'[1:3]
'es'
>>> [1, 2, 3][0:1]
[1]
>>> [1, 2, 3][1:3]
[2, 3]

Ja vastaavasti negatiivisilla numeroilla:

>>> 'testi'[1:-1]
'est'
>>> [1, 2, 3][1:-1]
[2]

Jos määrittelyn ensimmäisen numeron jättää pois, sen arvoksi tulee 0. Jos toisen numeron jättää pois, sen arvoksi tulee merkkijonon tai listan pituus. Tämän ansiosta [:n] vastaa merkkijonon n ensimmäistä merkkiä tai listan n ensimmäistä alkiota ja [-n:] vastaa merkkijonon n viimeistä merkkiä tai listan n viimeistä alkiota. Tämän lisäksi [:-n] on sama kuin merkkijono ilman n viimeistä merkkiä tai lista ilman n viimeistä alkiota ja [n:] on sama kuin merkkijono ilman n ensimmäistä merkkiä tai lista ilman n ensimmäistä alkiota.

Pakkosisennys

Lähes kaikissa ohjelmointikielissä sisentäminen kuuluu hyvään ohjelmointitapaan. Mutta Pythonissa on pakko sisentää - halusi tai ei! Se on nimittäin ainoa tapa määrittää, mitkä koodirivit kuuluvat lauserakenteeseen. Onneksi sisennyksestä on aina hyötyä ohjelman luettavuuden kannalta...

if-ehtolause

Pythonissa if-ehtolauseen rakenne on seuraavanlainen:

# if.py
# tulostetaan tekstiä x:n arvon mukaan
if x == 1:
   print 'x on yksi.'
elif x == 2:
   print 'x on kaksi.'
elif x > 2:
   print 'x on suurempi kuin kaksi.'
else:
   print 'x on nolla tai negatiivinen.'

Ehto on tosi, jos lausekkeen arvo on joku muu kuin nolla. Vertailuoperaattorit ovat samat kuin mm. C-kielessä: ==, >, <, >= ja , <=. Erisuuruus on joko != tai <>. Käytössä ovat tuttuun tapaan and-, or- ja not-operaattorit.

while-silmukka

while-silmukan jälkeisiä lauseita toistetaan niin kauan kuin ehtolauseke on tosi.

# while.py
# tulostetaan luvut kymmenestä yhteen
x = 10
while x > 0:
   print x
   x -= 1

for-silmukka

Pythonin for-silmukka poikkeaa melko merkittävällä tavalla muista kielistä; se vastaa enemmänkin esim. PHP:n foreach-rakennetta. Ideana on, että listan kunkin alkion arvo on vuorollaan silmukkamuuttujan arvo.

# for1.py
# tulostetaan listan autonmerkit
autot = ['Audi', 'BMW', 'Cadillac', 'Daihatsu']
for auto in autot:
   print auto

Sanakirjan läpikäyminen onnistuu näin:

# for2.py
# tulostetaan sanakirjan sanat suomeksi ja saksaksi
sanat = {'puu':'der Baum', 'joki':'der Fluss', 'taivas':'der Himmel'}
for suomi, saksa in sanat.items():
   print suomi + ' = ' + saksa

Mutta mitäs sitten, jos halutaankin ihan vain "vanhanaikaisesti" käydä läpi kaikki luvut tietyltä väliltä? Tällöin hyödyllinen on range-funktio, joka palauttaa luvuista koostuvan listan parametrien mukaan:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5, 15)
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> range(0, 10, 2)
[0, 2, 4, 6, 8]

Funktiota voi käyttää hyväksi for-silmukassa vaikkapa näin:

# for3.py
# tulostetaan luvut 0 - 9
for i in range(10):
   print i

Funktiot

Tämän kappaleen aiheena on omien funktioiden luominen (esimerkkiohjelmissa on myös erilaisia tapoja muotoilla tulostettava teksti). Pythonissa kaikki aliohjelmat ovat funktioita, vaikka ne eivät mitään arvoa palauttaisikaan.

Funktion määrittäminen tapahtuu def-lauseella.

# funktio1.py
# tulostaa kertotaulun
def kertotaulu(n):
   for i in range(10):
      print n, '*', i, '=', n * i

kertotaulu(7)

Funktio voi palauttaa arvon return-lauseen avulla.

# funktio2.py
# muuttaa markat euroiksi
def markateuroiksi(mk):
   return mk / 5.94573

print "10 markkaa on %.2f euroa." % markateuroiksi(10)

Funktion parametreilla voi myös olla oletusarvoja:

# funktio3.py
# funktion parametrin oletusarvo
def viesti(teksti = 'Moikka!'):
   print teksti

viesti()
viesti('Terve!')

Tämän lisäksi funktion parametrit voi ilmoittaa missä tahansa järjestyksessä, jos funktiokutsussa on mukana parametrien nimet.

# funktio4.py
# parametrien muuttunut järjestys
def lause(eka, toka, kolmas):
   print eka, toka, kolmas

lause(kolmas = 'testi.', toka = 'on', eka = 'Tämä')

Tarvittaessa parametrien määrä voi olla muuttuva. Tällöin funktion parametrit luetaan listasta.

# funktio5.py
# muuttuva määrä parametreja
def tulosta(*lista):
   for i in lista:
      print i,


tulosta('Tässä', 'funktiossa', 'voi', 'parametreja', 'olla', 'enemmänkin.')

Moduulit

Kaikkein tärkeimmät funktiot, jotka liittyvät esimerkiksi tekstin tulostamiseen tai muuttujien käsittelyyn, ovat Pythonissa sisäänrakennettuja. Mutta monesti on tarvetta liittää ohjelmaan mukaan erillinen moduuli, mikä tapahtuu import-komennolla.

Esimerkissä halutaan laskea neliöjuuri luvusta 25. Sen vuoksi otetaan ohjelmaan mukaan math-moduuli:

>>> import math

Tämän jälkeen neliöjuuren laskeminen käy näin:

>>> math.sqrt(25)
5.0

Yksittäisen funktion voi poimia moduulista from-komennon avulla.

from math import sqrt

Nyt sqrt-funktio on käytössä sellaisenaan:

>>> sqrt(25)
5.0

Kaikki matemaattiset funktiot - nyt siis niin, että math-moduulia ei tarvitse mainita funktiokutsussa - voisi taas ottaa mukaan näin:

from math import *

Oikeastaan tavallinen, tallennettu, funktioita sisältävä Python-ohjelma on myös moduuli. Näin ollen omien moduulien tekeminen ja mukaanottaminen on varsin helppoa.

Loppusanat

Tässäpä tämä nyt oli. Toivottavasti olet saanut jonkinlaisen kuvan siitä, minkätyyppinen ohjelmointikieli Python on. Johdatukseen ei kuitenkaan kaikkea mahdu, ja jotkut kenties tärkeätkin asiat saattavat puuttua tästä oppaasta. Nyt lieneekin aika siirtyä englanninkieliseen dokumentaatioon, joka löytyy siis osoitteesta http://www.python.org/.

Palautetta ja kysymyksiä voit lähettää vaikkapa sähköpostilla. Kerro samalla, haluaisitko Ohjelmointiputkaan lisää Python-asiaa.

Antti Laaksonen, 6.11.2003