NumPy-arrays en gevectoriseerd rekenen

NumPy slaat numerieke gegevens op in arrays, zodat één expressie op veel waarden kan werken. Importeer NumPy met import numpy as np; de korte naam np is de gebruikelijke manier om de functies aan te roepen.

Lees de structuur van een array af

Een ndarray is een rechthoekig raster waarvan de elementen één datatype delen. Een dimensie wordt ook een as genoemd. Begin met een kleine tabel:

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

De attributen beantwoorden vier verschillende vragen:

As 0 indexeert rijen; as 1 indexeert kolommen. Een gegevenstabel met één rij per persoon en kolommen voor lengte, massa en leeftijd heeft voor 100 personen vorm (100, 3). Het product van de waarden in de vorm geeft het aantal elementen.

Een vector heeft geen rij- of kolomas

np.array([2, 4, 6, 8]) heeft vorm (4,) en één as. De komma maakt hiervan een tuple met één item. Vorm (1, 4) heeft twee assen: één rij en vier kolommen. Vorm (4, 1) heeft ook twee assen, maar vier rijen en één kolom. Deze arrays bevatten vier waarden, maar gedragen zich anders als je ze met andere arrays combineert. np.array(7) is een nuldimensionale array: de vorm is () en de ndim is 0.

Arrays veranderen de betekenis van operatoren

Een lijst is een algemene Python-container. Een array is ontworpen voor berekeningen op overeenkomstige posities.

Bij het optellen van de arrays wordt 1 gekoppeld aan 3 en 2 aan 4. Het aantal elementen van de array blijft gelijk.

Waarom numerieke arrays efficiënt zijn

Een nieuw gemaakte numerieke array slaat waarden van hetzelfde type bij elkaar op in het geheugen. NumPy doorloopt deze waarden in gecompileerde code en vermijdt zo een afzonderlijke bewerking op Python-niveau voor elk getal. Een miljoen float64-waarden nemen 8.000.000 bytes aan elementopslag in. Bij een array van die omvang kun je dit aflezen met a.nbytes. Een Python-lijst slaat ook verwijzingen naar Python-objecten op en heeft daardoor aanzienlijk meer ruimte nodig. De prestatiewinst hangt af van de berekening en de computer.

Het aantal elementen van een array groeit niet door een append-methode in het bestaande geheugen. np.append(a, value) reserveert geheugen voor een nieuwe array. Voor gegevens die je één waarde tegelijk verzamelt, maak je een Python-lijst die je één keer converteert. Geneste invoer moet rechthoekig zijn: np.array([[1, 2], [3]]) geeft een ValueError omdat de rijlengtes verschillen.

Herken weergegeven resultaten

print(np.array([1, 2, 3])) toont [1 2 3]. Een interactieve weergave gebruikt array([1, 2, 3]). Voor np.array([5, 6])[0] op een 64-bitscomputer toont NumPy 2 np.int64(5); deze waarde neemt als het getal 5 deel aan berekeningen.

Kies een aanmaakfunctie door na te gaan wat je weet: de daadwerkelijke waarden, een vorm en vulwaarde, een stapgrootte of een vereist aantal punten. Die keuze laat de code uitdrukken hoe de gegevens moeten worden opgebouwd.

Begin met waarden of een vorm

np.array([3, 1, 4]) maakt een vector. Een lijst van even lange lijsten maakt een tabel. Geef de waarden als één reeks door; met np.array(1, 2, 3) geef je de drie elementen niet correct op.

Bij een multidimensionale vorm zijn de haakjes belangrijk. np.zeros((2, 3)) geeft één tuple door. Bij np.zeros(2, 3) geeft Python 3 door als argument voor het datatype, wat een typefout veroorzaakt. Nullen en enen gebruiken standaard float64; full leidt het datatype af uit de vulwaarde. Voeg dtype=int toe als je opslag voor gehele getallen nodig hebt.

empty garandeert geen nullen of betekenisvolle beginwaarden. Lees de array pas nadat je elk element dat je gaat gebruiken een waarde hebt gegeven. zeros is een eenvoudigere keuze als een beginwaarde van nul betekenis heeft.

Kies een stap of een aantal punten

np.arange(start, stop, step) volgt hetzelfde principe van stappen als range van Python. np.arange(2, 11, 3) geeft [2 5 8]: begin bij 2 en tel steeds 3 op zolang je onder 11 blijft. Met één argument begint np.arange(5) bij 0 en geeft de functie [0 1 2 3 4].

Stappen met drijvendekommagetallen kunnen verrassende eindpunten opleveren. Zo bevat np.arange(1, 1.3, 0.1) de weergegeven waarde 1,3 omdat binaire afronding de berekening van de reeks beïnvloedt. Gebruik voor een decimaal raster met een vast aantal punten linspace:

grid = np.linspace(0, 1, 5)
# array([0.  , 0.25, 0.5 , 0.75, 1.  ])

Beide eindpunten worden standaard meegenomen. Vijf punten maken vier tussenruimtes. Tien punten tussen 0 en 1 maken negen tussenruimtes, dus hun afstand is ongeveer 0,111; voor stappen van 0,1 zijn 11 punten nodig.

Gebruik een bestaande structuur opnieuw

np.zeros_like(a), np.ones_like(a) en np.full_like(a, value) maken nieuwe arrays met de vorm en het datatype van a. Het overgenomen datatype is van belang: als je een sjabloon met gehele getallen vult met een decimaal getal, kan het decimale deel verloren gaan tenzij je om een drijvendekommatype vraagt. np.eye(3) maakt een vierkante eenheidsmatrix met enen op de diagonaal en elders nullen.

Reserveer één keer geheugen voor een gegevenstabel

Voor neerslag in millimeters op drie meetstations gedurende vier weken:

rain = np.zeros((3, 4))
rain[0] = [12.0, 0.0, 5.5, 8.0]

De eerste toekenning vult één rij en behoudt vorm (3, 4). Als het aantal metingen bekend is, voorkom je door geheugen voor de volledige tabel te reserveren dat je herhaaldelijk geheugen voor grotere arrays moet reserveren. Als de hoeveelheid invoer onbekend is, verzamel je waarden in een lijst en roep je np.array aan zodra het verzamelen klaar is.

Het datatype van een array bepaalt wat die kan opslaan en hoeveel geheugen elke waarde nodig heeft. Door het juiste type te kiezen voorkom je ook dat berekeningen ongemerkt informatie verliezen.

Controleer het opslagtype

int64 bevat 64-bits gehele getallen, float64 bevat binaire drijvendekommagetallen en bool bevat waar-of-onwaarwaarden. Unicode-datatypes zoals <U5 slaan tekst op met een maximaal aantal tekens. a.itemsize is het aantal bytes per element; a.nbytes is a.size * a.itemsize. Een float64 gebruikt 8 bytes en heeft een precisie van ongeveer 15 significante decimale cijfers.

