ubuntuusers.de

numpy

Dieser Artikel wurde für die folgenden Ubuntu-Versionen getestet:


Du möchtest den Artikel für eine weitere Ubuntu-Version testen? Mitarbeit im Wiki ist immer willkommen! Dazu sind die Hinweise zum Testen von Artikeln zu beachten.

Zum Verständnis dieses Artikels sind folgende Seiten hilfreich:

numpy_logo.png NumPy 🇬🇧 ist ein Python-Modul, welches in erster Linie für (wissenschaftliche) Berechnungen konzipiert ist. Eine Kernfunktionalität von NumPy ist die Datenstruktur "ndarray", welche (sehr) große Mengen an Daten speichereffizient verwalten kann. Außerdem stellt das Modul diverse Methoden und Klassen für Lineare Algebra, Zufallszahlen und die Schnelle Fourier-Transformation bereit.

Die Berechnungen selbst werden teilweise durch die in C und Fortran geschriebenen, hochgradig optimierten Bibliotheken LAPACK und BLAS vorgenommen, wodurch diese sehr schnell sind.

Andere Python-Programme, die größere Mengen an (wissenschaftlichen oder finanztechnischen) Daten nutzen, wie z.B. SciPy 🇬🇧 oder Pandas 🇬🇧, setzen auf NumPy auf.

Installation

Für Python 3 installiert man NumPy über das Paket[1]:

  • python3-numpy

Befehl zum Installieren der Pakete:

sudo apt-get install python3-numpy 

Oder mit apturl installieren, Link: apt://python3-numpy

Manuell

NumPy ist zwar in den offiziellen Paketquellen enthalten, allerdings nicht unbedingt in der aktuellsten Version. Wer diese benötigt, der sollte NumPy manuell via pip installieren. NumPy unterstützt ab der Version 1.17 ausschließlich Python in der Version >= 3.5.

NumPy via pip installiert werden[2]:

pip3 install numpy 

Wer NumPy systemweit installieren möchte, der muss diesen Befehl mit Root-Rechten[3].

Verwendung

NumPy kann, wie bei allen Python-Modulen üblich, über import initialisiert werden, wobei es gängige Praxis ist, NumPy an den Namen np zu binden:

1
>>> import numpy as np

Wie in der Einleitung erwähnt, ist eine Kernfunktion von NumPy die Datenstruktur ndarray, welche n-dimensionale Arrays bereit stellt:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
>>> data = np.array([1, 2, 3])
>>> data
array([1, 2, 3])
>>> data_2D = np.array([[1, 2, 3],
...                     [4, 5, 6]])
>>> data_2D
array([[1, 2, 3],
       [4, 5, 6]])
>>> data_text = np.array(['foo', 'bar'])
>>> data_many_types = np.array([1, 2.0, 'spamegg'])
>>> data_many_types
array(['1', '2.0', 'spamegg'], 
      dtype='<U32')
>>> data_text
array(['foo', 'bar'], 
      dtype='<U3')

Alle Daten haben einen Typ, der in NumPy als dtype bezeichnet wird. Diesen kann man auch explizit abfragen, beim Anlegen eines Arrays festlegen und nachträglich umwandeln:

1
2
3
4
5
6
7
8
>>> data.dtype
dtype('int64')
>>> data2 = np.array([1, 2, 3], dtype=float)
>>> data2
array([ 1.,  2.,  3.])
>>> data_as_float = data.astype(float)
>>> data_as_float
array([ 1.,  2.,  3.])

Arrays in NumPy unterstützen wie in Python gewohnt den Zugriff auf Elemente über den Index als auch Slicing:

1
2
3
4
5
6
7
8
>>> data[2]
3
>>> data_2D[0]
array([1, 2, 3])
>>> data_2D[0][1]
2
>>> data_2D[1:]
array([[4, 5, 6]])

Mehrdimensionale Arrays können auch umstrukturiert werden:

1
2
3
4
5
6
7
8
>>> data_2D.reshape([3, 2])
array([[1, 2],
       [3, 4],
       [5, 6]])
>>> data.reshape([3, 1])
array([[1],
       [2],
       [3]])

Mit den Funktionen arange 🇬🇧 und linspace 🇬🇧 erhält man Daten, die zwischen einem Start- und einem Endpunkt gleichmäßig verteilt sind:

1
2
3
4
5
6
7
>>> line = np.arange(1, 10, 1)
>>> line
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> another_line = np.linspace(1, 10, 19)
>>> another_line
array([  1. ,   1.5,   2. ,   2.5,   3. ,   3.5,   4. ,   4.5,   5. ,
         5.5,   6. ,   6.5,   7. ,   7.5,   8. ,   8.5,   9. ,   9.5,  10. ])

Mit Arrays kann man normal Rechnen:

1
2
3
4
5
>>> data+data2
array([ 2.,  4.,  6.])
>>> data * data_2D
array([[ 1,  4,  9],
       [ 4, 10, 18]])

numpy.linalg 🇬🇧 stellt dabei noch eine Vielzahl von weiteren Rechenoperationen, auch für die Vektorrechnung, bereit.

In den letzten beiden Beispielen wird mit Hilfe von NumPy ein lineares Gleichungssystem gelöst:

3 * x0 + x1 = 9
x0 + 2 * x1 = 8
1
2
3
4
>>> a = np.array([[3, 1], [1, 2]])
>>> b = np.array([9, 8])
>>> np.linalg.solve(a, b)
array([ 2.,  3.])

Die Lösungen sind also 2 und 3.

4*x + 2*y + 2*z = 8
3*x - 4*y + 3*z = -2
1*x + 3*y + 2*z = 4
1
2
3
4
>>> a = np.array([[4, 2, 2], [3, -4, 3], [1, 3, 2]])
>>> b = np.array([8, -2, 4])
>>> np.linalg.solve(a, b)
array([ 1.75,  1.25, -0.75]

Hier sind die Lösungen 1,75, 1,25 und -0,75.

Problem und Lösung

fehlende Bibliotheken bei der manuellen Installation

Erhält man bei der manuellen Installation via pip eine Fehlermeldung, dass Bibliotheken, Headerdateien oder der Compiler nicht gefunden werden, dann müssen diese nachinstalliert werden, um die in C und Fortran geschriebenen Routinen kompilieren zu können. Dazu müssen die beiden folgenden Pakete installiert sein:

  • build-essential

  • python3-dev

Befehl zum Installieren der Pakete:

sudo apt-get install build-essential python3-dev 

Oder mit apturl installieren, Link: apt://build-essential,python3-dev

Diese Revision wurde am 29. März 2024 16:31 von noisefloor erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Python, Bildung, Wissenschaft