Loeng 14: Teadusarvutused Pythonis, algoritm (meeldetuletus), teegid: NumPy, SciPy, matplotlib, jm., andmemassiiv numpy.ndarray, jooniste ja graafikute loomine, joonistega töötamine Spyder IDEs ja Jupyteris, näiteid¶

Viimati uuendatud 8.12.2024.

Koodinäited¶

Teadusarvutused¶

Teadusavastuste kolm komponenti: teooria, eksperiment, arvutused.

  • Teadusarvutused
    • Keeruliste ülesannete lahendamine (mittelineaarsus, mittelineaarne dünaamika, kaos, komplekssüsteemid)
    • Kallite või eetiliselt tundlikke eksperimentide simulatsioon
  • Arvutusvõimsus ja raudvara
    • Arvutiklastrid, võrkandmetöötlus
    • Paralleelarvutused, lihtsamal juhul ka hargtöötlus (multithreading)
  • Algoritmid
    • Teadusarvutuste teegid + enda loodud algoritmid ja moodulid
  • Andmete analüüs
    • Visualiseerimine
    • Modelleerimine

Lisainfot: https://en.wikipedia.org/wiki/Computational_science

Algoritm¶

Definitsioon Loengust 3:
Algoritm (=lahenduseeskiri) on fikseeritud juhiste jada, millega teisendatakse algoritmi sisendandmed algoritmi väljundandmeteks. Algoritmi esitatakse kas juhiste loendina või graafiliselt kasutades voodiagrammi. Algoritmi rakendatakse probleemi lahendamiseks.

Vikipeedia definitsioon:
Algoritm on sammsammuline tegevusjuhis, juhend, eeskiri mingi tegevuse sooritamiseks või eesmärgi saavutamiseks. Kõige sagedamini kasutatakse seda terminit matemaatilise ülesande lahendamiseks mõeldud eeskirja kohta. Algoritmi esitust mingis formaalses keeles, tavaliselt programmeerimiskeeles või masinakoodis, nimetatakse arvutiprogrammiks.
Allikas Vikipeedia: https://et.wikipedia.org/wiki/Algoritm

Näide: Lambi põlema panemine¶

Sisend: Lamp

Väljund: Lamp annab valgust

Tegevused:
A. Vaata kas lamp põleb?
B. Lüliti lülitamine (vajadusel pirni vahetus ja lambi parandus)

Algoritm:
(A) Kontrolli, kas lamp põleb. Kui jah, siis on valgus. Kui ei, siis kontrolli, kas lülit on sisse lülitatud. Kui ei, siis (B) lülita lülit sisse ja korda A. Kui jah, siis lülita see välja ja kontrolli, kas lambipirn on terve. Kui jah, siis vaheta lambipirn ja korda B. Kui ei, siis paranda lamp ja korda B.

Joonis 1 kujutab eelmainitud algoritmi voodiagrammina.

No description has been provided for this image
Joonis 1. Algoritm voodiagrammina: Lambi põlema panemine.

Lahendus: Algoritmile vastav programmikood.

In [1]:
def lamp_põleb(lamp):
    valgus = lamp['lylit'] and lamp['pirn'] and lamp['korras']
    print(f'Lambi olek: {lamp} --> {valgus}')
    
    if valgus:  # Sama mis valgus == True.
        return True
    
    if lamp['lylit']:
        lamp['lylit'] = False
        if lamp['pirn']:
            lamp['korras'] = True
        else:
            lamp['pirn'] = True
    else:
        lamp['lylit'] = True
    
    return lamp_põleb(lamp)


lambi_olek = dict(lylit=False, pirn=False, korras=False)
lamp_põleb(lambi_olek)

Lambi olek: {'lylit': False, 'pirn': False, 'korras': False} --> False
Lambi olek: {'lylit': True, 'pirn': False, 'korras': False} --> False
Lambi olek: {'lylit': False, 'pirn': True, 'korras': False} --> False
Lambi olek: {'lylit': True, 'pirn': True, 'korras': False} --> False
Lambi olek: {'lylit': False, 'pirn': True, 'korras': True} --> False
Lambi olek: {'lylit': True, 'pirn': True, 'korras': True} --> True
Out[1]:
True

