NumPy Arrays: o introducere [cu exemple]

Doriți să începeți cu NumPy? Acest ghid vă va învăța elementele de bază ale tablourilor NumPy în Python.

Ca prim pas, veți afla cum funcționează tablourile NumPy diferit de listele Python. Apoi veți învăța mai multe moduri de a crea matrice NumPy și de a efectua operațiuni de bază asupra acestora.

Sa incepem!

Bazele matricelor NumPy

NumPy este una dintre cele mai populare biblioteci Python pentru calculul științific și analiza datelor. Structurile de bază de date din NumPy sunt matrice N-dimensionale (matrice ND). Au capacități de difuzare și ne permit să vectorizăm operațiunile pentru viteză și să folosim funcții matematice încorporate pentru îmbunătățirea performanței.

Pentru a începe să lucrați cu NumPy, ar trebui mai întâi să instalați biblioteca și să o importați în mediul dvs. de lucru. Este disponibil ca pachet PyPI care poate fi instalat prin pip.

Pentru a instala NumPy, deschideți terminalul și rulați următoarea comandă:

 pip3 install numpy

După instalarea NumPy, îl puteți importa în mediul dvs. de lucru sub un alias. Aliasul obișnuit este np .

 import numpy as np

Notă : Importarea NumPy sub alias np nu este o cerință, ci o convenție recomandată.

Liste Python vs. tablouri NumPy

Luați în considerare următoarea listă de numere Python:

 py_list = [1,2,3,4]

Puteți obține o matrice NumPy dintr-o listă existentă apelând funcția np.array() cu lista ca argument.

 np_arr1 = np.array(py_list) print(np_arr1) [1 2 3 4]

Pentru a verifica tipul de np_arr1 , apelați funcția încorporată type() , veți vedea că este ndarray , structura de date fundamentală în NumPy.

 type(np_arr1) # numpy.ndarray

Deși lista Python și matricea NumPy pot arăta similare, există anumite diferențe:

• O listă Python poate conține obiecte de diferite tipuri de date, în timp ce o matrice NumPy conține elemente de același tip de date. Tipul implicit de date este float cu o precizie de 64 de biți (float64).
• Elementele unei liste Python nu sunt neapărat stocate în locații adiacente în memorie. Cu toate acestea, elementele unui tablou NumPy sunt stocate într-un bloc contiguu în memorie. Ca rezultat, este mai rapid să căutați și să accesați elemente.

Să trecem peste alte câteva diferențe.

Difuzare

O caracteristică puternică a matricelor NumPy este difuzarea. Să presupunem că am dori să adăugăm 2 la toate elementele lui np_arr1 și py_list .

Să încercăm să adăugăm 2 la py_list și să vedem ce se întâmplă:

 >>> py_list + 2

Vedem că obținem o TypeError care afirmă că putem concatena doar două liste, iar adăugarea py_list + 2 astfel nu este acceptată.

 --------------------------------------------------------------------------- TypeError Traceback (most recent call last) <ipython-input-5-c0f9974899df> in <module> ----> 1 py_list + 2 TypeError: can only concatenate list (not "int") to list

Să încercăm aceeași operațiune pe matrice, np_arr1 .

 >>> np_arr1 + 2

În rezultat, vedem că s-au adăugat 2 la fiecare element al matricei.

 array([3, 4, 5, 6])

Acest lucru se datorează faptului că NumPy a difuzat implicit scalarul 2 la o matrice de formă compatibilă pentru a obține acest rezultat.

Vectorizare

Matricele NumPy acceptă vectorizarea pentru operații mai rapide pe elemente. Să presupunem că am dori să găsim suma elementară a celor două tablouri.

Folosind o operațiune simplă + pe listă ar returna concatenarea celor două liste (ceea ce nu este ceea ce ne dorim!).

 >>> py_list + py_list # [1, 2, 3, 4, 1, 2, 3, 4]

Dar aceeași operație pe tabloul NumPy, np_arr1 , returnează suma în funcție de elemente a lui np_arr1 cu ea însăși.

 >>> np_arr1 + np_arr1 # array([2, 4, 6, 8])

În mod similar, listele imbricate pot arăta similare ca structură cu o matrice NumPy N-dimensională. Cu toate acestea, diferențele discutate până acum sunt valabile.

 nested_list = [[1,2],[3,4],[5,6]] np_arr2 = np.array(nested_list) print(np_arr2)

 [[1 2] [3 4] [5 6]]

Cum se creează matrice NumPy

Puteți crea oricând tablouri NumPy din listele Python existente folosind np.array(list-obj) . Cu toate acestea, acesta nu este cel mai eficient mod.

