Programmeerimise alused II 2017/18 kevad

---

ANDMETÖÖTLUS MOODULIGA NUMPY

Sissejuhatus

NumPy (ingl Numerical Python) on mitmemõõtmeliste järjendite töötlemiseks mõeldud Pythoni moodul. See loodi 1995. aastal ja kandis nime Numeric. Alates aastast 2006 kannab moodul nime NumPy. Mooduli loojaks on ameeriklane Travis Oliphant, kes on andmeteadlane ja ärimees ning on õppinud näiteks matemaatikat ja elektrotehnikat. Peamiselt kasutatakse NumPy moodulit andmetöötluses ja teaduslikes arvutustes. Näiteks on Numpyt kasutatud heliprogrammis Pitch Perfect ning multimeediast tuntud vektorgraafika programmi Inkspace’i viimases versioonis kujutise moonutamisel. Andmetöötluses eelistatakse kasutada NumPyt, sest lisaks Pythonile on selle kirjutamiseks kasutatud C keelt ning moodul on seetõttu palju kiirem kui tavaline Python. Ka lihtsate järjendi operatsioonide jaoks on NumPy mugavam tänu sisseehitatud funktsioonidele. Käesolev peatükk tutvustab, kuidas NumPyt kasutada ja mida sellega teha saab.

Installeerimine

Thonny on üks populaarsemaid ja lihtsamaid programme Pythonis programmeerimiseks. Seetõttu on installeerimise sammud kirjeldatud just selle programmi põhjal.

Video NumPy installeerimisest Thonnys:

Installeerimise sammud:

• Ava Thonny programm
• Vali ülevalt menüüribalt Tools
• Sealt vali Manage packages…
• Avaneb uus aken
• Sisesta otsinguribale numpy
• Kliki nupul Find package from PyPI
• Kui avaneb numpy informatsioon, kliki nupul Install
• Pärast installeerimist ongi Thonny programmil moodul NumPy
• Kasutamiseks kirjuta import numpy as np programmi algusesse. Et kiiremini proovida NumPy funktsioone ja järjendi loomist, võib selle kirjutada ka otse käsureale

np on levinud lühend NumPy kasutamiseks.

NumPy

NumPy järjendite loomine

NumPy järjendid jagatakse mõõtmete järgi erinevatesse kategooriatesse. Selles materjalis pöörame peamist tähelepanu ühe-ja kahemõõtmelistele järjenditele. On võimalik töödelda ka kolmemõõtmelistest kuni N-mõõtmeliste järjenditeni, kuid nende kasutamist selles materjalis ei tutvustata. Alustuseks vaatame, kuidas luua NumPy abil järjendeid.

NumPy ühemõõtmelised järjendid

Kõigepealt proovime NumPy abil luua ühemõõtmelisi järjendeid. NumPy kasutamiseks, peab selle Pythonis sisse importima käsuga import numpy as np, kus np on levinud lühend selle mooduli kasutamiseks. Programmis ei pea pikalt kirjutama välja numpy, vaid saab kasutada lühedit np. Järjendi saab NumPy abil luua array funktsiooni kasutades. Võrreldes tavalise Pythoniga, kus järjendi elemendid lisatakse nurksulgude vahele, siis NumPy puhul kasutatakse järjendit array funktsiooni argumendina ehk np.array(järjend)

NumPy programmis puuduvad järjendi väljastamisel elementide vahel komad, näiteks [1 2 3].

#NumPy järjendi loomine ja väljastamine
import numpy as np

b = np.array([1,2,3])
print(b)

⇒ Väljund: [1 2 3]

Väga lihtsalt saab Numpy järjendi dtype parameetrit kasutades muuta järjendi tüüpi.

• Int → Float:

  • a = np.array([1,2,3], dtype=float) ⇒ Väljund: [1. 2. 3.]

    (NumPys ei ole ujukomaarvudel 0 punkti järel)
• Float → Bool:

  • a = np.array([1.,0.,6.], dtype=bool) ⇒ Väljund: [True False True]

    (Arv 0 on False, ülejäänud arvud on True)

Samanimelise funktsiooni abil saab ka järjendi tüübi teada. Näiteks järjendi a = np.array([1,2,3,4]) tüüp a.dtype on int (tähistatakse int32).

NumPy kahemõõtmelised järjendid

Peamiselt kasutatakse andmetöötluses kahemõõtmelisi järjendeid, kus andmetabeleid saab kirjutada kahemõõtmelise järjendi kujul. Nende loomine käib sarnaselt Pythoni käsule, kuid taas peab juurde lisama np.array().

