NumPy

Attribute

array.ndim    # => Anzahl der Dimensionen
array.shape   # => Anzahl der Elemente je Dimension
array.size    # => Anzahl der Elemente
array.dtype   # => Datentyp (float, int, etc)

Array erstellen

np.array(<iterable>, <dtype>)             # => Umwandlung list => ndarray
  # Structured arrays mit Angabe von dtype je Element möglich => besser in Pandas
np.zeros(<shape>, <dtype>)               # => mit "0"er vorbelegen
  # Shape = (<Zeilen>, <Spalten>)
np.ones(<shape>, <dtype>)                # => mit "1"er vorbelegen
np.full(<shape>, fill_value=<Zahl>)  # => ganzes Array mit <Zahl> vorbelegen
np.arange(<start>, <stop>, <step>)  # => <stop> ist nicht enthalten!
np.linspace(<start>, <stop>, <num>) # => <stop> ist enthalten, <num> Zahlen gleichmäßig verteilt
np.eye(<N>)     # => quadratische NxN-Matrix mit "1" auf der Hauptdiagonalen und sonst "0" = Einheitsmatrix
np.diag(<list>) # => ähnlich wie eye, Liste wird auf Hauptdiagonale verteilt

Indizierung

array[<Zeile>][<Spalte>] (Python)                      # => array[<Zeile, Spalte>] (NumPy)
array[1:3]                                             # => Zeile 1-2 (3 nicht mehr enthalten)
array[0:2, 0]                                          # => Spalte 0 von Zeile 0+1 (2 nicht enthalten)
array[<liste>] = array[<liste>, :] = array[[1,2,4], :] # => liefert Zeilen 1 & 2 & 4
# Slicing erzeugt eine View => auch Daten im Original können verändert werden (keine Kopie!)
array[<slicing>].copy()                                # => erstellt echte Kopie der Daten

Reshaping

np.reshape(<array>, <newshape>) # => Daten auf neue Form verteilen, kann auch Anzahl der Dimensionen ändern
array[np.newaxis, :]            # => fügt dem Array eine weitere Dimension hinzu
array.ravel()                   # => erzeugt aus allen Elementen des Arrays ein ein-dimensionales Array als View
array.flatten()                 # => erzeugt aus allen Elementen des Arrays ein ein-dimensionales Array als Kopie
array.reshape((<a>, -1, <b>))   # => "-1" = automatic reshaping, berechnet fehlende Dimension selbständig

Datentyp ändern

np.<datatype>(<list>)        # => <datatype> = [(u)int8/16/32/64, float32/64, complex64/128)
np.array(<list>, dtype=<datatype>)
x = array.astype(<datatype>) # => bestehendes Array konvertieren

Arrays zusammenfügen

np.concatenate([x,y], axis=0)    #=> aneinander hängen: axis = 0 "untereinander", axis = 1 "nebeneinander"
np.vstack([<array1>, <array2>])  # => "vertikal" = "untereinander"
np.hstack([<array1>, <array2>])  # => "horizontal" = "nebeneinander"

ufuncs

• Rechenoperation wird auf jedes Element des Arrays angewendet:  add, subtract, multiply, matmul, divide, negative, positive, mod, absolute, fabs, sign, exp, log, sqrt, square, reciprocal, gcd, lcm
• Trigonometrie: sin, cos, tan
• Bit-Operationen: bitwise_and, bitwise_or, bitwise_xor,
• binary_repr
• Vergleichsfunktionen: >, >=, <, <=, !=, ==

Aggregations

np.max(<array>, axis=0) = array.max(axis=0) # => Achse <axis> wird reduziert ("gelöscht")

np.max(x)                                   # => Maximum über alle Elemente
np.max(x, axis=0)                           # => Maximum spaltenweise
np.max(x, axis=1)                           # => Maximum zeilenweise

• Weitere Aggregations: max, min, sum, prod, median, average, mean, std, var, cumprod, cumsum, diff

Broadcasting ("Erweiterung")

• Vektor/Matrix + Skalar => jedes Element des Vektors/der Matrix + Skalar
• Matrix + Vektor => Vektor wird als Zeile aufgefasst und erweitert
• Zeilenvektor + Spaltenvektor => Summe Z(i) + S(j)
• Beispiel Normierung:

x_mean = np.mean(x, axis=0)                # => Mittelwert pro Spalte
x_centered = x - x_mean                    # => elementweise Differenz
x_var = np.var(x, axis=0)                  # => Varianz pro Spalte
x_std = x_centered / np.sqrt(1e-6 + x_var) # => Z-normierte Werte

• weitere Funktionen:

np.equal(new_mean, 0.0)   # => prüft ob new_mean genau gleich 0 ist
np.isclose(new_mean, 0.0) # => prüft ob new_mean etwa 0 Null (Abweichung =?)

Array Masks

np.count_nonzero(<array> > <const>) # => zählt, wie oft die Bedingung erfüllt wurde
np.all(<array> > <const>)           # => prüft, ob alle Elemente die Bedingung erfüllen
np.any(<array> > <const>)           # => prüft, ob mind. 1 Element die Bedingung erfüllt
x[x < 1.0]                          # => alle Elemente, die die Bedingung erfüllen. Shape => einfache Liste (1,)

Masked array = numpy.ndarray + (boolean) mask

masked_data = ma.masked_array(data, mask=[0, 0, 0, 1, 0])

• Berechnungen auf masked array wie auf numpy array möglich
• Weitere Funktionen: fix_invalid, masked_equal, masked_greater, masked_greater_equal, masked_inside, masked_invalid, masked_less, masked_less_equal, masked_not_equal, masked_where

Zufallszahlen

np.random.randint(<low>, <high>, <size>) # => zufällige, gleich-verteilete Int-Zufallszahlen zwischen 
                                         # "low" und "high" ("high" ist nicht enthalten!)
np.random.random(<size>)                 # => zufällige, gleich-verteilete Float-Zufallszahlen

Zufallszahlen, Random

np.random.randint(low=0, high=5, size=<shape>) # => integer, gleichverteilt (Bsp. 0 bis 4, 5 nicht enthalten)
np.random.random                               # => float, gleichverteilt
np.random.randn                                # => float, normalverteilt, feste Parameter: µ = 0, std = 1
np.random.choice                               # => Wählt zufälliges Element aus Liste
np.random.shuffle(<list>)                      # => Reihenfolge einer Liste ändern ("mischen"), in-place
np.random.permutation(<list>)                  # => Reihenfolge einer Liste ändern ("mischen"), Kopie
np.random.normal                               # => Normalverteilung, Parameter einstellbar
np.random.uniform(low=0, high=5, size=<shape>) # => Gleichverteilung, Parameter einstellbar

Multivariate => mehrdimensionale Normalverteilung

Achsen verschieben

np.moveaxis(<array>, source=0, destination=2) # => tauscht zwei beliebige Achsen
np.transpose(<array>)                         # => transponierte eines Arrays (gesamte Achsenliste wird "umgedreht")
<array>.T                                     # => transpose
np.roll(<array>, axis=0, shift=-1)            # => Zeilen (axis=0) bzw. Spalten (axis=1) nach oben/links (shift=-1)
                                              # bzw. unten/rechts(shift=+1) verschieben

Indices

np.indices(<shape>)   # => Array mit N+1 Dimensionen, das die Position aller Felder wiedergibt
np.diag_indices(N)    # => Indices der Hauptdiagonales einer Matrix NxX
np.tril_indices(N)    # => "lower": Indices der Hauptdiagonales und des unteren Dreiecks
np.triu_indices(N)    # => "upper": Indices der Hauptdiagonales und des oberen Dreiecks
np.where(x >= 2)      # => Indices der Elemente, die die Bedingung erfüllen

Sortieren

• Erzeugt eine Kopie des Feldes

np.sort(<array>)     # => sortiert Elemente (zeilenweise), sonst: axis=0 (spaltenweise)
np.argsort(<array>)  # => gibt die Indices (=Liste der Position im <array>) einer sortierten Liste zurück
np.argmax(<array>)   # => Index des größten Elements im <array>
np.argmin(<array>)   # => Index des kleinsten Elements im <array>

I/O

np.save(<file>, <array>)  # => Daten (ein oder mehrere Array/s) binär speichern (*.npy)
data = np.load(<file>)    # => binäre Daten laden
np.savez                  # => mehrere Arrays in einer Datei speichern (*.npz)
np.savetxt                # => Array im ASCII-Format speichern => nur Zahlenwerte, Zuordnung zu mehreren nicht möglich (?)
np.loadtxt                # => Array im ASCII-Format laden