NumPy Tutorial: Analiză de date cu Python

Nu ratați foaia noastră GRATUITĂ cu NumPy din partea de jos a acestei postări

NumPy este un pachet de analiză de date Python utilizat în mod obișnuit. Utilizând NumPy, vă puteți accelera fluxul de lucru și vă puteți interfața cu alte pachete din ecosistemul Python, cum ar fi scikit-learn, care utilizează NumPy sub capotă. NumPy a fost dezvoltat inițial la mijlocul anilor 2000 și a luat naștere dintr-un pachet și mai vechi numit Numeric. Această longevitate înseamnă că aproape fiecare pachet de analiză a datelor sau de învățare automată pentru Python utilizează NumPy într-un fel sau altul.

În acest tutorial, vom trece prin utilizarea NumPy pentru a analiza datele privind calitatea vinului. Datele conțin informații despre diverse atribute ale vinurilor, cum ar fi pH și fixed acidity, împreună cu un scor de calitate între 0 și 10 pentru fiecare vin. Scorul de calitate este media a cel puțin 3 degustători umani. Pe măsură ce învățăm cum să lucrăm cu NumPy, vom încerca să aflăm mai multe despre calitatea percepută a vinului.

Vinurile pe care le vom analiza sunt din regiunea Minho din Portugalia.

Datele au fost descărcate din UCI Machine Learning Repository și sunt disponibile aici. Iată primele câteva rânduri din fișierul winequality-red.csv, pe care îl vom folosi pe parcursul acestui tutorial:

"fixed acidity";"volatile acidity";"citric acid";"residual sugar";"chlorides";"free sulfur dioxide";"total sulfur dioxide";"density";"pH";"sulphates";"alcohol";"quality"7.4;0.7;0;1.9;0.076;11;34;0.9978;3.51;0.56;9.4;57.8;0.88;0;2.6;0.098;25;67;0.9968;3.2;0.68;9.8;5

Datele sunt în ceea ce voi numi formatul ssv (semicolon separated values) – fiecare înregistrare este separată de un punct și virgulă (;), iar rândurile sunt separate de o nouă linie. Există 1600 rânduri în fișier, inclusiv un rând de antet, și 12 coloane.

Înainte de a începe, o scurtă notă despre versiune – vom folosi Python 3.5. Exemplele noastre de cod vor fi realizate folosind caietul Jupyter.

Liste de liste pentru date CSV

Înainte de a folosi NumPy, vom încerca mai întâi să lucrăm cu datele folosind Python și pachetul csv. Putem citi fișierul folosind obiectul csv.reader, care ne va permite să citim și să împărțim tot conținutul din fișierul ssv.

În codul de mai jos, noi:

• Importăm biblioteca csv.
• Deschidem fișierul winequality-red.csv.
  • Cu fișierul deschis, creăm un nou obiect csv.reader.
    • Pasați argumentul cuvânt cheie delimiter=";" pentru a vă asigura că înregistrările sunt împărțite pe caracterul punct și virgulă în loc de caracterul implicit virgulă.
  • Apelează tipul de listă pentru a obține toate rândurile din fișier.
  • Asemnați rezultatul la wines.

import csvwith open('winequality-red.csv', 'r') as f: wines = list(csv.reader(f, delimiter=';'))

După ce am citit datele, putem tipări primele 3 rânduri:

print(wines)

, , ]

Datele au fost citite într-o listă de liste. Fiecare listă interioară este un rând din fișierul ssv. După cum probabil ați observat, fiecare element din întreaga listă de liste este reprezentat ca un șir de caractere, ceea ce va îngreuna efectuarea calculelor.

Vom formata datele într-un tabel pentru a le face mai ușor de vizualizat:

După cum puteți vedea în tabelul de mai sus, am citit trei rânduri, dintre care primul conține titluri de coloană. Fiecare rând de după rândul de antet reprezintă un vin. Primul element al fiecărui rând este fixed acidity, al doilea este volatile acidity, și așa mai departe. Putem afla media quality a vinurilor. Codul de mai jos va:

