Python Numpy Array Tutorial

Installeren met Python Wheels

Zorg er eerst voor dat je Python hebt geïnstalleerd. Je kunt onze gids bekijken over hoe je Python installeert als je dit nog moet doen :)

Als je op Windows werkt, zorg er dan voor dat je Python hebt toegevoegd aan de PATH-omgevingsvariabele. Vergeet vervolgens niet een pakketbeheerder te installeren, zoals pip, zodat je de open-sourcebibliotheken van Python kunt gebruiken.

Let op dat recente versies van Python 3 met pip komen, dus controleer dubbel of je het hebt, en als dat zo is, upgrade het dan voordat je NumPy installeert:

pip install pip --upgrade
pip --version

Download het juiste NumPy wheel-bestand voor je systeem van de PyPI-website. Je vindt de lijst met beschikbare NumPy-wheels op de Python Package Index.

 

Zodra je het NumPy wheel-bestand hebt gedownload, navigeer je naar de map waar het bestand is opgeslagen via de opdrachtprompt of terminal.

 

Installeer NumPy met het volgende commando, waarbij je "numpy-<version>-<architecture>.whl" vervangt door de naam van het gedownloade NumPy wheel-bestand:

pip install numpy-<version>-<architecture>.whl

Als je bijvoorbeeld NumPy versie 1.20.3 voor een 64-bits Windows-systeem hebt gedownload, zou het commando zijn:

Nadat de installatie is voltooid, kun je controleren of NumPy is geïnstalleerd door een Python-interpreter te openen en het volgende commando uit te voeren:

import numpy

Als er geen foutmeldingen zijn, is NumPy geïnstalleerd en klaar voor gebruik!

Installeren met de Anaconda Python-distributie

Om NumPy te krijgen kun je ook de Anaconda Python-distributie downloaden. Dit is eenvoudig en laat je snel starten! Als je deze nog niet hebt gedownload, ga dan naar de officiële pagina om hem te halen. Volg de instructies om te installeren en je kunt aan de slag!

Vraag je je af waarom dit makkelijker zou zijn?

Het fijne aan deze Python-distributie is dat je je niet te veel zorgen hoeft te maken over het apart installeren van NumPy of een van de grote pakketten die je gaat gebruiken voor je data-analyses, zoals pandas, scikit-learn, enzovoort.

Want vooral als je heel nieuw bent met Python, programmeren of terminals, kan het een opluchting zijn dat Anaconda al 100 van de populairste Python-, R- en Scala-pakketten voor data science bevat. Maar ook voor meer ervaren data scientists is Anaconda de manier om snel te beginnen met het aanpakken van data science-problemen.

Daarnaast bevat Anaconda ook verschillende open-source ontwikkelomgevingen, zoals Jupyter en Spyder. Als je na deze tutorial met Jupyter Notebook aan de slag wilt, ga dan naar onze Jupyter-notebook-tutorial.

Kortom, overweeg om Anaconda te downloaden om aan de slag te gaan met numpy en andere pakketten die relevant zijn voor data science!

import numpy as np

# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_array`
print(my_array)

Hoe maak je een “lege” NumPy-array

Wat mensen vaak bedoelen als ze zeggen dat ze “lege” arrays maken, is dat ze initiële placeholders willen gebruiken die je achteraf kunt vullen. Je kunt arrays initialiseren met enen of nullen, maar je kunt ook arrays maken die gevuld worden met gelijkmatig verdeelde waarden, constante of willekeurige waarden.

Toch kun je ook een volledig lege array maken.

Gelukkig zijn er best veel functies om dit te doen.

Probeer het hieronder allemaal uit!

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

Tip: speel met de bovenstaande functies zodat je begrijpt hoe ze werken!

• Voor sommige, zoals np.ones(), np.random.random(), np.empty(), np.full() of np.zeros(), is het enige wat je hoeft te doen om arrays met enen of nullen te maken, de shape van de array doorgeven die je wilt maken. Als optie bij np.ones() en np.zeros() kun je ook het datatype specificeren. In het geval van np.full() moet je ook de constante waarde opgeven die je in de array wilt zetten.
• Met np.linspace() en np.arange() kun je arrays met gelijkmatig verdeelde waarden maken. Het verschil tussen deze twee functies is dat de laatste waarde van de drie die hierboven worden doorgegeven ofwel de stapgrootte aanduidt voor np.linspace() of een aantal samples voor np.arange(). Wat er in het eerste geval gebeurt, is dat je bijvoorbeeld een array van 9 waarden wilt die tussen 0 en 2 liggen. Voor de tweede geef je aan dat je een array wilt die bij 10 begint en met stappen van 5 waarden voor de array genereert die je maakt.