Teadusarvutused Pythonis¶

Teadusarvutused Pythonis, valik teeke mida oleme juba maininud Loengus 10. Joonis 2 kujutab siinmainitud teekide logosid.

  • NumPy $-$ andmete esitus massiividena, https://numpy.org
    • pandas $-$ andmete säilitamine ja analüüs (kasutab NumPy), https://pandas.pydata.org
  • SciPy $-$ teadusarvutuste algoritmid, https://www.scipy.org
  • IPython $-$ interaktiivne andmete analüüs, https://ipython.org
  • SymPy $-$ sümbolarvutus (CAS, computer algebra system), https://www.sympy.org/en/index.html
  • matplotlib $-$ andmete analüüs ja visualiseerimine, https://matplotlib.org
    • seaborn $-$ andmete analüüs ja visualiseerimine (kasutab matplotlib) http://seaborn.pydata.org/index.html
No description has been provided for this image
Joonis 2. Eelmainitud teekide ja projektide logod, seisuga 2022.

Eelmainitud teekide ja tööriistade kasutamine:

  • Dokumentatsioon (DocString), abiinfo, näited
  • Lähtekood
  • Arendajate ja kautajate kogukond

Enamus teadusarvutuste teeke on vaikimisi kaasas Anaconda Pythoni distributsiooniga või allaletavad konsoolis kasutadesconda't või pip'i (Python Package Index (PyPI) manager). Pythoni distribusiooni haldamisest rääkisime Loengus 10.

NumPy ülevaade¶

Kasutusjuhend veebis https://numpy.org/doc/stable/index.html Ära unusta ka kohalikult instaleerituid abivahendeid, vt. Loeng 9.

Andmetüüp numpy.ndarray ehk andmemassiiv (multidimensional array)

  • Andmetüüp, optimeeritud kiirusele ja ekonoomsusele
    • Täisarvud, erinevad arvu laiused (bitdepth)
    • Ujuvkomaarvud (kümnendmurdarvud), erinevad arvu laiused ehk bitisügavus
    • ...
  • Andmemassiivide dimensioonaalsus
  • Ligipääs andmetele ja nende analüüs
    • Indekseerimine
    • Aritmeetilised tehted massiividega
    • Arvutusmeetodid
    • Massiivi võtmesõnaline ehk nimega argument axis

Alampaketid:

  • fft $-$ kiire Fourier teisendused
  • linalg $-$ lineaaralgebra
  • matlib $-$ maatriksid
  • random $-$ juhuslikud arvud
  • ...

NumPy andmemassiiv numpy.ndarray¶

massiivi defineerimine¶

Andmetüübi numpy.ndarray objekti saame luua kasutades funktsiooni np.array väljakutset. Näide: Massiivi loomine selle meetodid ja muud atribuudid.

In [2]:
import numpy as np  # Soovituslik nimekasutus.

massiiv = np.array([1, 2, 3])  # teisendame Pythoni listi andmemassiiviks.

print(type(massiiv))  # Mis andmetüüp?
print(massiiv)        # Näeb konsoolis ilus välja.
massiiv

<class 'numpy.ndarray'>
[1 2 3]
Out[2]:
array([1, 2, 3])
In [3]:
a = np.arange(0, 5, 0.5)  # Parem kui Pythoni range, murdarvuline samm.

print(a)
a

[0.  0.5 1.  1.5 2.  2.5 3.  3.5 4.  4.5]
Out[3]:
array([0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5])

Loodud massiivi kopeerimine:

In [4]:
b = a  # Kõigest viide originaalile.
c = a.copy()  # Massiivi meetod.

print(id(a))
print(id(b))
print(id(c))

4373385392
4373385392
4355811408
In [5]:
d = np.array(a)  # Sisuliselt konstruktorfunktsioon.

