Articles

Numpy standard deviation explained

by admin

Deze tutorial zal uitleggen hoe de Numpy standaardafwijking functie (AKA, np.SOA).

op een hoog niveau is de Nompy standaardafwijking functie eenvoudig. Het berekent de standaardafwijking van de waarden in een Numpy array.

maar de details over hoe de functie precies werkt zijn een beetje complex en vereisen enige uitleg.

Dit gezegd zijnde, zal deze tutorial uitleggen hoe de Numpy standaardafwijking functie te gebruiken.

Het zal de syntaxis van np verklaren.std (), en laat u duidelijke, stap-voor-stap voorbeelden zien van hoe de functie werkt.

de tutorial is georganiseerd in secties. U kunt klikken op een van de volgende links, die u naar de juiste sectie.

inhoudsopgave:

  • een zeer snel overzicht van Numpy
  • Inleiding tot Numpy standaardafwijking
  • de syntaxis van np.std
  • Numpy standaardafwijking voorbeelden
  • Numpy standaardafwijking FAQ

Dit gezegd hebbende, als u relatief nieuw bent voor Numpy, wilt u misschien de hele tutorial lezen.

een snelle beoordeling van Numpy

laten we beginnen met een veeeery snelle beoordeling van Numpy.

Wat is Numpy?

Numpy is een toolkit voor het werken met numerieke data

simpel gezegd, Numpy is een toolkit voor het werken met numerieke data.

ten eerste heeft Numpy een set tools voor het maken van een datastructuur, een Numpy array genaamd.

u kunt een Nobbelige array zien als een rij-en-kolom raster van getallen. Numpy arrays kunnen 1-dimensionaal, 2-dimensionaal of zelfs n-dimensionaal zijn.

een 2D array ziet er ongeveer zo uit:

een voorbeeld van een 2-dimensionale NumPy array met de getallen 0 tot en met 7.

omwille van de eenvoud, in deze tutorial, zullen we vasthouden aan 1 of 2-dimentionele arrays.

er zijn verschillende manieren om verschillende typen arrays met verschillende soorten getallen aan te maken. Een paar andere tools voor het maken van Numpy arrays omvatten numpy arrangement, numpy nullen, numpy enen, numpy tile, en andere methoden.

ongeacht hoe u uw Numpy array maakt, op een hoog niveau zijn ze gewoon arrays van getallen.

Numpy biedt tools voor het manipuleren van Numpy arrays

Numpy biedt niet alleen tools voor het maken van Numpy arrays, Numpy biedt ook tools voor het werken met Numpy arrays.

enkele van de belangrijkste van deze Numpy tools zijn Numpy functies voor het uitvoeren van berekeningen.

Er is een hele set van Numpy functies voor het doen van dingen zoals:

  • berekenen van de som van een Numpy array
  • berekenen van het maximum
  • berekenen van de exponentiële van de getallen in een array
  • berekenen van de waarde x tot enig vermogen, voor elke waarde in een Numpy array

… en een verscheidenheid aan andere berekeningen.

de standaarddeviatie van Numpy lijkt in wezen veel op deze andere Numpy tools. Het wordt gewoon gebruikt om een berekening (de standaardafwijking) uit te voeren van een groep getallen in een Numpy array.

een snelle introductie tot Nompy standaardafwijking

op een zeer hoog niveau is standaardafwijking een maat voor de verspreiding van een dataset. In het bijzonder, het is een maat van hoe ver de datapunten zijn van het gemiddelde van de gegevens.

laten we kort de basisberekening bekijken.

standaarddeviatie wordt berekend als de vierkantswortel van de variantie.

dus als we een dataset hebben met N getallen, zal de variantie:

\begin{equation*} \frac{1}{N} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2 \end{equation*}

En de standaarddeviatie wordt de vierkantswortel van de variantie:

\begin{equation*} \sqrt{\frac{1}{N} \displaystyle\sum_{i=1}^N (x_i - \overline{x})^2} \end{equation*}

Waar:

x_i = de individuele waarden in de dataset
N = het aantal waarden in de dataset
\overline{x} = het gemiddelde van de waarden x_i

de Meeste van de tijd, de berekening van de standaardafwijking met de hand is een beetje ingewikkeld, want je moet voor het berekenen van het gemiddelde, de afwijkingen van elk gegevenspunt van het gemiddelde, dan is het kwadraat van de afwijkingen, etc. Eerlijk gezegd is het een beetje vervelend.

Als u echter in Python werkt, kunt u de Standaarddeviatiefunctie van Numpy gebruiken om de berekening voor u uit te voeren.

een korte opmerking als je nieuw bent in statistieken

omdat deze blogpost gaat over het gebruik van de numpy.std () functie, Ik wil niet te diep in het onkruid over hoe de berekening wordt uitgevoerd met de hand. Deze tutorial gaat echt over hoe we de functie gebruiken. Dus, als u een snelle herziening van wat standaarddeviatie is nodig, kunt u deze video bekijken.

Ok. Na snel te hebben beoordeeld wat standaarddeviatie is, laten we eens kijken naar de syntaxis voor np.SOA.

de syntaxis van np.std

de syntaxis van de Numpy standaardafwijking functie is vrij eenvoudig.

Ik leg het zo uit, maar eerst wil ik je een korte opmerking vertellen over Numpy syntaxis.

een snelle opmerking: de exacte syntaxis hangt af van hoe u Numpy

importeert wanneer we Numpy syntaxis schrijven, gebruiken we meestal de alias “np”. Dat is de gemeenschappelijke conventie onder de meeste datawetenschappers.

om die alias in te stellen, moet u Numpy als volgt importeren:

import numpy as np

als we Numpy importeren met deze alias, kunnen we de Numpy standaardafwijking functie noemen als np.std().

Ok, dat gezegd hebbende, laten we eens een kijkje nemen op de syntaxis.

np.std syntaxis

op een hoog niveau, de syntaxis voor np.std ziet er ongeveer zo uit:

een afbeelding die de syntaxis van Numpy standaardafwijking verklaart.

zoals ik al eerder zei, aangenomen dat we Numpy hebben geïmporteerd met de alias “np” noemen we de functie met de syntaxis np.std().

dan binnen de haakjes, zijn er verschillende parameters die u toelaten om precies te bepalen hoe de functie werkt.

laten we eens kijken naar deze parameters.

de parameters van numpy.std

Er zijn een paar belangrijke parameters die u moet weten:

  • a
  • axis
  • dtype
  • ddof
  • keepdims
  • out

Laten we een kijkje nemen op elk van hen.

a(vereist)

De parameter a specificeert de reeks waarden waarover u de standaardafwijking wilt berekenen.

anders gezegd, dit stelt u in staat om de input array voor de functie te specificeren.

geschikte ingangen zijn Numpy arrays, maar ook “array-achtige” objecten zoals Python lijsten.

belangrijk is dat u een input moet geven voor deze parameter. Een input is vereist.

Dit gezegd hebbende, kan de parameter zelf impliciet of expliciet zijn. Wat ik daarmee bedoel, is dat je direct de parameter a= kunt typen, of je kunt de parameter uit je syntaxis laten, en gewoon de naam van je input array typen.

Ik zal u voorbeelden hiervan tonen in Voorbeeld 1.

axis

met de asparameter kunt u een as specificeren waarlangs de standaardafwijking wordt berekend.

om dit te begrijpen, moet u echt de assen begrijpen.

Numpy arrays hebben Assen.

u kunt denken aan een” as ” als een richting langs de array.

in een 2-dimensionale array zijn er 2 assen: axis-0 en axis-1.

in een 2D-array wijst as-0 naar beneden langs de rijen, en as-1 punten horizontaal langs de kolommen.

visueel kunt u de assen van een 2D-array visualiseren zoals dit:

een visueel voorbeeld van NumPy array-Assen.

met de parameter axis kunt u de standaardafwijking in een bepaalde richting langs de array berekenen.

Dit is het best geïllustreerd met voorbeelden, dus Ik zal je een voorbeeld laten zien in Voorbeeld 2.

(voor een volledige uitleg van Numpy array Assen, zie onze tutorial genaamd Numpy axes explained.)

dtype

(optioneel)
met de parameter dtype kunt u het gegevenstype opgeven dat u wilt gebruiken wanneer np.soa berekent de standaardafwijking.

als de gegevens in de input array gehele getallen zijn, dan zal dit standaard float64zijn.

anders, als de gegevens in de input array floats zijn, dan zal dit standaard hetzelfde float type zijn als de input array.

ddof

(optioneel)
Hiermee kunt u de” vrijheidsgraden ” voor de berekening opgeven.

om dit te begrijpen, moet u Vergelijking 2 opnieuw bekijken.

\

in deze vergelijking is de eerste term \frac{1}{n}.

onthoud: N is het aantal waarden in de array of dataset.

maar als we in statistische termen denken, is er eigenlijk een verschil tussen het berekenen van een populatie standaarddeviatie versus een steekproef standaarddeviatie.

als we een populatie standaarddeviatie berekenen, gebruiken we de term \frac{1}{N} in onze vergelijking.

echter, wanneer we de standaardafwijking berekenen op een steekproef van gegevens (een steekproef van n datapunten), dan moeten we de vergelijking wijzigen zodat de leidende term \frac{1}{n - 1}is. In dat geval wordt de vergelijking voor een standaarddeviatie van een monster:

\begin{vergelijking*} s_{sample} = \sqrt{\frac{1}{n - 1} \displaystyle\sum_{i=1}^n (x_i - \overline{x})^2} \end{vergelijking*}

hoe implementeren we dit met NP.soa?

We kunnen dit doen met deddof parameter, doorddof = 1in te stellen.

en in feite kunnen we de term ddof algemener instellen. Wanneer we ddof gebruiken, zal het de berekening van de standaardafwijking wijzigen in:

\begin{vergelijking*} \sqrt{\frac{1}{n - ddof} \displaystyle\sum_{i=1}^n (x_i - \overline{x})^2} \end{equation*}

om eerlijk te zijn is dit een beetje technisch. Als je hier meer over wilt weten, moet je deze video op Khan academy bekijken over vrijheidsgraden en populatie Versus standaarddeviatie van monsters.

out

(optioneel)
met de parameter out kunt u een alternatieve array opgeven waarin de uitvoer moet worden geplaatst.

Het moet dezelfde vorm hebben als de verwachte uitvoer.

keepdims

(optioneel)
De parameter keepdims kan worden gebruikt om het oorspronkelijke aantal dimensies te” behouden”. Als u keepdims = True instelt, zal de uitvoer hetzelfde aantal dimensies hebben als de invoer.

onthoud: wanneer we de standaardafwijking berekenen, zal de berekening het aantal dimensies “samenvouwen”.

bijvoorbeeld, als we een 2-dimensionale array invoeren als invoer, dan is standaard np.std geeft een getal uit. Een scalaire waarde.

maar als we willen dat de uitvoer een getal is binnen een 2D array (d.w.z. een uitvoer array met dezelfde afmetingen als de input), dan kunnen we keepdims = Trueinstellen.

om eerlijk te zijn, sommige van deze parameters zijn een beetje abstract, en ik denk dat ze veel zinvoller zullen zijn met voorbeelden.

laten we een paar voorbeelden bekijken.

voorbeelden van het gebruik van Numpy standaardafwijking

Hier zullen we een paar voorbeelden doornemen. We beginnen eenvoudig en verhogen dan de complexiteit.

voorbeelden:

  • Bereken de standaardafwijking van een 1-dimensionale array
  • Bereken de standaardafwijking van een 2-dimensionale array
  • gebruik np.gebruik np om de standaardafwijkingen van de kolommen
  • te berekenen.std om de standaardafwijkingen van de rijen
  • te berekenen Verander de vrijheidsgraden
  • gebruik de keepdims-parameter in np.std

Voer deze code eerst uit

voordat u een van de voorbeeldcode uitvoert, moet u Numpy importeren.

hiervoor kunt u de volgende code uitvoeren:

import numpy as np

Dit zal Numpy importeren met de alias “np“.

voorbeeld 1: Bereken de standaardafwijking van een 1 dimensionale array

Hier beginnen we eenvoudig.

We gaan de standaardafwijking van een eendimensionale Numpy array berekenen.

Create 1D array

eerst maken we gewoon onze 1D array:

array_1d = np.array()
Bereken standaard dev

nu berekenen we de standaardafwijking van die getallen.

np.std(array_1d)

OUT:

30.84369195367723

dus wat is hier gebeurd?

Het np.de functie std heeft zojuist de standaardafwijking van de getallen berekend met behulp van vergelijking 2 die we eerder zagen. Elk getal is een van de x_i in die vergelijking.

