Curs 9

NumPy
 Pachete & Python

IPython shell i consola extins a fost iniial un instrument proiectat

pentru oameni de tiin de ctre oamenii de tiin.

IPython ofer o modalitate convenabil de a face calcule tiinifice

interactiv cu Python.

IPython nu ofer caracteristici tiinifice de calcul per se, ci o

interfa interactiv pentru biblioteci externe puternice, cum ar fi
NumPy, SciPy, Pandas, Matplotlib, i altele asemenea.

mpreun, aceste instrumente ofer un cadru pentru calculul tiinific

ce poate concura cu instrumentele comerciale folosite pe scar larg n
comunitatea din domeniul tiinific - Matlab sau Mathematica.
 Pachete & Python

NumPy ofer calcul optimizat al structurilor de date n-dimensionale

SciPy ofer o larg varietate de algoritmi tiinifici (de prelucrare a

semnalului, optimizare, imagistic, etc), care se bazeaz pe NumPy.

Panda ofer structuri de date pentru date sub form de tabele care provin
din seturi de date reale.

Matplotlib permite desenarea figurilor grafice, astfel nct s se

vizualizeze interactiv orice form de date i posibilitatea de a face figuri
de calitate pentru articolele tiinifice.
 NumPy- Numeric Python

NumPy este baza pentru majoritatea calculelor numerice din Python.

NumPy este pachetul de calcul optimizat al structurilor de date n-

dimensionale

NumPy prevede instrumente pentru integrarea propriului cod cu cod C ,

C ++ i Fortran.

NumPy algebr liniar /transformata Fourier/numere random

Obiectul de baz din NumPy este matricea omogen n-dimensional

 Import NumPy
Pachetele trebuiesc instalate i apoi importate n scripturi/fiiere sau
folosite interactiv n IPython:

In[]: import numpy sau aa In[]: from numpy import *

# folosesc asa:
x= numpy.array([1,2,3]) #array este o funcie din pachetul numpy

In[]: import numpy as np #pot s redenumesc un pachet:

# folosesc asa:
x=np.array([1,2,3])

In[]: from numpy import array #import doar o funcie dintr-un pachet
# folosesc doar asa:
x=array([1,2,3])

In[]: %pylab #NumPy i Matplotlib sunt ncrcate cu namespace-ul

np pentru numpy i plt pentru matplotlib.pyplot
 NumPy - array

array =bloc de date organizat n mai multe dimensiuni

array un alt tip de date adugat n Python de NumPy,

clasa acestui obiect este ndarray alias array.

array folosit pentru a reprezenta vectori, matrici, alte structuri n-dim

array au dimensiune fix dat la construirea lor

Elementele arrays sunt toate de acelasi tip de date ( scriem cod mai
simplu i mai eficient) stocate ntr-un boc continnuu de memorie

Dimensiunile unui numpy array se numesc axe, iar numrul de axe rank

np.array([ 1, 2, 3]) # array rank 1 (are o singur ax de lungime 3)

 Atributele obiectului ndarray
ndarray.ndim
numrul de axe (dimensiuni) a unui array = rank
ndarray.shape
dimensiunile unui array acesta este o tupl indicnd lungimea n
fiecare dimensiune. Ptr o matrice cu n linii i m coloane, atributul shape
va fi (n,m).
ndarray.size
numrul total de elemente, este egal cu produsul elementelor din shape.
ndarray.dtype
un obiect ce descrie tipul de elemente din array.
ndarray.data
un buffer ce conine toate elementele din array. Nu folosim acest
atribut, deoarece elementele din array se vor accesa prin indexare
ndarray.itemsize :dimensiunea n bytes a fiecrui element (4 int32,
8 float64)

In[]:help(np.array) # accesez help-ul

In[]: np.lookfor(cuvantcheie) # accesez help-ul
 Atributele obiectului ndarray

In[]: %pylab

In[]: poz=rand(10000000, 2)

In[]: type(poz)
numpy.ndarray

In[]: poz.dtype
dtype('float64')

In[]: poz.ndim, poz.shape

2 , (10000000, 2)