Op doorsnee 64-bitscomputers gebruikt invoer van gehele getallen 64-bits gehele getallen. NumPy 2 gebruikt die standaard ook op 64-bits Windows. Decimale invoer geeft normaal gesproken float64.

Automatische typeafleiding kiest één gedeeld type

np.array([1, 2.5]) wordt [1. 2.5]: het gehele getal wordt weergegeven als float. np.array([True, 2]) wordt [1 2]. Als je getallen en tekst mengt, kan de hele array in tekst veranderen, zodat een label zoals 'n/a' latere berekeningen kan laten mislukken. Controleer dtype als gegevens die numeriek lijken niet kunnen worden opgeteld of vermenigvuldigd.

Converteer bewust

astype geeft een geconverteerde kopie terug:

x = np.array([1.7, -1.7, 2.5])
whole = x.astype(int)
# array([ 1, -1,  2])

Deze conversie kapt af richting nul; die rondt niet af. np.round(x).astype(int) geeft [2 -2 2] omdat exacte halven worden afgerond naar het dichtstbijzijnde even getal. Tekst zoals '1.5' kan met astype(float) worden geconverteerd, maar 'n/a' geeft een ValueError. Schoon plaatsvervangende waarden op vóór de conversie.

Toekenningen gebruiken het datatype van de bestemming. Na a = np.array([1, 2, 3]) slaat de toekenning a[0] = 9.9 zonder waarschuwing 9 op. Als je eerst de hele array naar float converteert, kunnen latere toekenningen decimalen behouden.

Gehele getallen met een vaste breedte kunnen overlopen

Een int8 bevat waarden van −128 tot en met 127; een uint8 bevat 0 tot en met 255. Als je twee uint8-arrays met 250 en 10 optelt, krijg je door terugloop 4. Als je een int8-array met 100 vermenigvuldigt met 2, krijg je −56. Een geheel Python-getal dat niet in het arraytype past, zoals 300 opgeteld bij een int8-array in NumPy 2, geeft daarentegen een OverflowError. Zet kleine geheelgetaltypes om naar ruimere types voordat je berekeningen uitvoert die buiten hun bereik kunnen komen.

Delen en benaderde decimale getallen

Geheeltallige deling rondt naar beneden af, richting min oneindig. Bij negatieve resultaten verschilt dit van afkappen. Gewone deling geeft bij gehele invoer drijvendekommaresultaten terug.

Veel decimale breuken zijn binair opgeslagen benaderingen. 0.1 + 0.2 == 0.3 is onwaar; np.isclose vergelijkt overeenkomstige waarden met een tolerantie en np.allclose geeft één antwoord voor de hele array.

De markering voor ontbrekende waarden np.nan is een drijvendekommawaarde. Arrays met gehele getallen kunnen die niet opslaan. np.array([1, 2, np.nan]) wordt daarom een array met drijvendekommagetallen; ontbrekende waarden naar gehele getallen converteren herstelt ze niet en kan betekenisloze resultaten opleveren.

Met indexering zoek je waarden op positie. Met deelbereiken selecteer je een regelmatige reeks posities. Schrijf in een tabel voor elke as een selector, zodat de code aangeeft welke rijen en welke kolommen je nodig hebt.

Lees een vector

Voor a = np.array([10, 20, 30, 40, 50]) bevat positie 0 de waarde 10 en positie −1 de waarde 50. Een deelbereik heeft de vorm start:stop:step, waarbij de stoppositie is uitgesloten:

Als je start of stop weglaat, loopt het bereik door tot het betreffende uiteinde. Een deelbereik kan buiten de array lopen en wordt dan automatisch ingekort. Eén ongeldige positie, zoals a[5], geeft een IndexError.

Geef elke tabelas een eigen selector

m = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

m[1, 2] leest rij 1, kolom 2 en geeft 6. De komma scheidt de assen. Een dubbele punt op zichzelf selecteert de volledige as: m[0, :] geeft de eerste rij [1 2 3] en m[:, 1] geeft de tweede kolom [2 5 8]. Voor een blok selecteert m[:2, 1:] de rijen 0 en 1 en de kolommen 1 en 2, wat [[2 3] [5 6]] geeft.

Behandel herhaalde indexering met vierkante haken niet als uitwisselbaar met indexering met een komma. m[1][2] vindt toevallig dezelfde scalaire waarde als m[1, 2]. Maar m[:][0] neemt eerst alle rijen en selecteert daarna de eerste rij. Het selecteert niet de eerste kolom; dat doet m[:, 0].

Voorspel welke assen overblijven

Een selector met één gehele index verwijdert de bijbehorende as. Een deelbereik behoudt de as, ook als maar één positie is geselecteerd. Zo heeft m[:, 1] vorm (3,), terwijl m[:, 1:2] vorm (3, 1) heeft. Beide selecteren 2, 5 en 8, maar alleen de tweede behoudt een kolomas. Dit verschil wordt belangrijk als je arrays met andere vormen aftrekt of vermenigvuldigt.

Dezelfde regel geldt ook buiten tabellen. Als t.shape gelijk is aan (2, 3, 4), heeft t[0] vorm (3, 4), heeft t[0, 1] vorm (4,) en heeft t[:, :, 0] vorm (2, 3). Assen aan het eind die in de index zijn weggelaten, worden volledig geselecteerd.

Wijzig de geselecteerde posities

Een toekenning via een index schrijft in de bestaande array. a[1:3] = 0 vervangt beide geselecteerde waarden door nul; de scalaire waarde wordt op de hele selectie toegepast. m[0] = [0, 0, 0] vervangt een volledige rij. De toegekende waarden moeten passen bij de vorm van de selectie en worden geconverteerd naar het datatype ervan.

Voor vier leerlingen en drie toetsen:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores[2] is de uitvoer [88 91 95] van de derde leerling. scores[:, -1] geeft de resultaten van de laatste toets [92 58 95 80]. scores[1:3, :2] geeft [[64 70] [88 91]]: twee leerlingen, elk met behoud van twee toetskolommen.

Een selectie kan gegevens delen met de oorspronkelijke array of eigen, onafhankelijke gegevens hebben. Als je weet welke van de twee je hebt, voorkom je dat wijzigingen in een kleine selectie onverwacht een grotere tabel veranderen.

Onderscheid een alias, een weergave en een kopie

Voor a = np.arange(6) en b = a[2:5] maakt de toekenning b[0] = 99 de array a gelijk aan [0 1 99 3 4 5]. De eerste positie van de weergave verwijst naar positie 2 in het origineel. Dit verschilt van een deelbereik van een Python-lijst, dat een nieuwe lijst maakt.

Kopieer voordat je wijzigingen aanbrengt als het origineel intact moet blijven. Een kleine bewaarde weergave kan ook een grote oorspronkelijke gegevensbuffer in het geheugen houden; door dat kleine deel te kopiëren, kan het zelfstandig bestaan.

Selecteer willekeurige posities

Indexering met indexarrays gebruikt een lijst of array van gehele getallen. Hiermee kun je posities in een andere volgorde zetten en herhalen:

a = np.array([10, 20, 30, 40, 50])
a[[4, 0, 0]]
# array([50, 10, 10])

Voor m = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) selecteert m[[0, 2]] de eerste en derde rij. m[:, [2, 0]] selecteert de laatste en eerste kolom in die volgorde, wat [[3 1] [6 4] [9 7]] geeft.

Twee lijsten met gehele indexen in één index selecteren gepaarde coördinaten. m[[0, 2], [1, 2]] koppelt rij 0 aan kolom 1 en rij 2 aan kolom 2, wat [2 9] oplevert. Dit neemt niet alle combinaties. Gebruik het volgende om het blok van beide rijen en beide kolommen te krijgen:

m[np.ix_([0, 2], [1, 2])]
# array([[2, 3], [8, 9]])

Als je eerst de rijen en daarna de kolommen selecteert, m[[0, 2]][:, [1, 2]], krijg je hetzelfde blok.

Lezen en toekennen gedragen zich anders

Indexering met indexarrays en booleaanse filtering geven kopieën terug. Als c = a[[0, 1]], blijft a ongewijzigd wanneer je c[0] wijzigt. Maar a[[0, 1]] = -1 schrijft rechtstreeks naar die oorspronkelijke posities. Een opgeslagen selectie en een toekenning via een index zijn verschillende bewerkingen.

Dit verklaart ook waarom geketende wijzigingen de bron soms niet bereiken. In a[[0, 1]][0] = -1 is de eerste selectie al een tijdelijke kopie. De laatste schrijfbewerking wijzigt die tijdelijke array, niet a.

Controleer gedeeld geheugengebruik direct

np.shares_memory(x, y) controleert of twee arrays overlappen in het geheugen. De functie geeft waar terug voor een gewoon niet-leeg deelbereik en onwaar voor een kopie door indexering met indexarrays. Het attribuut base kan aangeven welk object eigenaar is van het onderliggende geheugen, maar hoeft niet de array aan te wijzen waaruit je het laatst een deelbereik nam. Als a = np.arange(6), b = a[2:5] en c = b[0:2], dan is c.base is a waar en c.base is b onwaar. Gebruik shares_memory als je specifiek wilt weten of twee arrays gegevens delen.

Een booleaans masker legt vast welke waarden aan een voorwaarde voldoen. Zodra een masker bestaat, kun je dezelfde waar-of-onwaarbeslissingen gebruiken om waarden te selecteren, gebeurtenissen te tellen of vervangende waarden te kiezen.

Maak een masker en pas het toe

t = np.array([18.5, 22.0, 15.2, 25.8, 21.1])
warm = t > 20
t[warm]
# array([22. , 25.8, 21.1])

De vergelijking levert [False True False True True] op. Booleaanse indexering behoudt de posities waar de waarde waar is en geeft een kopie terug. Een 1-dimensionaal masker dat op een as wordt gebruikt, moet dezelfde lengte hebben als die as.

Gebruik & voor en, | voor of en ~ voor niet om voorwaarden te combineren. Zet elke vergelijking tussen haakjes:

comfortable = (t > 18) & (t < 23)
t[comfortable]
# array([18.5, 22. , 21.1])

De Python-operatoren and en or proberen één waarheidswaarde uit een hele array te halen en dat mislukt bij arrays met meerdere elementen. Als je de haakjes weglaat, verandert ook hoe Python de expressie groepeert, omdat bitsgewijze operatoren vóór vergelijkingen worden toegepast.

Tel, meet of toets voorwaarden

True draagt 1 bij en False draagt 0 bij. warm.sum() is 3 en warm.mean() is 0,6, het aandeel dagen boven 20 °C. np.count_nonzero(warm) telt ook de items die waar zijn. warm.any() vraagt of minstens één dag warm is; warm.all() vraagt of elke dag warm is.

Deze bewerkingen beantwoorden andere vragen dan t[warm].mean(), dat de gemiddelde temperatuur op warme dagen berekent. Het gemiddelde van een masker meet een aandeel; het gemiddelde van geselecteerde metingen behoudt de eenheid van de meting.

Vervang waarden of kies tussen mogelijkheden

Een toekenning via een masker wijzigt de geselecteerde posities. Met t2 = t.copy() verhoogt de regel t2[t2 < 16] = 16 lage metingen tot 16. np.clip(t, 16, 25) geeft een nieuwe array terug die aan beide kanten is begrensd, [18.5 22. 16. 25. 21.1].

np.where(condition, x, y) maakt een nieuw resultaat met x op posities waar de voorwaarde waar is en y op posities waar die onwaar is. np.where(t > 20, 'warm', 'cool') levert op elke oorspronkelijke positie een label. Filteren maakt het resultaat daarentegen korter. Met alleen een voorwaarde geeft np.where(t > 20) een tuple van indexarrays terug, hier (array([1, 3, 4]),).

Behoud waarden of volledige records

Een masker met dezelfde vorm als een 2-dimensionale array haalt overeenkomende elementen op als één platte vector. In m[m > 5] gaat de rijstructuur verloren. Om hele records te behouden, leid je per rij één booleaanse waarde af uit een kolom:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])
scores[scores[:, 2] >= 90]
# array([[78, 85, 92], [88, 91, 95]])

Zoek ontbrekende waarden expliciet

NaN is bij vergelijking zelfs niet gelijk aan zichzelf. Gelijkheids- en volgordevergelijkingen met NaN zijn onwaar; ongelijkheid is waar. Daarom herkennen noch x == np.nan noch x != np.nan aanwezige en ontbrekende items correct. np.isnan(x) markeert ontbrekende posities en x[~np.isnan(x)] behoudt aanwezige waarden.

Als je de vorm wijzigt, verandert de manier waarop waarden over assen zijn gegroepeerd. De vorm wijzigen, transponeren en een as toevoegen doen elk iets anders, ook als sommige dezelfde uiteindelijke vorm opleveren.

Wijzig de vorm zonder het aantal elementen te veranderen

a = np.arange(6)
r = a.reshape(2, 3)
# array([[0, 1, 2], [3, 4, 5]])

De standaardvolgorde vult steeds één rij: de laatste as verandert het snelst. Als je dezelfde waarden de vorm (3, 2) geeft, krijg je [[0 1] [2 3] [4 5]]. Het product van de nieuwe dimensies moet gelijk zijn aan het oorspronkelijke aantal elementen. Twaalf elementen passen in (3, 4), maar niet in (5, 3).

Eén dimensie kan -1 zijn, zodat NumPy de lengte ervan afleidt. np.arange(12).reshape(-1, 3) geeft vier rijen van drie; reshape(2, -1) geeft twee rijen van zes. Twee onbekende dimensies zijn niet toegestaan, omdat hun afzonderlijke lengtes niet alleen uit het totaal kunnen worden bepaald.

Transponeren verwisselt de assen

Voor r hierboven is r.T gelijk aan [[0 3] [1 4] [2 5]], met vorm (3, 2). Elke oorspronkelijke kolom is nu een rij. Die rangschikking verschilt van r.reshape(3, 2), hoewel de vormen van de resultaten gelijk zijn.

Transponeren is handig als de volgende bewerking de omgekeerde asvolgorde nodig heeft. De vorm wijzigen is handig als een reeks al een betekenisvolle groepering heeft, zoals maanden die in kwartalen zijn gegroepeerd.

Transponeren maakt van een 1-dimensionale array geen kolom

v = np.arange(3) heeft maar één as, dus v.T heeft nog steeds vorm (3,). Voeg expliciet een as toe:

column = v[:, np.newaxis]  # shape (3, 1)
row = v[np.newaxis, :]     # shape (1, 3)

v.reshape(-1, 1) en np.expand_dims(v, 1) maken ook een kolom. np.squeeze(column) verwijdert de as met lengte één en geeft vorm (3,) terug. Een as toevoegen verandert geen waarden, maar bepaalt hoe ze bij latere berekeningen moeten worden uitgelijnd.

Afvlakken en gedeeld geheugengebruik

r.ravel() en r.flatten() geven beide de waarden in een 1-dimensionaal resultaat. ravel geeft waar mogelijk een weergave terug; flatten kopieert altijd. reshape(-1) is een andere manier om een 1-dimensionale rangschikking te vragen, maar of die geheugen deelt, hangt af van de indeling van de invoer. Bij het wijzigen van de vorm kan een kopie nodig zijn; transponeren deelt gegevens in de arrayweergave. Gebruik .copy() als onafhankelijke opslag nodig is.

Groepeer maandwaarden in kwartalen

Voor monthly = np.array([120, 135, 150, 160, 155, 170, 180, 175, 165, 150, 140, 130]) maakt monthly.reshape(4, 3) vier kwartaalrijen met elk drie maanden. Elke rij optellen met .sum(axis=1) geeft [405 485 520 420]. Het eerste totaal is 120 + 135 + 150 = 405. Het wijzigen van de vorm werkt omdat de chronologische invoer de maanden van elk kwartaal al bij elkaar zet.

Samenvoegen combineert waarden uit meerdere arrays. Opsplitsen verdeelt één array in stukken. Bepaal eerst of de bewerking een bestaande as moet uitbreiden of een nieuwe as moet toevoegen.

Voeg samen langs een bestaande as

np.concatenate([a, b], axis=0) voegt vectoren achter elkaar samen. Samenvoegen van [1 2] met [3 4 5] geeft [1 2 3 4 5].

Voor twee arrays met elk vorm (2, 3) voegt as 0 rijen toe en geeft (4, 3). As 1 voegt kolommen toe en geeft (2, 6). Alleen de samenvoegas mag in lengte verschillen. Daarom kun je vormen (2, 3) en (2, 2) langs as 1 samenvoegen tot (2, 5), maar niet langs as 0, omdat hun aantallen kolommen verschillen.

Je moet de arrays samen als een reeks doorgeven, zoals [a, b]. Samenvoegen maakt een nieuwe gecombineerde array en kopieert de gegevens van de invoerarrays.

Stapel langs een nieuwe as

Voor p = np.array([1, 2, 3]) en q = np.array([4, 5, 6]):

stack vereist gelijke invoervormen en voegt een as toe. concatenate behoudt het aantal assen. De hulpfuncties drukken veelgebruikte rangschikkingen uit: vstack([p, q]) maakt rijen, hstack([p, q]) voegt deze 1-dimensionale invoerarrays achter elkaar samen en column_stack([p, q]) maakt kolommen. Door het gedrag van hstack bij 1-dimensionale invoer is de naam alleen niet genoeg om een tabel te voorspellen.

Splits op grenzen of op aantal delen

np.split(np.arange(10), [3, 7]) splitst vóór posities 3 en 7 en levert [0 1 2], [3 4 5 6] en [7 8 9] op. De grensposities zijn geen lengtes van de delen.

Met een geheel getal als tweede argument vraag je juist om gelijke delen: np.split(x, 3) vraagt om drie gelijke stukken. Tien elementen kun je niet gelijk verdelen in drie stukken met een geheel aantal elementen, dus dit geeft een ValueError. np.array_split(np.arange(10), 3) staat ongelijke lengtes toe en levert 4, 3 en 3 op. Deze aanroepen geven een verzameling arrays terug, niet één array met een nieuwe stapelas.

Maak een tabel met metingen

h = np.array([1.62, 1.75, 1.80])  # meters
w = np.array([55.0, 72.5, 80.0])  # kilograms
data = np.column_stack([h, w])

Vorm (3, 2) betekent drie personen met lengte en massa in kolommen. De expressie data[:, 1] / data[:, 0] ** 2 berekent voor elke rij de massa gedeeld door de lengte in het kwadraat en geeft ongeveer 21,0, 23,7 en 24,7 kg/m². Het is essentieel dat de twee meetarrays dezelfde volgorde van personen aanhouden.

Als invoer in batches binnenkomt, verzamel je de batcharrays in een Python-lijst en roep je één keer concatenate aan. Als je tijdens elke lusgang een groeiende array opnieuw samenvoegt, worden de bestaande gegevens telkens opnieuw gekopieerd.

Vectorisatie drukt een berekening uit voor volledige arrays. NumPy voert het herhaalde werk per element uit in gecompileerde code, zodat de Python-expressie dicht bij de bedoelde berekening kan blijven.

Zet een lus om in een berekening op overeenkomstige posities

prices = np.array([2.50, 4.00, 1.20])
qty = np.array([3, 1, 5])
line_totals = prices * qty
order_total = line_totals.sum()

De producten zijn [7.5 4. 6.] en hun som is 17,5. Elke prijs wordt gekoppeld aan het bijbehorende aantal. Een Python-lus die een totaal bijwerkt, levert hetzelfde resultaat op, maar laat Python elk paar afzonderlijk verwerken.

Alle rekenoperatoren werken elementsgewijs: +, -, *, /, //, % en **. Een scalaire waarde wordt op elk item toegepast. 10 - np.array([1, 2, 3]) geeft [9 8 7]; de volgorde van de operanden blijft van belang. Twee arrays hebben gelijke vormen nodig of vormen die compatibel zijn voor broadcasting.

Houd elementsgewijze producten en matrixproducten uit elkaar