Eén snelle noot

in het bovenstaande voorbeeld hebben we de parameter a= niet expliciet gebruikt. Dat komt omdat np.std begrijpt dat wanneer we een argument geven aan de functie zoals in de code np.std(array_1d), de invoer moet worden doorgegeven aan de parameter a.

U kunt ook expliciet dea= parameter:

np.std(a = array_1d)

OUT:

30.84369195367723

voorbeeld 2: Bereken de standaardafwijking van een 2-dimensionale array

Ok. Laten we nu eens kijken naar een voorbeeld met een 2-dimensionale array.

Create 2-dimensional array

Hier gaan we een 2D array maken, met behulp van de np.willekeurig.randint functie.

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

deze array heeft 3 rijen en 4 kolommen.

laten we het uitprinten, zodat we het kunnen zien.

print(array_2d)

OUT:

 ]

Dit is slechts een 2D array die 12 willekeurige gehele getallen tussen 0 en 20 bevat.

Bereken de standaardafwijking met np.std

Oké, laten we de standaardafwijking berekenen.

np.std(array_2d)

OUT:

5.007633062524539

Hier, numpy.std () is gewoon het berekenen van de standaardafwijking van alle 12 gehele getallen.

de standaardafwijking is 5.007633062524539.

voorbeeld 3: Bereken de standaardafwijking van de kolommen

nu gaan we de standaardafwijking van de kolommen berekenen.

om dit te doen, moeten we de parameter axis gebruiken. (U leerde over deaxis parameter in de sectie over de parameters van numpy.std)

specifiek moeten we axis = 0instellen.

waarom?

zoals ik al zei in de uitleg van de axis parameter eerder, hebben Numpy arrays Assen.

in een tweedimensionale array is as-0 de as die naar beneden wijst.

een NumPy array die toont dat axis = 0 de as is onderaan de rijen van de array.

wanneer we numpy gebruiken.std met axis = 0, die de standaarddeviaties naar beneden berekent in de as-0 richting.

laten we een voorbeeld bekijken zodat je kunt zien wat ik bedoel.

Create 2-dimensional array

eerst maken we een 2D array, met behulp van de np.willekeurig.randint functie.

(Dit is dezelfde array die we hebben gemaakt in Voorbeeld 2, dus als je het al hebt gemaakt, hoef je het niet opnieuw te maken.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

laten we het uitprinten, zodat we het kunnen zien.

print(array_2d)

OUT:

 ]

Dit is slechts een 2D array die gehele getallen tussen 0 en 20 bevat.

gebruik np.std om de standaardafwijking van de kolommen

te berekenen, zetten we nu axis = 0 binnen in np.std om de standaardafwijkingen van de kolommen te berekenen.

np.std(array_2d, axis = 0)

OUT:

array()
uitleg

Wat gebeurt hier?

wanneer we np gebruiken.std met axis = 0 berekent Numpy de standaardafwijking naar beneden in de as-0 richting. Onthoud, zoals ik hierboven al zei, as-0 wijst naar beneden.

Dit heeft het effect van het berekenen van de standaardafwijking van elke kolom van de Numpy array.

een afbeelding die laat zien hoe Numpy standaardafwijking met axis = 0 wordt gebruikt om de standaardafwijkingen van de kolom te berekenen.

laten we nu een vergelijkbaar voorbeeld doen met de standaarddeviaties van de rij.

voorbeeld 4: Gebruik np.std om de standaardafwijkingen van de rijen

te berekenen, gaan we nu np gebruiken.std om de standaarddeviaties horizontaal te berekenen langs een 2D numpy array.

onthoud wat ik eerder zei: numpy arrays hebben Assen. De assen zijn als richtingen langs de Numpy array. In een 2D array, as-1 punten horizontaal, zoals dit:

een afbeelding die laat zien hoe as-1 horizontaal langs een 2D Numpy array wijst.

dus, als we de standaardafwijkingen horizontaal willen berekenen, kunnen we axis = 1instellen. Dit heeft het effect van de berekening van de standaarddeviaties van de rij.

laten we eens kijken.

Create 2-dimensional array

om dit voorbeeld uit te voeren, hebben we opnieuw een 2D Numpy array nodig, dus maken we een 2D array met de np.willekeurig.randint functie.