#NumPy järjendi loomine ja väljastamine
import numpy as np

b = np.array([[1,2,3],[4,5,6]])
print(b)

⇒ Väljund: [[1 2 3]
            [4 5 6]]

Sisseehitatud funktsioonid

Nagu ka Pythonil, on NumPyl endal sisseehitatud funktsioonid, mille abil saab järjendite kohta andmeid või vastavalt soovile neid töödelda. Järgnevalt vaatame lähemalt peamisi Numpy funktsioone ja mille jaoks neid kasutatakse.

Järjendi suurus

Järjendi suuruse leidmine on sarnane Pythonile. Kui Pythonis on käsk len(järjend), siis NumPys näeb see välja nii (olgu järjendi nimi a):

• Ühemõõtmeline järjend

#NumPy järjendi elementide arvu leidmine ja väljastamine
import numpy as np

a = np.array([1,2,3])
print("Järjendi suurus: ", a.size)

⇒ Väljund: 3

• Kahemõõtmeline järjend

#NumPy järjendi elementide arvu leidmine ja väljastamine
import numpy as np

b = np.array([[1,2,3],[4,5,6]])
print("Järjendi suurus: ", b.size)

⇒ Väljund: 6

Järjendist elemendi võtmine

Üks lihtsamaid järjendi operatsioone on järjendist elemendi võtmine. Ühemõõtmelise järjendi puhul käib see samamoodi nagu Pythonis. Järjendi nime taha tuleb lisada nurksulgude vahele soovitud elemendi indeks. Kahemõõtmeliste järjendite puhul on Pythonil ja NumPyl väike erinevus. NumPy abil saab indeksid kirjutada mugavalt ühe paari nurksulgude vahele.

Meeldetuletuseks: indeksid algavad nullist.

#NumPy järjendist elemendi võtmine
import numpy as np

a = np.array([[1,2,3],[4,5,6]])
#Võtame järjendi esimese osa teise elemendi ja tagastame selle
print("Järjendi esimene osa teine element: ", a[0,1])

⇒ Väljund: Järjendi esimene osa teine element: 2

Nüüd aga vaatame natuke keerulisemat olukorda. Oletame, et meil on antud järjend, mis koosneb nii positiivsetest kui ka negatiivsetest täisarvudest. Me soovime teha programmi, mis väljastab kõik negatiivsed täisarvud järjendina. Pythonis peab selleks looma tulemuslisti. Sinna hakatakse lisama elemente algsest järjendist, mis vastavad meie avaldisele. Avaldis on element < 0.

#Pythoni järjendist negatiivsete täisarvude võtmine
b = [3,-1,-2,4,-6,8]
#tulemuslist
tulemus = []
#Võtame järjendist b järjest elemente
for element in b:
    #Kui element on väiksem nullist...
    if element < 0:
        #...siis lisame selle elemendi tulemuslisti
        tulemus.append(element)
#Väljastame tulemuslisti
print("Tulemuslist: ", tulemus)

⇒ Väljund: Tulemuslist: [-1, -2, -6]

NumPy puhul on see palju lihtsam. Me saame suvalisele muutujale anda argumendiks avaldise ning seda kasutada esialgse järjendi peal. Siin on aga oluline, et avaldises esineks järjendi nimi. Ehk kui me tahame saada järjendist b negatiivseid täisarve, peab meie kontrollavaldis välja nägema b < 0. Samuti ei pea me looma tulemuslisti, kuna NumPy tagastab elemendid automaatselt järjendina.

#NumPy järjendist negatiivsete täisarvude võtmine
import numpy as np

b = np.array([3,-1,-2,4,-6,8])
#Avaldis, mille põhjal hakkame järjendist elemente võtma
negatiivsed = b < 0
print("Järjendi negatiivsed täisarvud: ", b[negatiivsed])

⇒ Väljund: Järjendi negatiivsed täisarvud: [-1 -2 -6]

Järjendisse elemendi/elementide lisamine

Nii Pythoni kui NumPy puhul on käib elemendi lisamine append käsuga. Seetõttu vaatame näitena ainult kahemõõtmelisse järjendisse elemendi lisamist. NumPy append funktsioonil on võimalus lisada ka juurde täpsustav parameeter axis, mis näitab, kas uued elemendid lisatakse mitmemõõtmelisse järjendisse rea järgi või veeru järgi. Rida tähistab arv 0 ja veergu arv 1. Lisamisel peab aga teadma järjendi mõõtmeid, muidu pole võimalik elemente juurde lisada. Kui täpsustavat parameetrit (axis) append funktsiooni ei kirjutata, lisab NumPy uue elemendi või elemendid järjendi lõppu ning väljund näitab kahemõõtmelist järjendit ühemõõtmelise järjendina. Vaatame kõigepealt, milline näeb välja ilma rida/veergu tähistava parameetrita append funktsioon.

