Universelle Funktionen (ufunc)

Eine universelle Funktion, oder ufunc, ist eine Funktion, die elementweise Operationen auf Daten in ndarrays durchführt. Man kann sie sich als schnelle vektorisierte Wrapper für einfache Funktionen vorstellen, die einen oder mehrere skalare Werte annehmen und ein oder mehrere skalare Ergebnisse erzeugen.

Viele ufuncs sind einfache elementweise Transformationen, wie sqrt oder exp:

import numpy as np

data = np.arange(10)

data

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

np.sqrt(data)

array([0.        , 1.        , 1.41421356, 1.73205081, 2.        ,
       2.23606798, 2.44948974, 2.64575131, 2.82842712, 3.        ])

np.exp(data)

array([1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01,
       5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03,
       2.98095799e+03, 8.10308393e+03])

Diese werden als einstellige ufuncs bezeichnet. Andere, wie add oder maximum, nehmen zwei Arrays (also binäre ufuncs) und geben ein einziges Array als Ergebnis zurück:

x = np.random.randn(8)

y = np.random.randn(8)

x

array([ 0.27787269, -0.58356193, -0.10184236,  1.35055943, -1.57973878,
        1.14278195, -1.08386512,  0.09227202])

y

array([ 0.32170798,  0.7041202 , -0.22124585, -0.01662225,  0.20266652,
        0.53028692,  1.09999517, -0.47938682])

np.maximum(x, y)

array([ 0.32170798,  0.7041202 , -0.10184236,  1.35055943,  0.20266652,
        1.14278195,  1.09999517,  0.09227202])

Hier berechnete numpy.maximum das elementweise Maximum der Elemente in x und y.

Manche ufunc, wie z.B. modf , eine vektorisierte Version des eingebauten Python divmod, geben mehrere Arrays zurückgeben: die Bruch- und Integralteile eines Gleitkomma-Arrays:

data = x * 5

data

array([ 1.38936344, -2.91780966, -0.50921179,  6.75279713, -7.89869391,
        5.71390974, -5.4193256 ,  0.46136012])

remainder, whole_part = np.modf(x)

remainder

array([ 0.27787269, -0.58356193, -0.10184236,  0.35055943, -0.57973878,
        0.14278195, -0.08386512,  0.09227202])

whole_part

array([ 0., -0., -0.,  1., -1.,  1., -1.,  0.])

Ufuncs akzeptieren ein optionales out-Argument, das es euch erlaubt, eure Ergebnisse an ein bestehendes Array zu übertragen, anstatt ein neues zu erstellen:

out = np.zeros_like(data)

np.add(data, 1)

array([ 2.38936344, -1.91780966,  0.49078821,  7.75279713, -6.89869391,
        6.71390974, -4.4193256 ,  1.46136012])

np.add(data, 1, out=out)

array([ 2.38936344, -1.91780966,  0.49078821,  7.75279713, -6.89869391,
        6.71390974, -4.4193256 ,  1.46136012])

out

array([ 2.38936344, -1.91780966,  0.49078821,  7.75279713, -6.89869391,
        6.71390974, -4.4193256 ,  1.46136012])

Einige einstellige ufuncs:

Funktion	Beschreibung
abs, fabs	berechnet den absoluten Wert elementweise für Ganzzahl-, Gleitkomma- oder komplexe Werte
sqrt	berechnet die Quadratwurzel aus jedem Element (entspricht data ** 0,5)
square	berechnet das Quadrat eines jeden Elements (entspricht data ** 2)
exp	berechnet den Exponenten ex eines jeden Elements
log, log10, log2, log1p	Natürlicher Logarithmus (Basis e), log Basis 10, log Basis 2 bzw. log(1 + x)
sign	berechnet das Vorzeichen jedes Elements: 1 (positiv), 0 (Null), oder -1 (negativ)
ceil	berechnet die Obergrenze jedes Elements (d.h. die kleinste ganze Zahl, die größer oder gleich dieser Zahl ist)
floor	berechnet die Untergrenze jedes Elements (d.h. die größte ganze Zahl, die kleiner oder gleich jedem Element ist)
rint	rundet Elemente auf die nächste Ganzzahl, wobei der dtype erhalten bleibt
modf	gibt den gebrochenen und ganzzahligen Teile des Arrays als separate Arrays zurück
isnan	gibt ein boolesches Array zurück, das angibt, ob jeder Wert NaN (Not a Number) ist
isfinite, isinf	gibt ein boolesches Array zurück, das angibt, ob jedes Element endlich (non-inf, not-NaN) bzw. unendlich ist
cos, cosh, sin, sinh, tan, tanh	reguläre und hyperbolische trigonometrische Funktionen
arccos, arccosh, arcsin, arcsinh, arctan, arctanh	Inverse trigonometrische Funktionen
logical_not	berechnet den Wahrheitswert von not x elementweise (entspricht ~data)

Einige binäre universelle Funktionen:

Funktion	Beschreibung
add	hinzufügen entsprechender Elemente in Arrays
subtract	subtrahiert Elemente im zweiten Array vom ersten Array
multiply	Array-Elemente multiplizieren
divide, floor_divide	Dividieren oder Abschneiden des Rests
power	erhöht Elemente im ersten Array auf die im zweiten Array angegebenen Potenzen
maximum, fmax	elementweises Maximum; fmax ignoriert NaN
minimum, fmin	elementweises Minimum; fmin ignoriert NaN
mod	Elementweiser Modulus (Rest der Division)
copysign	kopiert das Vorzeichen der Werte im zweiten Argument auf die Werte im ersten Argument
greater, greater_equal, less, less_equal, equal, not_equal	Elementweise Vergleiche durchführen, die ein boolesches Array ergeben (entspricht den Infix-Operatoren >, >=, <, <=, ==, !=)
logical_and	berechnet den elementweisen Wahrheitswert der logischen Operation AND (&).
logical_or	berechnet den elementweisen Wahrheitswert der logischen Operation OR (|).
logical_xor	berechnet den elementweisen Wahrheitswert der logischen Operation XOR (^).

Hinweis:

Eine vollständige Übersicht über binäre universelle Funktionen findet ihr in Universal functions (ufunc).