print(id(a))
print(id(b))
print(id(c))
print(id(d))

4373385392
4373385392
4355811408
4373386448
In [6]:
e = a[:]  # Lõikamine (slicing).

print(id(a))
print(id(b))
print(id(c))
print(id(d))
print(id(e))

4373385392
4373385392
4355811408
4373386448
4373388080

Massiivi kuju¶

Andmemassiivi meetodi reshape kasutus:

In [7]:
a = np.arange(15).reshape(3, 5)  # Kolm rida, viis veergu. 

print(a)
a

[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]
Out[7]:
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
In [8]:
a.shape  # Massiivi kuju...
Out[8]:
(3, 5)
In [9]:
a.ndim  # Mitmemõõtmeline massiiv?
Out[9]:
2
In [10]:
a.dtype.name  # Salvestatud andmete ehk numbrite andmetüüp.
Out[10]:
'int64'
In [11]:
a.itemsize  # Massiivi andmete suurus bittides.
Out[11]:
8
In [12]:
a.size  # Mitu elementi massiivis?
Out[12]:
15

Kahemõõtmeline massiiv¶

Kahemõõtmelise massiivi mis sisaldab reaal- ja kompleksarve loomine kasutades funktsiooni np.array:

In [13]:
data = [
    [1, 2, 3],
    [4, 5, 6.0]
]

np.array(data)  # Vaikimisi käitumine.
Out[13]:
array([[1., 2., 3.],
       [4., 5., 6.]])
In [14]:
np.array([[1, 2, 3], [4, 5, 6]], dtype=complex)  # Määrame andmetüübi ise.
Out[14]:
array([[1.+0.j, 2.+0.j, 3.+0.j],
       [4.+0.j, 5.+0.j, 6.+0.j]])

Spetsiaalsete ja eriotstavega massiivide defineerimine¶

In [15]:
np.linspace(-1, 1, num=6)  # Algus, lõpp, jagame võrdselt kuueks arvuks.
Out[15]:
array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ])
In [16]:
np.zeros((2, 3))  # Nullmassiiv.
Out[16]:
array([[0., 0., 0.],
       [0., 0., 0.]])
In [17]:
np.zeros_like(a)  # Sama dimensioon ja kuju mis massiivil a (eespoole defineeritud).
Out[17]:
array([[0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0]])
In [18]:
np.ones((2, 3))
Out[18]:
array([[1., 1., 1.],
       [1., 1., 1.]])
In [19]:
np.empty((2, 3))  # Algväärtustamata massiiv kujuga (2, 3).
Out[19]:
array([[1., 1., 1.],
       [1., 1., 1.]])
In [20]:
np.random.rand(2, 3)  # Juhuslike arvude gen., ühtlane jaotus = valge müra.
Out[20]:
array([[0.19069844, 0.88546279, 0.44499663],
       [0.66830919, 0.28861177, 0.2672533 ]])
In [21]:
np.random.randn(2, 3)  # Juhuslike arvude gen., normaaljaotus.
Out[21]:
array([[-2.06984601,  1.20535492,  1.6404525 ],
       [-1.58935343, -0.09193378, -1.47138942]])
In [22]:
np.fromfunction(lambda i, j: i + j, (2, 3))  # Itereerib üle massiivi andmete indeksite, rida i, veerg j.
Out[22]:
array([[0., 1., 2.],
       [1., 2., 3.]])

Iteraatortugi¶

Loodud NumPy massiivid on iteraatortoega objektid:

In [23]:
m = np.array([1, 2, 3])

for i in m:
    print(i)

1
2
3
In [24]:
for i in np.arange(3):
    print(i)

0
1
2
In [25]:
for i in np.ones(3):
    print(i)

1.0
1.0
1.0

Toetatud andmetüübid¶

Massiivides toetatud numbrite andmetüübid, arvude laiused bittides:

In [26]:
np.array([1, 2, 3], dtype=np.int8)
Out[26]:
array([1, 2, 3], dtype=int8)
In [27]:
np.array([1, 2, 3], dtype=np.int64)  # Lisaks kõik kahe astmed mis jäävad 8 ja 64 biti vahele.
Out[27]:
array([1, 2, 3])
In [28]:
np.array([1, 2, 3], dtype=np.float16)
Out[28]:
array([1., 2., 3.], dtype=float16)
In [29]:
np.array([1, 2, 3], dtype=np.float64)  # Lisaks vahepealsed ja eksisteerib ka float128.
Out[29]:
array([1., 2., 3.])
In [30]:
np.array([1, 2, 3], dtype=np.complex64)
Out[30]:
array([1.+0.j, 2.+0.j, 3.+0.j], dtype=complex64)
In [31]:
np.array([1, 2, 3], dtype=np.complex128)  # Lisaks vahepealsed ja eksisteerib ka float256.
Out[31]:
array([1.+0.j, 2.+0.j, 3.+0.j])

Aritmeetika- ja võrdlusoperaatorid¶

NumPy andmemassiivid ja teegis NumPy ülekirjutatud aritmeetika- ja võrdlusoperaatorid:

In [32]:
a = np.array([20, 30, 40, 50])
b = np.arange(4)  # --> [0 1 2 3]

a - b  # a + b, a * b, b / a, a**2, jne. Element-element haaval.
Out[32]:
array([20, 29, 38, 47])
In [33]:
a + b
Out[33]:
array([20, 31, 42, 53])
In [34]:
2 * a  # Element haaval, proovi ka /, %, //, jne.
Out[34]:
array([ 40,  60,  80, 100])
In [35]:
a + 1
Out[35]:
array([21, 31, 41, 51])
In [36]:
a += b  # -=, *=, /=, **=, jne. Itereerib ise element-element haaval.
a
Out[36]:
array([20, 31, 42, 53])
In [37]:
a == 20  # Element haaval, kahe massiivi korral võrdleb vastavaid elemente.
Out[37]:
array([ True, False, False, False])
In [38]:
a < 35  # >, <=, jne.
Out[38]:
array([ True,  True, False, False])
In [39]:
~(a < 35)  # Eitus, biti NOT on siin ülekirjutatatud.
Out[39]:
array([False, False,  True,  True])
In [40]:
(a > 20) & (a < 40)  # bitwse AND üle kirjutataud
Out[40]:
array([False,  True, False, False])

Massiivide omavahelised korrutustehted:

In [41]:
A = np.array([[1, 2], [3, 4]])

A.dot(A)  # Maatrikskorrutis (dot product).
Out[41]:
array([[ 7, 10],
       [15, 22]])
In [42]:
A @ A  # Sama mis eelmine, Pythoni kohahoidja operaatori kasutus.
Out[42]:
array([[ 7, 10],
       [15, 22]])
In [43]:
A * A  # Korrutamine element-element kaupa.
Out[43]:
array([[ 1,  4],
       [ 9, 16]])
In [44]:
A**2  # Astendamine element-element kaupa.
Out[44]:
array([[ 1,  4],
       [ 9, 16]])

Maatriksi astendamine (lineaaralgebrast teada reeglid):

In [45]:
from numpy.linalg import matrix_power

matrix_power(A, 3)
Out[45]:
array([[ 37,  54],
       [ 81, 118]])
In [46]:
A.T  # Maatriksi transponeerimine.
Out[46]:
array([[1, 3],
       [2, 4]])

NumPy massiivide meetodid ja funktsioonid¶

Valik NumPy funktsioone mis itereerivad automaatselt üle massiivi andmete:

In [47]:
a = np.array([20, 30, 40, 50])

print(type(a))
a.min()  # Meetodile vastab ka funktsioon np.min.

<class 'numpy.ndarray'>
Out[47]:
20
In [48]:
a.max()  # Meetodile vastab ka funktsioon np.max. Allpool ka...
Out[48]:
50
In [49]:
a.sum()
Out[49]:
140
In [50]:
a.cumsum()
Out[50]:
array([ 20,  50,  90, 140])
In [51]:
a.mean()
Out[51]:
35.0
In [52]:
a.std()  # Standardhälve (standard diviation).
Out[52]:
11.180339887498949
In [53]:
a.var()  # Dispersioon (variance).
Out[53]:
125.0

