6.8. Operátorok¶

A matematika első fajtája, amelyet a numpy egy ndarray objektumon futtat, a szabványos Python operátorok. Az aritmetikai, összehasonlító és bitenkénti operátorok mind elemenként működnek – minden operátor egyszer járja be a tömböt (vagy mindkét tömböt) elejétől a végéig egyetlen könyvtárhíváson belül, sokkal gyorsabban, mint az ezzel egyenértékű Python for ciklus.

6.8.1. Aritmetika¶

A +, -, *, /, //, %, ** mind működik két kompatibilis alakú tömb között, vagy egy tömb és egy skalár között:

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

Az eredmény dtype-ja a Dtype-ok oldalon leírt feljebb-konvertálási szabályokat követi. Az egész tömbök túlcsorduláskor körbefordulnak; konvertálj szélesebb dtype-ra a művelet előtt, ha ez számít.

A mátrixszorzás operátor @ nincs megvalósítva. Mátrix-/vektorszorzatokhoz használd a dot() függvényt.

6.8.1.1. Helyben végrehajtott formák¶

Minden aritmetikai operátornak van helyben végrehajtott formája – +=, -=, *=, /=, %=, **=. A helyben végrehajtott forma a meglévő pufferbe ír, ahelyett hogy ideiglenest allokálna:

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

Egy mikrokontrolleren a második forma lényegében kötelező minden forró ciklushoz.

6.8.2. Bitenkénti¶

A bitenkénti &, |, ^ operátorok elemenként működnek egész tömbökön. Egy float vagy complex tömbre alkalmazva TypeError kivételt váltanak ki:

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)

Az egyoperandusú ~ bitenkénti NEM műveletet hajt végre egy egész tömbön.

A << és >> eltolási operátorok nincsenek bekötve a Python operátor szintjén. A függvényformák, a left_shift() és right_shift(), működnek:

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

6.8.3. Összehasonlítás¶

A ==, !=, <, <=, >, >= mind egy bool ndarray objektumot ad vissza a broadcast alakjával:

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

A logikai eredmény pontosan az, amit az indexelés és a Kiválasztás és átrendezés felhasznál.

6.8.3.1. Az oldalszabály¶

A ndarray objektumnak a relációs operátor bal oldalán kell lennie, amikor egy skalárhoz hasonlítjuk. Az a > 2 működik; a 2 < a TypeError kivételt vált ki. A szimmetrikus formához használd a függvényneveket:

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. Egyoperandusú operátorok¶

+a – a tömb másolatát adja vissza.
-a – negálás. Előjel nélküli dtype-okon az értékek \(2^N\) modulo szerint körbefordulnak, ugyanúgy, ahogy a bináris operátorok teszik.
abs(a) – elemenkénti abszolút érték. Előjel nélküli dtype-okon számítás nélkül ad vissza egy másolatot.
~a – bitenkénti inverzió (csak egész tömbök).
len(a) – a első tengely hosszát adja vissza, a Python szekvenciakonvenciónak megfelelően.

6.8.5. Mi hiányzik¶

Az összehasonlítás és néhány bitenkénti művelet jobb oldali operátorai nincsenek ugyanúgy megvalósítva, ahogy az aritmetikai operátorok. Használd a függvényformákat (fent), amikor egy ndarray a jobb oldalra kerülne.

A támogatott operátorok teljes listájáért és az általuk követett feljebb-konvertálásért lásd: numpy — numpy-kompatibilis tömbműveletek.