• Extrage ultimul element din fiecare rând după rândul de antet.
• Convertește fiecare element extras într-un float.
• Asemnează toate elementele extrase în lista qualities.
• Divizați suma tuturor elementelor din qualities la numărul total de elemente din qualities pentru a obține media.

qualities =) for item in wines]sum(qualities) / len(qualities)

5.6360225140712945

Deși am reușit să facem calculul dorit, codul este destul de complex și nu va fi amuzant să trebuiască să facem ceva similar de fiecare dată când vrem să calculăm o cantitate. Din fericire, putem folosi NumPy pentru a ușura lucrul cu datele noastre.

Numpy 2-Dimensional Arrays

Cu NumPy, lucrăm cu array-uri multidimensionale. Ne vom scufunda în toate tipurile posibile de matrici multidimensionale mai târziu, dar deocamdată ne vom concentra asupra matricelor bidimensionale. O matrice bidimensională este, de asemenea, cunoscută sub numele de matrice și este ceva cu care ar trebui să fiți familiarizați. De fapt, este doar un mod diferit de a ne gândi la o listă de liste. O matrice are rânduri și coloane. Prin specificarea unui număr de rânduri și a unui număr de coloane, putem extrage un element dintr-o matrice.

În matricea de mai jos, primul rând este rândul de antet, iar prima coloană este coloana fixed acidity:

Dacă am alege elementul de la primul rând și a doua coloană, am obține volatile acidity. Dacă am alege elementul de la al treilea rând și a doua coloană, am obține 0.88.

Într-un array NumPy, numărul de dimensiuni se numește rang, iar fiecare dimensiune se numește axă. Deci rândurile sunt prima axă, iar coloanele sunt a doua axă.

Acum că ați înțeles elementele de bază ale matricelor, să vedem cum putem trece de la lista noastră de liste la un array NumPy.

Crearea unui array NumPy

Potem crea un array NumPy folosind funcția numpy.array. Dacă trecem o listă de liste, aceasta va crea automat un array NumPy cu același număr de rânduri și coloane. Deoarece dorim ca toate elementele din array să fie elemente float pentru a facilita calculul, vom omite rândul de antet, care conține șiruri de caractere. Una dintre limitările NumPy este că toate elementele dintr-un array trebuie să fie de același tip, așa că, dacă includem rândul de antet, toate elementele din array vor fi citite ca șiruri de caractere. Pentru că dorim să putem face calcule precum aflarea mediei quality vinurilor, avem nevoie ca toate elementele să fie float.

În codul de mai jos, noi:

• Importăm pachetul numpy.
• Pasăm lista de liste wines în funcția array, care o convertește într-un array NumPy.
  • Excludeți rândul de antet cu ajutorul list slicing.
  • Specificați argumentul cuvânt cheie dtype pentru a vă asigura că fiecare element este convertit într-un float. Ne vom scufunda mai mult în ceea ce este dtype mai târziu.

import csvwith open("winequality-red.csv", 'r') as f: wines = list(csv.reader(f, delimiter=";"))import numpy as npwines = np.array(wines, dtype=np.float)

Încercați să executați codul de mai sus și să vedeți ce se întâmplă!

Dacă afișăm wines, vom obține acum un array NumPy:

wines

array(,,,...,,,])

Puteți verifica numărul de rânduri și coloane din datele noastre folosind proprietatea shape a array-urilor NumPy:

wines.shape

(1599, 12)

Metode alternative de creare a array-urilor NumPy

Există o varietate de metode pe care le puteți folosi pentru a crea array-uri NumPy. Pentru început, puteți crea un array în care fiecare element este zero. Codul de mai jos va crea un array cu 3 rânduri și 4 coloane, în care fiecare element este 0, folosind numpy.zeros:

import numpy as np

empty_array = np.zeros((3,4)) empty_array