(Dit is dezelfde array die we hebben gemaakt in Voorbeeld 2, dus als je het al hebt gemaakt, hoef je het niet opnieuw te maken.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

laten we het uitprinten, zodat we het kunnen zien.

print(array_2d)

OUT:

 ]

Dit is slechts een 2D array die gehele getallen tussen 0 en 20 bevat.

gebruik np.std om de standaardafwijking van de rijen

te berekenen, gebruiken we nu np.std met axis = 1 om de standaardafwijkingen van de rijen te berekenen.

np.std(array_2d, axis = 1)

OUT:

array()
uitleg

Als u Voorbeeld 3 hebt begrepen, zou dit nieuwe voorbeeld zinvol moeten zijn.

wanneer we np gebruiken.std en set axis = 1, Numpy berekent de standaardafwijkingen horizontaal langs as-1.

een afbeelding die wordt weergegeven met np.std met as = 1 om de standaarddeviaties van de rij te berekenen.

effectief, wanneer we Numpy standaardafwijking gebruiken met axis = 1, berekent de functie de standaardafwijking van de rijen.

voorbeeld 5: Verander de vrijheidsgraden

laten we nu de vrijheidsgraden veranderen.

hier in dit voorbeeld gaan we een grote array van getallen maken, een sample nemen van die array, en de standaardafwijking berekenen op dat sample.

laten we eerst onze arrays maken.

Create Numpy array

eerst maken we gewoon een normaal gedistribueerde Numpy array met een gemiddelde van 0 en een standaardafwijking van 10.

om dit te doen, gebruiken we de Numpy random normal functie. Merk op dat we de Numpy random seed functie gebruiken om de seed voor de random number generator in te stellen. Voor meer informatie hierover, lees onze tutorial over np.willekeurig.zaad.

np.random.seed(22)population_array = np.random.normal(size = 100, loc = 0, scale = 10)

Ok. Nu hebben we een Numpy array, population_array, die 100 elementen heeft met een gemiddelde van 0 en een standaardafwijking van 10.

create sample

nu zullen we Numpy random choice gebruiken om een willekeurige sample uit de Numpy array te nemen, population_array.

np.random.seed(22)sample_array = np.random.choice(population_array, size = 10)

Deze nieuwe array, sample_array, is een willekeurige steekproef van 10 elementen uit population_array.

we gebruiken sample_array wanneer we onze standaardafwijking berekenen met behulp van de parameter ddof.

Bereken de standaardafwijking van het monster

nu berekenen we de standaardafwijking van het monster.

specifiek gaan we de Numpy standaardafwijking functie gebruiken met de ddof parameter ingesteld op ddof = 1.

np.std(sample_array, ddof = 1)

OUT:

10.703405562234051
verklaring

Hier hebben we berekend:

\

En als we ddof = 1 de vergelijking resulteert in:

\

om duidelijk Te zijn, bij het berekenen van de standaardafwijking van een steekproef, stelt u ddof = 1.

om eerlijk te zijn, de details over waarom zijn een beetje technisch (en buiten het bereik van dit bericht), dus voor meer informatie over het berekenen van een steekproef standaardafwijking, raad ik u aan om deze video te bekijken.

Houd er rekening mee dat u voor sommige andere gevallen ddof kunt instellen op andere waarden dan 1 of 0. Als u de parameter ddof helemaal niet gebruikt, zal deze standaard op 0 staan.

ongeacht welke waarde u selecteert, de Numpy standaardafwijking functie berekent de standaardafwijking met de vergelijking:

\

voorbeeld 6: Gebruik de keepdims parameter in np.std

Ok. Tot slot doen we nog een laatste voorbeeld.

Hier gaan we de parameter keepdims instellen op keepdims = True.

Create 2-dimensional array

eerst maken we een 2D array, met behulp van de np.willekeurig.randint functie.

(Dit is dezelfde array die we hebben gemaakt in Voorbeeld 2, dus als je het al hebt gemaakt, hoef je het niet opnieuw te maken.) 

np.random.seed(22)array_2d = np.random.randint(20, size =(3, 4))

laten we het uitprinten:

print(array_2d)

OUT:

 ]
controleer de dimensies

nu, laten we een kijkje nemen op de dimensies van deze array.

array_2d.ndim

OUT:

2

Dit is een 2D array, precies zoals we bedoeld hadden.

