{"id":272,"date":"2020-12-21T21:47:33","date_gmt":"2020-12-21T21:47:33","guid":{"rendered":"https:\/\/web.htk.tlu.ee\/digitaru\/tarkvara2\/?post_type=chapter&p=272"},"modified":"2020-12-28T18:43:28","modified_gmt":"2020-12-28T18:43:28","slug":"numpy-kahemootmeliste-jarjendite-elemendid","status":"publish","type":"chapter","link":"https:\/\/web.htk.tlu.ee\/digitaru\/tarkvara2\/chapter\/numpy-kahemootmeliste-jarjendite-elemendid\/","title":{"raw":"NumPy kahem\u00f5\u00f5tmeliste j\u00e4rjendite elemendid","rendered":"NumPy kahem\u00f5\u00f5tmeliste j\u00e4rjendite elemendid"},"content":{"raw":"

J\u00e4rjendist elemendi v\u00f5tmine<\/h2>\r\nKahem\u00f5\u00f5tmeliste j\u00e4rjendite puhul on Pythonil ja NumPyl v\u00e4ike erinevus. Nimelt kui Pythonis peab rea ja veeru indeksid kirjutama eraldi nurksulgude vahele, j\u00e4rjend[0][1]<\/code>, siis NumPy abil saab indeksid kirjutada mugavalt \u00fche paari nurksulgude vahele, kus esimene arv on reaindeks ja teine on veeruindeks.\r\n
# NumPy j\u00e4rjendist elemendi v\u00f5tmine\r\n\r\na = np.array([[1, 2, 3],[4, 5, 6]])\r\n\r\n# V\u00f5tame j\u00e4rjendi esimese rea teise elemendi ja v\u00e4ljastame selle\r\nprint(\"J\u00e4rjendi esimene rea teine element: \", a[0, 1])\r\nprint(\"J\u00e4rjendi teise rea kolmas element: \", a[1, 2])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n\u00a0 J\u00e4rjendi esimene rea teine element:\u00a0 2\r\n\u00a0 J\u00e4rjendi teise rea kolmas element:\u00a0 6<\/pre>\r\nJoonisel on esitatud ridade ja veergude indeksid paksus kirjas ning eelmises n\u00e4ites v\u00f5etud elemendid punaselt.\r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n0<\/strong><\/td>\r\n1<\/strong><\/td>\r\n2<\/strong><\/td>\r\n<\/tr>\r\n
0<\/strong><\/td>\r\n1<\/td>\r\n2<\/span><\/strong><\/td>\r\n3<\/td>\r\n<\/tr>\r\n
1<\/strong><\/td>\r\n4<\/td>\r\n5<\/td>\r\n6<\/span><\/strong><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
J\u00e4rjendisse elemendi\/elementide lisamine<\/h2>\r\n
Kahem\u00f5\u00f5tmelisse j\u00e4rjendisse elemendi lisamisel on NumPy append<\/code> funktsioonil v\u00f5imalus lisada ka juurde t\u00e4psustav parameeter axis<\/code>, mis n\u00e4itab, kas uued elemendid lisatakse mitmem\u00f5\u00f5tmelisse j\u00e4rjendisse rea j\u00e4rgi v\u00f5i veeru j\u00e4rgi. Rida t\u00e4histab arv 0<\/code> ja veergu arv 1<\/code>. Lisamisel peab aga teadma j\u00e4rjendi m\u00f5\u00f5tmeid, muidu pole v\u00f5imalik elemente juurde lisada. Kui t\u00e4psustavat parameetrit (axis<\/code>) append<\/code> funktsiooni ei kirjutata, lisab NumPy uue elemendi v\u00f5i elemendid j\u00e4rjendi l\u00f5ppu ning v\u00e4ljund n\u00e4itab kahem\u00f5\u00f5tmelist j\u00e4rjendit \u00fchem\u00f5\u00f5tmelise j\u00e4rjendina. Vaatame k\u00f5igepealt, milline n\u00e4eb v\u00e4lja ilma rida\/veergu t\u00e4histava parameetrita append<\/code> funktsioon.<\/div>\r\n
a = np.array([[2, 4], [6, 7]])\r\n\r\n# Lisame elemendid j\u00e4rjendi l\u00f5ppu\r\nb = np.append(a, [3, 4])\r\nprint(\"Uute elementidega j\u00e4rjend: \", b)<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute ridadega j\u00e4rjend:\u00a0 [2 4 6 7 3 4]<\/pre>\r\nKahem\u00f5\u00f5tmeliste j\u00e4rjendite puhul on alati m\u00f5istlik elemente lisada rea v\u00f5i veeru j\u00e4rgi, sest nii s\u00e4ilib j\u00e4rjendi kahem\u00f5\u00f5tmelisus. N\u00fc\u00fcd vaatame, kuidas rea v\u00f5i veeru j\u00e4rgi elemente lisada.\r\n\r\n\u00a0! <\/span>\u00a0Juurde lisatav j\u00e4rjend peab olema ka kahem\u00f5\u00f5tmeline.<\/span>\r\n
a = np.array([[2, 4], [6, 7]])\r\n\r\n#Lisame j\u00e4rjendisse a samam\u00f5\u00f5tmelise j\u00e4rjendi rea j\u00e4rgi\r\n#J\u00e4rjendisse a tekivad uued read, v\u00e4ljastame j\u00e4rjendi uue j\u00e4rjendina b\r\nb = np.append(a, [[3, 4], [5, 6]], axis=0)\r\nprint(\"Uute ridadega j\u00e4rjend: \", b)<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute ridadega j\u00e4rjend: [[2 4]\r\n  [6 7]\r\n  [3 4]\r\n  [5 6]]<\/pre>\r\n\r\n\r\n\r\n\r\n
\r\n
 b <\/strong><\/span>= np.append( a <\/strong><\/span>, [<\/strong>[<\/strong>3,<\/span> 4<\/span>]<\/strong><\/span>, [<\/strong>5,<\/span> 6<\/span>]<\/strong><\/span>]<\/strong><\/span>, axis=0<\/strong><\/span>)<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
0 <\/span>\u2193<\/span><\/td>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
a<\/span><\/td>\r\n<\/tr>\r\n
2<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
6<\/td>\r\n7<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n\u2192<\/td>\r\n0<\/span>\u2193<\/span><\/td>\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n<\/tr>\r\n
2<\/span><\/td>\r\n4<\/span><\/td>\r\n<\/tr>\r\n
6<\/span><\/td>\r\n7<\/span><\/td>\r\n<\/tr>\r\n
3<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
5<\/td>\r\n6<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n\u2192<\/td>\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n\r\n
b<\/span><\/td>\r\n<\/tr>\r\n
2<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
6<\/td>\r\n7<\/td>\r\n<\/tr>\r\n
3<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
5<\/td>\r\n6<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
# Lisame j\u00e4rjendisse a samam\u00f5\u00f5tmelise j\u00e4rjendi veeru j\u00e4rgi\r\n# J\u00e4rjendisse a tekivad uued veerud, v\u00e4ljastame j\u00e4rjendi uue j\u00e4rjendina c\r\nc = np.append(a, [[3, 4],[5, 6]], axis=1)\r\nprint(\"Uute veergudega j\u00e4rjend: \", c)<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute veergudega j\u00e4rjend: [[2 4 3 4]\r\n    [6 7 5 6]]<\/pre>\r\n\r\n\r\n\r\n\r\n
\r\n
 c <\/strong><\/span>= np.append( a <\/strong><\/span>, [[<\/span><\/strong>3<\/span>, 4<\/span>]<\/strong><\/span>, [<\/strong>5<\/span>, 6<\/span><\/span>]<\/span>]<\/strong><\/span>, axis=1<\/strong><\/span>)<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
1 <\/span>\u2192<\/span>\r\n\r\n\r\n\r\n\r\n\r\n
a<\/span><\/td>\r\n<\/tr>\r\n
2<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
6<\/td>\r\n7<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n\u2192<\/span><\/td>\r\n1 <\/span>\u2192<\/span>\r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n<\/tr>\r\n
2<\/span><\/td>\r\n4<\/span><\/td>\r\n3<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
6<\/span><\/td>\r\n7<\/span><\/td>\r\n5<\/td>\r\n6<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n\u2192<\/span><\/td>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
c<\/span><\/td>\r\n<\/tr>\r\n
2<\/td>\r\n4<\/td>\r\n3<\/td>\r\n4<\/td>\r\n<\/tr>\r\n
6<\/td>\r\n7<\/td>\r\n5<\/td>\r\n6<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n
T\u00fckeldamine<\/h2>\r\nT\u00fckeldamine (ingl slicing<\/em>) on j\u00e4rjendist vajamineva osa v\u00f5tmine. \u00dchem\u00f5\u00f5tmeliste j\u00e4rjendite puhul ei erine NumPy siin Pythonist. Vaatame aga, kuidas t\u00fckeldada NumPy kahem\u00f5\u00f5tmelist j\u00e4rjendit. K\u00f5igepealt loome j\u00e4rjendi b.\r\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjend b: \", b)<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjend b: [[10 34 21 65]\r\n    [51 77 23 16]]<\/pre>\r\nTabeli kujul n\u00e4eks see v\u00e4lja selline (paksus kirjas on m\u00e4rgitud tabeli indeksid).\r\n\r\n \r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n0<\/strong><\/td>\r\n1<\/strong><\/td>\r\n2<\/strong><\/td>\r\n3<\/strong><\/td>\r\n<\/tr>\r\n
0<\/strong><\/td>\r\n10<\/td>\r\n34<\/td>\r\n21<\/td>\r\n65<\/td>\r\n<\/tr>\r\n
1<\/strong><\/td>\r\n51<\/td>\r\n77<\/td>\r\n23<\/td>\r\n16<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nNii nagu Pythonis, on ka NumPys vaja kasutada t\u00fckeldamisel nurksulge ja indekseid. T\u00fckeldamise juures t\u00e4hendab nurksulgude vahel esimene arv ridu<\/strong> ja teine arv veerge<\/strong>. N\u00e4iteks soovime j\u00e4rjendist b<\/code> v\u00f5tta terve viimase veeru. Selleks tuleb j\u00e4rjendi nime j\u00e4rel nurksulgudesse kirjutada komaga eraldatult vastavad indeksid. Kuna me soovime k\u00f5iki 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]<\/code>.\r\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"Neljas veerg: \", b[:, 3]) # Reaindeksina v\u00f5ib kasutada ka 0:2,\r\n# indeksiga 2 element on v\u00e4lja arvatud.\r\nprint(\"Teine kuni neljas veerg: \", b[:, 1:4])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Neljas veerg:\u00a0 [65 16]\r\n  Teine kuni neljas veerg:\u00a0 [[34 21 65]\r\n    [77 23 16]]<\/pre>\r\n\r\n\r\n\r\n\r\n
\r\n
b[:<\/strong><\/span>, 3<\/strong><\/span>] v\u00f5i b[0:2<\/strong><\/span>, 3<\/strong><\/span>]<\/pre>\r\n<\/td>\r\n
\r\n
b[:<\/strong><\/span>, 1:4<\/strong><\/span>] v\u00f5i b[0:2<\/strong><\/span>, 1:4<\/strong><\/span>]<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
\r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n0<\/strong><\/span><\/td>\r\n1<\/strong><\/span><\/td>\r\n2<\/strong><\/span><\/td>\r\n3<\/strong><\/span><\/td>\r\n<\/tr>\r\n
0<\/strong><\/span><\/td>\r\n10<\/span><\/td>\r\n34<\/span><\/td>\r\n21<\/span><\/td>\r\n65<\/strong><\/td>\r\n<\/tr>\r\n
1<\/strong><\/span><\/td>\r\n51<\/span><\/td>\r\n77<\/span><\/td>\r\n23<\/span><\/td>\r\n16<\/strong><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
<\/td>\r\n0<\/span><\/strong><\/td>\r\n1<\/strong><\/span><\/td>\r\n2<\/strong><\/span><\/td>\r\n3<\/strong><\/span><\/td>\r\n<\/tr>\r\n
0<\/strong><\/span><\/td>\r\n10<\/span><\/td>\r\n34<\/strong><\/td>\r\n21<\/strong><\/td>\r\n65<\/strong><\/td>\r\n<\/tr>\r\n
1<\/strong><\/span><\/td>\r\n51<\/span><\/td>\r\n77<\/strong><\/td>\r\n23<\/strong><\/td>\r\n16<\/strong><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nAnaloogselt saab ka tabelist rea v\u00f5tta.\r\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi teine rida: \", b[1, :]) # Sobib ka b[1], b[1, 0:4]<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi teine rida:\u00a0 [51 77 23 16]<\/pre>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n
b[1<\/strong><\/span>, :<\/strong><\/span>],\r\n\r\nb[1<\/strong><\/span>, 0:4<\/strong><\/span>] v\u00f5i\r\n\r\nb[1<\/strong><\/span>]<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
<\/td>\r\n0<\/span><\/strong><\/td>\r\n1<\/span><\/strong><\/td>\r\n2<\/span><\/strong><\/td>\r\n3<\/span><\/strong><\/td>\r\n<\/tr>\r\n
0<\/strong><\/span><\/td>\r\n10<\/span><\/td>\r\n34<\/span><\/td>\r\n21<\/span><\/td>\r\n65<\/span><\/td>\r\n<\/tr>\r\n
1<\/span><\/strong><\/td>\r\n51<\/strong><\/td>\r\n77<\/strong><\/td>\r\n23<\/strong><\/td>\r\n16<\/strong><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nSamuti on v\u00f5imalik j\u00e4rjendist v\u00f5tta veerge v\u00f5i ridu nii, et v\u00f5etakse veergusid iga m\u00e4\u00e4ratud sammu j\u00e4rel. Selleks peab kirjutama veeru indeksid nii algus::samm<\/code>, kus algus on veeru indeks, millest alates andmeid v\u00f5etakse ja samm m\u00e4\u00e4rab \u00e4ra \u00fcle mitme veeru veerge v\u00f5etakse, n\u00e4iteks a[1::2]<\/code> puhul v\u00f5etakse teine ja kolmas veerg ehk veerge v\u00f5etakse \u00fcle \u00fche veeru.\r\n
a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi esimene ja kolmas veerg: \", a[:, 1::2])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi teine ja neljas veerg: [[34 65]\r\n    [77 16]]<\/pre>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n
a[:<\/strong><\/span>, 1::2<\/strong><\/span>])<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
<\/td>\r\n0<\/strong><\/span><\/td>\r\n1<\/strong><\/span><\/td>\r\n2<\/strong><\/span><\/td>\r\n3<\/strong><\/span><\/td>\r\n<\/tr>\r\n
0<\/strong><\/span><\/td>\r\n10<\/span><\/td>\r\n34<\/strong><\/td>\r\n21<\/span><\/td>\r\n65<\/strong><\/td>\r\n<\/tr>\r\n
1<\/strong><\/span><\/td>\r\n51<\/span><\/td>\r\n77<\/strong><\/td>\r\n23<\/span><\/td>\r\n16<\/strong><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nSarnaselt saab teha ka ridadega.\r\n
a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi esimese rea teine ja neljas element: \", a[0, 1::2])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi esimese rea teine ja neljas element: [34, 65]<\/pre>\r\n\r\n\r\n\r\n\r\n\r\n\r\n
\r\n
a[0<\/strong><\/span>, 1::2<\/strong><\/span>]<\/pre>\r\n<\/td>\r\n<\/tr>\r\n
<\/td>\r\n0<\/span><\/strong><\/td>\r\n1<\/strong><\/span><\/td>\r\n2<\/span><\/strong><\/td>\r\n3<\/strong><\/span><\/td>\r\n<\/tr>\r\n
0<\/span><\/strong><\/td>\r\n10<\/span><\/td>\r\n34<\/td>\r\n21<\/span><\/td>\r\n65<\/td>\r\n<\/tr>\r\n
1<\/span><\/strong><\/td>\r\n51<\/span><\/td>\r\n77<\/span><\/td>\r\n23<\/span><\/td>\r\n16<\/span><\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nT\u00fckeldamine on eriti kasulik siis, kui soovime mingi konkreetset veergu v\u00f5i rida eraldada tabelist, et selle peal teha arvutusi, n\u00e4iteks leida veeru aritmeetiline keskmine. Kui vastav veerg v\u00f5i rida on leitud, siis saab seda k\u00e4sitleda kui \u00fchem\u00f5\u00f5tmelist Numpy j\u00e4rjendit ja rakendada sellel k\u00f5iki funktsioone ja operatsioone, mida tavalisel Numpy \u00fchem\u00f5\u00f5tmelisel j\u00e4rjendil.\r\n\r\n[h5p id=\"32\"]\r\n
Tehted j\u00e4rjendi elementidega<\/h2>\r\nKahem\u00f5\u00f5tmeliste j\u00e4rjendite puhul saab kasutada samu tehteid, mis \u00fchem\u00f5\u00f5tmeliste j\u00e4rjendite peal. N\u00e4iteks soovime liita kahem\u00f5\u00f5tmeliste j\u00e4rjendite vastavad elemendid.\r\n
x = np.array([[1, 2, 3],[4, 5, 6]])\r\ny = np.array([[3, 5, 7],[1, 4, 0]])\r\n\r\nprint(x + y)<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  [[ 4\u00a0 7 10]\r\n   [ 5\u00a0 9\u00a0 6]]<\/pre>\r\nSarnaselt saab j\u00e4rjendeid omavahel lahutada, korrutada, jagada, korrutada konstandiga, astendada.\r\n\r\nKahem\u00f5\u00f5tmeliste j\u00e4rjenditega on ka lihtne leida elemente, mis vastavad mingile kriteeriumile. N\u00e4iteks soovime leida k\u00f5ik elemendid, mis on suuremad kui 7.\r\n
y = np.array([[10, 5, 7],[13, 41, 0]])\r\n\r\nprint(y[y > 7])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  [10 13 41]<\/pre>\r\nTuleb t\u00e4hele panna seda, et tulemuseks ei ole kahem\u00f5\u00f5tmeline j\u00e4rjend, vaid \u00fchem\u00f5\u00f5tmeline j\u00e4rjend, milles on k\u00f5ik elemendid, mis vastavad kriteeriumile.\r\n
J\u00e4rjendist elemendi\/elementide otsimine<\/h2>\r\nNumPyl on j\u00e4rjendist elemendi otsimise jaoks olemas funktsioon where<\/code>, mis tagastab otsitava elemendi indeksi ja t\u00fc\u00fcbi. Kahem\u00f5\u00f5tmelise j\u00e4rjendi puhul leiame tulemuse, kui teame, millisest veerust\/reast me elementi otsime. N\u00e4iteks leiame j\u00e4rjendist k\u00f5ikide nende ridade indeksid<\/strong>, mille esimene element on 1<\/strong>.\r\n
b = np.array([[1, 2, 3, 4],\r\n[5, 6, 7, 8],\r\n[1, 6, 3, 7],\r\n[1, 6, 7, 2],\r\n[5, 7, 3, 2]])\r\n\r\n# Where funktsiooni kasutamine\r\n\r\n# V\u00f5tame k\u00f5ik read ja kontrollime esimese veeru elemente\r\nel = np.where(b[:, 0] == 1)\r\nprint(el[0])<\/pre>\r\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  [0 2 3]<\/pre>","rendered":"
J\u00e4rjendist elemendi v\u00f5tmine<\/h2>\n
Kahem\u00f5\u00f5tmeliste j\u00e4rjendite puhul on Pythonil ja NumPyl v\u00e4ike erinevus. Nimelt kui Pythonis peab rea ja veeru indeksid kirjutama eraldi nurksulgude vahele, j\u00e4rjend[0][1]<\/code>, siis NumPy abil saab indeksid kirjutada mugavalt \u00fche paari nurksulgude vahele, kus esimene arv on reaindeks ja teine on veeruindeks.<\/p>\n
# NumPy j\u00e4rjendist elemendi v\u00f5tmine\r\n\r\na = np.array([[1, 2, 3],[4, 5, 6]])\r\n\r\n# V\u00f5tame j\u00e4rjendi esimese rea teise elemendi ja v\u00e4ljastame selle\r\nprint(\"J\u00e4rjendi esimene rea teine element: \", a[0, 1])\r\nprint(\"J\u00e4rjendi teise rea kolmas element: \", a[1, 2])<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n\u00a0 J\u00e4rjendi esimene rea teine element:\u00a0 2\r\n\u00a0 J\u00e4rjendi teise rea kolmas element:\u00a0 6<\/pre>\n
Joonisel on esitatud ridade ja veergude indeksid paksus kirjas ning eelmises n\u00e4ites v\u00f5etud elemendid punaselt.<\/p>\n\n\n\n\n\n
<\/td>\n0<\/strong><\/td>\n1<\/strong><\/td>\n2<\/strong><\/td>\n<\/tr>\n
0<\/strong><\/td>\n1<\/td>\n2<\/span><\/strong><\/td>\n3<\/td>\n<\/tr>\n
1<\/strong><\/td>\n4<\/td>\n5<\/td>\n6<\/span><\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
J\u00e4rjendisse elemendi\/elementide lisamine<\/h2>\n
Kahem\u00f5\u00f5tmelisse j\u00e4rjendisse elemendi lisamisel on NumPy append<\/code> funktsioonil v\u00f5imalus lisada ka juurde t\u00e4psustav parameeter axis<\/code>, mis n\u00e4itab, kas uued elemendid lisatakse mitmem\u00f5\u00f5tmelisse j\u00e4rjendisse rea j\u00e4rgi v\u00f5i veeru j\u00e4rgi. Rida t\u00e4histab arv 0<\/code> ja veergu arv 1<\/code>. Lisamisel peab aga teadma j\u00e4rjendi m\u00f5\u00f5tmeid, muidu pole v\u00f5imalik elemente juurde lisada. Kui t\u00e4psustavat parameetrit (axis<\/code>) append<\/code> funktsiooni ei kirjutata, lisab NumPy uue elemendi v\u00f5i elemendid j\u00e4rjendi l\u00f5ppu ning v\u00e4ljund n\u00e4itab kahem\u00f5\u00f5tmelist j\u00e4rjendit \u00fchem\u00f5\u00f5tmelise j\u00e4rjendina. Vaatame k\u00f5igepealt, milline n\u00e4eb v\u00e4lja ilma rida\/veergu t\u00e4histava parameetrita append<\/code> funktsioon.<\/div>\n
a = np.array([[2, 4], [6, 7]])\r\n\r\n# Lisame elemendid j\u00e4rjendi l\u00f5ppu\r\nb = np.append(a, [3, 4])\r\nprint(\"Uute elementidega j\u00e4rjend: \", b)<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute ridadega j\u00e4rjend:\u00a0 [2 4 6 7 3 4]<\/pre>\n
Kahem\u00f5\u00f5tmeliste j\u00e4rjendite puhul on alati m\u00f5istlik elemente lisada rea v\u00f5i veeru j\u00e4rgi, sest nii s\u00e4ilib j\u00e4rjendi kahem\u00f5\u00f5tmelisus. N\u00fc\u00fcd vaatame, kuidas rea v\u00f5i veeru j\u00e4rgi elemente lisada.<\/p>\n
\u00a0! <\/span>\u00a0Juurde lisatav j\u00e4rjend peab olema ka kahem\u00f5\u00f5tmeline.<\/span><\/p>\n
a = np.array([[2, 4], [6, 7]])\r\n\r\n#Lisame j\u00e4rjendisse a samam\u00f5\u00f5tmelise j\u00e4rjendi rea j\u00e4rgi\r\n#J\u00e4rjendisse a tekivad uued read, v\u00e4ljastame j\u00e4rjendi uue j\u00e4rjendina b\r\nb = np.append(a, [[3, 4], [5, 6]], axis=0)\r\nprint(\"Uute ridadega j\u00e4rjend: \", b)<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute ridadega j\u00e4rjend: [[2 4]\r\n  [6 7]\r\n  [3 4]\r\n  [5 6]]<\/pre>\n\n\n\n\n
\n
 b <\/strong><\/span>= np.append( a <\/strong><\/span>, [<\/strong>[<\/strong>3,<\/span> 4<\/span>]<\/strong><\/span>, [<\/strong>5,<\/span> 6<\/span>]<\/strong><\/span>]<\/strong><\/span>, axis=0<\/strong><\/span>)<\/pre>\n<\/td>\n<\/tr>\n
0 <\/span>\u2193<\/span><\/td>\n\n\n\n\n\n\n
a<\/span><\/td>\n<\/tr>\n
2<\/td>\n4<\/td>\n<\/tr>\n
6<\/td>\n7<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n\u2192<\/td>\n0<\/span>\u2193<\/span><\/td>\n\n\n\n\n\n\n\n\n
<\/td>\n<\/tr>\n
2<\/span><\/td>\n4<\/span><\/td>\n<\/tr>\n
6<\/span><\/td>\n7<\/span><\/td>\n<\/tr>\n
3<\/td>\n4<\/td>\n<\/tr>\n
5<\/td>\n6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n\u2192<\/td>\n\n\n\n\n\n\n\n\n
b<\/span><\/td>\n<\/tr>\n
2<\/td>\n4<\/td>\n<\/tr>\n
6<\/td>\n7<\/td>\n<\/tr>\n
3<\/td>\n4<\/td>\n<\/tr>\n
5<\/td>\n6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
# Lisame j\u00e4rjendisse a samam\u00f5\u00f5tmelise j\u00e4rjendi veeru j\u00e4rgi\r\n# J\u00e4rjendisse a tekivad uued veerud, v\u00e4ljastame j\u00e4rjendi uue j\u00e4rjendina c\r\nc = np.append(a, [[3, 4],[5, 6]], axis=1)\r\nprint(\"Uute veergudega j\u00e4rjend: \", c)<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Uute veergudega j\u00e4rjend: [[2 4 3 4]\r\n    [6 7 5 6]]<\/pre>\n\n\n\n\n
\n
 c <\/strong><\/span>= np.append( a <\/strong><\/span>, [[<\/span><\/strong>3<\/span>, 4<\/span>]<\/strong><\/span>, [<\/strong>5<\/span>, 6<\/span><\/span>]<\/span>]<\/strong><\/span>, axis=1<\/strong><\/span>)<\/pre>\n<\/td>\n<\/tr>\n
1 <\/span>\u2192<\/span><\/p>\n\n\n\n\n\n
a<\/span><\/td>\n<\/tr>\n
2<\/td>\n4<\/td>\n<\/tr>\n
6<\/td>\n7<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n\u2192<\/span><\/td>\n1 <\/span>\u2192<\/span><\/p>\n\n\n\n\n\n
<\/td>\n<\/tr>\n
2<\/span><\/td>\n4<\/span><\/td>\n3<\/td>\n4<\/td>\n<\/tr>\n
6<\/span><\/td>\n7<\/span><\/td>\n5<\/td>\n6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n\u2192<\/span><\/td>\n\n\n\n\n\n\n
c<\/span><\/td>\n<\/tr>\n
2<\/td>\n4<\/td>\n3<\/td>\n4<\/td>\n<\/tr>\n
6<\/td>\n7<\/td>\n5<\/td>\n6<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
T\u00fckeldamine<\/h2>\n
T\u00fckeldamine (ingl slicing<\/em>) on j\u00e4rjendist vajamineva osa v\u00f5tmine. \u00dchem\u00f5\u00f5tmeliste j\u00e4rjendite puhul ei erine NumPy siin Pythonist. Vaatame aga, kuidas t\u00fckeldada NumPy kahem\u00f5\u00f5tmelist j\u00e4rjendit. K\u00f5igepealt loome j\u00e4rjendi b.<\/p>\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjend b: \", b)<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjend b: [[10 34 21 65]\r\n    [51 77 23 16]]<\/pre>\n
Tabeli kujul n\u00e4eks see v\u00e4lja selline (paksus kirjas on m\u00e4rgitud tabeli indeksid).<\/p>\n
 <\/p>\n\n\n\n\n\n
<\/td>\n0<\/strong><\/td>\n1<\/strong><\/td>\n2<\/strong><\/td>\n3<\/strong><\/td>\n<\/tr>\n
0<\/strong><\/td>\n10<\/td>\n34<\/td>\n21<\/td>\n65<\/td>\n<\/tr>\n
1<\/strong><\/td>\n51<\/td>\n77<\/td>\n23<\/td>\n16<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Nii nagu Pythonis, on ka NumPys vaja kasutada t\u00fckeldamisel nurksulge ja indekseid. T\u00fckeldamise juures t\u00e4hendab nurksulgude vahel esimene arv ridu<\/strong> ja teine arv veerge<\/strong>. N\u00e4iteks soovime j\u00e4rjendist b<\/code> v\u00f5tta terve viimase veeru. Selleks tuleb j\u00e4rjendi nime j\u00e4rel nurksulgudesse kirjutada komaga eraldatult vastavad indeksid. Kuna me soovime k\u00f5iki 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]<\/code>.<\/p>\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"Neljas veerg: \", b[:, 3]) # Reaindeksina v\u00f5ib kasutada ka 0:2,\r\n# indeksiga 2 element on v\u00e4lja arvatud.\r\nprint(\"Teine kuni neljas veerg: \", b[:, 1:4])<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  Neljas veerg:\u00a0 [65 16]\r\n  Teine kuni neljas veerg:\u00a0 [[34 21 65]\r\n    [77 23 16]]<\/pre>\n\n\n\n\n
\n
b[:<\/strong><\/span>, 3<\/strong><\/span>] v\u00f5i b[0:2<\/strong><\/span>, 3<\/strong><\/span>]<\/pre>\n<\/td>\n
\n
b[:<\/strong><\/span>, 1:4<\/strong><\/span>] v\u00f5i b[0:2<\/strong><\/span>, 1:4<\/strong><\/span>]<\/pre>\n<\/td>\n<\/tr>\n
\n\n\n\n\n\n
<\/td>\n0<\/strong><\/span><\/td>\n1<\/strong><\/span><\/td>\n2<\/strong><\/span><\/td>\n3<\/strong><\/span><\/td>\n<\/tr>\n
0<\/strong><\/span><\/td>\n10<\/span><\/td>\n34<\/span><\/td>\n21<\/span><\/td>\n65<\/strong><\/td>\n<\/tr>\n
1<\/strong><\/span><\/td>\n51<\/span><\/td>\n77<\/span><\/td>\n23<\/span><\/td>\n16<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n\n\n\n\n\n\n
<\/td>\n0<\/span><\/strong><\/td>\n1<\/strong><\/span><\/td>\n2<\/strong><\/span><\/td>\n3<\/strong><\/span><\/td>\n<\/tr>\n
0<\/strong><\/span><\/td>\n10<\/span><\/td>\n34<\/strong><\/td>\n21<\/strong><\/td>\n65<\/strong><\/td>\n<\/tr>\n
1<\/strong><\/span><\/td>\n51<\/span><\/td>\n77<\/strong><\/td>\n23<\/strong><\/td>\n16<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Analoogselt saab ka tabelist rea v\u00f5tta.<\/p>\n
b = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi teine rida: \", b[1, :]) # Sobib ka b[1], b[1, 0:4]<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi teine rida:\u00a0 [51 77 23 16]<\/pre>\n\n\n\n\n\n\n
\n
b[1<\/strong><\/span>, :<\/strong><\/span>],\r\n\r\nb[1<\/strong><\/span>, 0:4<\/strong><\/span>] v\u00f5i\r\n\r\nb[1<\/strong><\/span>]<\/pre>\n<\/td>\n<\/tr>\n
<\/td>\n0<\/span><\/strong><\/td>\n1<\/span><\/strong><\/td>\n2<\/span><\/strong><\/td>\n3<\/span><\/strong><\/td>\n<\/tr>\n
0<\/strong><\/span><\/td>\n10<\/span><\/td>\n34<\/span><\/td>\n21<\/span><\/td>\n65<\/span><\/td>\n<\/tr>\n
1<\/span><\/strong><\/td>\n51<\/strong><\/td>\n77<\/strong><\/td>\n23<\/strong><\/td>\n16<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Samuti on v\u00f5imalik j\u00e4rjendist v\u00f5tta veerge v\u00f5i ridu nii, et v\u00f5etakse veergusid iga m\u00e4\u00e4ratud sammu j\u00e4rel. Selleks peab kirjutama veeru indeksid nii algus::samm<\/code>, kus algus on veeru indeks, millest alates andmeid v\u00f5etakse ja samm m\u00e4\u00e4rab \u00e4ra \u00fcle mitme veeru veerge v\u00f5etakse, n\u00e4iteks a[1::2]<\/code> puhul v\u00f5etakse teine ja kolmas veerg ehk veerge v\u00f5etakse \u00fcle \u00fche veeru.<\/p>\n
a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi esimene ja kolmas veerg: \", a[:, 1::2])<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi teine ja neljas veerg: [[34 65]\r\n    [77 16]]<\/pre>\n\n\n\n\n\n\n
\n
a[:<\/strong><\/span>, 1::2<\/strong><\/span>])<\/pre>\n<\/td>\n<\/tr>\n
<\/td>\n0<\/strong><\/span><\/td>\n1<\/strong><\/span><\/td>\n2<\/strong><\/span><\/td>\n3<\/strong><\/span><\/td>\n<\/tr>\n
0<\/strong><\/span><\/td>\n10<\/span><\/td>\n34<\/strong><\/td>\n21<\/span><\/td>\n65<\/strong><\/td>\n<\/tr>\n
1<\/strong><\/span><\/td>\n51<\/span><\/td>\n77<\/strong><\/td>\n23<\/span><\/td>\n16<\/strong><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Sarnaselt saab teha ka ridadega.<\/p>\n
a = np.array([[10, 34, 21, 65], [51, 77, 23, 16]])\r\nprint(\"J\u00e4rjendi esimese rea teine ja neljas element: \", a[0, 1::2])<\/pre>\n
>>><\/strong><\/span> %Run guido.py<\/span>\r\n  J\u00e4rjendi esimese rea teine ja neljas element: [34, 65]<\/pre>\n\n\n\n\n\n\n
\n
a[0<\/strong><\/span>, 1::2<\/strong><\/span>]<\/pre>\n<\/td>\n<\/tr>\n
<\/td>\n0<\/span><\/strong><\/td>\n1<\/strong><\/span><\/td>\n2<\/span><\/strong><\/td>\n3<\/strong><\/span><\/td>\n<\/tr>\n
0<\/span><\/strong><\/td>\n10<\/span><\/td>\n34<\/td>\n21<\/span><\/td>\n65<\/td>\n<\/tr>\n
1<\/span><\/strong><\/td>\n51<\/span><\/td>\n77<\/span><\/td>\n23<\/span><\/td>\n16<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
T\u00fckeldamine on eriti kasulik siis, kui soovime mingi konkreetset veergu v\u00f5i rida eraldada tabelist, et selle peal teha arvutusi, n\u00e4iteks leida veeru aritmeetiline keskmine. Kui vastav veerg v\u00f5i rida on leitud, siis saab seda k\u00e4sitleda kui \u00fchem\u00f5\u00f5tmelist Numpy j\u00e4rjendit ja rakendada sellel k\u00f5iki funktsioone ja operatsioone, mida tavalisel Numpy \u00fchem\u00f5\u00f5tmelisel j\u00e4rjendil.<\/p>\n
\n