Este util să creați un array cu toate elementele zero în cazurile în care aveți nevoie de un array de dimensiune fixă, dar nu aveți încă valori pentru el.

De asemenea, puteți crea un array în care fiecare element este un număr aleatoriu folosind numpy.random.rand. Iată un exemplu:

np.random.rand(3,4)

array(,,])

Crearea de array-uri pline de numere aleatoare poate fi utilă atunci când doriți să vă testați rapid codul cu array-uri de probă.

Utilizarea NumPy pentru a citi în fișiere

Este posibil să folosiți NumPy pentru a citi direct csv sau alte fișiere în array-uri. Putem face acest lucru folosind funcția numpy.genfromtxt. O putem folosi pentru a citi în datele noastre inițiale despre vinurile roșii.

În codul de mai jos, noi:

• Utilizăm funcția genfromtxt pentru a citi în fișierul winequality-red.csv.
• Specificați argumentul cuvânt cheie delimiter=";" astfel încât câmpurile să fie analizate corect.
• Specificați cuvântul cheie argument skip_header=1 astfel încât rândul de antet să fie sărit.

wines = np.genfromtxt("winequality-red.csv", delimiter=";", skip_header=1)

wines va sfârși prin a arăta la fel ca și cum l-am citi într-o listă și apoi l-am converti într-o matrice de numere flotante. NumPy va alege automat un tip de date pentru elementele dintr-un array pe baza formatului lor.

Indexarea array-urilor NumPy

Știm acum cum să creăm array-uri, dar dacă nu putem prelua rezultate din ele, nu putem face prea multe cu NumPy. Putem folosi indexarea array-urilor pentru a selecta elemente individuale, grupuri de elemente sau rânduri și coloane întregi. Un lucru important de reținut este că, la fel ca și listele Python, NumPy este indexat cu zero, ceea ce înseamnă că indexul primului rând este 0, iar indexul primei coloane este 0. Dacă vrem să lucrăm cu al patrulea rând, vom folosi indicele 3, dacă vrem să lucrăm cu al doilea rând, vom folosi indicele 1, și așa mai departe. Vom lucra din nou cu matricea wines:

Să selectăm elementul de la rândul 3 și coloana 4. În codul de mai jos, trecem indexul 2 ca index de rând și indexul 3 ca index de coloană. Astfel se recuperează valoarea din a patra coloană a celui de-al treilea rând:

wines

wines

2.2999999999999998

Din moment ce lucrăm cu o matrice bidimensională în NumPy, specificăm 2 indici pentru a prelua un element. Primul index este indexul rândului, sau al axei 1, iar al doilea index este indexul coloanei, sau al axei 2. Orice element din wines poate fi recuperat folosind indicii 2.

Slicing NumPy Arrays

Dacă în schimb dorim să selectăm primele trei elemente din a patra coloană, o putem face folosind două puncte (:). Două puncte indică faptul că dorim să selectăm toate elementele de la indicele de început până la indicele final, dar fără a-l include. Acest lucru este cunoscut și sub numele de feliere:

wines

array()

Ca și în cazul felierii unei liste, este posibil să omitem 0 pentru a prelua doar toate elementele de la început până la elementul 3:

wines

array()

Potem selecta o întreagă coloană specificând că dorim toate elementele, de la primul până la ultimul. Specificăm acest lucru folosind doar două puncte (:), fără indici de început sau de sfârșit. Codul de mai jos va selecta întreaga a patra coloană:

wines

array()

Am selectat o coloană întreagă mai sus, dar putem extrage și un rând întreg:

wines

array()

Dacă ducem indexarea noastră la extrem, putem selecta întreaga matrice folosind două puncte de suspensie pentru a selecta toate rândurile și coloanele din wines. Acesta este un truc de petrecere grozav, dar nu are o mulțime de aplicații bune:

wines

array(,,<br />,<br />...,,,<br />])

Asignarea de valori în array-urile NumPy

De asemenea, putem folosi indexarea pentru a atribui valori anumitor elemente din array-uri. Putem face acest lucru prin atribuirea directă la valoarea indexată:

wines = 10

Potem face același lucru pentru felii. Pentru a suprascrie o întreagă coloană, putem face acest lucru:

wines = 50

Codul de mai sus suprascrie toate valorile din a unsprezecea coloană cu 50.

Rețele NumPy unidimensionale

Până acum, am lucrat cu rețele bidimensionale, cum ar fi wines. Cu toate acestea, NumPy este un pachet pentru lucrul cu array-uri multidimensionale. Unul dintre cele mai comune tipuri de array-uri multidimensionale este array-ul 1-dimensional, sau vectorul. După cum probabil ați observat mai sus, atunci când am feliat wines, am recuperat o matrice 1-dimensională. O matrice 1-dimensională are nevoie doar de un singur index pentru a prelua un element. Fiecare rând și fiecare coloană dintr-o matrice bidimensională este o matrice unidimensională. La fel cum o listă de liste este analogă cu o matrice bidimensională, o singură listă este analogă cu o matrice unidimensională. Dacă feliem vinurile și recuperăm doar al treilea rând, obținem un array 1-dimensional:

third_wine = wines

Iată cum arată third_wine:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

Potem recupera elemente individuale din third_wine folosind un singur index. Codul de mai jos va afișa al doilea element din third_wine:

third_wine

0.28000000000000003

Majoritatea funcțiilor NumPy cu care am lucrat, cum ar fi numpy.random.rand, pot fi utilizate cu array-uri multidimensionale. Iată cum am folosi numpy.random.rand pentru a genera un vector aleator:

np.random.rand(3)

array()

Anterior, când am apelat np.random.rand, am trecut o formă pentru o matrice bidimensională, astfel încât rezultatul a fost o matrice bidimensională. De data aceasta, am trecut o formă pentru o matrice unidimensională. Forma specifică numărul de dimensiuni și mărimea tabloului în fiecare dimensiune. O formă de (10,10) va fi o matrice bidimensională cu 10 rânduri și 10 coloane. O formă de (10,) va fi un array unidimensional cu 10 elemente.

Unul în care NumPy devine mai complex este atunci când începem să avem de-a face cu array-uri care au mai mult de 2 dimensiuni.

N-Dimensional NumPy Arrays

Acest lucru nu se întâmplă extrem de des, dar există cazuri în care veți dori să aveți de-a face cu array-uri care au mai mult de 3 dimensiuni. Un mod de a vă gândi la aceasta este ca la o listă de liste de liste. Să spunem că dorim să stocăm câștigurile lunare ale unui magazin, dar vrem să putem consulta rapid rezultatele pentru un trimestru și pentru un an. Câștigurile pentru un an ar putea arăta astfel:

Magazinul a câștigat 0 în ianuarie, 5 în februarie, și așa mai departe. Putem împărți aceste câștiguri pe trimestru într-o listă de liste:

year_one = , , , ]

Potem prelua câștigurile din ianuarie prin apelarea year_one. Dacă dorim rezultatele pentru un întreg trimestru, putem apela year_one sau year_one. Acum avem o matrice sau un array bidimensional. Dar ce se întâmplă dacă acum dorim să adăugăm rezultatele din alt an? Trebuie să adăugăm o a treia dimensiune:

earnings = , , , ], , , , ]]

Potem prelua câștigurile din luna ianuarie a primului an prin apelarea earnings. Acum avem nevoie de trei indici pentru a prelua un singur element. O matrice tridimensională în NumPy este cam la fel. De fapt, putem converti earnings într-un array și apoi să obținem câștigurile pentru luna ianuarie a primului an:

earnings = np.array(earnings)earnings

500

De asemenea, putem afla forma array-ului:

earnings.shape

(2, 4, 3)

Indexarea și felierea funcționează exact în același mod cu un array tridimensional, dar acum avem o axă în plus de trecut. Dacă am dori să obținem câștigurile pentru luna ianuarie din toți anii, am putea face acest lucru:

earnings

