NumPy-Tutorial

NumPy (Numerical Python) ist die grundlegende Bibliothek für numerisches Rechnen in Python. Sie führt das ndarray ein — ein schnelles, typisiertes mehrdimensionales array — und ergänzt es mit Hunderten von mathematischen Funktionen, die auf ganze Arrays auf einmal angewendet werden. Praktisch jede wissenschaftliche Python-Bibliothek (Pandas, SciPy, Matplotlib, scikit-learn) baut auf NumPy auf.

Dieses Kapitel behandelt:

• Was NumPy ist und warum es schneller als einfache Python-Listen ist
• Installation von NumPy und die übliche Import-Konvention
• Erstellen von Arrays mit np.array, np.zeros, np.ones, np.arange und np.linspace
• Indizierung, Slicing und boolean-Maskierung
• Umformen und Transponieren
• Broadcasting — Operationen auf Arrays mit unterschiedlichen Formen
• Aggregationsfunktionen (sum, mean, std, min, max)
• Elementweise Mathematik und lineare Algebra
• Nützliche Hilfsfunktionen (sort, unique, where, concatenate)

Was ist NumPy?

NumPy ist eine Open-Source-Python-Bibliothek, die Folgendes bereitstellt:

1. Ein leistungsstarkes N-dimensionales array-Objekt (ndarray).
2. Elementweise mathematische Funktionen (ufuncs), die auf jedes Element eines Arrays in kompiliertem C-Code statt in einer Python-Schleife angewendet werden.
3. Lineare Algebra, Fourier-Transformationen und Zufallszahlen-Routinen.

Warum NumPy schneller als Python-Listen ist

Eine Python-Liste kann Elemente beliebigen Typs enthalten, sodass jedes Element ein Typ-Tag und einen Zeiger auf den tatsächlichen Wert speichert. NumPy-Arrays speichern rohe numerische Daten in einem zusammenhängenden Speicherblock — keine Zeiger, keine Typ-Suchen. In Verbindung mit vektorisierten C-Schleifen (ufuncs) laufen Operationen auf einem NumPy-array mit einer Million Elementen typischerweise 10–100× schneller als äquivalenter Python-for-Schleifen-Code.

NumPy installieren

NumPy ist in der Anaconda-Distribution enthalten. Zur manuellen Installation mit pip:

pip install numpy

NumPy importieren

Die universelle Konvention ist, NumPy als np zu importieren:

import numpy as np

Jedes Beispiel in diesem Kapitel setzt voraus, dass dieser Import bereits im Geltungsbereich ist.

Arrays erstellen

Aus einer Python-Liste

Übergebe eine beliebige Liste (oder Liste von Listen) an np.array():

[1 2 3 4 5]
int64
(5,)

Ein 2-D-array (Matrix) verwendet eine Liste von Listen:

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

Kurzformen zur Array-Erstellung

import numpy as np

print(np.zeros((2, 3)))
print(np.ones(4, dtype=int))
print(np.arange(0, 10, 2))
print(np.linspace(0, 1, 5))

[[0. 0. 0.]
 [0. 0. 0.]]
[1 1 1 1]
[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]

np.linspace ist besonders nützlich, wenn man eine genaue Anzahl von Punkten benötigt — zum Beispiel beim Vorbereiten einer x-Achse für ein Diagramm. Im Kapitel Matplotlib Intro wird erklärt, wie man es mit Plot-Funktionen kombiniert.

Indizierung und Slicing

1-D-Indizierung und Slicing

NumPy verwendet dieselbe [start:stop:step]-Syntax wie Python-Listen, unterstützt aber auch negative Indizes und Schrittweiten.

import numpy as np

a = np.array([10, 20, 30, 40, 50])

print(a[0])      # first element
print(a[-1])     # last element
print(a[1:4])    # elements at index 1, 2, 3
print(a[::2])    # every other element

10
50
[20 30 40]
[10 30 50]

2-D-Indizierung

Bei einem 2-D-array gibt man [Zeile, Spalte] an:

import numpy as np

b = np.array([[1, 2, 3],
              [4, 5, 6],
              [7, 8, 9]])

print(b[1, 2])    # row 1, col 2 → 6
print(b[0, :])    # first row  → [1 2 3]
print(b[:, 1])    # second column → [2 5 8]
print(b[0:2, 1:3])  # sub-matrix

6
[1 2 3]
[2 5 8]
[[2 3]
 [5 6]]

Boolean-Maskierung

Übergebe ein boolean-array als Index, um nur die Elemente auszuwählen, bei denen die Bedingung True ist:

import numpy as np

a = np.array([1, 2, 3, 4, 5])

print(a[a > 3])        # elements greater than 3
print(a[a % 2 == 0])   # even elements

[4 5]
[2 4]

Boolean-Masken sind der idiomatische NumPy-Ersatz für gefilterte Listen-Komprehensionen und sind bei großen Arrays um ein Vielfaches schneller.

Umformen und Transponieren

Umformen

np.reshape() (oder die .reshape()-Methode) gibt eine Ansicht der Daten mit einer neuen Form zurück. Die Gesamtanzahl der Elemente muss gleich bleiben.

[[1 2 3]
 [4 5 6]]

Verwende -1 für eine Dimension, die NumPy automatisch ableiten soll:

import numpy as np

a = np.arange(12)
print(a.reshape(3, -1))   # 3 rows, NumPy infers 4 columns

[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Transponieren

.T oder np.transpose() tauscht Achsen (Zeilen ↔ Spalten bei 2-D-Arrays):

[[1 3 5]
 [2 4 6]]
(2, 3)

Elemente hinzufügen und entfernen

Elemente anhängen

np.append() gibt ein neues flaches array zurück — es verändert das Original nicht direkt (im Gegensatz zu list.append).

[1 2 3 4 5 6]

Bei wiederholten Anhängevorgängen in einer Schleife ist es weitaus effizienter, eine Python-Liste aufzubauen und diese am Ende einmalig mit np.array() zu konvertieren, als np.append() wiederholt aufzurufen.

Elemente entfernen

np.delete(arr, indices) gibt ein neues array zurück, aus dem die angegebenen Indizes entfernt wurden:

[1 2 5]

Arrays zusammenführen

np.concatenate() verbindet zwei oder mehr Arrays entlang einer vorhandenen Achse:

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.concatenate([a, b]))

[1 2 3 4]

Broadcasting

Broadcasting ist NumPys Regel zur Anwendung von Operationen zwischen Arrays unterschiedlicher Formen — ohne Daten zu kopieren. Das klassische Beispiel ist das Addieren eines Skalars zu einem array:

import numpy as np

a = np.array([1, 2, 3])
print(a + 10)    # 10 is broadcast across all elements

[11 12 13]

Ein leistungsfähigerer Fall: ein 1-D-array zu jeder Zeile eines 2-D-Arrays addieren:

import numpy as np

matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])
row    = np.array([10, 20, 30])

print(matrix + row)

[[11 22 33]
 [14 25 36]]

NumPy vergleicht Formen von rechts: (2, 3) + (3,) ist gültig, weil die nachgestellten Dimensionen übereinstimmen; row wird konzeptuell zu einem (2, 3)-array erweitert, ohne Speicher zuzuweisen.

Mathematische Operationen

Elementweise Arithmetik

Alle Standardoperatoren (+, -, *, /, **) wirken elementweise auf Arrays derselben Form. Die entsprechenden benannten Funktionen (np.add, np.subtract, np.multiply, np.divide) können nützlich sein, wenn man Operationen als Argumente übergibt.

[5 7 9]
[ 4 10 18]
[1 4 9]

Universelle mathematische Funktionen (ufuncs)

NumPy stellt vektorisierte Versionen aller Standard-Mathematikfunktionen bereit:

import numpy as np

a = np.array([0, 1, 4, 9, 16], dtype=float)

print(np.sqrt(a))
print(np.log(np.array([1, np.e, np.e**2])))   # natural log
print(np.sin(np.array([0, np.pi/2, np.pi])))

[0. 1. 2. 3. 4.]
[0. 1. 2.]
[ 0.000e+00  1.000e+00 -8.742e-08]

Der kleine Wert nahe null für sin(π) ist normales Gleitkomma-Runden — np.pi ist eine Näherung von π.

Aggregationsfunktionen

Aggregationsfunktionen reduzieren ein array (oder eine seiner Achsen) auf einen einzigen Wert:

import numpy as np

a = np.array([1, 2, 3, 4, 5])

print(np.sum(a))    # 15
print(np.mean(a))   # 3.0
print(np.std(a))    # 1.4142135623730951
print(np.min(a))    # 1
print(np.max(a))    # 5

15
3.0
1.4142135623730951
1
5

Bei 2-D-Arrays übergibt man axis=0, um entlang der Spalten zu aggregieren, oder axis=1, um entlang der Zeilen zu aggregieren:

import numpy as np

m = np.array([[1, 2, 3],
              [4, 5, 6]])

print(np.sum(m, axis=0))   # column totals: [5 7 9]
print(np.sum(m, axis=1))   # row totals:    [6 15]

[5 7 9]
[ 6 15]

Lineare Algebra

NumPys np.dot() berechnet das Skalarprodukt zweier 1-D-Vektoren oder das Matrizenprodukt zweier 2-D-Arrays. Für die Matrizenmultiplikation ist der @-Operator (Python 3.5+) die moderne Kurzschreibweise.

import numpy as np

a = np.array([1, 2])
b = np.array([3, 4])
print(np.dot(a, b))     # 1*3 + 2*4 = 11

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print(A @ B)            # matrix product

11
[[19 22]
 [43 50]]

np.linalg enthält weiterführende Operationen:

Hilfsfunktionen

Sortieren

import numpy as np

a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
print(np.sort(a))         # returns a sorted copy
print(np.argsort(a))      # indices that would sort the array

[1 1 2 3 4 5 6 9]
[1 3 6 0 2 4 7 5]

Eindeutige Werte

import numpy as np

a = np.array([1, 2, 2, 3, 3, 3])
print(np.unique(a))

[1 2 3]

Bedingte Auswahl mit np.where

np.where(condition, x, y) gibt x zurück, wo die Bedingung True ist, und y überall sonst:

import numpy as np

a = np.array([1, 2, 3, 4, 5])
print(np.where(a > 2, a, 0))

[0 0 3 4 5]

NumPy mit Matplotlib

NumPy und Matplotlib sind so konzipiert, dass sie zusammenarbeiten. np.linspace erzeugt die x-Werte; NumPy-ufuncs berechnen y; Matplotlib stellt das Ergebnis dar:

import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0, 2 * np.pi, 200)
plt.plot(x, np.sin(x), label='sin')
plt.plot(x, np.cos(x), label='cos')
plt.legend()
plt.title('Sine and Cosine')
plt.show()

Dieses Beispiel erfordert eine installierte Matplotlib (pip install matplotlib) sowie ein Display oder ein Agg-Backend für Umgebungen ohne Anzeige. Im Kapitel Matplotlib Intro findet sich eine ausführliche Anleitung.

Was als Nächstes lernen

• SciPy-Tutorial — wissenschaftliches Rechnen auf höherem Niveau (Integration, Optimierung, Signalverarbeitung), das auf NumPy-Arrays aufbaut.
• Matplotlib Intro — NumPy-Arrays als Liniendiagramme, Streudiagramme, Histogramme und mehr visualisieren.
• Matplotlib Plotting — Figure-Layout, Achsen und Stile verfeinern.