#NumPy järjendisse elementide lisamine
import numpy as np

a = np.array([[8,9,7],[10,11,12]])
#Lisame järjendisse a ühe elemendi
a = np.append(a, 4)
print("Uue elemendiga järjend: ", a)

⇒ Väljund: Uue elemendiga järjend: [8 9 7 10 11 12 4]

#Lisame järjendisse a kaks elementi
a = np.append(a, [4,5])
print("Uute elementidega järjend: ", a)

⇒ Väljund: Uute elementidega järjend: [8 9 7 10 11 12 4 4 5]

Nüüd vaatame, kuidas rea või veeru järgi elemente lisada.

#NumPy järjendisse elementide lisamine
import numpy as np

a = np.array([[2,4],[6,7]])
#Lisame järjendisse a samamõõtmelise järjendi rea järgi
#Järjendisse a tekivad uued read, väljastame järjendi uue järjendina b
b = np.append(a, [[3,4],[5,6]], axis = 0)
print("Uute ridadega järjend: ", b)

⇒ Väljund: Uute ridadega järjend: [[2 4]
                                    [6 7]
                                    [3 4]
                                    [5 6]]

#Lisame järjendisse a samamõõtmelise järjendi veeru järgi
#Järjendisse a tekivad uued veerud, väljastame järjendi uue järjendina c
c = np.append(a, [[3,4],[5,6]], axis = 1)
print("Uute veergudega järjend: ", c)

⇒ Väljund: Uute veergudega järjend: [[2 4 3 4]
                                      [6 7 5 6]]

Järjendi suurima/vähima väärtuse leidmine

Järjendist saab väga lihtsalt leida suurimat ja vähimat väärtust. Pythonis oleme kasutanud selleks funktsioone max(järjend) ja min(järjend). NumPys on need aga vastavalt: np.amax(järjend) ja np.amin(järjend).

#NumPy min ja max
import numpy as np

a = np.array([1,2,3])
#Järjendi suurim element
print("Järjendi suurim element: ", np.amax(a))

⇒ Väljund: Järjendi suurim element: 3

#Järjendi vähim element
print("Järjendi vähim element: ", np.amin(a))

⇒ Väljund: Järjendi vähim element: 1

Järjendi aritmeetilise keskmise leidmine

Üks levinumaid matemaatilisi funktsioone on arvude aritmeetilise keskmise leidmine. Seda saab väga lihtsalt ka teha NumPy järjendiga, kasutades mean funktsiooni. Mean funktsioon liidab automaatselt järjendi elemendid kokku ja jagab järjendi pikkuse ehk elementide arvuga. Vaatame näidet:

#NumPy järjendi keskmine väärtus
import numpy as np

a = np.array([2,8,10,6,12])
#Leiame arvude keskmise väärtuse
print("Järjendi keskmine väärtus: ", np.mean(a))

⇒ Väljund: Järjendi keskmine väärtus: 7.6

Pythonis sisseehitatud funktsiooni ei leidu.

Tükeldamine

Tükeldamine (ingl slicing) on järjendist vajamineva osa võtmine. Ühemõõtmeliste järjendite puhul ei erine NumPy siin Pythonist. Vaatame aga, kuidas tükeldada NumPy kahemõõtmelist järjendit. Kõigepealt loome järjendi b.

#NumPy järjendi tükeldamine
import numpy as np

b = np.array([[10,34,21,65],[51,77,23,16]])
print("Järjend b: ", b)

⇒ Väljund: Järjend b: [[10 34 21 65]
                        [51 77 23 16]]

Tabeli kujul näeks see välja selline (Tumedaga on märgitud tabeli indeksid).

	0	1	2	3
0	10	34	21	65
1	51	77	23	16

Tükeldamise juures tähendab nurksulgude vahel esimene arv ridu ja teine arv veerge. Meeldetuletuseks: Kõikide elementide saamiseks reas/veerus piisab, kui kirjutada :, näiteks a[:]. Mingis vahemikus elementide saamiseks peab kirjutama: algus::lõpp, näiteks a[1::2]. Vaatame näiteid:

• Esimene ja kolmas veerg:

print("Järjendi esimene ja kolmas veerg: ", b[:, 0::2])

⇒ Väljund: Järjendi esimene ja kolmas veerg: [[10 21]
                                               [51 23]]

	0	1	2	3
0	10	34	21	65
1	51	77	23	16

• Teine rida:

print("Järjendi teine rida: ", b[1, :])

⇒ Väljund: Järjendi teine rida: [51 77 23 16]

	0	1	2	3
0	10	34	21	65
1	51	77	23	16

• Esimese rea teine ja neljas element:

print("Järjendi esimese rea teine ja neljas element: ", b[0, 1::2])

⇒ Väljund: Järjendi esimese rea teine ja neljas element: [34 65]

	0	1	2	3
0	10	34	21	65
1	51	77	23	16

Järjendist elemendi/elementide otsimine

NumPyl on järjendist elemendi otsimise jaoks olemas funktsioon where, mis tagastab otsitava elemendi indeksi ja tüübi. Vaatame näidet. Olgu meil järjend a, mille elemendid on [1 2 3 4]. Leiame arvu 3 indeksi:

# Where funktsiooni kasutamine
import numpy as np

a = np.array([1,2,3,4])
# Where võtab argumendiks järjendi nime ja tingimuse, mida tahetakse leida
el = np.where(a == 3)
# Kogu informatsioon
print(el)

⇒ Väljund: (array([2], dtype=int32),)

# Indeksi saamiseks peame võtma esimese elemendi
# Ning tegema selle täisarvuks
print(int(el[0]))

⇒ Väljund: 2

Kahemõõtmelise järjendi puhul leiame tulemuse, kui teame, millisest veerust/reast me elementi otsime. Näiteks leiame järjendist kõikide nende ridade indeksid, mille esimene element on 1.

Olgu järjend b = [[1 2 3 4]
                  [5 6 7 8]
                  [1 6 3 7]
                  [1 6 7 2]
                  [5 7 3 2]]

# Võtame kõik read ja kontrollime esimese veeru elemente
el = np.where(b[:, 0] == 1)
print(el[0])

⇒ Väljund: [0 2 3]

Tehted järjendi elementidega

Siin tuleb kõige paremini välja NumPy eelis tavalise Pythoni ees. Oletame, et tahame teha kahe või enama järjendi elementide vahel järgnevaid tehteid: liitmine, lahutamine, korrutamine, korrutamine konstandiga, jagamine, astendamine. Kui Pythonis peab sellise tehte tegemiseks looma tsükli, siis NumPy puhul piisab ühest reast. NB! See toimib nii ainult juhul, kui järjendid sisaldavad sama palju elemente. Vaatame liitmise näidet:

#NumPy järjendite elementide liitmine
import numpy as np

a = np.array([1,2,3])
b = np.array([10,11,12])
#Järjendite a ja b elementide summa, tagastatakse tulemuse järjend
print("Järjendite a ja b elementide summa tulemuse järjend: ", a + b)

⇒ Väljund: Järjendite a ja b elementide summa tulemuse järjend: [11 13 15]

Sarnaselt saab järjendeid omavahel lahutada, korrutada, jagada, korrutada konstandiga, astendada.

CSV faili lugemine

Andmetöötluses on eelnevalt vaja tabel failist sisse lugeda, mis on tihti csv kujul. NumPyga on mugav kasutada funktsiooni genfromtxt(). Funktsiooni sulgudesse tuleb lisada faili nimi, delimiter ehk eraldaja väärtus, mis eraldab andmeid teineteisest, ja parameeter names=True, mille abil saab veeru pealkirja kasutades väga lihtsalt tabelist terve veeru. Näiteks tabel[“sugu”] tagastab kõik väärtused, mis asuvad veerus pealkirjaga “sugu”. Populaarsemad eraldajad on näiteks tühik, koma või semikoolon. Vaatame näidet. Olgu csv faili sisu on selline:

Esimene;Teine;Kolmas
1;11;21
2;12;22
3;13;23
4;14;24

#CSV faili sisselugemine
import numpy as np

csv = np.genfromtxt('file.csv', delimiter=";", names=True, encoding = 'UTF-8')

# Terve tabeli väljastamine
print(csv)

⇒ Väljund:[(1., 11., 21.)
            (2., 12., 22.)
            (3., 13., 23.)
            (4., 14., 24.)]

#väljastame esimese veeru
print("Esimene veerg: ", csv["Esimene"])

