ubuntuusers.de

Du betrachtest eine alte Revision dieser Wikiseite.

numpy

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

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

Paketliste zum Kopieren:

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.

Da NumPy wie oben erwähnt teilweise auf in C und Fortran geschriebene Routinen zurückgreift, werden diese bei der manuellen Installation diese kompiliert. Deswegen müssen die beiden folgenden Pakete installiert sein:

  • build-essential

  • python3-dev

Paketliste zum Kopieren:

sudo apt-get install build-essential python3-dev 

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

Danach kann NumPy via pip installiert werden[2]:

pip3 install --user numpy 

Wer NumPy systemweit installieren möchte, der muss diesen Befehl mit Root-Rechten[3] und ohne die Option --user ausführen.

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=np.float)
>>> data2
array([ 1.,  2.,  3.])
>>> data_as_float = data.astype(np.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. ])

NumPy besitzt eine Vielzahl von Funktionen für Zufallszahlen 🇬🇧. Im folgenden Beispiel wird ein 3x3-Array mit Zufallszahlen befüllt:

1
2
3
4
5
>>> rand_data = np.random.rand(3, 3)
>>> rand_data
array([[ 0.74366382,  0.6128714 ,  0.50743328],
       [ 0.54610234,  0.41035337,  0.85165437],
       [ 0.83093576,  0.60663416,  0.14470856]])

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.

  • Projektseite 🇬🇧

  • Dokumentation 🇬🇧 zu NumPy, welche sehr umfangreich und detailliert ist

  • User Guide 🇬🇧 für NumPy

  • NumPy - Wikipedia

  • Dask 🇬🇧 - Python-Modul, welche noch größere Datenmengen als NumPy parallel verarbeiten kann

Diese Revision wurde am 5. Januar 2020 19:06 von noisefloor erstellt.
Die folgenden Schlagworte wurden dem Artikel zugewiesen: Wissenschaft, Bildung, Python