array()

Dacă am dori să obținem câștigurile din primul trimestru din ambii ani, am putea face acest lucru:

earnings

array(,])

Adăugarea mai multor dimensiuni poate face mult mai ușoară interogarea datelor, dacă acestea sunt organizate într-un anumit mod. Pe măsură ce trecem de la array-uri tridimensionale la array-uri 4-dimensionale și mai mari, se aplică aceleași proprietăți, iar acestea pot fi indexate și feliate în aceleași moduri.

Tipurile de date NumPy

După cum am menționat mai devreme, fiecare array NumPy poate stoca elemente de un singur tip de date. De exemplu, wines conține numai valori float. NumPy stochează valori folosind propriile sale tipuri de date, care sunt distincte de tipurile Python, cum ar fi float și str. Acest lucru se datorează faptului că nucleul lui NumPy este scris într-un limbaj de programare numit C, care stochează datele în mod diferit față de tipurile de date Python. Tipurile de date NumPy se mapează între Python și C, permițându-ne să folosim array-urile NumPy fără probleme de conversie.

Puteți afla tipul de date al unui array NumPy prin accesarea proprietății dtype:

wines.dtype

dtype('float64')

NumPy are mai multe tipuri de date diferite, care se mapează în mare parte cu tipurile de date Python, cum ar fi float, și str. Puteți găsi o listă completă a tipurilor de date NumPy aici, dar iată câteva dintre cele mai importante:

• float – date numerice cu virgulă mobilă.
• int – date întregi.
• string – date de caractere.
• object – obiecte Python.

Tipurile de date se termină în plus cu un sufix care indică numărul de biți de memorie pe care îi ocupă. Astfel, int32 este un tip de date întregi pe 32 de biți, iar float64 este un tip de date float pe 64 biți.

Conversia tipurilor de date

Puteți utiliza metoda numpy.ndarray.astype pentru a converti un array într-un tip diferit. Metoda va copia de fapt matricea și va returna o nouă matrice cu tipul de date specificat. De exemplu, putem converti wines în tipul de date int:

wines.astype(int)

array(,,,...,,,])

După cum puteți vedea mai sus, toate elementele din array-ul rezultat sunt numere întregi. Rețineți că am folosit tipul Python int în loc de un tip de date NumPy atunci când am convertit wines. Acest lucru se datorează faptului că mai multe tipuri de date Python, inclusiv float, int și string, pot fi utilizate cu NumPy și sunt convertite automat în tipuri de date NumPy.

Potem verifica proprietatea name din dtype a tabloului rezultat pentru a vedea la ce tip de date NumPy a mapat tabloul rezultat:

int_wines = wines.astype(int)int_wines.dtype.name

'int64'

Tabloul a fost convertit la un tip de date întreg pe 64 de biți. Acest lucru permite valori întregi foarte lungi, dar ocupă mai mult spațiu în memorie decât stocarea valorilor ca numere întregi pe 32 de biți.

Dacă doriți mai mult control asupra modului în care matricea este stocată în memorie, puteți crea direct obiecte NumPy de tip dtype ca numpy.int32:

np.int32

numpy.int32

Puteți utiliza direct acestea pentru a converti între tipuri:

wines.astype(np.int32)

array(,,,...,,,], dtype=int32)

NumPy Array Operations

NumPy simplifică efectuarea de operații matematice asupra tablourilor. Acesta este unul dintre principalele avantaje ale NumPy și face destul de ușor de efectuat calcule.

Single Array Math

Dacă efectuați oricare dintre operațiile matematice de bază (/, *, -, +, ^) cu un array și o valoare, se va aplica operația la fiecare dintre elementele din array.

Să spunem că vrem să adăugăm 10 puncte la fiecare scor de calitate pentru că suntem beți și ne simțim generoși. Iată cum am face acest lucru:

wines + 10

array()

Rețineți că operația de mai sus nu va modifica tabloul wines – va returna un nou tablou unidimensional în care 10 a fost adăugat la fiecare element din coloana de calitate a vinurilor.

