6.8. Operatorer¶

Den första sortens matematik som numpy kör på en ndarray är de vanliga Python-operatorerna. Aritmetiska, jämförelse- och bitvisa operatorer fungerar alla elementvis – varje operator går igenom arrayen (eller båda arrayerna) en gång från början till slut inuti ett enda biblioteksanrop, mycket snabbare än motsvarande Python-for-loop.

6.8.1. Aritmetik¶

+, -, *, /, //, %, ** fungerar alla mellan två arrayer av kompatibel form, eller mellan en array och en skalär:

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.array([10, 20, 30, 40], dtype=np.float)

print(a + b)        # array([11.0, 22.0, 33.0, 44.0])
print(a * 2)        # array([2.0, 4.0, 6.0, 8.0])
print(b - a)        # array([9.0, 18.0, 27.0, 36.0])
print(b / a)        # array([10.0, 10.0, 10.0, 10.0])

Resultatets dtype följer uppkonverteringsreglerna som beskrivs på Dtyper. Heltalsarrayer slår runt vid spill; konvertera till en bredare dtype före operationen när det spelar roll.

Matrismultiplikationsoperatorn @ är inte implementerad. Använd dot() för matris-/vektorprodukter.

6.8.1.1. På-plats-former¶

Varje aritmetisk operator har en på-plats-form – +=, -=, *=, /=, %=, **=. På-plats-formen skriver genom den befintliga bufferten istället för att allokera en temporär:

b = b + 1            # allocates a temporary the size of b
b += 1               # no temporary

På en mikrokontroller är den andra formen i princip obligatorisk för varje het loop.

6.8.2. Bitvis¶

De bitvisa operatorerna &, |, ^ fungerar elementvis på heltalsarrayer. Tillämpade på en float- eller complex-array ger de upphov till TypeError

a = np.array([0b1100, 0b1010], dtype=np.uint8)
b = np.array([0b1010, 0b1100], dtype=np.uint8)
print(a & b)        # array([8, 8], dtype=uint8)
print(a | b)        # array([14, 14], dtype=uint8)
print(a ^ b)        # array([6, 6], dtype=uint8)

Den unära ~ utför bitvis NOT på en heltalsarray.

Skiftoperatorerna << och >> är inte kopplade på Python-operatornivån. Funktionsformerna left_shift() och right_shift() fungerar:

np.left_shift(a, 2)
np.right_shift(b, 1)

6.8.3. Jämförelse¶

==, !=, <, <=, >, >= returnerar alla en bool-ndarray av broadcastformen:

a = np.array([1, 2, 3, 4, 5], dtype=np.uint8)
print(a < 3)
# array([True, True, False, False, False], dtype=bool)

Det booleska resultatet är exakt vad indexering och Urval och omarrangering förbrukar.

6.8.3.1. Sidregeln¶

ndarray måste vara på vänster sida om en relationsoperator vid jämförelse med en skalär. a > 2 fungerar; 2 < a ger upphov till TypeError. För den symmetriska formen, använd funktionsnamnen:

np.greater(5, a)        # 5 > a, element-wise
np.less(5, a)           # 5 < a, element-wise
np.equal(5, a)          # 5 == a, element-wise
np.not_equal(5, a)      # 5 != a, element-wise

6.8.4. Unära operatorer¶

+a – returnerar en kopia av arrayen.
-a – negation. På osignerade dtyper slår värdena runt modulo \(2^N\), på samma sätt som de binära operatorerna gör.
abs(a) – elementvist absolutvärde. På osignerade dtyper returneras en kopia utan beräkning.
~a – bitvis inversion (endast heltalsarrayer).
len(a) – returnerar längden på den första axeln, i enlighet med Pythons sekvenskonvention.

6.8.5. Vad som saknas¶

Högerhandsoperatorerna för jämförelse och en del av de bitvisa operationerna är inte implementerade på samma sätt som de aritmetiska operatorerna är. Använd funktionsformerna (ovan) när en ndarray skulle hamna till höger.

För den fullständiga listan över operatorer som stöds och den uppkonvertering de följer, se numpy — numpy-kompatibla arrayoperationer.