In[]: poz.itemsize
8 # float64
 Cum crem un array

Sunt mai multe moduri n care putem crea un numpy array:

- pe baza listelor sau tuplelor

- folosind funcii dedicate ( arange, linspace, zeros, ones etc.)

- citim date din fiiere

 Crem un array cu liste
Folosim liste ca argumente n funcia array() :
In[]: from numpy import *
In[]: v = array([1,2,3,4,5]) sau v = array([1, 2, 3, 4, 6], dtype=int32)
In[]: v
array([1,2,3,4,5])

In[]: M = array([ [1, 2], [3, 4] ]) - list n list

In[]: M
array([[1, 2], # default NumPy afieaz ordinarea pe linii (C-order)
[3, 4]])

v i M sunt obiecte de tipul ndarray.

In[]: type(v) , type(M) # numpy.ndarray
In[]: M.shape ?
In[]: v.shape ?

Pentru a crea n-dim array, trebuie s scriem liste n liste de liste cu n

nivele de recursivitate.
 numpy.ndarray

numpy.ndarray arat foarte asemnator cu o list (sau lista imbricat).

De ce s nu utilizm pur i simplu liste pentru calcule n loc s crem un

nou tip de date - array?

Listele sunt foarte generale, pot conine orice fel de obiecte, sunt scrise
n mod dinamic. Listele nu ofer suport pentru funcii matematice.

numpy array sunt omogene i statice (tipul elementelor este determinat

atunci cnd sunt create). Sunt eficiente din pct de vedere al memoriei i
suport aplicarea rapid a funciilor matematice
 Crem un array cu liste

Putem defini explicit tipul unui array cnd l crem folosind atributul
dtype ca argument:

In []: M = array([[1, 2], [3, 4]], dtype=complex)

In []: M
array([[ 1.+0.j, 2.+0.j],
[ 3.+0.j, 4.+0.j]])

Tipurile de date ce pot fi folosite : int, float, complex, bool, string, object

Putem defini explicit dimensiunea pe biti a tipurilor de date:

int64, int16, float128, complex128.
 Cum crem un array cu funcii
Pentru date de dimensiuni mari, nu este practic s le iniializm manual,
folosind liste.

Putem folosi diverse funcii: arange, linspace, rand, randn, zeros,

zeros_like, ones, ones_like, empty, empty_like, fromfunction, fromfile

In[]: x = arange(0, 10, 1) # argumente: start, stop, step in [start, stop)

In[]: linspace(0, 10, 25) # genereaz 25 de valori in [start, stop]

In[]: random.rand(5,5) # genereaz o matrice de 5 linii i 5 coloane

de numere random distribuite uniform n [0,1]

In[]: random.randn(5,5) # genereaz o matrice de 5 linii i 5 coloane

de numere random -distribuite Gaussian n [0,1]
 Cum crem un array cu funcii
In[]: zv=zeros(5) # am creat vectorul de 5 elemente 0
In[]: zv
Array ([0., 0., 0., 0., 0.]) # default nr in virgul mobil - float

In[]: zm= zeros ( (3,3) ) # trebuie s scriem tupla ( lin,col)

In[]: zm # am creat matricea cu 3 linii si 3 coloane de 0
array([[ 0., 0., 0.],
[ 0., 0., 0.],
[ 0., 0., 0.]])

Funciile ones() i eye() - creaz matricea de 1 i matricea Identitate

In[]: diag([1,2,3]) sau # matricea cu diagonala principal [1,2,3]

In[] :diag([1,2, 3] , k=1) #offset faa de diagonala principal dat de k
array ([[0, 1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3],
[0, 0, 0, 0]])
 Cum crem un array din fiiere
De obicei fiierele de date sunt n unul din aceste formate (CSV) comma-
separated values sau (TSV) tab-separated values

# comanda head afieaza primele 10 linii dintr-un fisier

In[]: !head stkdate.dat
1800 1 1 -6.1 -6.1 -6.1 1
1800 1 2 -15.4 -15.4 -15.4 1
1800 1 3 -15.0 -15.0 -15.0 1
1800 1 4 -19.3 -19.3 -19.3 1

