NumPy

NumPy
Basisdaten
Hauptentwickler	Das NumPy-Team
Entwickler	Travis Oliphant
Erscheinungsjahr	1995 (als Numeric); 2006 (als NumPy)
Aktuelle Version	1.26.4 (5. Februar 2024)
Betriebssystem	plattformübergreifend
Programmiersprache	Python, C
Kategorie	Numerische Bibliothek für wissenschaftliches Rechnen
Lizenz	BSD (neu)
www.numpy.org

NumPy ist eine Programmbibliothek für die Programmiersprache Python, die eine einfache Handhabung von Vektoren, Matrizen oder generell großen mehrdimensionalen Arrays ermöglicht. Neben den Datenstrukturen bietet NumPy auch effizient implementierte Funktionen für numerische Berechnungen an.

Der Vorgänger von NumPy, Numeric, wurde unter Leitung von Jim Hugunin entwickelt. Travis Oliphant gliederte modifizierte Funktionalitäten des Konkurrenten Numarray in Numeric ein und veröffentlichte dies 2005 als NumPy. Die Bibliothek ist quelloffen und wird von vielen Mitwirkenden weiterentwickelt.

Merkmale

Der für Python standardmäßig installierte Interpreter CPython führt Kommandos als unoptimierten Bytecode aus. Mathematische Algorithmen sind in dieser Python-Variante oft langsamer als eine äquivalente compilierte Umsetzung. NumPy stellt hier eine performante Alternative dar. Bestehende iterative Algorithmen müssen dazu gegebenenfalls für mehrdimensionale Array-Operationen umgeschrieben werden. NumPys Operatoren und Funktionen sind optimiert für derartige Arrays und ermöglichen so eine besonders effiziente Evaluation.

Die Handhabung von NumPy-Arrays in Python ist damit vergleichbar zu MATLAB; beide ermöglichen eine schnelle Ausführung von Algorithmen, solang diese für ganze Arrays oder Matrizen statt einzelne Skalare konzipiert sind. MATLAB bietet große Erweiterungsmöglichkeiten mit Zusatzprodukten wie zum Beispiel Simulink. Die Integration von NumPy in Python ermöglicht die Verwendung und Kombination mit vielen weiteren Paketen aus dem umfangreichen Python Umfeld. Weitere MATLAB-ähnliche Funktionen bietet die Python-Bibliothek SciPy. Auch der Funktionsumfang der Matplotlib zur einfachen Erstellung von Plots in Python ist den Möglichkeiten von MATLAB sehr ähnlich. Intern verwenden sowohl MATLAB als auch NumPy die beiden Programmbibliotheken BLAS und LAPACK für eine effiziente Berechnung linearer Algebra.

Die Python-Schnittstelle des weit verbreiteten Computer-Vision-Pakets OpenCV verwendet intern NumPy-Arrays zur Verarbeitung von Daten. Bilder mit mehreren Farbkanälen werden beispielsweise mit dreidimensionalen Arrays dargestellt. Indexierung, Slicing oder Maskierung mit anderen Arrays sind daher sehr effiziente Methoden um gezielt auf bestimmte Pixel zugreifen zu können. NumPy-Arrays als universelle Datenstruktur für Bilder, extrahierte Feature-Punkte, Faltungsmatrizen und vieles mehr erleichtern die Entwicklung und das Debugging von Algorithmen zur Bildverarbeitung.

Die ndarray-Datenstruktur

Die Kernfunktionalität von NumPy basiert auf der Datenstruktur „ndarray“ (n-dimensionales Array), einem zusammenhängenden Speicherbereich fester Größe. Anders als in Pythons eigener List-Datenstruktur (welche konträr zu ihrem Namen eigentlich durch ein dynamisches Array verwirklicht ist) sind ndarrays homogen typisiert: Alle Elemente eines Arrays müssen vom selben Datentyp sein.

Diese Arrays erlauben es außerdem von allozierten Puffern anderer Sprachen zu lesen ohne Daten kopieren zu müssen. Mit C/C++-, Cython- oder Fortran-Erweiterungen des CPython-Interpreters können so auch einfach weitere bestehende Numerikbibliotheken mitverwendet werden. Dieses Verhalten wird beispielsweise von SciPy genutzt, welches Wrapper für externe Bibliotheken wie BLAS oder LAPACK bereitstellt. NumPy bietet native Unterstützung für Memory Mapping der ndarrays.

Einschränkungen

Tatsächliches Einfügen oder Anhängen von Array-Einträgen wie bei Pythons Listen ist nicht möglich. Die Funktion np.pad(), mit der Arrays erweitert werden können, legt neue Arrays gewünschter Größe an, kopiert bestehende hinein und liefert dies zurück. Auch bei der Aneinanderreihung zweier Arrays mit np.concatenate([a1,a2]) werden die Arrays nicht wirklich verkettet, sondern ein neues zusammenhängendes Array zurückgegeben. Bei NumPys Funktion np.reshape() ist eine Umformung auch nur möglich, wenn sich die Anzahl der Array-Einträge nicht ändert. Diese Einschränkungen sind darauf zurückzuführen, dass NumPy-Arrays im Speicher als zusammenhängender Bereich angelegt werden müssen. Das Blaze-Framework bietet hier eine Alternative, welches diese Einschränkung beheben soll.

Die Verwendung von NumPy-Arrays allein gegenüber Python-Listen bringt noch keinen Geschwindigkeitsvorteil mit sich. Entsprechende Algorithmen müssen zunächst in eine vektortaugliche Form umgeschrieben werden. Dies kann von Nachteil sein, da eventuell temporäre Arrays in Größe der Eingabe angelegt werden müssen und sich damit die Speicherkomplexität von konstant zu linear vergrößert. Eine Laufzeitkompilation wurde schon in einigen Paketen implementiert um diese Probleme zu vermeiden. Open-Source-Lösungen, die mit NumPy interagieren können, sind unter anderem scipy.weave, numexpr und Numba. Außerdem wäre Cython noch eine statisch kompilierbare Alternative.

Beispiele

Array-Erzeugung

>>> import numpy as np
>>> x = np.array([1, 2, 3])
>>> x
array([1, 2, 3])
>>> y = np.arange(10) # analog zu Python's range-Funktion, nur wird ein Array statt einer Liste generiert
>>> y
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Basic operations

>>> a = np.array([1, 2, 3, 6])
>>> b = np.linspace(0, 2, 4) # erzeugt vier äquidistante Werte im Intervall [0,2]
>>> c = a - b
>>> c
array([ 1.    , 1.33333333, 1.66666667, 4.    ])
>>> a**2 # Python Operatoren können direkt auf Arrays angewandt werden
array([ 1, 4, 9, 36])

Universelle Funktionen

>>> a = np.linspace(-np.pi, np.pi, 100)
>>> b = np.sin(a)
>>> c = np.cos(a)

Lineare Algebra

>>> from numpy.random import rand
>>> from numpy.linalg import solve, inv
>>> a = np.array([[1, 2, 3], [3, 4, 6.7], [5, 9.0, 5]])
>>> a.transpose()
array([[1. , 3. , 5. ],
       [ 2. , 4. , 9. ],
       [ 3. , 6.7, 5. ]])
>>> inv(a)
array([[-2.27683616, 0.96045198, 0.07909605],
       [ 1.04519774, -0.56497175, 0.1299435 ],
       [ 0.39548023, 0.05649718, -0.11299435]])
>>> b = np.array([3, 2, 1])
>>> solve(a, b) # Löst die Gleichung ax = b
array([-4.83050847, 2.13559322, 1.18644068])
>>> c = rand(3, 3) # Erzeugt eine zufällige 3x3 Matrix mit Werten im Intervall [0,1]
>>> c
array([[3.98732789,  2.47702609,  4.71167924],
       [ 9.24410671,  5.5240412 , 10.6468792 ],
       [ 10.38136661,  8.44968437, 15.17639591]])
>>> np.dot(a, c) # Punkt Produkt der Matrizen
array([[53.61964114,  38.8741616 ,  71.53462537],
       [ 118.4935668 ,  86.14012835, 158.40440712],
       [ 155.04043289, 104.3499231 , 195.26228855]])
>>> a @ c # Möglich ab Python 3.5 und NumPy 1.10
array([[53.61964114,  38.8741616 ,  71.53462537],
       [ 118.4935668 ,  86.14012835, 158.40440712],
       [ 155.04043289, 104.3499231 , 195.26228855]])

Integration in OpenCV

>>> import numpy as np
>>> import cv2
>>> r = np.reshape(np.arange(256*256)%256,(256,256)) # 256x256 Pixel Array mit horizontalem Verlauf von 0 bis 255 für den roten Farbkanal
>>> g = np.zeros_like(r) # Array selber Größe und selbem Datentyp wie r aber gefüllt mit Nullen für den grünen Farbkanal
>>> b = r.T # Das transponierte r Array wird als vertikaler Verlauf des blauen Farbkanals verwendet.
>>> cv2.imwrite('gradients.png', np.dstack([b,g,r])) # OpenCV interpretiert Bilder in BGR, das in dritter Dimension gestapelte Array wird als 8bit RGB PNG-Datei 'gradients.png' gespeichert
True

Nächste-Nachbar-Suche - Iterativer Python-Algorithmus und vektorisierte NumPy-Alternative

>>> # # # Iterative Python Variante # # #
>>> points = [[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]]
>>> qPoint = [4,5,3]
>>> minIdx = -1
>>> minDist = -1
>>> for idx, point in enumerate(points): # iteriere über alle Punkte
        dist = sum([(dp-dq)**2 for dp,dq in zip(point,qPoint)])**0.5 # berechne die Euklidische Distanz jedes Punkts zu q
        if dist < minDist or minDist < 0: # wenn nötig, aktualisiere die minimale Distanz und Index des entsprechenden Punkts
            minDist = dist
            minIdx = idx

>>> print 'Nächster Punkt zu q: ', points[minIdx]
Nächster Punkt zu q: [3, 4, 4]
>>>
>>>
>>> # # # Äquivalente NumPy Vektorisierung # # #
>>> import numpy as np
>>> points = np.array([[9,2,8],[4,7,2],[3,4,4],[5,6,9],[5,0,7],[8,2,7],[0,3,2],[7,3,0],[6,1,1],[2,9,6]])
>>> qPoint = np.array([4,5,3])
>>> minIdx = np.argmin(np.linalg.norm(points-qPoint,axis=1)) # berechne alle Euklidischen Distanzen auf einmal und bestimme den Index des kleinsten Werts
>>> print 'Nächster Punkt zu q: ', points[minIdx]
Nächster Punkt zu q: [3 4 4]

Geschichte

Die Programmiersprache Python war ursprünglich nicht für numerische Berechnungen optimiert, erlangte aber schnell große Bekanntheit im Anwendungsbereich des Wissenschaftlichen Rechnens. So wurde 1995 die Interessengemeinschaft matrix-sig gegründet, die das Ziel verfolgte, ein einheitliches Paket zur Array-Handhabung zu definieren. Eines der Mitglieder war Python-Autor Guido van Rossum, welcher Syntaxerweiterungen, besonders die Indexierung, direkt in Python einpflegte, um die Verwendung von Arrays zu vereinfachen. Die erste Implementierung eines Matrizenpakets wurde von Jim Fulton entwickelt, die später von Jim Hugunin generalisiert und als Numeric (teilweise auch Numerical Python Extensions) bekannt wurde, dem Vorläufer von NumPy. Hugunin war damals Student am MIT,, verließ das Projekt aber 1997 um weiter an JPython zu arbeiten. Paul Dubois vom LLNL übernahm die Leitung des Projekts. Weitere Beitragende der ersten Stunde waren außerdem David Ascher, Konrad Hinsen und Travis Oliphant.

Das Paket Numarray wurde als Alternative zu Numeric entwickelt, die mehr Flexibilität bieten sollte. Beide Pakete gelten inzwischen als veraltet und werden nicht mehr weiterentwickelt. Numarray and Numeric hatten jeweils ihre Stärken und Schwächen und wurden eine Zeit lang noch parallel für unterschiedliche Anwendungsbereiche eingesetzt. Die letzte Version (v24.2) von Numeric erschien am 11. November 2005, die letzte (v1.5.2) von Numarray am 24. August 2006.

Anfang 2005 begann Travis Oliphant den Funktionsumfang von Numarray in Numeric zu übertragen, um die Entwicklergemeinschaft auf ein vereinigtes Projekt zu konzentrieren; das Ergebnis wurde 2005 als NumPy 1.0 veröffentlicht. Dieses neue Projekt war außerdem Teil von SciPy, wurde aber auch separat als NumPy angeboten um zu vermeiden, dass das große SciPy-Paket installiert werden muss nur um mit Array-Objekten arbeiten zu können. Von Version 1.5.0 an kann NumPy auch mit Python 3 verwendet werden.

2011 begann die Entwicklung einer NumPy-API für PyPy. Bislang wird allerdings noch nicht der gesamte NumPy-Funktionsumfang unterstützt.

Am 15. November 2017 wurde Numpy in die Liste der Python 3 Erklärung aufgenommen und verpflichtete sich damit dazu, Python 2 nur noch bis 2020 zu unterstützen. Das Team rund um Numpy gab bekannt, ab dem 1. Januar 2019 neue Funktionen nur noch für Python 3 bereit stellen zu wollen, während für Python 2 nur noch Fehlerbereinigungen erscheinen werden. Ab dem 1. Januar 2020 würden dann keine weiteren Aktualisierungen mehr für Python 2 folgen.

Siehe auch

• SciPy
• Matplotlib

Literatur

• Eli Bressert: Scipy and Numpy: An Overview for Developers. O’Reilly Media, 2012, ISBN 978-1-4493-0546-8. 

Weblinks

Commons: NumPy – Sammlung von Bildern, Videos und Audiodateien

• Offizielle Website
• Die Entstehung von NumPy (englisch)