Dacă în schimb am face +=, am modifica tabloul în loc:

wines += 10wines

array()

Toate celelalte operații funcționează în același mod. De exemplu, dacă dorim să înmulțim fiecare dintre scorurile de calitate cu 2, am putea face astfel:

wines * 2

array()

Multiple Array Math

De asemenea, este posibil să facem operații matematice între array-uri. Aceasta va aplica operația la perechi de elemente. De exemplu, dacă adăugăm coloana quality la ea însăși, iată ce obținem:

wines + wines

array()

Rețineți că acest lucru este echivalent cu wines * 2 – acest lucru se datorează faptului că NumPy adaugă fiecare pereche de elemente. Primul element din primul tablou este adăugat la primul element din al doilea tablou, al doilea la al doilea și așa mai departe.

De asemenea, putem folosi acest lucru pentru a înmulți tablouri. Să spunem că vrem să alegem un vin care să maximizeze conținutul de alcool și calitatea (vrem să ne îmbătăm, dar suntem eleganți). Am înmulți alcohol cu quality și am selecta vinul cu cel mai mare punctaj:

wines * wines

array()

Toate operațiile comune (/, *, -, +, ^) vor funcționa între array-uri.

Broadcasting

Dacă array-urile pe care operați nu au exact aceeași dimensiune, nu este posibil să faceți operații pe elemente. În astfel de cazuri, NumPy efectuează broadcasting pentru a încerca să potrivească elementele. În esență, difuzarea implică câțiva pași:

• Se compară ultima dimensiune a fiecărui array.
  • Dacă lungimile dimensiunilor sunt egale, sau dacă una dintre dimensiuni are lungimea 1, atunci continuăm.
  • Dacă lungimile dimensiunilor nu sunt egale și niciuna dintre dimensiuni nu are lungimea 1, atunci apare o eroare.
• Continuăm să verificăm dimensiunile până când cel mai scurt tablou nu mai are dimensiuni.

De exemplu, următoarele două forme sunt compatibile:

A: (50,3)B (3,)

Aceasta se datorează faptului că lungimea dimensiunii din urmă a tabloului A este 3, iar lungimea dimensiunii din urmă a tabloului B este 3. Ele sunt egale, deci dimensiunea respectivă este în regulă. Array B nu mai are apoi elemente, deci suntem în regulă, iar array-urile sunt compatibile pentru operații matematice.

Următoarele două forme sunt de asemenea compatibile:

A: (1,2)B (50,2)

Ultima dimensiune se potrivește, iar A are lungimea 1 în prima dimensiune.

Aceste două matrici nu sunt compatibile:

A: (50,50)B: (49,49)

Lungimile dimensiunilor nu sunt egale și niciuna dintre matrici nu are lungimea uneia dintre dimensiuni egală cu 1.

Există o explicație detaliată a transmiterii aici, dar vom trece prin câteva exemple pentru a ilustra principiul:

wines * np.array()

------------------------------------------------------------------------ValueError Traceback (most recent call last)<ipython -input-40-821086ccaf65> in <module>()----> 1 wines * np.array()ValueError: operands could not be broadcast together with shapes (1599,12) (2,)</module></ipython>

Exemplul de mai sus nu a funcționat deoarece cele două matrici nu au o dimensiune finală corespunzătoare. Iată un exemplu în care ultima dimensiune se potrivește:

array_one = np.array( , ])array_two = np.array()array_one + array_two

array(,])

După cum puteți vedea, array_two a fost difuzat pe fiecare rând din array_one. Iată un exemplu cu datele noastre din wines:

rand_array = np.random.rand(12)wines + rand_array

array(,,,...,,,])

Elementele din rand_array sunt difuzate pe fiecare rând din wines, astfel încât primei coloane din wines i se adaugă prima valoare din rand_array și așa mai departe.

Metode NumPy Array