Formatul datelor: an,luna,zi, temp_med/zi, minima, maxima, locaia.

Funciile genfromtxt(), loadtxt() i fromfile() permit ncrcarea datelor

din fiiere text sau fiiere binare i s le converteasc NumPy array.

In[]: dd=genfromtxt('stkdate.dat')
In[]: dd.shape
(643, 7) # 643 de linii si 7 coloane
 Cum crem un array din fiiere
In[]: d=loadtxt('stkdate.dat')
In[]: d
array([[ 1.80000000e+03, 1.00000000e+00, 1.00000000e+00,
-6.10000000e+00, -6.10000000e+00, -6.10000000e+00,
1.00000000e+00],
[ 1.80000000e+03, 1.00000000e+00, 2.00000000e+00,
-1.54000000e+01, -1.54000000e+01, -1.54000000e+01,
1.00000000e+00],
[ 1.80000000e+03, 1.00000000e+00, 1.00000000e+01,
-9.50000000e+00, -9.50000000e+00, -9.50000000e+00,
1.00000000e+00]])

Similar, funcia fromstring() permite fie text ASCII cu valori separate

de orice delimitator fie date binare de orice tip:

In []:x = fromstring('1 2 5 10', dtype=int, sep=' ')

In[]: x
array([ 1, 2, 5, 10])
 Salvm un array n fiier
Pentru salvarea arrays (datelor) n fiiere avem funciile save() pentru
formatul binar i savetxt() pentru formatul text
In[]: M = rand(3,3)
In[]: M
array([[ 0.77872576, 0.40043577, 0.66254019],
[ 0.60410063, 0.4791374 , 0.8237106 ],
[ 0.96856318, 0.15459644, 0.96082399]])
In[]: savetxt("mtx.csv", M)
In[]:!cat mtx.csv # comanda cat afiseaz coninutul fiierului mtx.csv
7.787257639287014088e-01 4.004357670697732408e-01 6.625401863466899854e-01
6.041006328761111543e-01 4.791373994963619154e-01 8.237105968088237473e-01
9.685631757740569281e-01 1.545964379103705877e-01 9.608239852111523094e-01

In[]: savetxt("mtx.csv", M, fmt='%.5f') # fmt specific formatul

In[]: !cat mtx.csv
0.77873 0.40044 0.66254
0.60410 0.47914 0.82371
0.96856 0.15460 0.96082
 Manipularea arrays
Indexarea, Slicing i Iterarea- permit selecia unei poriuni din array

1D array indexarea, slicing si iterarea exact ca n listele Python

Indexarea ncepe de la 0.

In[]: a = arange(10)**3
In[]: a
array([ 0, 1, 8, 27, 64, 125, 216, 343, 512, 729])
In[]: a[0], a[2], a[-1] # primul, al treilea si ultimul element
(0, 8, 729)
In[]: a[2:5] # a[start: stop: step] echivalent cu a[start, stop) default step 1
array([ 8, 27, 64])
In[]: a[:6:2] = -1000 # echivalent cu a[0:6:2] = -1000
In[]: a
array([-1000, 1, -1000, 27, -1000, 125, 216, 343, 512, 729])
In[]: a[ : :-1] # n ordine invers a
array([ 729, 512, 343, 216, 125, -1000, 27, -1000, 1, -1000])
 Manipularea arrays
Multidimensional arrays 2D, 3D... pot avea un index pe axa. Indexii sunt
tuple de ntregi

Dac indexii sunt mai putini ca nr axelor se ntoarce array de dimensiune N-1

In[]: x=diag(arange(3))
x
array([[0, 0, 0],
[0, 1, 0],
[0, 0, 2]])
In[]: x[1,1] # linia 1, coloana 1

In[]: x[1] # ntoarce ntreaga linie

array([0, 1, 0])
In[]: x[-1] # ntoarce ultima linie

In[] : x[1, :] # ntoarce prima linie array([0, 1, 0])

In[]: x[:, 1] # ntoarce prima coloan array([0, 1, 0])

 Manipularea arrays