NumPy argument axis¶

Nimega argument axis ja eelmainitud funktsioonid, itereerimine kindlas andmemassiivi telje suunas:

In [54]:
A = np.array([[1, 2], [3, 4]])

A.sum(axis=0)  # Veeru andmed.
Out[54]:
array([4, 6])
In [55]:
A.sum(axis=1)  # Ridade andmed.
Out[55]:
array([3, 7])
In [56]:
A.sum()  # Kõigi elementide summa.
Out[56]:
10

Andmemassiivide teljed ja nimega argument axis¶

1D massiiv ja selle telg axis=0. Joonis 3 kujutab massiivitelge graafiliselt.

In [57]:
np.arange(2, 6)
Out[57]:
array([2, 3, 4, 5])
No description has been provided for this image
Joonis 3. 1D massiiv ja selle telg, axis=0.

2D massiiv ja selle teljed axis=0 ja axis=1. Joonsi 4 kujutab eelmainitud massiivitelgi graafiliselt.

In [58]:
np.arange(2, 10).reshape(2, 4)
Out[58]:
array([[2, 3, 4, 5],
       [6, 7, 8, 9]])
No description has been provided for this image
Joonis 4. 2D massiiv ja tema teljed, axis=0 ja axis=1.

3D massiiv ja selle teljed axis=0, axis=1 ja axis=2. Joonsi 5 kujutab eelmainitud massiivitelgi graafiliselt.

In [59]:
massiiv = np.arange(24).reshape(4, 3, 2)
massiiv
Out[59]:
array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5]],

       [[ 6,  7],
        [ 8,  9],
        [10, 11]],

       [[12, 13],
        [14, 15],
        [16, 17]],

       [[18, 19],
        [20, 21],
        [22, 23]]])
No description has been provided for this image
Joonis 5. 3D massiiv ja tema teljed, axis=0, axis=1 ja axis=2.
In [60]:
massiiv.sum(axis=2)  # Kontrollime.
Out[60]:
array([[ 1,  5,  9],
       [13, 17, 21],
       [25, 29, 33],
       [37, 41, 45]])

Kui sa tahad kasutada kõiki elemente ehk pakkida see lahti (flattened array, collapsed into 1D array) vali axis = None:

In [61]:
massiiv.sum(axis=None)
Out[61]:
276
In [62]:
massiiv.sum()  # Teatavasti annab sama tulemeuse.
Out[62]:
276

Massiivi indekseerimine¶

Osaliselt erineb Pythoni listide ja teiste iteraatortoega objektide omast.

In [63]:
x = np.arange(10)

print(x)
x[2]   # Sama mis Pythoni listis.

[0 1 2 3 4 5 6 7 8 9]
Out[63]:
2
In [64]:
x[-2]  # Toetab negatiivset indeksit.
Out[64]:
8
In [65]:
x.shape = (2, 5)  # Muudan 2D-ks
x
Out[65]:
array([[0, 1, 2, 3, 4],
       [5, 6, 7, 8, 9]])
In [66]:
x[1][3]  # Toetab Pythoni indekseerimist.
Out[66]:
8
In [67]:
x[1, 3]  # NumPy enda lahendus: rida, veerg. Palju mugavam.
Out[67]:
8
In [68]:
x[1, -1]  # Rida, veerg.
Out[68]:
9
In [69]:
x[0]  # Esimene rida.
Out[69]:
array([0, 1, 2, 3, 4])
In [70]:
x = np.arange(10)
x
Out[70]:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
In [71]:
x[2:5]  # Lõige kahest viieni (5 mitte-kaasaarvatud). Slicing.
Out[71]:
array([2, 3, 4])
In [72]:
x[:-7]  # Kuni indeksini, -7 mitte-kaasaarvatud.
Out[72]:
array([0, 1, 2])
In [73]:
x[1:7:2]  # Toetab sammu, iga teine.
Out[73]:
array([1, 3, 5])
In [74]:
x[[1, 3, 5, 9]]  # Valib inkeksite järgi.
Out[74]:
array([1, 3, 5, 9])
In [75]:
y = np.arange(20).reshape(5, 4)
y
Out[75]:
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19]])
In [76]:
y[1, 0]
Out[76]:
4
In [77]:
y[[0, 0, 1], [1, 3, 3]]  # Valib indeksite järgi ja mõlema koordinaaadi järgi [[rida], [veerg]]
Out[77]:
array([1, 3, 7])
In [78]:
y[1:5:2, ::3]  # Rida, veerg.
Out[78]:
array([[ 4,  7],
       [12, 15]])