* vermenigvuldigt overeenkomstige items. Voor A = np.array([[1, 2], [3, 4]]) en B = np.array([[5, 6], [7, 8]]) geeft A * B de uitvoer [[5 12] [21 32]]. Matrixvermenigvuldiging gebruikt @ en zou [[19 22] [43 50]] geven. Kies * voor gekoppelde metingen zoals prijs en aantal.

Vergelijkingen geven ook één antwoord per positie

a == b levert een booleaanse array op. De expressie vraagt niet of twee arrays als volledige objecten gelijk zijn. Een if-instructie heeft één waarheidswaarde nodig, dus if a == b: mislukt bij resultaten met meerdere elementen. np.array_equal(a, b) toetst of volledige arrays exact gelijk zijn. Voor benaderde decimale getallen toetst np.allclose(a, b) of ze binnen een tolerantie overeenkomen.

Begrijp waarschuwingen bij deling

Met de standaardfoutinstellingen van NumPy levert deling van drijvendekommagetallen door nul een waarschuwing en speciale waarden op:

np.array([1.0, -1.0, 0.0]) / 0
# array([ inf, -inf, nan])

np.isfinite herkent resultaten die noch oneindig noch NaN zijn. Geheeltallige deling door nul met afronding naar beneden geeft daarentegen gehele nullen terug met een waarschuwing. Die nullen lijken eindig, dus controleer gehele noemers met (d == 0).any() voordat je zo deelt. Een waarschuwing verdient aandacht, ook als het programma doorgaat.

Bepaal of je in het bestaande geheugen wilt wijzigen

a += value wijzigt de bestaande opslag en behoudt het datatype. Als a een array met gehele getallen is, geeft a += 0.5 een conversiefout, omdat het drijvendekommaresultaat volgens de conversieregel van die bewerking niet kan worden opgeslagen. a = a + 0.5 maakt een drijvendekommaresultaat en bindt a daaraan. Dit verschilt van het toekennen van één decimaal getal aan een geheel element, waarbij het decimale deel ongemerkt kan worden afgekapt.

Bouw een expressie met meerdere stappen

Voor old = np.array([2.50, 4.00, 8.00]) en new = np.array([3.00, 3.00, 8.00]) geeft (new - old) / old * 100 de uitvoer [20. -25. 0.]. Bepaal eerst elke verandering, deel die door de oorspronkelijke waarde en druk de verhouding vervolgens uit als percentage. De tekens tonen een stijging, een daling en geen verandering. Voor deze percentageberekening mogen de oorspronkelijke waarden niet nul zijn.

Een universele functie, of ufunc, past een berekening afzonderlijk toe op elke arraypositie. Deze functies breiden vectorisatie uit van gewoon rekenen naar wortels, logaritmen, afronding, vergelijkingen en andere numerieke bewerkingen.

Kies een functie die met arrays werkt

Unaire ufuncs nemen één invoer. np.sqrt(np.array([1, 4, 9])) geeft [1. 2. 3.] en np.abs(np.array([-2, 3])) geeft [2 3]. np.exp is de exponentiële functie, np.log is de natuurlijke logaritme en np.log10 is de logaritme met grondtal 10. Zo is np.exp(0) gelijk aan 1,0 en np.log10(1000) aan 3,0.

De Python-module math werkt op afzonderlijke getallen. math.sqrt(np.array([1, 4])) kan niet beide wortels berekenen en geeft een typefout. Gebruik voor numerieke arrays de versie van NumPy. Ook operatoren roepen ufuncs aan: a + b komt overeen met np.add(a, b) en a * b met np.multiply(a, b).

Vergelijk overeenkomstige waarden of reduceer een hele array

Binaire ufuncs nemen twee invoerwaarden. np.maximum([1, 5, 3], [4, 2, 6]) geeft [4 5 6] en kiest op elke positie de grootste waarde. np.minimum kiest de kleinste en np.power verheft overeenkomstige grondtallen tot machten.

np.maximum(x, 0) zet negatieve items in een nieuw resultaat op nul. Dit verschilt van np.max(x), een aggregatie die één grootste waarde teruggeeft. Voor [1, 5, 3] geeft max de waarde 5; maximum heeft nog een invoer nodig en behoudt de elementsgewijze structuur.

Rond af volgens de bedoelde regel

np.round(x, 2) behoudt twee decimalen. Exacte halven volgen de regel voor even getallen: np.round([0.5, 1.5, 2.5]) geeft [0. 2. 2.]. Binaire benadering kan waarden beïnvloeden die decimaal weergegeven precies halverwege lijken te liggen. Houd daarom bij de interpretatie van weergegeven decimalen rekening met hun drijvendekommaweergave.

Controleer waarden buiten het domein van een functie

Voor reële drijvendekomma-invoer geeft np.sqrt(-1.0) de waarde NaN terug met een waarschuwing, terwijl np.log(0.0) bij de standaardfoutinstellingen min oneindig teruggeeft met een waarschuwing. Anders dan bij math.sqrt(-1) stoppen deze aanroepen normaal gesproken niet met een domeinfout. Controleer de invoer als de wiskundige bewerking een beperkt bereik vereist. np.isnan markeert NaN; np.isfinite markeert waarden die noch NaN noch oneindig zijn; np.isclose vergelijkt waarden met een tolerantie.

Combineer ufuncs tot een bruikbare berekening

Bereken voor coördinatenarrays x = np.array([3, 5, 8]) en y = np.array([4, 12, 15]) de afstand tot de oorsprong met np.sqrt(x ** 2 + y ** 2). Kwadrateren geeft [9 25 64] en [16 144 225]; optellen geeft [25 169 289]; de wortels zijn [5. 13. 17.]. np.hypot(x, y) berekent die afstanden rechtstreeks.

Broadcasting maakt het mogelijk om arrays met verschillende vormen te gebruiken in elementsgewijze berekeningen. De uitgelijnde assen bepalen welke waarden worden gekoppeld en welke worden herhaald.

Vergelijk dimensies vanaf rechts

Lijn vormen rechts uit. Elk paar aslengtes moet gelijk zijn of één lengte moet gelijk zijn aan 1. Ontbrekende assen aan het begin tellen als lengte 1. Een as met lengte één wordt denkbeeldig uitgebreid om overeen te komen met de andere lengte; NumPy hoeft de herhaalde invoerwaarden niet te kopiëren.

Voor (4, 3) en (3,) komen de laatste lengtes overeen: 3. De ontbrekende eerste dimensie gedraagt zich als 1 en wordt uitgebreid tot 4. Het resultaat is (4, 3): de vector wordt op elke rij toegepast. (4, 3) en (4,) werken niet, omdat de laatste lengtes 3 en 4 verschillen en geen van beide 1 is. Een niet-compatibel paar geeft een ValueError.

Centreer of standaardiseer kolommen

X = np.array([[1, 10], [2, 20], [3, 30]])
centered = X - X.mean(axis=0)

De kolomgemiddelden zijn [2. 20.], met vorm (2,). Ze lijnen uit met de laatste as van (3, 2), wat [[-1. -10.] [0. 0.] [1. 10.]] geeft. Door het gecentreerde resultaat te delen door X.std(axis=0) standaardiseer je elke kolom. Dit levert in beide kolommen ongeveer −1,22, 0 en 1,22 op. Voor deze deling mag de spreiding van geen enkele kolom nul zijn.

Behoud een as voor rijberekeningen

Gebruik een tabel met scores van vier leerlingen en drie toetsen:

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

scores.mean(axis=1) heeft vorm (4,). Die vorm kan niet via broadcasting als één gemiddelde per rij met (4, 3) worden gecombineerd. Behoud de verwijderde as:

row_mean = scores.mean(axis=1, keepdims=True)
centered = scores - row_mean

row_mean heeft nu vorm (4, 1). De eerste 4 komt overeen met de rijen; de laatste 1 wordt uitgebreid over drie kolommen. scores.mean(axis=1)[:, np.newaxis] maakt dezelfde vorm. Als je van de rij [78, 85, 92] het gemiddelde 85 aftrekt, krijg je [-7. 0. 7.].

Gebruik dezelfde regel om een tabel te maken

np.arange(1, 4)[:, np.newaxis] * np.arange(1, 5) combineert (3, 1) en (4,). Beide arrays worden uitgebreid tot de resultaatvorm (3, 4), wat [[1 2 3 4] [2 4 6 8] [3 6 9 12]] oplevert.

Uitbreiding kan ook onbedoeld plaatsvinden. Een kolom met vorm (3, 1) min een vector met vorm (3,) maakt alle negen paarsgewijze verschillen, met vorm (3, 3). Als je drie overeenkomstige verschillen bedoelde, geef je beide invoerarrays vorm (3,), bijvoorbeeld met column.ravel().

Weeg elke kolom vóór het optellen

Voor dezelfde scoretabel en w = np.array([0.2, 0.3, 0.5]) past scores * w de drie gewichten toe op elke rij. Optellen met .sum(axis=1) geeft [87.1 62.8 92.4 74.8]. Het eerste resultaat is 15,6 + 25,5 + 46,0 = 87,1.

Een aggregatie combineert waarden tot minder resultaten: een totaal, gemiddelde, uiterste of spreidingsmaat. De keuze van de as hoort bij de keuze van de vraag, omdat die bepaalt welke groepen waarden worden gecombineerd.

Voeg de opgegeven as samen

Voor een tabel met vorm (4, 3) met vier leerlingen en drie toetsen gebruikt een aggregatie zonder axis alle 12 waarden. scores.sum() geeft één totaal. scores.mean(axis=0) voegt de leerlingenas samen en laat drie toetsgemiddelden over. scores.mean(axis=1) voegt de toetsas samen en laat vier leerlinggemiddelden over.

scores = np.array([[78, 85, 92], [64, 70, 58],
                   [88, 91, 95], [72, 68, 80]])

De totale som is 941. De kolomgemiddelden zijn [75.5 78.5 81.25]; de rijgemiddelden zijn ongeveer [85. 64. 91.33 73.33]. Vraag je af welke as moet verdwijnen. Als je zegt “as 0 betekent elke rij”, draai je de bewerking om: as 0 combineert rijen.

Kies welke grootheid je wilt terugkrijgen

Methoden zoals a.sum() en functies zoals np.sum(a) drukken dezelfde basisbewerking uit. Met NumPy-methoden vermijd je het andere gedrag van de ingebouwde Python-functies. Zo telt sum(scores) van Python rijarrays op tot kolomtotalen, terwijl scores.sum() alle items combineert. max(scores) van Python probeert rijen te vergelijken en geeft een fout over een dubbelzinnige waarheidswaarde.

Posities verschillen van waarden

scores.mean(axis=1).argmax() is 2: de derde leerling heeft het hoogste gemiddelde. argmax geeft de eerste positie terug als maxima gelijk zijn. Zonder as geeft de functie op een tabel een rijgewijs afgevlakte index terug; scores.argmax() is 8. np.unravel_index(8, scores.shape) haalt de coördinaat (2, 2) terug.

Gebruik keepdims=True als een samenvatting moet uitlijnen met de oorspronkelijke tabel. scores.sum(axis=1, keepdims=True) heeft vorm (4, 1) en is daardoor geschikt voor één normalisatiewaarde per rij. Zonder deze instelling heeft het resultaat vorm (4,).

Behoud tussentotalen als volgorde van belang is

np.cumsum([3, 1, 4, 1, 5]) geeft [3 4 8 9 14]. Elke positie is het totaal tot en met dat punt. np.cumprod([1, 2, 3, 4]) geeft op dezelfde manier [1 2 6 24]. np.diff([3, 1, 4, 1, 5]) geeft de vier veranderingen tussen aangrenzende waarden [-2 3 -3 4]. Geef bij een tabel axis=1 op voor afzonderlijke cumulatieve totalen over de rijen.

Vermeld de afspraak voor spreiding

std en var delen het totaal van de gekwadrateerde afwijkingen standaard door het aantal waarden: ddof=0. Gebruik ddof=1 voor de steekproefformule, waarvan de deler één kleiner is. Voor [2, 4, 4, 4, 5, 5, 7, 9] is het gemiddelde 5, de standaardafwijking met de standaardinstelling 2,0 en de steekproefstandaardafwijking ongeveer 2,14. Een rapport moet duidelijk maken welke afspraak het gebruikt.

Samenvattingen op basis van volgorde beschrijven waar waarden in een gesorteerde verdeling liggen. Sorteren helpt ook bij het rangschikken van records, maar bij een tabel moet je zorgvuldig te werk gaan om de velden van elk record bij elkaar te houden.

Bepaal het midden en de kwartielen

Voor x = np.array([12, 15, 11, 20, 18, 14]) is de gesorteerde volgorde [11 12 14 15 18 20]. Bij zes waarden neemt np.median(x) het gemiddelde van de middelste twee, 14 en 15, wat 14,5 geeft. Bij een oneven aantal is de mediaan de ene middelste waarde.

np.percentile(x, q) accepteert een percentage van 0 tot 100. np.quantile(x, q) accepteert de overeenkomstige fractie van 0 tot 1. De standaard lineaire interpolatie kan een waarde tussen waarnemingen opleveren. Bij zes waarden is de positie van het 25e percentiel, geteld vanaf nul, 0,25 × 5 = 1,25. Die ligt op een kwart van de afstand van 12 naar 14 en geeft 12,5. Het 50e en 75e percentiel zijn 14,5 en 17,25, dus de interkwartielafstand is 4,75.