Pentru n-dim arrays: expresia x[i] este tratat ca i urmat de attea instane : necesare s
reprezinte axele. NumPy permite i notaia cu puncte aa x[i,...].
Punctele (...) reprezint nr de coloane necesare pentru a indexa tuple.
De examplu, dac x este de rank 5 (i.e., avem 5 axe):

x[1,2, . . .] este echivalent cu x[1, 2, : ,: ,:]

x[. . . ,3] este echivalent cu x[: ,: ,: ,: , 3]
x[4, . . . , 5, :] este echivalent cu x[4, : , : , 5, : ].

In[]: m = np.array( [[[ 0, 1, 2], # 3D array (stacked 2 arrays 2D)

... [ 10, 12, 13]],
... [[100,101,102],
... [110,112,113]]])
In[]: m.shape
(2, 2, 3)
In[]: m[1,...] # echivalent cu m[1, : , :] sau m[1]
array([[100, 101, 102],
[110, 112, 113]])
In[]: m[ , 2] # echivalent cu m[: , : , 2]
array([[ 2, 13],
[102, 113]])
 Indexare boolean

Mask index: este un Numpy array de data tip boolean.

Elementul este selectat (True) sau nu (False) depinznd de valoarea indexului

din mask de la poziia fiecrui element:

In []: B = array([n for n in range(5)])

In[]:B
Array([0, 1, 2, 3, 4])

In []: msk = array([True, False, True, False, False])

B[msk]
array([0, 2])

In []: ms = array([1,0,1,0,0], dtype=bool) # obtin acelai lucru

B[ms]
array([0, 2])
 Indexare boolean
Aceast caracteristic este util cnd folosim operatori de compara ie pentru a
selecta elementele dintr-un array,:
In []: x = arange(0, 10, 0.5)
In[]: x
array([ 0. , 0.5, 1. , 1.5, 2. , 2.5, 3. , 3.5, 4. , 4.5, 5. , 5.5, 6. , 6.5, 7. ,
7.5, 8. , 8.5, 9. , 9.5])
In []: masca = (5 < x) * (x < 7.5)
In[]:masca
array([False, False, False, False, False, False, False, False, False,
False, False, True, True, True, True, False, False, False,
False, False], dtype=bool)
In []: x[masca]
array([ 5.5, 6. , 6.5, 7. ])

Masca de indexi poate fi convertita la poziia indexilor cu functia where():

In []: indici = where(masca)
In[] : indici
(array([11, 12, 13, 14]), )
In []: x[indici] # aceast indexare este echivalenta cu x[masca]
array([ 5.5, 6. , 6.5, 7. ])
 Funcii de Indexare
Functia take() este similar cu metoda de indexarea:
In []: v = arange(-3,3)
In[]:v
array([-3, -2, -1, 0, 1, 2])
In []: ind = [1, 3, 5]
v[ind] # exemplul anterior de indexare
array([-2, 0, 2])

In []: v.take(ind)
Array([-2, 0, 2])

In []: take([-3, -2, -1, 0, 1, 2], ind) # fct take() aplicat pe liste i alte obiecte
Array([-2, 0, 2])

Functia choose() construieste un array, alegnd elemente din alte arrays:

In []: care = [1, 0, 1, 0]

In[]: deunde = [[-2,-2,-2,-2], [5,5,5,5]]
In[]:choose(care, deunde)
array([ 5, -2, 5, -2])
 Reshape, resize, stacking array
Formatul unui Numpy array se poate modifica fr s copiem structura datelor
shape numrul de elemente pe fiecare ax:

In[]: b = arange(12).reshape(4,3) # 2D array

In[]: b
array([[ 0 1 2],
[ 3 4 5],
[ 6 7 8],
[ 9 10 11]])
In[]: z=b.reshape(1,12) # acelasi efect cu funcia ravel()
array([[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]])
In[]: c = arange(24).reshape(2,3,4) # 3D array
In[]: c
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]]])
 Reshape, resize, stacking array

Functiile repeat(), tile(), concatenate(), vstack()

In[]:a = array([[1, 2], [3, 4]])

In[]:b = array([[5, 6]])
In[]: repeat(a, 3) # repet fiecare element de 3 ori
array([1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4])
In[]: tile(a, 3)
array([[1, 2, 1, 2, 1, 2],
[3, 4, 3, 4, 3, 4]])
In[]: concatenate((a, b), axis=0) similar cu vstack((a,b))
array([[1, 2],
[3, 4],
[5, 6]])
In[]: concatenate((a, b.T), axis=1) similar cu hstack((a,b.T))
array([[1, 2, 5],
[3, 4, 6]])
 Algebra Liniar
Operaii aritmetice scalar-array:multiplicare, adunare, scadere, mpr irea
comportamentul default este element cu element:
In[]:v = arange(0, 5)
In[]:v * 2 , v + 2
array([0, 2, 4, 6, 8]), array([2, 3, 4, 5, 6])
In[]: v * v # sau aa v**2 , element cu element
array([ 0, 1, 4, 9, 16])
In[]: A= array([[ 0, 1, 2, 3, 4],
[10, 11, 12, 13, 14],
[20, 21, 22, 23, 24],
[30, 31, 32, 33, 34],
[40, 41, 42, 43, 44]])
In[]: A +2, A*2
In[]: A*A # element cu element
In[]: A*v # multiplicare element cu element fiecare linie
array([[ 0, 1, 4, 9, 16],
[ 0, 11, 24, 39, 56],
[ 0, 21, 44, 69, 96],
[ 0, 31, 64, 99, 136],
[ 0, 41, 84, 129, 176]])
 Algebra Liniar
Functia dot( x,y) multiplica cele 2 argumente: matrice -matrice, matrice-vector
In[]:dot(A, A)
array([[ 300, 310, 320, 330, 340],
[1300, 1360, 1420, 1480, 1540],
[2300, 2410, 2520, 2630, 2740],
[3300, 3460, 3620, 3780, 3940],
[4300, 4510, 4720, 4930, 5140]])
In []: dot(A, v) #array([ 30, 130, 230, 330, 430])
In[]: dot(v, v) # 30
Facem cast obiectului array la tipul matrice sa putem folosi operatorii
aritmetici standard +, - , * pe matrici.
In[]: M = matrix(A)
In[]:vv = matrix(v).T # fac vectorul coloan
vv
matrix([[0],
[1],
[2],
[3],
[4]])
 Algebra Liniar
Functia dot( x,y) multiplica cele 2 argumente: matrice -matrice, matrice-vector
In[]:dot(A, A)
array([[ 300, 310, 320, 330, 340],
[1300, 1360, 1420, 1480, 1540],
[2300, 2410, 2520, 2630, 2740],
[3300, 3460, 3620, 3780, 3940],
[4300, 4510, 4720, 4930, 5140]])
In []: dot(A, v) #array([ 30, 130, 230, 330, 430])
In[]: dot(v, v) # 30
Facem cast obiectului array la tipul matrice sa putem folosi operatorii
aritmetici standard +, - , * : M*M, M*c, c.T*c, c+M*c, inv(a), det(A)
In[]: M = matrix(A)
In[]:c = matrix(v).T # fac vectorul coloan folosind transpusa
c
matrix([[0],
[1],
[2],
[3],
[4]])
 Procesm date

Formatul datelor: an,luna,zi, temp_med/zi, minima, maxima, locaia.

In[]: !head stkdate.dat
1800 1 1 -6.1 -6.1 -6.1 1
1800 1 2 -15.4 -15.4 -15.4 1
1800 1 3 -15.0 -15.0 -15.0 1
1800 1 4 -19.3 -19.3 -19.3 1

In[]: data=genfromtxt('stkdate.dat')
In[]: data.shape
(643, 7) # 643 de linii si 7 coloane
In[]: mean(data[:,3]) # calculez temp medie in ultimii ani
In[]: std(data[:,3]), var(data[:,3]) # deviatia standard si varianta
In[]: data[:,3].min() , data[:,3].max() # valoarea min si max
 Bibliografie

http://www.numpy.org/