SciPy ülevaade¶

SciPy kasutusjuhendid veebis (reference guide): https://docs.scipy.org/doc/scipy/reference/ Ära unusta ka kohalikult instaleerituid abivahendeid, vt. Loeng 9.

SciPy $-$ kogum matemaatilisi algoritme ja abivahendeid:

  • cluster $-$ andmekaeve
  • constants $-$ füüsika ja matemaatika konstandid
  • fftpack $-$ kiire Fourier algoritmid
  • integrate $-$ integraatorid ja ODE lahendajad
  • interpolate $-$ interplatsioon, splainid
  • io $-$ sisend-väljund
  • linalg $-$ lineaaralgebra
  • ndimage $-$ N-mõõtmeline pildianalüüs
  • odr $-$ regressiooni analüüs
  • optimize $-$ optimeerimine, võrrandisüsteemide lahendamine
  • signal $-$ signaalitöötlus
  • sparse $-$ hõredad maatriksid
  • spatial $-$ arvutusgeomeetria
  • special $-$ erifunktsioonid
  • stats $-$ statistika jaotused ja funktsioonid

Näide lineaaralgebrast: Lahenda süsteem kujul: $$ \begin{cases} x + 3y = 1,\\ 2x + 5y = 2, \end{cases} $$ mida saame esitada ka maatrikskujul: $$ \begin{pmatrix} 1 & 3\\ 2 & 5 \end{pmatrix}\!\cdot\! \begin{pmatrix} x\\ y \end{pmatrix}= \begin{pmatrix} 1\\ 2 \end{pmatrix}, $$ s.t., et leia tundmatud $x$ ja $y$ või vektor $(x, y)^T$.

In [79]:
from scipy import linalg

A = np.array([[1, 3], [2, 5]])  # Süsteemi koefitsentide maatriks.
vec = [1, 2]  # Pythoni list, saad kasutada ka massiivi numpy.ndarray.

linalg.solve(A, vec)  # --> LAHEND: [1., 0.]
Out[79]:
array([1., 0.])

Kontrollime tulemust:

In [80]:
A.dot(np.array([1, 0]))
Out[80]:
array([1, 2])

Mida veel saab teha?

In [81]:
linalg.det(A)  # Determinant.
Out[81]:
-1.0000000000000002
In [82]:
linalg.inv(A)  # Pöördmaatriks (inverse matrix).
Out[82]:
array([[-5.,  3.],
       [ 2., -1.]])

Joonised ja graafikud¶

Teek matplotlib¶

Juhend ja näited veebis: https://matplotlib.org/stable/users/index.html Ära unusta ka kohalikult instaleerituid abivahendeid, vt. Loeng 9.

Matplotlib $-$ andmete analüüsi tööriistad ja visualiseerimine

  • 2-mõõtmelised (3-mõõtmelised) joonised, teljed konfigureeritavad
  • Teaduspublikatsioonile nõutav kvaliteet, $\LaTeX$'i tugi, vektorgraafika tugi, EPS salvestus, jm.
  • Lihtne kasutada, Matlab'le sarnane süntaks

Teatavasti skriptimiskeelt $\LaTeX$ see kursus ei käsitle, vt. iseseisvalt $\LaTeX$ projekti koduleht https://www.latex-project.org/ Lisaks mainisime $\LaTeX$'it Loeng 1 lisades.

Joonise loomise töövoog:

  • Joonise tekitamine
  • Telgede lisamine joonisele, telgede konfigureerimine
  • Graafikute lisamine telgedele
  • Joonise salvestamine ja kuvamine

Järgmine nädal laiendame jooniste loomise teemat.

Joonise, graafiku teljepaari ja graafiku loomine¶

Teek matplotlib võimaldab luua teljepaare ja graafikuid kasutades kahte koodi kirjutamise viisi: 1) Detailsem kood kus opereerime teljepaaride ja muude objektidega ja 2) Lihtsam kood mis võimaldab jooneseid kiiresti luua.

Joonise loomine: Lihtne graafik ja matplotlibi lihtsam süntaks.

In [83]:
import matplotlib.pyplot as plt
%config InlineBackend.figure_format='retina'  # Vajadusel sisesta Spyderi konsooli, maagiline käsk.

x = np.linspace(0.0, 2.0, 100)  # Vaikimisi, num = 50.
y = 1 + np.sin(3 * np.pi * x)  # Funktsioon sin toetab massiivi.

plt.plot(x, y)  # Graafiku loomine.

plt.xlabel('Argument $x$')  # LaTeXi exit tag on '$'.
plt.ylabel('Funktsioon $y(x)$')
plt.title('Pealkiri $y(x) = \int_{-10}^{x}(t-b)^2dt$')
plt.grid()  # Ruudustiku lisamine, pole kohustuslik.

plt.savefig("test.pdf")  # Joonise salvestamine, vali faililaiend ise.
plt.show()               # Joonise kuvamine.
No description has been provided for this image

Mitme graafiku lisamine samale teljepaarile¶

In [84]:
x = np.linspace(0.0, 2.0, 100)

y = 1 + np.sin(3 * np.pi * x)
y2 = 1.2 + np.sin(4 * np.pi * x)

plt.plot(x, y)
plt.plot(x, y2)  # Võid mitu graafikut lisada.

#plt.plot(x, y, x, y2)  # Töötab ka nii.

plt.xlabel('x')
plt.ylabel('y')
plt.title('Pealkiri')

plt.show()
No description has been provided for this image

Tutvu dokumentatsiooniga. DocString sisaldab infot selle kohta kuidas näiteks lisada andmepunktide markeeringuid, jne.

In [85]:
#plt.plot?
In [86]:
#help(plt.plot)

Lisame eespool loodud graafikutele andmepunktide markerid:

In [87]:
x = np.linspace(0.0, 2.0, 100)

y = 1 + np.sin(3 * np.pi * x)
y2 = 1.2 + np.sin(4 * np.pi * x)

plt.plot(x, y, '^')  # Loe dokumentatsiooni.
plt.plot(x, y2, '-og')

plt.xlabel('x')
plt.ylabel('y')
plt.title('Pealkiri')

plt.show()
No description has been provided for this image

Argumendi telje ehk horisontaalse telje andmed pole kohustuslikud. Nende puudumisel kasutatakse massiivide või listide indekseid.

In [88]:
y = np.array([1, 2, 3, 4, 5, 4, 3, 2, 1])  # Saab ka tavalist Pythoni listi kasutada.

plt.plot(y, '-or')  # Argumeti x pole vaja, kasutab indekseid.

plt.xlabel('Indeks')
plt.ylabel('Andmed y')
plt.title('Pealkiri')

plt.show()
No description has been provided for this image

Mitme teljepaari lisamine¶

Matplotlib lubab luua mitme teljepaariga jooniseid.

Kaks teljepaari paigutatud veergu:

In [89]:
x = np.linspace(0, 2*np.pi, 300)
y = np.sin(x**2)

plt.subplot(2, 1, 1)  # 2 rida, 1 veerg, esimene teljepaar.
plt.plot(x, y, label='legend 1')
plt.legend(loc=1)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Graafiku pealkiri')

