NumPy Tutorial: Data Analysis with Python

Niet te missen ons GRATIS NumPy spiekbriefje onderaan deze post

NumPy is een veelgebruikt Python data analyse pakket. Door NumPy te gebruiken, kun je je workflow versnellen, en kun je interfacen met andere pakketten in het Python ecosysteem, zoals scikit-learn, die NumPy onder de motorkap gebruiken. NumPy is oorspronkelijk ontwikkeld in het midden van de jaren 2000, en is voortgekomen uit een nog ouder pakket genaamd Numeric. Deze lange levensduur betekent dat bijna elke data-analyse of machine learning pakket voor Python maakt gebruik van NumPy op een of andere manier.

In deze tutorial lopen we door het gebruik van NumPy om gegevens over wijnkwaliteit te analyseren. De gegevens bevatten informatie over verschillende attributen van wijnen, zoals pH en fixed acidity, samen met een kwaliteitsscore tussen 0 en 10 voor elke wijn. De kwaliteitsscore is het gemiddelde van ten minste 3 menselijke smaaktesters. Terwijl we leren werken met NumPy, zullen we proberen meer te weten te komen over de waargenomen kwaliteit van wijn.

De wijnen die we zullen analyseren, komen uit de Minho-regio van Portugal.

De gegevens zijn gedownload van de UCI Machine Learning Repository, en zijn hier beschikbaar. Hier zijn de eerste paar rijen van het winequality-red.csv bestand, dat we zullen gebruiken in deze 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

De gegevens zijn in wat ik ga noemen ssv (puntkomma gescheiden waarden) formaat – elk record wordt gescheiden door een puntkomma (;), en rijen worden gescheiden door een nieuwe regel. Er zijn 1600 rijen in het bestand, inclusief een header rij, en 12 kolommen.

Voordat we aan de slag gaan, een snelle versie noot – we zullen Python 3.5 gebruiken. Onze codevoorbeelden zullen worden gedaan met behulp van Jupyter notebook.

Lijsten van lijsten voor CSV-gegevens

Voordat we NumPy gebruiken, zullen we eerst proberen om met de gegevens te werken met behulp van Python en het csv-pakket. We kunnen het bestand inlezen met behulp van het object csv.reader, waarmee we alle inhoud van het ssv-bestand kunnen inlezen en splitsen.

In de onderstaande code:

• Importeer de csv bibliotheek.
• Open het winequality-red.csv bestand.
  • Met het bestand open, maakt u een nieuw csv.reader object.
    • Geef het sleutelwoordargument delimiter=";" in om ervoor te zorgen dat de records worden gesplitst op het teken puntkomma in plaats van het standaard teken komma.
  • Roep het lijsttype op om alle rijen uit het bestand te halen.
  • Benoem het resultaat aan wines.

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

Als we de gegevens hebben ingelezen, kunnen we de eerste 3 rijen uitprinten:

print(wines)

, , ]

De gegevens zijn ingelezen in een lijst van lijsten. Elke binnenste lijst is een rij uit het ssv-bestand. Zoals je misschien hebt gemerkt, wordt elk item in de hele lijst van lijsten voorgesteld als een string, wat het moeilijker maakt om berekeningen uit te voeren.

We zullen de gegevens in een tabel formatteren, zodat ze makkelijker te bekijken zijn:

Zoals u in de tabel hierboven kunt zien, hebben we drie rijen ingelezen, waarvan de eerste kolomkoppen bevat. Elke rij na de header-rij vertegenwoordigt een wijn. Het eerste element van elke rij is de fixed acidity, het tweede is de volatile acidity, enzovoort. We kunnen het gemiddelde quality van de wijnen vinden. De onderstaande code zal:

• Extraheer het laatste element van elke rij na de header rij.
• Converteer elk geëxtraheerd element naar een float.
• Benoem alle geëxtraheerde elementen aan de lijst qualities.
• Deel de som van alle elementen in qualities door het totaal aantal elementen in qualities om het gemiddelde te krijgen.

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

5.6360225140712945

Hoewel we in staat waren om de berekening uit te voeren die we wilden, is de code vrij complex, en het zal niet leuk zijn om iets soortgelijks te moeten doen elke keer dat we een hoeveelheid willen berekenen. Gelukkig kunnen we NumPy gebruiken om het makkelijker te maken om met onze gegevens te werken.

