6.12. Urval och omarrangering¶

Reduktioner kollapsade en array ned till en skalär eller ett resultat av lägre rang. Urval täcker de operationer som väljer vilka element som överlever och var de hamnar: villkorligt val, klippning, sortering, uppslagning av index, omordning längs en axel.

6.12.1. Villkorligt val¶

where() returnerar en array som tar element från x där villkoret är sant och från y annars. De tre operanderna broadcastas tillsammans:

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])

Detta är rätt verktyg för ett ”if/else per element” utan att skriva en Python-loop.

clip() är en förkortning för maximum(lo, minimum(a, hi)) – mätta värdena till ett intervall:

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

maximum() och minimum() tar två operander och returnerar elementvis det större / mindre:

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

6.12.2. Hitta index¶

nonzero() returnerar koordinaterna för varje element som inte är noll, uppdelade i en indexarray per dimension. För 2-D-indata är resultatet en tupel av två arrayer: den första innehåller radindexen, den andra innehåller kolumnindexen. Att para ihop dem kolumnvis ger (row, col) för varje position som inte är noll:

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 element i m som inte är noll är m[0, 1] = 2 och m[1, 0] = 3. Den första returnerade arrayen [0, 1] ger deras radindex; den andra [1, 0] ger deras kolumnindex. Att läsa de två arrayerna sida vid sida återskapar positionerna (0, 1) och (1, 0).

Två reduktioner producerar också index:

argmin() / argmax() – index för det minsta / största elementet.
argsort() – en heltalsarray som skulle sortera indata längs den givna axeln (standard är den sista):
```
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 returnerar alltid uint16; arrayen som sorteras får därför inte ha fler än 65 535 element på den sorterade axeln.

bincount() räknar förekomster av varje icke-negativt heltal i en 1-D uint8 / uint16-indata:

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

Användbart för att bygga histogram av pixelvärden med små heltal utan att skriva en Python-loop.

6.12.3. Sortering och omordning¶

sort() returnerar en sorterad kopia av arrayen längs den givna axeln (den sista som standard). Använd sort() direkt på arrayen för en version på plats:

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

flip() vänder ordningen längs den givna axeln (varje axel när ingen axis anges):

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

roll() förskjuter element cykliskt med det givna antalet. Användbart för att implementera ett skiftregister i ringbuffert-stil:

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

take() är den explicita formen av avancerad indexering – plocka element vid godtyckliga index:

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. Filtrering och strukturella ändringar¶

compress() är den explicita formen av boolesk indexering – returnera de delar av a som väljs av det booleska villkoret:

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

delete() returnerar en kopia där posterna vid de givna indexen är borttagna:

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

diff() returnerar den n:te diskreta framåtdifferensen av arrayen längs en axel. Används för att beräkna förstaordningsändringar mellan intilliggande sampel:

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. Vad varje operation kostar¶

Nästan varje funktion på denna sida returnerar en nyallokerad array. Två undantag:

sort() sorterar på plats; den fristående funktionen sort() returnerar en sorterad kopia.
take() accepterar nyckelordet out= för att skriva in i en buffert som redan finns.

I en loop som körs många gånger per sekund, föredra sort() på plats och återanvänd förallokerade buffertar överallt annars. Booleska masker allokeras själva varje gång jämförelsen körs – bygg en mask en gång och återanvänd den över flera operationer i stället för att bygga om den inuti varje iteration.