În plus față de operațiile matematice obișnuite, NumPy are, de asemenea, mai multe metode pe care le puteți folosi pentru calcule mai complexe pe array-uri. Un exemplu în acest sens este metoda numpy.ndarray.sum. Aceasta găsește suma tuturor elementelor dintr-un array în mod implicit:

wines.sum()

9012.0

Suma tuturor evaluărilor noastre de calitate este 154.1788. Putem trece ca argument cuvântul cheie axis în metoda sum pentru a găsi sumele pe o axă. Dacă apelăm sum peste matricea wines și trecem în axis=0, vom găsi sumele pe prima axă a matricei. Aceasta ne va da suma tuturor valorilor din fiecare coloană. Acest lucru poate părea pe dos faptul că sumele pe prima axă ne-ar da suma fiecărei coloane, dar un mod de a ne gândi la acest lucru este că axa specificată este cea care „pleacă”. Deci, dacă specificăm axis=0, dorim ca rândurile să dispară, iar noi vrem să găsim sumele pentru fiecare dintre axele rămase pe fiecare rând:

wines.sum(axis=0)

array()

Potem verifica dacă am făcut suma corect verificând forma. Forma ar trebui să fie 12, corespunzând numărului de coloane:

wines.sum(axis=0).shape

(12,)

Dacă trecem axis=1, vom găsi sumele pe cea de-a doua axă a matricei. Aceasta ne va da suma fiecărui rând:

wines.sum(axis=1)

array()

Există alte câteva metode care se comportă ca metoda sum, inclusiv:

• numpy.ndarray.mean – găsește media unui array.
• numpy.ndarray.std – găsește abaterea standard a unui array.
• numpy.ndarray.min – găsește valoarea minimă dintr-un array.
• numpy.ndarray.max – găsește valoarea maximă într-un array.

Puteți găsi o listă completă a metodelor de array aici.

NumPy Array Comparisons

NumPy face posibilă testarea pentru a vedea dacă rândurile se potrivesc cu anumite valori folosind operații matematice de comparație precum <, >, >=, <= și ==. De exemplu, dacă dorim să vedem ce vinuri au un rating de calitate mai mare decât 5, putem face acest lucru:

wines > 5

array(, dtype=bool)

Obținem un array boolean care ne spune care dintre vinuri au un rating de calitate mai mare decât 5. Putem face ceva similar cu ceilalți operatori. De exemplu, putem vedea dacă există vinuri care au un rating de calitate egal cu 10:

wines == 10

array(, dtype=bool)

Subsetting

Unul dintre lucrurile puternice pe care le putem face cu un tablou boolean și un tablou NumPy este să selectăm doar anumite rânduri sau coloane din tabloul NumPy. De exemplu, codul de mai jos va selecta doar rândurile din wines în care calitatea este mai mare de 7:

high_quality = wines > 7wines

array(,,])

Selecționăm doar rândurile în care high_quality conține o valoare True, precum și toate coloanele. Această subîmpărțire simplifică filtrarea tablourilor pentru anumite criterii. De exemplu, putem căuta vinuri cu mult alcool și de înaltă calitate. Pentru a specifica mai multe condiții, trebuie să punem fiecare condiție între paranteze și să separăm condițiile cu o ampersandă (&):

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines

array(,,,,,,,,,,,,,,,])

Potem combina subansamblarea și atribuirea pentru a suprascrie anumite valori dintr-un array:

high_quality_and_alcohol = (wines > 10) & (wines > 7)wines = 20

Reshaping NumPy Arrays

Potem schimba forma array-urilor, păstrând în același timp toate elementele acestora. Acest lucru poate facilita adesea accesul la elementele tablourilor. Cea mai simplă remodelare este de a inversa axele, astfel încât rândurile să devină coloane și invers. Putem realiza acest lucru cu ajutorul funcției numpy.transpose:

np.transpose(wines).shape

(12, 1599)

Puteți utiliza funcția numpy.ravel pentru a transforma un array într-o reprezentare unidimensională. Aceasta va aplatiza, în esență, un array într-o secvență lungă de valori:

wines.ravel()

array()

Iată un exemplu în care putem vedea ordonarea lui numpy.ravel:

array_one = np.array( , ])array_one.ravel()

array()

În cele din urmă, putem folosi funcția numpy.reshape pentru a remodela un array la o anumită formă pe care o specificăm. Codul de mai jos va transforma al doilea rând din wines într-un array bidimensional cu 2 rânduri și 6 coloane:

wines.reshape((2,6))

array(,])

Combinarea array-urilor NumPy

Cu NumPy, este foarte comun să combinăm mai multe array-uri într-un singur array unificat. Putem folosi numpy.vstack pentru a stivui pe verticală mai multe array-uri. Gândiți-vă că elementele celui de-al doilea array sunt adăugate ca noi rânduri în primul array. Putem citi setul de date winequality-white.csv, care conține informații despre calitatea vinurilor albe, apoi îl putem combina cu setul nostru de date existent, wines, care conține informații despre vinurile roșii.

În codul de mai jos, noi:

• Lecturăm winequality-white.csv.
• Afișăm forma lui white_wines.

white_wines = np.genfromtxt("winequality-white.csv", delimiter=";", skip_header=1)white_wines.shape

(4898, 12)

După cum puteți vedea, avem atribute pentru 4898 vinuri. Acum că avem datele despre vinurile albe, putem combina toate datele despre vinuri.

În codul de mai jos, noi:

• Utilizați funcția vstack pentru a combina wines și white_wines.

.

• Afișează forma rezultatului.

all_wines = np.vstack((wines, white_wines))all_wines.shape

(6497, 12)

După cum puteți vedea, rezultatul are 6497 rânduri, care este suma numărului de rânduri din wines și a numărului de rânduri din red_wines.

Dacă dorim să combinăm array-uri pe orizontală, unde numărul de rânduri rămâne constant, dar coloanele sunt unite, atunci putem folosi funcția numpy.hstack. Array-urile pe care le combinăm trebuie să aibă același număr de rânduri pentru ca acest lucru să funcționeze.

În cele din urmă, putem folosi numpy.concatenate ca o versiune de uz general a funcțiilor hstack și vstack. Dacă dorim să concatenăm două matrici, le trecem în concatenate, apoi specificăm argumentul axis cu cuvântul cheie axis pe care dorim să îl concatenăm împreună. Concatenarea de-a lungul primei axe este similară cu vstack, iar concatenarea de-a lungul celei de-a doua axe este similară cu hstack:

np.concatenate((wines, white_wines), axis=0)

array(,,,...,,,])

Free NumPy Cheat Sheet

Dacă sunteți interesat să aflați mai multe despre NumPy, consultați cursul nostru interactiv despre NumPy și Pandas. Puteți să vă înregistrați și să faceți primele misiuni gratuit.

De asemenea, ați putea dori să vă duceți abilitățile NumPy la nivelul următor cu foaia noastră gratuită de înșelăciune NumPy!

Lecturi suplimentare

Ar trebui să aveți acum o bună înțelegere a NumPy și a modului de aplicare a acestuia la un set de date.

Dacă doriți să vă scufundați mai mult în profunzime, iată câteva resurse care vă pot fi de ajutor:

• NumPy Quickstart – are exemple bune de cod și acoperă majoritatea funcționalităților de bază ale NumPy.
• Python NumPy Tutorial – un tutorial excelent despre NumPy și alte biblioteci Python.
• Visual NumPy Introduction – un ghid care folosește jocul vieții pentru a ilustra conceptele NumPy.

În următorul tutorial, ne scufundăm mai mult în Pandas, o bibliotecă care se bazează pe NumPy și face analiza datelor și mai ușoară. Aceasta rezolvă două dintre cele mai mari puncte dureroase care sunt următoarele:

• Nu puteți amesteca mai multe tipuri de date într-un array.
• Trebuie să vă amintiți ce tip de date conține fiecare coloană.

.