Numpy 2-Dimensionale Arrays

Met NumPy werken we met multidimensionale arrays. We zullen later ingaan op alle mogelijke types van multidimensionale arrays, maar voor nu zullen we ons richten op 2-dimensionale arrays. Een 2-dimensionale array is ook gekend als een matrix, en is iets waarmee je vertrouwd zou moeten zijn. In feite is het gewoon een andere manier van denken over een lijst van lijsten. Een matrix heeft rijen en kolommen. Door een rij nummer en een kolom nummer op te geven, kunnen we een element uit een matrix halen.

In de onderstaande matrix is de eerste rij de header-rij, en de eerste kolom is de fixed acidity-kolom:

Als we het element in de eerste rij en de tweede kolom zouden kiezen, zouden we volatile acidity krijgen. Als we het element in de derde rij en de tweede kolom zouden kiezen, zouden we 0.88 krijgen.

In een NumPy-array wordt het aantal dimensies de rang genoemd, en elke dimensie wordt een as genoemd. Dus de rijen zijn de eerste as, en de kolommen zijn de tweede as.

Nu u de basis van matrices begrijpt, laten we eens kijken hoe we van onze lijst van lijsten naar een NumPy-array kunnen komen.

Een NumPy-array maken

We kunnen een NumPy-array maken met behulp van de functie numpy.array. Als we een lijst met lijsten invoeren, wordt er automatisch een NumPy array gemaakt met hetzelfde aantal rijen en kolommen. Omdat we willen dat alle elementen in de array float-elementen zijn voor eenvoudige berekeningen, laten we de header-rij weg, die strings bevat. Een van de beperkingen van NumPy is dat alle elementen in een matrix van hetzelfde type moeten zijn, dus als we de header-rij invoegen, zullen alle elementen in de matrix als strings worden ingelezen. Omdat we berekeningen willen kunnen uitvoeren, zoals het gemiddelde quality van de wijnen vinden, moeten de elementen allemaal vlotters zijn.

In de onderstaande code, we:

• Importeer het numpy pakket.
• Pass de lijst van lijsten wines in de array functie, die het omzet in een NumPy array.
  • Excludeer de header rij met list slicing.
  • Specificeer het keyword argument dtype om ervoor te zorgen dat elk element wordt geconverteerd naar een float. We zullen later dieper ingaan op wat de dtype is.

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)

Probeer de bovenstaande code uit te voeren en kijk wat er gebeurt!

Als we wines weergeven, krijgen we nu een NumPy array:

wines

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

We kunnen het aantal rijen en kolommen in onze gegevens controleren met behulp van de shape eigenschap van NumPy arrays:

wines.shape

(1599, 12)

Alternatieve NumPy Array Creation Methods

Er zijn verschillende methoden die u kunt gebruiken om NumPy arrays te maken. Om te beginnen kunt u een array maken waarvan elk element nul is. De onderstaande code maakt een array met 3 rijen en 4 kolommen, waarbij elk element 0 is, met behulp van numpy.nullen:

import numpy as np

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

Het is handig om een array met allemaal nul elementen te maken in gevallen waarin je een array van vaste grootte nodig hebt, maar er nog geen waarden voor hebt.

Je kunt ook een array maken waarbij elk element een willekeurig getal is met behulp van numpy.random.rand. Hier is een voorbeeld:

np.random.rand(3,4)

array(,,])

Het maken van arrays vol willekeurige getallen kan handig zijn als je snel je code wilt testen met voorbeeldarrays.

Gebruik NumPy om bestanden in te lezen

Het is mogelijk om NumPy te gebruiken om csv of andere bestanden direct in arrays in te lezen. We kunnen dit doen met de functie numpy.genfromtxt. We kunnen het gebruiken om onze eerste gegevens over rode wijnen in te lezen.

In onderstaande code:

• Gebruik de functie genfromtxt om het bestand winequality-red.csv in te lezen.
• Specificeer het sleutelwoordargument delimiter=";" zodat de velden goed worden geparst.
• Specifieer het sleutelwoordargument skip_header=1 zodat de header-rij wordt overgeslagen.

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

wines zal er uiteindelijk hetzelfde uitzien als wanneer we het in een lijst zouden lezen en het vervolgens zouden converteren naar een array van floats. NumPy kiest automatisch een gegevenstype voor de elementen in een array op basis van hun formaat.