Onthoud dat NumPy je ook laat een identiteitsarray of -matrix maken met np.eye() en np.identity(). Een identiteitsmatrix is een vierkante matrix waarvan alle elementen op de hoofddiagonaal enen zijn en alle andere elementen nullen. Als je een matrix vermenigvuldigt met een identiteitsmatrix, blijft de gegeven matrix onveranderd.

Met andere woorden, als je een matrix vermenigvuldigt met een identiteitsmatrix, is het resultaat volgens de standaardconventies van matrixvermenigvuldiging weer dezelfde matrix.

Hoewel de focus van deze tutorial niet ligt op het demonstreren van hoe identiteitsmatrices werken, is het genoeg om te zeggen dat identiteitsmatrices nuttig zijn wanneer je met matrixberekeningen begint: ze kunnen wiskundige vergelijkingen vereenvoudigen, wat je berekeningen efficiënter en robuuster maakt.

Hoe laad je NumPy-arrays uit tekst

Arrays maken met behulp van initiële placeholders of met wat voorbeelddata is een uitstekende manier om met numpy te beginnen. Maar als je met data-analyse aan de slag wilt, zul je data uit tekstbestanden moeten laden.

Met wat je tot nu toe hebt gezien, kom je niet heel ver. Maak gebruik van specifieke functies om data uit je bestanden te laden, zoals loadtxt() of genfromtxt().

Stel dat je de volgende tekstbestanden met data hebt; je zou de becommentarieerde waarden in de onderstaande code kopiëren en plakken, ze plakken in het tekstbestand en opslaan als “data.txt”. Je kunt dan de onderstaande code gebruiken:

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

In de bovenstaande code gebruik je loadtxt() om de data in je omgeving te laden. Je ziet dat het eerste argument dat beide functies nemen het tekstbestand data.txt is. Vervolgens zijn er enkele specifieke argumenten: in de eerste instructie sla je de eerste rij over en geef je de kolommen terug als aparte arrays met unpack=TRUE. Dit betekent dat de waarden in kolom Value1 in x worden gezet, enzovoort.

Let op dat er, als je kommagescheiden data hebt of als je het datatype wilt specificeren, ook de argumenten delimiter en dtype zijn die je aan de loadtxt()-argumenten kunt toevoegen.

Dat is gemakkelijk en rechttoe rechtaan, toch?

Laten we naar je tweede databestand kijken:

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

Je ziet dat je hier kiest voor genfromtxt() om de data te laden. In dit geval moet je omgaan met enkele missende waarden die worden aangegeven door de strings 'MISSING'.

Aangezien de genfromtxt()-functie tekenreeksen in numerieke kolommen omzet naar nan, kun je deze waarden omzetten naar andere waarden door het argument filling_values te specificeren. In dit geval kies je ervoor om de waarde van deze missende waarden op -999 te zetten.

Als je toevallig waarden hebt die niet naar nan worden geconverteerd door genfromtxt(), is er altijd nog het argument missing_values waarmee je precies kunt aangeven wat de missende waarden van je data zijn.

Maar dat is nog niet alles.

Tip: bekijk deze numpy.genfromtxt-pagina om te zien welke andere argumenten je kunt toevoegen om je data succesvol te importeren.

Je vraagt je nu misschien af wat het verschil tussen deze twee functies precies is.

De voorbeelden gaven dit misschien impliciet aan, maar in het algemeen geeft genfromtxt() je net wat meer flexibiliteit; Het is robuuster dan loadtxt().

Laten we dit verschil wat praktischer maken: de laatste, loadtxt(), werkt alleen wanneer elke rij in het tekstbestand hetzelfde aantal waarden heeft, dus als je eenvoudig met missende waarden wilt omgaan, zul je het meestal makkelijker vinden om genfromtxt() te gebruiken.

Maar dit is zeker niet de enige reden.