De mediaan is beter bestand tegen een extreme waarde dan het gemiddelde. Als je 200 aan deze gegevens toevoegt, verschuift het gemiddelde van 15,0 naar ongeveer 41,4; de mediaan verschuift van 14,5 naar 15,0. Geen van beide maten beschrijft op zichzelf de hele verdeling.

Kies gesorteerde gegevens of sorteerposities

np.sort(x) geeft een gesorteerde kopie terug. x.sort() wijzigt x en geeft None terug, dus y = x.sort() zet geen gesorteerde waarden in y. Gebruik voor aflopende waarden np.sort(x)[::-1].

Bij een 2-dimensionale array vindt sorteren standaard langs de laatste as plaats, waarbij elke rij afzonderlijk wordt gesorteerd. axis=0 sorteert elke kolom afzonderlijk. Geen van beide bewerkingen sorteert records. Voor tab = np.array([[3, 1], [1, 2], [2, 0]]) geeft np.sort(tab, axis=0) de uitvoer [[1 0] [2 1] [3 2]], waardoor waarden die oorspronkelijk bij elkaar hoorden worden gescheiden.

Om records te behouden, haal je een volgorde uit de sleutelkolom en pas je die toe op hele rijen:

order = tab[:, 0].argsort()
ranked = tab[order]
# array([[1, 2], [2, 0], [3, 1]])

Dezelfde indexvolgorde kan bijbehorende vectoren opnieuw ordenen. Als avg = np.array([85.0, 64.0, 91.33, 73.33]) en names = np.array(['Ana', 'Ben', 'Chen', 'Dara']), rangschikt order = np.argsort(avg)[::-1] de gemiddelden in aflopende volgorde. names[order] geeft ['Chen' 'Ana' 'Dara' 'Ben'].

Tel unieke waarden en controleer of waarden voorkomen

np.unique geeft gesorteerde unieke waarden terug. Met return_counts=True geeft de functie ook de bijbehorende aantallen terug:

colors = np.array(['red', 'blue', 'red', 'green', 'blue', 'red'])
values, counts = np.unique(colors, return_counts=True)

De uitvoer is ['blue' 'green' 'red'] en [2 1 3]. values[counts.argmax()] vindt de meest voorkomende waarde, 'red'. De posities van de aantallen komen overeen met die van de unieke waarden.

np.isin(a, allowed) geeft een masker terug dat aangeeft of waarden in een verzameling voorkomen. Voor a = np.arange(1, 6) geeft np.isin(a, [2, 4]) de uitvoer [False True False True False], klaar om die waarden of de bijbehorende records te selecteren.

Ontbrekende gegevens en gefilterde deelverzamelingen vragen om een expliciete werkwijze voor het samenvatten. Een numeriek resultaat kan onjuist zijn, ook als de arraybewerking succesvol wordt uitgevoerd: een plaatsvervangende waarde kan als meting worden meegeteld of een lege deelverzameling kan voor een betekenisvol gemiddelde worden aangezien.

Zoek ontbrekende waarden vóór het samenvatten

NaN werkt door in gewone sommen en gemiddelden. Voor x = np.array([3.0, np.nan, 5.0]) geven zowel x.sum() als x.mean() de waarde NaN. np.nansum(x) geeft 8,0 en np.nanmean(x) geeft 4,0, waarbij de ontbrekende positie wordt overgeslagen. Verwante functies zijn nanmax, nanmin, nanstd en nanmedian. Als elke waarde ontbreekt, geeft nanmean NaN terug met een waarschuwing, omdat er geen waargenomen waarden overblijven.

Voor sensormetingen in °C:

r = np.array([21.5, np.nan, 22.1, 23.0, np.nan, 21.9])
missing = np.isnan(r)

missing.sum() is 2, missing.mean() is ongeveer 0,33 en r[~missing] behoudt vier metingen. np.nanmean(r) is 22,125 en gebruikt alleen die vier waarden. De vergelijking r == np.nan zou de ontbrekende metingen niet markeren.

Converteer eerst codes voor ontbrekende waarden

Een getal zoals −999 kan in een invoersysteem ontbrekende gegevens aanduiden. NumPy behandelt het als een echte meting totdat je het vervangt:

v = np.array([12, -999, 15, -999, 9]).astype(float)
v[v == -999] = np.nan
np.nanmean(v)  # 12.0

Converteer eerst naar float, omdat een array met gehele getallen geen NaN kan opslaan. Deze vervanging is alleen geschikt als −999 voor die gegevens is gedefinieerd als code voor ontbrekende waarden.

Aanvullen verandert de verdeling

Als je ontbrekende temperaturen vervangt door nul, wordt het gemiddelde van het voorbeeld 14,75, hoewel er geen temperatuur van nul is gemeten. Als je ze aanvult met het waargenomen gemiddelde, 22,125, blijft dat gemiddelde behouden maar neemt de schijnbare spreiding af. Een aangevulde waarde is een toegevoegde schatting, dus het effect ervan hoort mee te wegen in de analysekeuze.

Voor een 2-dimensionale tabel D vat np.nanmean(D, axis=0) de waargenomen waarden van elke kolom samen. Elke kolom kan een ander aantal hebben. Om rijen met een ontbrekende waarde te verwijderen:

complete = ~np.isnan(D).any(axis=1)
clean_rows = D[complete]

De reductie maakt één beslissing per rij; de ontkenning behoudt rijen zonder ontbrekende items. Met D = np.array([[1., 2.], [np.nan, 4.], [5., np.nan], [7., 8.]]) behoudt dit [[1. 2.] [7. 8.]].

Vat een voorwaarde of een groep samen

Voor temperaturen t berekent t[t > 20].mean() het gemiddelde van alleen de dagen boven 20 °C. Gebruik bij gegroepeerde gegevens een passend labelmasker: met group = np.array(['A', 'B', 'A', 'B', 'A']) en value = np.array([10, 20, 14, 26, 12]) is value[group == 'A'].mean() gelijk aan 12,0 en het overeenkomstige gemiddelde voor B aan 23,0. Doorloop np.unique(group) om dit voor elke groep te herhalen.

Controleer mask.any() voordat je een gefilterde deelverzameling samenvat. Het gemiddelde van een lege selectie is NaN met een waarschuwing, terwijl de som 0 is. Die nul kan een geldig leeg totaal zijn, maar bewijst niet dat er een meting aanwezig was.

Een toevalsgenerator ondersteunt steekproeven, schudden en simulatie. Een startwaarde maakt de begintoestand herhaalbaar, zodat je een analyse opnieuw kunt uitvoeren terwijl je de werking onderzoekt.

Maak één Generator en gebruik die opnieuw

rng = np.random.default_rng(42)