Indexeren van NumPy-arrays

We weten nu hoe we arrays moeten maken, maar tenzij we er resultaten uit kunnen halen, kunnen we niet veel doen met NumPy. We kunnen array indexering gebruiken om individuele elementen, groepen van elementen, of hele rijen en kolommen te selecteren. Een belangrijk ding om in gedachten te houden is dat NumPy, net als Python-lijsten, een nulindex heeft, wat betekent dat de index van de eerste rij 0 is, en de index van de eerste kolom 0 is. Als we met de vierde rij willen werken, gebruiken we index 3, als we met de tweede rij willen werken, gebruiken we index 1, enzovoort. We werken weer met de matrix wines:

Laten we het element selecteren op rij 3 en kolom 4. In de onderstaande code geven we de index 2 op als rij-index, en de index 3 als kolom-index. Dit haalt de waarde op uit de vierde kolom van de derde rij:

wines

2.2999999999999998

Omdat we werken met een 2-dimensionale array in NumPy, specificeren we 2 indexen om een element op te halen. De eerste index is de rij, of as 1, index, en de tweede index is de kolom, of as 2, index. Elk element in wines kan worden opgehaald met de 2 indexen.

Slicing NumPy Arrays

Als we in plaats daarvan de eerste drie items uit de vierde kolom willen selecteren, kunnen we dat doen met een dubbele punt (:). Een dubbele punt geeft aan dat we alle elementen willen selecteren vanaf de beginindex tot maar niet inclusief de eindindex. Dit wordt ook wel een slice genoemd:

wines

array()

Net als bij list slicing is het mogelijk om de 0 weg te laten om gewoon alle elementen vanaf het begin tot en met element 3 op te halen:

wines

array()

We kunnen een hele kolom selecteren door aan te geven dat we alle elementen willen, van de eerste tot en met de laatste. We specificeren dit door alleen de dubbele punt (:) te gebruiken, zonder begin- of eindindexen. De onderstaande code selecteert de hele vierde kolom:

wines

array()

We hebben hierboven een hele kolom geselecteerd, maar we kunnen ook een hele rij extraheren:

wines

array()

Als we onze indexering tot het uiterste doorvoeren, kunnen we de hele matrix selecteren door twee dubbele punten te gebruiken om alle rijen en kolommen in wines te selecteren. Dit is een leuke party-truc, maar heeft niet veel goede toepassingen:

wines

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

Waarden toewijzen aan NumPy-arrays

We kunnen indexering ook gebruiken om waarden toe te wijzen aan bepaalde elementen in arrays. We kunnen dit doen door direct toe te wijzen aan de geïndexeerde waarde:

wines = 10

Hetzelfde kunnen we doen voor slices. Om een hele kolom te overschrijven, kunnen we dit doen:

wines = 50

De bovenstaande code overschrijft alle waarden in de elfde kolom met 50.

1-Dimensionale NumPy-arrays

Tot nu toe hebben we gewerkt met 2-dimensionale arrays, zoals wines. NumPy is echter een pakket voor het werken met multidimensionale arrays. Een van de meest voorkomende types van multidimensionele arrays is de 1-dimensionale array, of vector. Zoals je hierboven misschien hebt opgemerkt, hebben we, toen we wines sneden, een 1-dimensionale array opgehaald. Een 1-dimensionale array heeft slechts een enkele index nodig om een element op te halen. Elke rij en kolom in een 2-dimensionale array is een 1-dimensionale array. Net zoals een lijst van lijsten analoog is aan een 2-dimensionale array, is een enkele lijst analoog aan een 1-dimensionale array. Als we wijn slicen en alleen de derde rij ophalen, krijgen we een 1-dimensionale array:

third_wine = wines

Hier ziet third_wine eruit:

11.2000.2800.5601.9000.07517.00060.0000.9983.1600.5809.8006.000

We kunnen individuele elementen uit third_wine ophalen met behulp van een enkele index. De onderstaande code zal het tweede item in third_wine weergeven:

third_wine

0.28000000000000003

De meeste NumPy-functies waarmee we hebben gewerkt, zoals numpy.random.rand, kunnen worden gebruikt met multidimensionale arrays. Hier is hoe we numpy.random.rand zouden gebruiken om een willekeurige vector te genereren:

np.random.rand(3)

array()

Vorige keer, toen we np.random.rand aanriepen, hebben we een vorm voor een 2-dimensionale matrix doorgegeven, dus het resultaat was een 2-dimensionale matrix. Deze keer hebben we een vorm voor een array van één dimensie doorgegeven. De vorm specificeert het aantal dimensies, en de grootte van de array in elke dimensie. Een vorm van (10,10) is een 2-dimensionale matrix met 10 rijen en 10 kolommen. Een shape van (10,) is een 1-dimensionale array met 10 elementen.

Waar NumPy complexer wordt, is wanneer we te maken krijgen met arrays die meer dan 2 dimensies hebben.

N-Dimensionale NumPy-arrays

Het komt niet zo vaak voor, maar er zijn gevallen waarin je te maken wilt krijgen met arrays die meer dan 3 dimensies hebben. Een manier om dit te zien is als een lijst van lijsten van lijsten. Laten we zeggen dat we de maandelijkse inkomsten van een winkel willen opslaan, maar we willen ook snel de resultaten van een kwartaal en een jaar kunnen bekijken. De verdiensten voor een jaar zouden er als volgt uit kunnen zien:

De winkel verdiende 0 in januari, 5 in februari, enzovoort. We kunnen deze verdiensten per kwartaal opsplitsen in een lijst:

year_one = , , , ]

We kunnen de verdiensten van januari opvragen door year_one op te roepen. Als we de resultaten voor een heel kwartaal willen, kunnen we year_one of year_one aanroepen. We hebben nu een 2-dimensionale array, of matrix. Maar wat als we nu de resultaten van een ander jaar willen toevoegen? We moeten een derde dimensie toevoegen:

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

We kunnen de resultaten van januari van het eerste jaar opvragen door earnings op te roepen. We hebben nu drie indexen nodig om een enkel element op te vragen. Een driedimensionale array in NumPy is ongeveer hetzelfde. In feite kunnen we earnings omzetten naar een array en dan de verdiensten voor januari van het eerste jaar krijgen:

earnings = np.array(earnings)earnings

500

We kunnen ook de vorm van de array vinden:

earnings.shape

(2, 4, 3)

Indexeren en slicen werken precies hetzelfde met een 3-dimensionale array, maar nu hebben we een extra as om door te geven. Als we de winst over januari van alle jaren willen krijgen, kunnen we dit doen:

earnings

array()

Als we de winst over het eerste kwartaal van beide jaren willen krijgen, kunnen we dit doen:

earnings

array(,])

Door meer dimensies toe te voegen, wordt het veel gemakkelijker om uw gegevens te doorzoeken als ze op een bepaalde manier zijn georganiseerd. Als we van 3-dimensionale arrays naar 4-dimensionale en grotere arrays gaan, gelden dezelfde eigenschappen, en ze kunnen op dezelfde manieren worden geïndexeerd en gesneden.

NumPy Data Types

Zoals we al eerder zeiden, kan elke NumPy array elementen van een enkel gegevenstype opslaan. wines bevat bijvoorbeeld alleen float-waarden. NumPy slaat waarden op met zijn eigen gegevenstypen, die verschillen van Python-typen zoals float en str. Dit komt omdat de kern van NumPy is geschreven in een programmeertaal genaamd C, die gegevens anders opslaat dan de Python datatypen. NumPy datatypen worden opgeslagen tussen Python en C, zodat we NumPy arrays kunnen gebruiken zonder conversieproblemen.

U kunt het datatype van een NumPy array vinden door de dtype eigenschap te gebruiken:

wines.dtype

dtype('float64')

NumPy heeft verschillende datatypen, die meestal overeenkomen met Python datatypen, zoals float, en str. U kunt een volledige lijst van NumPy-datatypen hier vinden, maar hier zijn een paar belangrijke:

• float – numerieke floating point data.
• int – integer data.
• string – character data.
• object – Python-objecten.

Datatatatatypen eindigen bovendien met een achtervoegsel dat aangeeft hoeveel bits van het geheugen ze in beslag nemen. Dus int32 is een 32 bit integer datatype, en float64 is een 64 bit float datatype.

Converting Data Types

U kunt de numpy.ndarray.astype methode gebruiken om een array te converteren naar een ander type. De methode zal in feite de array kopiëren, en een nieuwe array teruggeven met het gespecificeerde datatype. We kunnen bijvoorbeeld wines converteren naar het gegevenstype int:

wines.astype(int)

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

Zoals u hierboven kunt zien, zijn alle items in de resulterende array gehele getallen. Merk op dat we het Python int type hebben gebruikt in plaats van een NumPy datatype bij het omzetten van wines. Dit komt omdat verschillende Python datatypen, waaronder float, int, en string, gebruikt kunnen worden met NumPy, en automatisch geconverteerd worden naar NumPy datatypen.

We kunnen de name eigenschap van het dtype van de resulterende array controleren om te zien naar welk datatype NumPy de resulterende array heeft gemapped:

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

'int64'

De array is geconverteerd naar een 64-bit integer datatype. Dit maakt zeer lange integer waarden mogelijk, maar neemt meer ruimte in het geheugen in beslag dan wanneer de waarden worden opgeslagen als 32-bits integers.

Als u meer controle wilt over hoe de array in het geheugen wordt opgeslagen, kunt u rechtstreeks NumPy dtype-objecten maken zoals numpy.int32:

np.int32

numpy.int32

Je kunt deze direct gebruiken om te converteren tussen types:

wines.astype(np.int32)

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

NumPy Array Operations

NumPy maakt het eenvoudig om wiskundige bewerkingen op arrays uit te voeren. Dit is een van de belangrijkste voordelen van NumPy, en maakt het vrij eenvoudig om berekeningen uit te voeren.

Single Array Math

Als je een van de basis wiskundige bewerkingen (/, *, -, +, ^) uitvoert met een array en een waarde, zal het de bewerking toepassen op elk van de elementen in het array.

Laten we zeggen dat we 10 punten willen toevoegen aan elke kwaliteitsscore omdat we dronken zijn en ons gul voelen. Zo zouden we dat doen:

wines + 10

array()

Merk op dat de bovenstaande bewerking de wines-array niet zal veranderen – het zal een nieuwe 1-dimensionale array teruggeven waar 10 is toegevoegd aan elk element in de kwaliteitskolom van wijnen.

Als we in plaats daarvan += zouden doen, zouden we de array in de plaats wijzigen:

wines += 10wines

array()

Alle andere bewerkingen werken op dezelfde manier. Als we bijvoorbeeld elke kwaliteitsscore willen vermenigvuldigen met 2, kunnen we dat als volgt doen:

wines * 2

array()

Multiple Array Math

Het is ook mogelijk om wiskundige bewerkingen tussen arrays uit te voeren. Dit zal de bewerking toepassen op paren van elementen. Als we bijvoorbeeld de kolom quality bij zichzelf optellen, krijgen we het volgende:

wines + wines

array()

Merk op dat dit gelijkwaardig is aan wines * 2 – dit komt omdat NumPy elk paar elementen optelt. Het eerste element in de eerste array wordt opgeteld bij het eerste element in de tweede array, het tweede bij het tweede, enzovoort.

We kunnen dit ook gebruiken om arrays te vermenigvuldigen. Laten we zeggen dat we een wijn willen kiezen die het alcoholgehalte en de kwaliteit maximaliseert (we willen dronken worden, maar we zijn stijlvol). We vermenigvuldigen alcohol met quality, en kiezen de wijn met de hoogste score:

wines * wines

array()

Alle gebruikelijke bewerkingen (/, *, -, +, ^) werken tussen arrays.

Broadcasting

Niet als de arrays waarop je werkt exact even groot zijn, is het niet mogelijk om elementgewijze bewerkingen uit te voeren. In dat geval voert NumPy broadcasting uit om te proberen de elementen bij elkaar te brengen. In wezen omvat broadcasting een paar stappen:

• De laatste dimensie van elke array wordt vergeleken.
  • Als de dimensielengte gelijk is, of een van de dimensies heeft lengte 1, dan gaan we door.
  • Als de dimensielengte niet gelijk is, en geen van de dimensies heeft lengte 1, dan treedt er een fout op.
• Ga door met het controleren van dimensies totdat de kortste array geen dimensies meer heeft.

De volgende twee vormen zijn bijvoorbeeld compatibel:

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

Dit komt omdat de lengte van de achterste dimensie van array A 3 is, en de lengte van de achterste dimensie van array B is 3. Ze zijn gelijk, dus die dimensie is in orde. Array B heeft dan geen elementen meer, dus we zitten goed, en de arrays zijn compatibel voor wiskundige bewerkingen.

De volgende twee vormen zijn ook compatibel:

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

De laatste dimensie komt overeen, en A heeft in de eerste dimensie de lengte 1.

Deze twee matrices komen niet overeen:

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

De lengtes van de dimensies zijn niet gelijk, en geen van beide matrices heeft een dimensielengte gelijk aan 1.

Er staat hier een gedetailleerde uitleg van het uitzenden, maar we zullen een paar voorbeelden doorlopen om het principe te illustreren:

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>

Het bovenstaande voorbeeld werkte niet, omdat de twee matrices geen overeenkomende achterste dimensie hebben. Hier is een voorbeeld waar de laatste dimensie wel overeenkomt:

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

array(,])

Zoals u kunt zien, is array_two uitgezonden over elke rij van array_one. Hier is een voorbeeld met onze wines-gegevens:

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

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

Elementen van rand_array worden uitgezonden over elke rij van wines, dus de eerste kolom van wines krijgt de eerste waarde in rand_array erbij, enzovoort.

NumPy Array Methods

Naast de gebruikelijke wiskundige bewerkingen heeft NumPy ook verschillende methoden die u kunt gebruiken voor complexere berekeningen op arrays. Een voorbeeld hiervan is de numpy.ndarray.sum methode. Deze vindt standaard de som van alle elementen in een array:

wines.sum()

9012.0

Het totaal van al onze kwaliteitsbeoordelingen is 154.1788. We kunnen het sleutelwoordargument axis doorgeven aan de methode sum om sommen over een as te vinden. Als we sum aanroepen over de matrix wines, en axis=0 doorgeven, vinden we de sommen over de eerste as van de matrix. Dit geeft ons de som van alle waarden in elke kolom. Het lijkt misschien omgekeerd dat de sommen over de eerste as ons de som van elke kolom zouden geven, maar één manier om hierover na te denken is dat de gespecificeerde as degene is die “weggaat”. Dus als we axis=0 specificeren, willen we dat de rijen weggaan, en we willen de sommen vinden voor elk van de resterende assen over elke rij:

wines.sum(axis=0)

array()

We kunnen controleren of we de som correct hebben gemaakt door de vorm te controleren. De vorm moet 12 zijn, overeenkomend met het aantal kolommen:

wines.sum(axis=0).shape

(12,)

Als we axis=1 invoeren, vinden we de sommen over de tweede as van de matrix. Dit geeft ons de som van elke rij:

wines.sum(axis=1)

array()

Er zijn verschillende andere methoden die zich gedragen als de methode sum, waaronder:

• numpy.ndarray.mean – vindt het gemiddelde van een array.
• numpy.ndarray.std – vindt de standaardafwijking van een array.
• numpy.ndarray.min – vindt de minimumwaarde in een array.
• numpy.ndarray.max – vindt de maximale waarde in een array.

Een volledige lijst van array methods vindt u hier.

NumPy Array Comparisons

NumPy maakt het mogelijk om te testen of rijen overeenkomen met bepaalde waarden met behulp van wiskundige vergelijkingsoperaties zoals <, >, >=, <=, en ==. Als we bijvoorbeeld willen zien welke wijnen een kwaliteitsbeoordeling hebben die hoger is dan 5, kunnen we dit doen:

wines > 5

array(, dtype=bool)

We krijgen een Booleaanse matrix die ons vertelt welke van de wijnen een kwaliteitsbeoordeling hebben die hoger is dan 5. We kunnen iets soortgelijks doen met de andere operatoren. Zo kunnen we bijvoorbeeld zien of er wijnen zijn met een kwaliteitsbeoordeling gelijk aan 10:

wines == 10

array(, dtype=bool)

Subsetting

Een van de krachtige dingen die we kunnen doen met een Boolean array en een NumPy array is het selecteren van alleen bepaalde rijen of kolommen in de NumPy array. De onderstaande code selecteert bijvoorbeeld alleen rijen in wines waar de kwaliteit hoger is dan 7:

high_quality = wines > 7wines

array(,,])

We selecteren alleen de rijen waar high_quality een True waarde bevat, en alle kolommen. Deze subsetting maakt het eenvoudig om arrays te filteren op bepaalde criteria. We kunnen bijvoorbeeld zoeken naar wijnen met veel alcohol en van hoge kwaliteit. Om meerdere voorwaarden op te geven, moeten we elke voorwaarde tussen haakjes plaatsen, en de voorwaarden scheiden met een ampersand (&):

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

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

We kunnen subsetting en toewijzing combineren om bepaalde waarden in een array te overschrijven:

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

Reshaping NumPy Arrays

We kunnen de vorm van arrays veranderen terwijl alle elementen behouden blijven. Dit maakt het vaak makkelijker om array elementen te benaderen. De eenvoudigste vormverandering is het omdraaien van de assen, zodat rijen kolommen worden, en vice versa. We kunnen dit bereiken met de functie numpy.transpose:

np.transpose(wines).shape

(12, 1599)

We kunnen de functie numpy.ravel gebruiken om een array in een eendimensionale weergave te veranderen. Het zal in wezen een array afvlakken in een lange reeks van waarden:

wines.ravel()

array()

Hier is een voorbeeld waar we de volgorde van numpy.ravel kunnen zien:

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

array()

Ten slotte kunnen we de numpy.reshape functie gebruiken om een array een bepaalde vorm te geven die we specificeren. De onderstaande code zal de tweede rij van wines veranderen in een 2-dimensionale array met 2 rijen en 6 kolommen:

wines.reshape((2,6))

array(,])

Combining NumPy Arrays

Met NumPy is het heel gebruikelijk om meerdere arrays te combineren tot een enkele geünificeerde array. We kunnen numpy.vstack gebruiken om meerdere arrays verticaal te stapelen. Zie het als de items van de tweede array die worden toegevoegd als nieuwe rijen aan de eerste array. We kunnen de dataset winequality-white.csv inlezen die informatie bevat over de kwaliteit van witte wijnen, en deze vervolgens combineren met onze bestaande dataset, wines, die informatie bevat over rode wijnen.

In de onderstaande code, we:

• Lezen in winequality-white.csv.
• Weergave van de vorm van white_wines.

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

(4898, 12)

Zoals u kunt zien, hebben we attributen voor 4898 wijnen. Nu we de gegevens van de witte wijnen hebben, kunnen we alle wijngegevens combineren.

In de onderstaande code, we:

• Gebruik de vstack functie om wines en white_wines te combineren.
• Weergave van de vorm van het resultaat.

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

(6497, 12)

Zoals u kunt zien, heeft het resultaat 6497 rijen, wat de som is van het aantal rijen in wines en het aantal rijen in red_wines.

Als we arrays horizontaal willen combineren, waarbij het aantal rijen constant blijft, maar de kolommen worden samengevoegd, dan kunnen we de numpy.hstack functie gebruiken. De arrays die we combineren moeten hetzelfde aantal rijen hebben om dit te laten werken.

Ten slotte kunnen we numpy.concatenate gebruiken als een algemene versie van hstack en vstack. Als we twee arrays aan elkaar willen plakken, geven we ze door aan concatenate, en specificeren dan het axis sleutelwoordargument waarlangs we willen concateneren. Aaneenschakelen langs de eerste as is vergelijkbaar met vstack, en aaneenschakelen langs de tweede as is vergelijkbaar met hstack:

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

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

Gratis NumPy Cheat Sheet

Als u meer wilt leren over NumPy, bekijk dan onze interactieve cursus over NumPy en Pandas. Je kunt je registreren en de eerste missies gratis doen.

Je kunt je NumPy-vaardigheden ook naar een hoger niveau tillen met ons gratis NumPy-spiekbriefje!

Verder lezen

Je zou nu een goed begrip moeten hebben van NumPy, en hoe je het kunt toepassen op een dataset.

Als u er dieper in wilt duiken, zijn hier enkele bronnen die nuttig kunnen zijn:

• NumPy Quickstart – bevat goede codevoorbeelden en behandelt de meeste basisfuncties van NumPy.
• Python NumPy Tutorial – een goede tutorial over NumPy en andere Python-bibliotheken.
• Visual NumPy Introduction – een gids die het spel van het leven gebruikt om NumPy-concepten te illustreren.

In onze volgende tutorial duiken we meer in Pandas, een bibliotheek die voortbouwt op NumPy en gegevensanalyse nog eenvoudiger maakt. Het lost twee van de grootste pijnpunten op, namelijk:

• Je kunt niet meerdere gegevenstypen in een array mixen.
• Je moet onthouden welk gegevenstype elke kolom bevat.