În schimb, puteți utiliza mai multe funcții încorporate care vă permit să creați matrice cu o anumită formă. Forma matricei este un tuplu care denotă dimensiunea matricei de-a lungul fiecărei dimensiuni. De exemplu, forma unui tablou 2×2 cu două rânduri și două coloane este (2,2). În această secțiune, vom învăța cum să folosim unele dintre aceste funcții încorporate.

Crearea de matrice de zerouri și unu

Este adesea util să creați o serie de dimensiuni specifice populate cu toate zerourile sau cu toate cele. Și apoi folosiți-le și modificați-le în pașii următori din program.

Putem folosi funcția zeros() pentru a crea o matrice de zerouri. Treceți în forma matricei necesare ca tuplu: np.zeros(shape) .

 array0 = np.zeros((3,3)) print(array0)

Iată rezultatul, o matrice 2D de zerouri:

 [[0. 0. 0.] [0. 0. 0.] [0. 0. 0.]]

Puteți accesa atributele matricei NumPy, apelați atribute precum dtype și shape , folosind notația cu puncte, așa cum se arată mai jos:

 print(array0.dtype) # float64 print(array0.shape) # (3, 3)

Pentru a obține o matrice de cele, puteți utiliza funcția np.ones() .

 array1 = np.ones((3,3)) print(array1)

 [[1. 1. 1.] [1. 1. 1.] [1. 1. 1.]]

Crearea unei matrice de identitate

Matricea de identitate este utilizată pe scară largă în mai multe aplicații în algebra liniară. Și puteți folosi funcția np.eye() pentru a crea o matrice de identitate. Funcția np.eye() un singur argument: ordinea matricei ( n ).

 arrayi = np.eye(3) print(arrayi)

 [[1. 0. 0.] [0. 1. 0.] [0. 0. 1.]]

Crearea de tablouri de numere aleatorii

De asemenea, puteți crea matrice cu o anumită formă populată cu numere aleatorii extrase din anumite distribuții. Distribuțiile de probabilitate utilizate în mod obișnuit sunt distribuția uniformă și distribuția normală standard.

Funcția randn() , care face parte din modulul random al NumPy, poate fi utilizată pentru a genera matrice de numere care sunt eșantionate dintr-o distribuție normală standard . Distribuția normală standard este o distribuție Gaussiană cu medie zero și varianță unitară.

 std_arr = np.random.randn(3,4) print(std_arr)

 [[-0.13604072 1.21884359 2.06850932 0.78212093] [ 0.44314719 -0.78084801 -0.70517138 1.17984949] [ 1.13214829 1.02339351 0.15317809 1.83191128]]

np.random.rand() returnează o matrice de eșantion de numere dintr-o distribuție uniformă pe intervalul [0,1).

 uniform_arr = np.random.rand(2,3) print(uniform_arr)

 [[0.90470384 0.18877441 0.10021817] [0.741 0.10657658 0.71334643]]

De asemenea, puteți crea o matrice de numere întregi aleatoare folosind funcția randint() care face parte din modulul aleator al NumPy. np.random.randint(low, high, size) returnează o matrice de numere întregi. Forma matricei este dedusă din argumentul size și numerele întregi iau valori în intervalul [low,high) .

Iată un exemplu:

 int_arr = np.random.randint(1,100,(2,3)) print(int_arr)

 [[53 89 33] [24 85 33]]

Alte funcții încorporate utile

În continuare, să trecem peste câteva alte funcții utile pentru a crea matrice NumPy.

Funcția arange() returnează o matrice de numere între o valoare de start și de stop în pași ai unei valori de step : start , start + step , start + 2*step up până la, dar fără a include stop . Valorile de start și de step sunt opționale . Dimensiunea implicită a pasului este 1, iar valoarea de pornire implicită este 0.

În acest exemplu, array_a este o matrice de numere care încep de la 1, mergând până la, dar fără a include 10, în pași de 0,5.

 array_a = np.arange(1,10,0.5) print(array_a)

 [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]

De asemenea, puteți crea matrice de numere spațiate uniform folosind np.linspace() . Utilizați np.linspace(start, stop, num) pentru a obține o matrice de num numere uniform distanțate între valorile start și stop .

Aici, arr_lin este o matrice de 5 numere uniform spațiate în intervalul [1,10].

 array_lin = np.linspace(1,10,5) print(array_lin)

 [ 1. 3.25 5.5 7.75 10. ]

În mod similar, arr_lin2 este o matrice de 10 numere uniform distanțate în intervalul [1,20].

 array_lin2 = np.linspace(1,20,10) print(array_lin2)

 [ 1. 3.11111111 5.22222222 7.33333333 9.44444444 11.55555556 13.66666667 15.77777778 17.88888889 20. ]

Spre deosebire de funcția arange() , funcția linspace() include punctul final în mod implicit.

Operații de bază pe tablourile NumPy

În continuare, să trecem peste câteva dintre operațiunile de bază pe tablourile NumPy.

Găsirea elementelor minime și maxime