Bereken de standaardafwijking en controleer de afmetingen

Ok. Nu gaan we de standaardafwijking berekenen, en de afmetingen van de output controleren.

output = np.std(array_2d)

laten we snel de uitvoer afdrukken:

print(output)

OUT:

5.007633062524539

dus de standaardafwijking is 5.007633062524539.

nu, wat zijn de afmetingen van de uitvoer?

output.ndim

OUT:

0

De uitvoer heeft 0 dimensies (het is een scalaire waarde).

waarom?

wanneer np.soa berekent de standaardafwijking, het berekent een samenvatting statistiek. In dit geval neemt de functie een groot aantal waarden en vouwt ze in tot één enkele metriek.

dus de input was 2-dimensionaal, maar de output is 0-dimensionaal.

Wat als we dat willen veranderen?

Wat als we willen dat de uitvoer technisch 2-dimensies heeft?

We kunnen dat doen met de parameter keepdims.

bewaar de originele afmetingen wanneer we np gebruiken.std

hier zullen we keepdims = True Instellen om de uitvoer dezelfde afmetingen te geven als de invoer.

laten we nu eens kijken naar de uitvoer:

print(output_2d)

OUT:

]

merk op dat de uitvoer, de standaardafwijking, nog steeds 5.00763306 is. Maar het resultaat is ingesloten tussen dubbele beugels.

laten we output_2d inspecteren en een kijkje nemen.

type(output_2d)

OUT:

numpy.ndarray

So, output_2d is een Numpy array, geen scalaire waarde.

laten we de dimensies controleren:

output_2d.ndim

OUT:

2

Deze Numpy array, output_2d heeft 2 dimensies.

Dit is hetzelfde aantal dimensies als de invoer.

Wat is er gebeurd?

toen we keepdims = True instelden, veroorzaakte dat de np.std-functie om een uitgang te produceren met hetzelfde aantal dimensies als de ingang. Hoewel er geen rijen en kolommen in de uitvoer staan, heeft de uitvoer output_2d 2 dimensies.

dus, als je ooit nodig hebt dat je uitvoer hetzelfde aantal dimensies heeft als je invoer, kun je keepdims = Trueinstellen.

(Dit werkt ook als u de axis parameter gebruikt … probeer het!)

Veelgestelde vragen over Numpy standaardafwijking

Nu u over Numpy standaardafwijking hebt geleerd en enkele voorbeelden hebt gezien, laten we enkele veelgestelde vragen over np bekijken.SOA.

Veelgestelde vragen:

  • Waarom geeft numpy std() een ander resultaat dan matlab std() of een andere programmeertaal?

Vraag 1: Waarom geeft numpy std() een ander resultaat dan matlab std() of een andere programmeertaal?

De eenvoudige reden is dat matlab de standaard dev berekent als volgt:

\

(veel andere hulpmiddelen gebruiken dezelfde vergelijking.)

echter, Numpy berekent met het volgende:

\

merk het subtiele verschil op tussen de \frac{1}{n - 1} vs de \frac{1}{n}.

om dit op te lossen, kunt u de parameter ddof gebruiken in Numpy.

Als u np gebruikt.std met de parameterddof ingesteld op ddof = 1, krijgt u hetzelfde antwoord als matlab.

laat uw andere vragen achter in de opmerkingen hieronder

heeft u andere vragen over de Numpy standaardafwijking functie?

laat uw vraag achter in de commentaren hieronder.

doe mee aan onze cursus om meer te leren over Numpy

De voorbeelden die je in deze tutorial hebt gezien moeten genoeg zijn om je op weg te helpen, maar als je serieus bent over het leren van Numpy, moet je je inschrijven voor onze premium cursus genaamd Numpy Mastery.

Er is veel meer te leren over Numpy, en Numpy meesterschap zal je alles leren, inclusief:

  • Hoe maak je Numpy arrays
  • Hoe gebruik je de Numpy random functies
  • Wat doet de “Numpy random seed” functie
  • Hoe maak je een nieuwe vorm, split, en combineer je Numpy arrays
  • en meer …

bovendien zal het je helpen de syntaxis binnen een paar weken volledig onder de knie te krijgen. Je zult ontdekken hoe je “vloeiend” wordt in het schrijven van Numpy code.

meer informatie hier:

meer informatie over Numpy meesterschap