NumPy beveelt deze Generator-interface aan voor nieuwe code. De standaard bitgenerator is PCG64. Zonder startwaarde haalt default_rng() nieuwe entropie uit het besturingssysteem. Oudere aanroepen zoals np.random.seed en np.random.rand gebruiken een gedeelde globale toestand; met Generator-objecten kan een analyse de eigen toestand rechtstreeks beheren.

Pseudowillekeurige waarden komen uit een deterministisch algoritme. Dezelfde begintoestand en dezelfde reeks aanroepen reproduceren de getallenreeks in dezelfde omgeving. Elke trekking verandert de toestand. Als je tijdens elke lusgang een nieuwe Generator met startwaarde 42 maakt, begint de reeks opnieuw en worden dezelfde eerste trekkingen herhaald in plaats van de reeks voort te zetten. Leg naast de startwaarde ook de NumPy-versie en de code vast, omdat compatibiliteit van de reeks tussen versies of in alle omgevingen niet is gegarandeerd. Gebruik voor wachtwoorden of beveiligingstokens de Python-module secrets.

Kies een verdeling en een uitvoervorm

size kan een aantal elementen of een tuple met de vorm zijn. Voor normal is loc het gemiddelde van de verdeling en scale de standaardafwijking ervan. Een variantie van 100 vereist daarom scale=10. Het werkelijke gemiddelde en de werkelijke standaardafwijking van een kleine steekproef hoeven niet exact overeen te komen met de parameters van de verdeling.

Bij trekkingen van gehele getallen is de bovengrens standaard uitgesloten. Voor een dobbelsteen is integers(1, 7) nodig, omdat integers(1, 6) geen 6 kan trekken. integers(1, 6, endpoint=True) neemt de bovengrens mee en modelleert ook een dobbelsteen.

Trek waarden met of zonder teruglegging

rng.choice(['heads', 'tails'], size=5) doet vijf trekkingen met teruglegging. Een waarde kan meerdere keren voorkomen. Gebruik replace=False om verschillende posities te trekken; als je meer posities vraagt dan de populatie heeft, krijg je een ValueError. Kansen kun je opgeven als p=[0.7, 0.3], in dezelfde volgorde als de waarden. Ze moeten samen 1 zijn.

Zonder teruglegging voorkomt dat een invoerpositie twee keer wordt geselecteerd. Als de invoer zelf dubbele waarden bevat, kunnen gelijke waarden nog steeds in de steekproef voorkomen.

Schud records zonder hun velden te scheiden

rng.shuffle(a) herschikt de bestaande array en geeft None terug. rng.permutation(a) geeft een geschudde kopie terug. rng.permutation(10) geeft gehele getallen van 0 tot en met 9 in willekeurige volgorde, bruikbaar als rijindexen.

Bij een 2-dimensionale array is de standaardas 0: volledige rijen bewegen samen. Daardoor blijven de velden van elke waarneming uitgelijnd. Om twee bijbehorende arrays op dezelfde manier te schudden, maak je één permutatie van hun gedeelde recordindexen en pas je die op beide toe.

Een gevectoriseerde simulatie geeft herhaalde proeven weer als arrays, past de regel voor de gebeurtenis op die arrays toe en vat de resultaten samen. De vorm van de array moet laten zien wat één proef bevat.

Zet een gebeurtenis om in een aandeel

rng = np.random.default_rng(42)
rolls = rng.integers(1, 7, size=100_000)
estimate = (rolls == 6).mean()

Het masker is één keer waar voor elke waargenomen 6. Het gemiddelde ervan schat de kans op die gebeurtenis, dicht bij 1/6, of ongeveer 0,1667. rolls.mean() beantwoordt een andere vraag: de gemiddelde waarde op de dobbelsteen, dicht bij 3,5. Een vaste startwaarde herhaalt een schatting; die maakt de schatting niet exact.

Vectorisatie voorkomt werk op Python-niveau voor elke trekking, waardoor grote simulaties vaak veel sneller zijn dan een lus. De snelheidswinst hangt af van de berekening, de grootte van de array en de computer en is dus geen vaste eigenschap van de gebeurtenis.

Gebruik één rij per proef met meerdere waarden

Om in elke proef twee dobbelstenen te simuleren:

dice = rng.integers(1, 7, size=(100_000, 2))
totals = dice.sum(axis=1)
p_seven = (totals == 7).mean()

De tabel heeft 100.000 proefrijen en twee dobbelsteenkolommen. Reductie van as 1 levert één totaal per proef op. Zes van de 36 even waarschijnlijke geordende paren hebben samen 7, dus de geschatte kans zou dicht bij 6/36 moeten liggen. Reductie van as 0 zou daarentegen twee totalen over alle proeven geven en de gebeurtenis per proef verloren laten gaan.

Grotere simulaties variëren nog steeds

Voor onafhankelijke proeven is de standaardfout van een geschat aandeel:

Hier is $p$ de kans op de gebeurtenis en $n$ het aantal proeven. Voor een 6 met een dobbelsteen bij 100.000 proeven is die ongeveer 0,0012. Volgens een normale benadering ligt ongeveer 95% van de schattingen binnen 0,0023 van 1/6. Als het aantal proeven met een factor 100 toeneemt, neemt de standaardfout af met een factor 10. Meer trekkingen corrigeren een onjuist gecodeerde gebeurtenis niet.

Maak en inspecteer een toevalswandeling

steps = rng.choice([-1, 1], size=1000) trekt stappen naar links of rechts. walk = steps.cumsum() geeft de positie na elke stap. Het maximum en minimum geven de uiterste bezochte posities aan. Om het eerste punt op minstens 10 eenheden van het begin te vinden:

hit = np.abs(walk) >= 10
if hit.any():
    step_count = hit.argmax() + 1

argmax vindt het eerste item dat waar is, maar geeft ook 0 terug als elk item onwaar is. De controle met any() maakt onderscheid tussen een werkelijk bereikt punt en geen bereikt punt. Tel 1 op omdat arraypositie 0 de positie na stap 1 is.

Voor veel wandelingen telt rng.choice([-1, 1], size=(5000, 1000)).cumsum(axis=1) afzonderlijk op langs elke rij. walks[:, -1] selecteert alle eindposities; hun gemiddelde ligt dicht bij 0 en hun standaardafwijking dicht bij de vierkantswortel van 1.000, ongeveer 31,6.

Gebruik permutaties en exacte controles

Een willekeurige splitsing van 100 records kan idx = rng.permutation(100) gebruiken, gevolgd door data[idx[:80]] en data[idx[80:]]. De twee niet-overlappende deelbereiken van één permutatie wijzen elk record precies één keer toe. Vergelijk bij een simulatie een eenvoudig geval met een exact antwoord, zoals een dobbelsteengemiddelde van 3,5, voordat je op ingewikkeldere uitvoer vertrouwt.