Ori de câte ori folosim funcții din modulul aleator al NumPy pentru a crea matrice, vom obține un rezultat diferit de fiecare dată când codul este rulat. Pentru a obține rezultate reproductibile, ar trebui să setăm o sămânță: np.random.seed(seed_value) .

În exemplul următor, am setat sămânța pentru reproductibilitate, int_arr1 este o matrice de șapte numere întregi aleatoare în intervalul [1,100).

 np.random.seed(27) int_arr1 = np.random.randint(1,100,7) print(int_arr1) # [20 57 73 32 57 38 25]

• Pentru a găsi elementul maxim din matrice, puteți apela metoda max() pe obiectul matrice, int_arr1 și
• Pentru a găsi elementul minim din matrice, puteți apela metoda min() pe obiectul matrice, int_arr1 .

 int_arr1.max() # 73 int_arr1.min() # 20

Găsirea indicelui elementelor maxime și minime

Uneori, poate fi necesar să găsiți indicele elementelor maxime și minime. Pentru a face acest lucru, puteți apela metodele argmax() și argmin() de pe obiectul matrice.

Aici, elementul maxim 73 apare la indicele 2.

 int_arr1.argmax() # 2

Și elementul minim 20 apare la indicele 0.

 int_arr1.argmin() # 0

De asemenea, puteți utiliza np.argmax(array) și np.argmin(array) pentru a găsi indicii elementelor maxime și, respectiv, minime. Aflați mai multe despre funcția NumPy argmax() .

Cum să concatenați matricele NumPy

O altă operație comună pe care poate doriți să o faceți cu matricele NumPy este concatenarea.

Concatenare verticală folosind vstack

Puteți concatena matrice pe verticală folosind funcția vstack() .

Iată un exemplu. arr1 este o matrice de unități cu două rânduri și trei coloane și arr2 este o matrice de zerouri două rânduri și trei coloane.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Putem concatena aceste două matrice pe verticală folosind funcția vstack() așa cum se arată:

 np.vstack((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Pe măsură ce stivuirea are loc pe verticală, cele două matrice ar trebui să aibă același număr de coloane .

Să schimbăm arr2 să fie de formă (2,2). Acum are două rânduri și două coloane.

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,2)) np.vstack((arr1,arr2))

Prin urmare, concatenarea verticală nu este posibilă și obținem o valoare ValueError.

 --------------------------------------------------------------------------- ValueError Traceback (most recent call last) <ipython-input-21-d5d3bf37fc21> in <module> ----> 1 np.vstack((arr1,arr2)) ValueError: all the input array dimensions for the concatenation axis must match exactly, but along dimension 1, the array at index 0 has size 3 and the array at index 1 has size 2

Concatenare orizontală folosind hstack

Puteți concatena matrice NumPy pe orizontală folosind funcția hstack() , așa cum se arată mai jos.

 arr1 = np.ones((3,3)) arr2 = np.zeros((3,2))

 np.hstack((arr1,arr2))

Deoarece stivuirea are loc orizontal, matricele de intrare ar trebui să aibă același număr de rânduri . Aici, atât arr1 cât și arr2 au trei rânduri.

 array([[1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.], [1., 1., 1., 0., 0.]])

Folosind concatenate

De asemenea, puteți utiliza matrice NumPy concatenate de-a lungul unei axe specifice folosind funcția concatenate() . Setați argumentul opțional al axis la axa pe care doriți să o concatenați; valoarea implicită a axei este zero.

Iată câteva exemple:

 arr1 = np.ones((2,3)) arr2 = np.zeros((2,3))

Când nu specificăm axa de concatenat, matricele sunt concatenate de-a lungul axei 0. În matricea rezultată, a doua matrice arr2 este adăugată (sub formă de rânduri) sub primul tablou.

 np.concatenate((arr1,arr2))

 array([[1., 1., 1.], [1., 1., 1.], [0., 0., 0.], [0., 0., 0.]])

Când specificăm axis = 1 , obținem următorul rezultat. arr2 este concatenat (ca coloane) lângă prima matrice, arr1 .

 np.concatenate((arr1,arr2),axis=1)

 array([[1., 1., 1., 0., 0., 0.], [1., 1., 1., 0., 0., 0.]])

Ca și în cazul hstack() și vstack() , dimensiunile matricelor de-a lungul axei de concatenare ar trebui să se potrivească .

Concluzie

În acest tutorial, ați învățat diferențele dintre tablourile NumPy și listele Python, cu accent pe avantajele matricelor N-dimensionale în ceea ce privește viteza și eficiența.

De asemenea, ați învățat câteva funcții utile pentru a crea matrice de o anumită dimensiune și pentru a efectua operații comune, cum ar fi găsirea elementelor minime și maxime, concatenarea matricelor și multe altele.

Apoi, aflați cum să remodelați matricele NumPy.