6.12. Selectie en herschikking¶

Reducties vouwden een array samen tot een scalair of een resultaat met lagere rang. Selectie dekt de bewerkingen die kiezen welke elementen overleven en waar ze terechtkomen: voorwaardelijke keuze, afkappen, sorteren, indices opzoeken, herordenen langs een as.

6.12.1. Voorwaardelijke keuze¶

where() geeft een array terug die elementen uit x neemt waar de voorwaarde waar is en anders uit y. De drie operanden broadcasten samen:

a = np.array([1, 2, 3, 4, 5], dtype=np.float)
np.where(a < 3, a, 0.0)
# array([1.0, 2.0, 0.0, 0.0, 0.0])

Dit is het juiste gereedschap voor een “if/else per element” zonder een Python-lus te schrijven.

clip() is een afkorting voor maximum(lo, minimum(a, hi)) – verzadig de waarden tot een bereik:

np.clip(a, 2.0, 4.0)
# array([2.0, 2.0, 3.0, 4.0, 4.0])

maximum() en minimum() nemen twee operanden en geven elementsgewijs de grotere / kleinere terug:

np.maximum(a, 3.0)
np.minimum(a, np.array([5, 4, 3, 2, 1]))

6.12.2. Indices vinden¶

nonzero() geeft de coördinaten terug van elk niet-nul element, opgesplitst in één index-array per dimensie. Voor een 2-D-invoer is het resultaat een tuple van twee arrays: de eerste bevat de rij-indices, de tweede bevat de kolom-indices. Door ze kolomsgewijs te koppelen krijg je de (row, col) van elke niet-nul positie:

m = np.array([[0, 2, 0],
              [3, 0, 0]], dtype=np.float)
np.nonzero(m)
# (array([0, 1], dtype=uint16), array([1, 0], dtype=uint16))

De niet-nul elementen in m zijn m[0, 1] = 2 en m[1, 0] = 3. De eerste teruggegeven array [0, 1] geeft hun rij-indices; de tweede [1, 0] geeft hun kolom-indices. Door de twee arrays naast elkaar te lezen, herstel je de posities (0, 1) en (1, 0).

Twee reducties produceren ook indices:

argmin() / argmax() – index van het kleinste / grootste element.
argsort() – een geheeltallige array die de invoer langs de gegeven as zou sorteren (standaard de laatste):
```
a = np.array([40, 10, 30, 20], dtype=np.uint8)
idx = np.argsort(a)             # array([1, 3, 2, 0], dtype=uint16)
a[idx]                          # array([10, 20, 30, 40])
```
argsort geeft altijd uint16 terug; de te sorteren array mag daarom niet meer dan 65.535 elementen op de gesorteerde as hebben.

bincount() telt het aantal voorkomens van elk niet-negatief geheel getal in een 1-D uint8 / uint16-invoer:

histogram = np.bincount(np.array([0, 1, 1, 2, 2, 2], dtype=np.uint8))
# array([1, 2, 3], dtype=uint16)

Handig om histogrammen van pixelwaarden met kleine gehele getallen te bouwen zonder een Python-lus te schrijven.

6.12.3. Sorteren en herordenen¶

sort() geeft een gesorteerde kopie van de array langs de gegeven as terug (standaard de laatste). Gebruik sort() rechtstreeks op de array voor een in-place versie:

np.sort(np.array([3, 1, 2], dtype=np.float))
# array([1.0, 2.0, 3.0])

flip() keert de volgorde langs de gegeven as om (elke as wanneer er geen axis wordt meegegeven):

np.flip(np.array([1, 2, 3, 4]))
# array([4, 3, 2, 1])

roll() verschuift elementen cyclisch met het gegeven aantal. Handig voor het implementeren van een schuifregister in ringbufferstijl:

np.roll(np.array([1, 2, 3, 4]), 1)
# array([4, 1, 2, 3])

take() is de expliciete vorm van fancy indexing – kies elementen op willekeurige indices:

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

6.12.4. Filteren en structurele bewerkingen¶

compress() is de expliciete vorm van booleaanse indexing – geef de segmenten van a terug die door de booleaanse voorwaarde zijn geselecteerd:

a = np.array([10, 20, 30, 40], dtype=np.uint8)
np.compress(a > 15, a)
# array([20, 30, 40], dtype=uint8)

delete() geeft een kopie terug waarin de elementen op de gegeven indices zijn verwijderd:

a = np.array([10, 20, 30, 40, 50], dtype=np.uint8)
np.delete(a, [1, 3])
# array([10, 30, 50], dtype=uint8)

diff() geeft het n-de discrete voorwaartse verschil van de array langs een as terug. Gebruikt om eerste-orde veranderingen tussen aangrenzende monsters te berekenen:

samples = np.array([1, 3, 6, 10, 15], dtype=np.float)
np.diff(samples)
# array([2.0, 3.0, 4.0, 5.0])

6.12.5. Wat elke bewerking kost¶

Bijna elke functie op deze pagina geeft een vers toegewezen array terug. Twee uitzonderingen:

sort() sorteert in-place; de vrije functie sort() geeft een gesorteerde kopie terug.
take() accepteert een out=-trefwoord om in een al bestaande buffer te schrijven.

Geef in een lus die vele keren per seconde draait de voorkeur aan de in-place sort() en hergebruik overal elders vooraf toegewezen buffers. Booleaanse maskers zelf worden elke keer dat de vergelijking draait toegewezen – bouw een masker eenmalig en hergebruik het over bewerkingen heen in plaats van het binnen elke iteratie opnieuw op te bouwen.