plt.subplot(2, 1, 2)  # 2 rida, 1 veerg, teine teljepaar.
plt.scatter(x, y, label='legend 2')  # Graafiku tüüp, saab asendada plt.plot'ga.
plt.legend(loc=3)
plt.xlabel('x') 

plt.suptitle('Joonise peakiri')
plt.savefig('test.pdf')  # Joonise salvestamine.

plt.show()
No description has been provided for this image

Neli teljepaari millest kasutame kolme:

In [90]:
x = np.linspace(0, 2*np.pi, 300)
y = np.sin(x**2)

plt.subplot(2, 2, 1)  # 2 rida, 2 veerg, esimene teljepaar.
plt.plot(x, y, label='legend 1')
plt.legend(loc=1)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Graafiku pealkiri')

plt.subplot(2, 2, 2)  # 2 rida, 2 veerg, teine teljepaar.
plt.scatter(x, y, label='legend 2')  # Graafiku tüüp, saab asendada plt.plot'ga.
plt.legend(loc=3)
plt.xlabel('x')

# Kolmandat teljepaari ei defineeri.

plt.subplot(2, 2, 4)  # 2 rida, 2 veerg, neljas teljepaar.
plt.plot(x, y, '.', label='legend 2')
plt.legend(loc=3)
plt.xlabel('x') 

plt.suptitle('Joonise peakiri')
plt.savefig('test.pdf')

plt.show()
No description has been provided for this image

Matplotlib ja IPythoni konsool (Arenduskeskkonnad Jupyter ja Spyder)¶

Joonistega saab töötada ja neid saab avada kolmel erineval viisil arenduskeskonnas Spyder ja kahel erineval viisil arenduskeskonnas Jupyter (JupyterLab).

Spyder:

  • Plots aknas (üla-paremas aknas), vali vastav sakk
  • IPythoni konsooli väljatrüki osana
  • Eraldi avanevas matplotlibi aknas (koos Matplotlib'i graafilise kasutajaliidesega)

Jupyter notebook või JupyterLab:

  • IPythoni konsooli väljatrüki osana ehk koodirakku (vaikimisi)
  • Eraldi matplotlibi aknas (koos Matplotlib'i graafilise kasutajaliidesega)

Olemasolevate võimaluste valimiseks kasutame arenduskeskonna graafilist menüüd või maagilisi konsooli käske. Konsooli sisseehitatud maagilised käsud (Built-in magic console commands, line magic commands) muudavad arenduskeskonna käitumist. Meile olulised maagilised käsud (Spyder IDE konsool ja Jupyter):

  • %matplotlib inline või matplotlib inline $-$ graafikud kujutatakse konsooli aknas
  • %matplotlib auto või matplotlib auto (Spyder võib vajada restarti) $-$ graafikud avatakse eraldi aknas koos graafilise kasutajaliidesega (andmete visuaalne analüüs ja manipulatsioon; zoom, pan, crop, jne.)

Loomulikult saab graafikute kuvamise viisi kontrollida ka läbi Spydery graafilise kasutajaliidese (vt. Preferences $\to$ IPython console).

Joonised 6, 7 ja 8 kujutavad kolme arenduskeskkonna Spyder jooniste kuvamise moodust.

No description has been provided for this image
Joonis 6. Maagiliste käskude %matplotlib inline või matplotlib inline esile kutsutud joonise kujutamine konsooli aknas.
No description has been provided for this image
Joonis 7. Maagiliste käskude %matplotlib auto või matplotlib auto esile kutsutud joonise kujutaimne eraldi aknas koos graafilise kasutajaliidesega.

Joonis 8 näitab kuidas saab joonised konsooli väljatrükist eemaldada.

No description has been provided for this image
Joonis 8. Graafikute kujutamine ainult arenduskeskkonna Spyder "Plots" aknas.

Kui sa soovid järgi vaadata kõiki maagilisi käske siis sisesta konsooli %lsmagic.

Lisa: NumPy 3D andmemassiiv ja pildifail¶

Kliki siia.

















☻   ☻   ☻