36 NumPy ühemõõtmeliste järjendite elemendid

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.

x = np.array([1, 2, 3])
print("Järjendi teine element: ", x[1])

>>> %Run guido.py
  Järjendi teine element:  2

 !  Meeldetuletuseks: indeksid algavad nullist.

Järjendisse elemendi/elementide lisamine

Nii Pythoni kui ka NumPy puhul käib elemendi lisamine append käsuga.

# NumPy järjendisse elementide lisamine

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)

>>> %Run guido.py
  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)

>>> %Run guido.py
  Uute elementidega järjend:  [ 8  9  7 10 11 12  4  5]

Järjendist elemendi/elementide otsimine

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

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

# Where argumendiks on vastav tingimusavaldis
# Kõikide elementide indeksid, mis on võrdsed 3-ga
ix = np.where(a == 3)

# Indeksite väljastamine
print(ix)

>>> %Run guido.py
  (array([2, 3]),)

Tulemuseks saame ennikulaadse struktuuri, kus on NumPy järjend leitud indeksitega. Väga lihtsalt saab ka leitud indeksitega elemendid järjendist leida.

# Leiame leitud indeksitega elemendid
print(a[ix])

>>> %Run guido.py
  [3 3]

Tulemuseks on järjend leitud elementidega.

Elementide sorteerimine

Ühemõõtmeliste järjendite sorteerimisel saab kasutada sarnaselt Pythoni harilikule järjendile sort funktsiooni. Näiteks soovime elemendid järjestada kasvavalt vasakult paremale.

x = np.array([0, 8, 5, 1, 3])
print(np.sort(x))

>>> %Run guido.py
  [0 1 3 5 8]

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 näidet, kus liidame igale järjendi elemendile 3 juurde:

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

>>> %Run guido.py
  [4 5 6]

Ka kahe järjendi liitmine on väga lihtne.

x = np.array([1, 2, 3])
y = np.array([10, 20, 30])
print(x + y)

>>> %Run guido.py
  [11 22 33]

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

Järgnevalt teeme midagi veidi keerulisemalt. Olgu meil järjend, kus on inimeste kehakaalud kilogrammides ja järjend, kus on inimeste pikkused meetrites. Tahame arvutada nende järjendite põhjal inimeste kehamassiindeksi (KMI). KMI leidmiseks jagatakse kehakaal pikkuse ruuduga (KMI = kehakaal / pikkus**2). NumPyga on see lihtne.

kaal = np.array([66.4, 81.3, 54.0, 92.3])
pikkus = np.array([1.69, 1.81, 1.75, 1.95])
KMI = kaal / pikkus**2
print(np.round(KMI, 1)) # Ümardamine 1 koht pärast koma

>>> %Run guido.py
  [23.2 24.8 17.6 24.3]

Nüüd aga vaatame olukorda, kus 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)

>>> %Run guido.py
  Tulemuslist:  [-1, -2, -6]

NumPy puhul on see palju lihtsam. Me saame avaldist kasutada otse järjendi peal, kirjutades avaldise nurksulgude vahele pärast järjendi nime. 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.

import numpy as np

# NumPy järjendist negatiivsete täisarvude võtmine
b = np.array([3, -1, -2, 4, -6, 8])
print("Järjendi negatiivsed arvud: ", b[b < 0])

>>> %Run guido.py
  Järjendi negatiivsed täisarvud:  [-1 -2 -6]

Sarnaselt saab kasutada ka teisi tingimusavaldiste operaatoreid (==, >, >=, <=, !=).