Een korte blik op het aantal argumenten dat genfromtxt() biedt, leert je dat er nog veel meer zaken zijn die je kunt specificeren in je import, zoals het maximale aantal rijen om te lezen of de optie om automatisch witruimtes uit variabelen te strippen.

Hoe sla je NumPy-arrays op

Als je alles hebt gedaan wat je met je arrays wilde doen, kun je ze ook naar een bestand opslaan. Als je de array naar een tekstbestand wilt opslaan, kun je hiervoor de functie savetxt() gebruiken:

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

Onthoud dat np.arange() een NumPy-array met gelijkmatig verdeelde waarden maakt. De derde waarde die je aan deze functie doorgeeft, is de stapgrootte.

Er zijn natuurlijk ook andere manieren om je NumPy-arrays naar tekstbestanden op te slaan. Bekijk de functies in de onderstaande tabel als je je data naar binaire bestanden of archieven wilt wegschrijven:

save()	Sla een array op naar een binair bestand in NumPy-.npy-formaat
savez()	Sla meerdere arrays op in een ongecomprimeerd .npz-archief
savez_compressed()	Sla meerdere arrays op in een gecomprimeerd .npz-archief

Voor meer informatie of voorbeelden van hoe je de bovenstaande functies kunt gebruiken om je data op te slaan, bekijk deze NumPy-referentiepagina of maak gebruik van een van de helpfuncties die NumPy biedt om direct meer te weten te komen!

Weet je niet zeker wat die NumPy-helpfuncties zijn?

Geen zorgen! Je leert er meer over in een van de volgende secties!

Hoe inspecteer je je NumPy-arrays

Naast de arrayattributen die hierboven zijn genoemd, namelijk data, shape, dtype en strides, zijn er nog enkele die je kunt gebruiken om eenvoudig meer over je arrays te weten te komen. De attributen die je misschien interessant vindt als je net begint, zijn de volgende:

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

Dit zijn bijna alle attributen die een array kan hebben.

Maak je geen zorgen als je niet het gevoel hebt dat ze allemaal nuttig voor je zijn op dit moment. Dat is vrij normaal, want zoals je in de vorige sectie hebt gelezen, ga je je pas zorgen maken over geheugen wanneer je met grote datasets werkt.

Let ook op dat je, naast de attributen, ook nog andere manieren hebt om meer informatie te verkrijgen en zelfs je array lichtjes aan te passen:

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

Nu je je array hebt gemaakt, ofwel door er zelf een te maken met np.array() of een van de initiële placeholderfuncties, of door je data in te laden via de functies loadtxt() of genfromtxt(), is het tijd om dieper in te gaan op het tweede kernelement dat de NumPy-bibliotheek echt definieert: wetenschappelijk rekenen.

Hoe transposeer je je arrays

Wat transposeeren van je arrays eigenlijk doet, is de dimensies ervan permuteren. Of, anders gezegd, je draait de shape van de array om. Laten we een klein voorbeeld nemen om het effect van transponeren te laten zien:

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

Tip: als de visuele vergelijking tussen de array en de getransponeerde versie niet helemaal duidelijk is, inspecteer dan de shape van de twee arrays om zeker te weten dat je begrijpt waarom de dimensies zijn verwisseld.

Let op dat er twee transposeerfuncties zijn. Beide doen hetzelfde; Er is niet veel verschil. Je moet wel rekening houden met het feit dat T meer een handige snelkoppeling is en dat je veel meer flexibiliteit hebt met np.transpose(). Daarom wordt aanbevolen om die functie te gebruiken als je meer argumenten wilt.

Alles is prima wanneer je arrays met meer dan één dimensie transponeert, maar wat gebeurt er als je alleen een 1D-array hebt? Denk je dat er een effect is?

Probeer het zelf in het onderstaande codeblok. Je 1D-array is al ingeladen:

import numpy as np
my_array = np.array([1,2,3,4])

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

Je hebt helemaal gelijk! Er is geen effect wanneer je een 1D-array transponeert!

Reshapen versus resizen van je arrays

Je hebt in de broadcasting-sectie misschien gelezen dat de dimensies van je arrays compatibel moeten zijn als je ze geschikte kandidaten voor rekenkundige operaties wilt maken. Maar de vraag wat je moet doen als dat niet het geval is, was nog niet beantwoord.