⇒ Väljund: Esimene veerg: [1. 2. 3. 4.]

#väljastame teise rea
print("Teine rida: ", csv[1])

⇒ Väljund: Teine rida: (2., 12., 22.)

Tekstifaili salvestamine

NumPyga saab salvestada informatsiooni tekstifaili vaid ühe reaga. Selle jaoks on olemas funktsioon: np.savetxt(fail,sisu,eraldaja). Vaatame näidet, kus salvestama kahemõõtmelise järjendi faili ning seejärel avame selle faili ja väljastame sisu.

#Tekstifaili salvestamine ja selle sisu väljastamine
import numpy as np

#Loome ühe kahemõõtmelise järjendi
sisu = np.array([[1,11,21],[2,12,22],[3,13,23],[4,14,24]])
#Salvestame sisu faili fail.txt, eraldajaks määrame tühiku
np.savetxt('fail.txt',sisu,delimiter=' ')

#Nüüd avame faili fail.txt
fail = np.loadtxt('fail.txt')
#Väljastame sisu reahaaval
for rida in fail:
    print(rida)

⇒ Väljund: [ 1. 11. 21.]
            [ 2. 12. 22.]
            [ 3. 13. 23.]
            [ 4. 14. 24.]

Ülesanne

Nüüd on aeg saadud teadmisi praktikas proovida. Allpool on toodud tabel 20 kergejõustiklase tulemustest spordivõistlusel. Võistlejate nimesid ei ole kasutatud, vaid igaühel on vastav ID number (1-20). Lisaks on välja toodud igaühe vanus, sugu ja nelja ala tulemused. Sugu on samuti tähistatud numbriga, kus poisid on tähistatud nulliga ja tüdrukud ühega. Tabeli all on pisikesed ülesanded, mida saab lahendada selle õppematerjali abil. Ülesanded peavad olema lahendatud, kasutades NumPyt. Allpool on näitena toodud tabeli esimesed 5 rida ning tabel on kättesaadav failist tulemused.csv, mille peab programmi sisse lugema. Failis on eraldajaks kasutatud semikoolonit. NB! Failist lugemisel soovitame kasutada parameetrit names=True, sest siis ei pea veerust andmete kätte saamiseks kasutama tükeldamist, vaid saab kasutada veeru pealkirja (järjend['pealkiri']).

*Kõik andmed on väljamõeldud

1. Mis oli odaviske parim tulemus?
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia veerust maksimaalne väärtus funktsiooniga np.amax()
2. Mis oli kaugushüppe halvim tulemus?
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia veerust minimaalne väärtus funktsiooniga np.amin()
3. Leia võistlejate keskmine vanus.
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia veeru keskmine väärtus funktsiooniga np.mean()
4. Mitu poissi osales? Mitu tüdrukut?
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia tingimuste abil sobivad väärtused funktsiooniga np.where() (Vajadusel teisendada funktsiooni tagastus täisarvuks)
   c) Leia järjendi suurus funktsiooniga np.size()
5. Millise IDga osaleja oli kõige kiirem 400 m jooksus?
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia tingimuste abil sobivad väärtused funktsiooniga np.where() (Vajadusel teisendada funktsiooni tagastus täisarvuks)
6. Mitu 100 m jooksjat said aja alla 12 sekundi?
   SAMMUD:
   a) Leia veeru pealkirja abil õige veerg
   b) Leia tingimuste abil sobivad väärtused funktsiooniga np.where()
   c) Leia järjendi suurus funktsiooniga np.size()

Tagasiside

Palume, et vastaksite ka tagasiside küsimustikule. Nii saame õppematerjali paremaks muuta.

Tagasiside küsimustiku leiate siit: Tagasiside NumPy õppematerjalile

Kasutatud materjalid

• Chabot-LeClerc, A. (2018). Scientific Computing with Python. Austin: SciPy. Allikas: https://www.youtube.com/watch?v=V0D2mhVt7NE&feature=youtu.be
• Hill, C. (2015) Learning Scientific Programming with Python
• NumPy. (1. märts 2019. a.). Allikas: NumPy: http://www.numpy.org/
• Python For Data Science Cheat Sheet NumPy Basics. (15. märts 2019. a.). Allikas: DataCamp: https://s3.amazonaws.com/assets.datacamp.com/blog_assets/Numpy_Python_Cheat_Sheet.pdf
• NumPy basics. (1. märts 2019. a.). Allikas: SciPy: https://docs.scipy.org/doc/numpy/user/basics.html