39 NumPy kahemõõtmeliste järjendite elemendid

Järjendist elemendi võtmine

Kahemõõtmeliste järjendite puhul on Pythonil ja NumPyl väike erinevus. Nimelt kui Pythonis peab rea ja veeru indeksid kirjutama eraldi nurksulgude vahele, järjend[0][1], siis NumPy abil saab indeksid kirjutada mugavalt ühe paari nurksulgude vahele, kus esimene arv on reaindeks ja teine on veeruindeks.

# NumPy järjendist elemendi võtmine

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

# Võtame järjendi esimese rea teise elemendi ja väljastame selle
print("Järjendi esimene rea teine element: ", a[0, 1])
print("Järjendi teise rea kolmas element: ", a[1, 2])
>>> %Run guido.py
  Järjendi esimene rea teine element:  2
  Järjendi teise rea kolmas element:  6

Joonisel on esitatud ridade ja veergude indeksid paksus kirjas ning eelmises näites võetud elemendid punaselt.

0 1 2
0 1 2 3
1 4 5 6

Järjendisse elemendi/elementide lisamine

Kahemõõtmelisse järjendisse elemendi lisamisel on NumPy append funktsioonil 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.
a = np.array([[2, 4], [6, 7]])

# Lisame elemendid järjendi lõppu
b = np.append(a, [3, 4])
print("Uute elementidega järjend: ", b)
>>> %Run guido.py
  Uute ridadega järjend:  [2 4 6 7 3 4]

Kahemõõtmeliste järjendite puhul on alati mõistlik elemente lisada rea või veeru järgi, sest nii säilib järjendi kahemõõtmelisus. Nüüd vaatame, kuidas rea või veeru järgi elemente lisada.

 !  Juurde lisatav järjend peab olema ka kahemõõtmeline.

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)
>>> %Run guido.py
  Uute ridadega järjend: [[2 4]
  [6 7]
  [3 4]
  [5 6]]
 b = np.append( a , [[3, 4], [5, 6]], axis=0)
0
a
2 4
6 7
0
2 4
6 7
3 4
5 6
b
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)
>>> %Run guido.py
  Uute veergudega järjend: [[2 4 3 4]
    [6 7 5 6]]
 c = np.append( a , [[3, 4], [5, 6]], axis=1)
1

a
2 4
6 7
1

2 4 3 4
6 7 5 6
c
2 4 3 4
6 7 5 6

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.

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

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

 

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

Nii nagu Pythonis, on ka NumPys vaja kasutada tükeldamisel nurksulge ja indekseid. Tükeldamise juures tähendab nurksulgude vahel esimene arv ridu ja teine arv veerge. Näiteks soovime järjendist b võtta terve viimase veeru. Selleks tuleb järjendi nime järel nurksulgudesse kirjutada komaga eraldatult vastavad indeksid. Kuna me soovime kõiki arve reast, siis reaindeksina kasutame : ja vastav veeruindeks on 3. Kui tahame andmeid teisest veerust kuni viimase veeruni, siis rea indeks oleks : ja veerud indeksid on [1:4].

b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])
print("Neljas veerg: ", b[:, 3]) # Reaindeksina võib kasutada ka 0:2,
# indeksiga 2 element on välja arvatud.
print("Teine kuni neljas veerg: ", b[:, 1:4])
>>> %Run guido.py
  Neljas veerg:  [65 16]
  Teine kuni neljas veerg:  [[34 21 65]
    [77 23 16]]
b[:, 3] või b[0:2, 3]
b[:, 1:4] või b[0:2, 1:4]
0 1 2 3
0 10 34 21 65
1 51 77 23 16
0 1 2 3
0 10 34 21 65
1 51 77 23 16

Analoogselt saab ka tabelist rea võtta.

b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])
print("Järjendi teine rida: ", b[1, :]) # Sobib ka b[1], b[1, 0:4]
>>> %Run guido.py
  Järjendi teine rida:  [51 77 23 16]
b[1, :],

b[1, 0:4] või

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

Samuti on võimalik järjendist võtta veerge või ridu nii, et võetakse veergusid iga määratud sammu järel. Selleks peab kirjutama veeru indeksid nii algus::samm, kus algus on veeru indeks, millest alates andmeid võetakse ja samm määrab ära üle mitme veeru veerge võetakse, näiteks a[1::2] puhul võetakse teine ja kolmas veerg ehk veerge võetakse üle ühe veeru.

a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])
print("Järjendi esimene ja kolmas veerg: ", a[:, 1::2])
>>> %Run guido.py
  Järjendi teine ja neljas veerg: [[34 65]
    [77 16]]
a[:, 1::2])
0 1 2 3
0 10 34 21 65
1 51 77 23 16

Sarnaselt saab teha ka ridadega.

a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])
print("Järjendi esimese rea teine ja neljas element: ", a[0, 1::2])
>>> %Run guido.py
  Järjendi esimese rea teine ja neljas element: [34, 65]
a[0, 1::2]
0 1 2 3
0 10 34 21 65
1 51 77 23 16

Tükeldamine on eriti kasulik siis, kui soovime mingi konkreetset veergu või rida eraldada tabelist, et selle peal teha arvutusi, näiteks leida veeru aritmeetiline keskmine. Kui vastav veerg või rida on leitud, siis saab seda käsitleda kui ühemõõtmelist Numpy järjendit ja rakendada sellel kõiki funktsioone ja operatsioone, mida tavalisel Numpy ühemõõtmelisel järjendil.

Tehted järjendi elementidega

Kahemõõtmeliste järjendite puhul saab kasutada samu tehteid, mis ühemõõtmeliste järjendite peal. Näiteks soovime liita kahemõõtmeliste järjendite vastavad elemendid.

x = np.array([[1, 2, 3],[4, 5, 6]])
y = np.array([[3, 5, 7],[1, 4, 0]])

print(x + y)
>>> %Run guido.py
  [[ 4  7 10]
   [ 5  9  6]]

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

Kahemõõtmeliste järjenditega on ka lihtne leida elemente, mis vastavad mingile kriteeriumile. Näiteks soovime leida kõik elemendid, mis on suuremad kui 7.

y = np.array([[10, 5, 7],[13, 41, 0]])

print(y[y > 7])
>>> %Run guido.py
  [10 13 41]

Tuleb tähele panna seda, et tulemuseks ei ole kahemõõtmeline järjend, vaid ühemõõtmeline järjend, milles on kõik elemendid, mis vastavad kriteeriumile.

Järjendist elemendi/elementide otsimine

NumPyl on järjendist elemendi otsimise jaoks olemas funktsioon where, mis tagastab otsitava elemendi indeksi ja tüübi. 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.

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

# Where funktsiooni kasutamine

# Võtame kõik read ja kontrollime esimese veeru elemente
el = np.where(b[:, 0] == 1)
print(el[0])
>>> %Run guido.py
  [0 2 3]

Litsents

Icon for the Creative Commons Attribution 4.0 International License

Tarkvaraarendus. 2. trükk on loodud Eno Tõnisson, Tauno Palts, Kaarel Tõnisson, Heidi Meier, Merilin Säde, ja Säde Mai Krusberg jt poolt Creative Commons Attribution 4.0 International License litsentsi alusel, kui pole teisiti märgitud.

Jaga seda raamatut