Welnu, hier krijg je het antwoord!

Wat je kunt doen als de arrays niet dezelfde dimensies hebben, is je array resizen. Je krijgt dan een nieuwe array terug die de shape heeft die je aan de functie np.resize() hebt doorgegeven. Als je je originele array doorgeeft samen met de nieuwe dimensies, en als die nieuwe array groter is dan die je oorspronkelijk had, wordt de nieuwe array gevuld met kopieën van de originele array die zo vaak worden herhaald als nodig is.

Als je echter gewoon np.resize() op de array toepast en je geeft de nieuwe shape door, wordt de nieuwe array gevuld met nullen.

Laten we dit proberen met een voorbeeld:

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

Naast resizen kun je je array ook reshapen. Dit betekent dat je een nieuwe vorm aan een array geeft zonder de data te veranderen. De sleutel tot reshapen is ervoor zorgen dat de totale grootte van de nieuwe array ongewijzigd blijft. Als je het voorbeeld neemt van array x dat hierboven werd gebruikt, met een grootte van 3 × 4 of 12, moet je ervoor zorgen dat de nieuwe array ook een grootte van 12 heeft.

Psst… Als je de grootte van een array met code wilt berekenen, gebruik dan het size-attribuut: x.size of x.reshape((2,6)).size:

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

Output: 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

Als niets anders werkt, kun je ook een array aan je oorspronkelijke array toevoegen of array-elementen invoegen of verwijderen om ervoor te zorgen dat je dimensies passen bij de andere array die je voor je berekeningen wilt gebruiken.

Een andere bewerking die handig kan zijn wanneer je de shape van arrays verandert, is ravel(). Met deze functie kun je je arrays flatten. Dit betekent dat als je ooit 2D-, 3D- of nD-arrays hebt, je deze functie kunt gebruiken om alles plat te maken naar een 1D-array.

Best handig, toch?

Hoe voeg je arrays toe

Wanneer je arrays aan je oorspronkelijke array toevoegt, worden ze “vastgelijmd” aan het einde van die oorspronkelijke array. Als je ervoor wilt zorgen dat wat je toevoegt niet aan het einde van de array komt, kun je overwegen om het in te voegen. Ga naar de volgende sectie als je daar meer over wilt weten.

Toevoegen is vrij eenvoudig dankzij de NumPy-bibliotheek; Je kunt gewoon gebruikmaken van np.append().

Bekijk hoe het werkt in het onderstaande codeblok. Vergeet niet dat je altijd kunt controleren welke arrays zijn geladen door bijvoorbeeld my_array in de IPython-shell te typen en op ENTER te drukken.

import numpy as np

my_array = np.array([1,2,3,4])

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

Output:

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

Let op dat my_array ongewijzigd blijft na het toevoegen omdat np.append() een nieuwe array retourneert in plaats van de oorspronkelijke array in-place te wijzigen.

Toevoegen aan my_2d_array:

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

Output: 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

Let erop dat wanneer je een extra kolom aan my_2d_array toevoegt, de as is gespecificeerd. Onthoud dat as 1 de kolommen aangeeft, terwijl as 0 de rijen aangeeft in 2D-arrays.

Hoe voeg je array-elementen in en verwijder je ze

Naast toevoegen kun je ook array-elementen invoegen en verwijderen. Zoals je misschien al raadt, zijn de functies die je hiervoor gebruikt np.insert() en np.delete():

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

Hoe voeg je arrays samen en splits je ze

Je kunt je arrays ook ‘mergen’ of samenvoegen. Er zijn allerlei functies die je daarvoor kunt gebruiken en de meeste staan hieronder vermeld.

Probeer ze uit, maar test ook in de IPython-shell wat de shape van de arrays is. De arrays die zijn geladen zijn x, my_array, my_resized_array en my_2d_array.

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

Je zult een paar dingen opmerken terwijl je de functies doorloopt:

• Het aantal dimensies moet hetzelfde zijn als je twee arrays wilt concatenaten met np.concatenate(). Als je dus een array met my_array wilt samenvoegen, die 1D is, moet je ervoor zorgen dat de tweede array die je hebt ook 1D is.
• Met np.vstack() combineer je moeiteloos my_array met my_2d_array. Je hoeft er alleen voor te zorgen dat, omdat je de arrays rij-gewijs stapelt, het aantal kolommen in beide arrays gelijk is. Je zou dus ook een array met shape (2,4) of (3,4) aan my_2d_array kunnen toevoegen, zolang het aantal kolommen maar overeenkomt. Anders gezegd: de arrays moeten dezelfde shape hebben langs alle assen behalve de eerste. Hetzelfde geldt wanneer je np.r[] wilt gebruiken.
• Voor np.hstack() moet je ervoor zorgen dat het aantal dimensies hetzelfde is en dat het aantal rijen in beide arrays gelijk is. Dat betekent dat je arrays zoals (2,3) of (2,4) kunt stapelen met my_2d_array, dat zelf een shape van (2,4) heeft. Alles is mogelijk zolang je ervoor zorgt dat het aantal rijen overeenkomt. Deze functie wordt nog steeds ondersteund door NumPy, maar je zou de voorkeur moeten geven aan np.concatenate() of np.stack().
• Met np.column_stack() moet je ervoor zorgen dat de arrays die je invoert dezelfde eerste dimensie hebben. In dit geval zijn beide shapes hetzelfde, maar als my_resized_array (2,1) of (2,) zou zijn, zouden de arrays nog steeds worden gestapeld.
• np.c_[] is een andere manier om te concatenaten. Ook hier moet de eerste dimensie van beide arrays overeenkomen.

Wanneer je arrays hebt samengevoegd, wil je ze op een gegeven moment misschien ook splitsen. Net zoals je ze horizontaal kunt stapelen, kun je dat ook doen maar dan verticaal. Je gebruikt respectievelijk np.hsplit() en np.vsplit():

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

Wat je in gedachten moet houden wanneer je deze splitfuncties gebruikt, is waarschijnlijk de shape van je array. Neem het bovenstaande geval als voorbeeld: my_stacked_array heeft een shape van (2,8). Als je de index wilt selecteren waarop de splitsing moet plaatsvinden, moet je de shape in gedachten houden.

Met np.histogram()

In tegenstelling tot wat de functie lijkt te suggereren, tekent de functie np.histogram() de histogram niet, maar berekent hij de voorkomens van de array die in elke bin vallen; Dit bepaalt de oppervlakte die elke balk van je histogram inneemt.

Wat je dan aan de functie np.histogram() doorgeeft, is eerst de inputdata of de array waarmee je werkt. De array wordt afgevlakt wanneer het histogram wordt berekend.

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

Je ziet dat als resultaat het histogram wordt berekend: de eerste array geeft de frequenties weer voor alle elementen van je array, terwijl de tweede array de bins weergeeft die zouden worden gebruikt als je geen bins specificeert.

Als je wel een aantal bins specificeert, zal het resultaat van de berekening anders zijn: de floats zijn weg en je ziet alleen gehele getallen voor de bins.

Er zijn nog andere argumenten die je kunt specificeren die het berekende histogram kunnen beïnvloeden. Je vindt ze allemaal hier.

Maar wat is het nut van het berekenen van zo’n histogram als je het niet kunt visualiseren?

Visualiseren is een fluitje van een cent met behulp van Matplotlib, maar je hebt np.histogram() niet nodig om het histogram te berekenen. plt.hist() doet dit zelf wanneer je de (afgevlakte) data en de bins doorgeeft:

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

De bovenstaande code geeft je vervolgens het volgende (basis)histogram:

np.meshgrid() gebruiken

Een andere manier om je array (indirect) te visualiseren is door np.meshgrid() te gebruiken. Het probleem waar je met arrays tegenaan loopt, is dat je 2D-arrays van x- en y-coördinaten nodig hebt. Met de bovenstaande functie kun je uit een array van x-waarden en een array van y-waarden een rechthoekig grid maken: de functie np.meshgrid() neemt twee 1D-arrays en produceert twee 2D-matrices die overeenkomen met alle paren (x, y) in de twee arrays. Vervolgens kun je deze matrices gebruiken om allerlei soorten plots te maken.

np.meshgrid() is vooral handig als je functies op een grid wilt evalueren, zoals de onderstaande code laat zien:

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

De bovenstaande code geeft het volgende resultaat: