Die NumPy-Bibliothek ist ein leistungsstarkes Tool in Python zur Verarbeitung großer, mehrdimensionaler Arrays und Matrizen. Sie bietet eine Vielzahl an mathematischen Funktionen, die auf diese Arrays angewendet werden können, und ist ideal für wissenschaftliche und technische Berechnungen geeignet. Aufgrund ihrer Geschwindigkeit und Effizienz wird NumPy häufig für Datenanalyse, maschinelles Lernen und mathematische Anwendungen eingesetzt.

Numpy in detail

Hauptfunktionen von NumPy

• Mehrdimensionale Arrays: NumPy bietet das ndarray-Objekt, ein schnelles, flexibles Array-Objekt, das die Speicherung und Bearbeitung von mehrdimensionalen Daten unterstützt.
• Broadcasting: Ermöglicht Operationen zwischen Arrays unterschiedlicher Formen, was elementweise Berechnungen vereinfacht.
• Mathematische Funktionen: NumPy enthält eine Vielzahl an mathematischen Funktionen wie trigonometrische, logarithmische und statistische Berechnungen.
• Zufallszahlengenerierung: Das Modul numpy.random erlaubt das Erzeugen von Zufallszahlen, was für Simulationen und maschinelles Lernen hilfreich ist.

Installation von NumPy

Um NumPy zu verwenden, muss es installiert sein. Die Installation erfolgt über pip:

pip install numpy

Grundlegende Verwendung von NumPy

Importieren von NumPy

Die Bibliothek wird mit folgender Standardkonvention importiert:

import numpy as np

Erstellen von Arrays

• 1D-Array:  

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

• 2D-Array:  

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

Grundlegende Operationen auf Arrays

• Elementweise Operationen (Addition, Subtraktion, etc.):

  a = np.array([1, 2, 3])
  b = np.array([4, 5, 6])
  print(a + b)  # Ausgabe: [5 7 9]
  print(a * b)  # Ausgabe: [ 4 10 18]
  

  Copy code

Broadcasting

c = np.array([1, 2, 3])
print(c + 10)  # Ausgabe: [11 12 13]

Nützliche Funktionen für Arrays
np.zeros und np.ones, um Arrays nur mit Nullen oder Einsen zu erstellen:

zeros_array = np.zeros((2, 3))  # 2x3 Array mit Nullen
ones_array = np.ones((3, 3))    # 3x3 Array mit Einsen

np.arange, um ein Array mit einer Zahlenfolge zu erstellen:

sequence_array = np.arange(0, 10, 2)  # Ausgabe: [0 2 4 6 8]

np.linspace, um ein Array mit linear verteilten Elementen zu erstellen

linear_array = np.linspace(0, 1, 5)  # Ausgabe: [0. 0.25 0.5 0.75 1.]

Indexing und Slicing Man kann auf Elemente in einem NumPy-Array mit Indizes zugreifen, ähnlich wie bei Python-Listen, es wird aber auch weiterführendes Indexing unterstützt.

array = np.array([1, 2, 3, 4, 5])
print(array[0])    # Ausgabe: 1
print(array[1:3])  # Ausgabe: [2 3]

Arrays Umformen Ein Array kann auf eine andere Dimension umgeformt werden, wobei die Gesamtanzahl der Elemente gleich bleibt.

array = np.arange(1, 7)
reshaped_array = array.reshape((2, 3))
print(reshaped_array)
# Ausgabe:
# [[1 2 3]
#  [4 5 6]]

Mathematische Operationen NumPy bietet eine große Anzahl an mathematischen Funktionen, die auf Arrays angewendet werden können.

a = np.array([1, 2, 3])
print(np.sum(a))      # Ausgabe: 6
print(np.mean(a))     # Ausgabe: 2.0
print(np.std(a))      # Ausgabe: Standardabweichung

Arbeiten mit 2D-Arrays (Matrizen)

• Matrixmultiplikation

  a = np.array([[1, 2], [3, 4]])
  b = np.array([[5, 6], [7, 8]])
  produkt = np.dot(a, b)
  print(produkt)
  # Ausgabe:
  # [[19 22]
  #  [43 50]]
  

  Copy code
  
  
• Zufallszahlengenerierung Das Modul numpy.random ist nützlich, um Zufallszahlen und -arrays zu erzeugen.
  

  zufalls_array = np.random.rand(3, 3)  # 3x3 Array mit Zufallszahlen zwischen 0 und 1
  zufalls_ganze_zahlen = np.random.randint(1, 10, size=(2, 2))  # 2x2 Array mit Zufallszahlen zwischen 1 und 9
  

  Copy code

Beispiel: Verwendung von NumPy in einem technischen Kontext

Angenommen, wir haben eine Reihe von Dickewerten in Millimetern für verschiedene Bleche und möchten das Volumen für eine bestimmte Breite berechnen:

import numpy as np

dicke = np.array([2.0, 2.5, 1.8, 3.0, 2.2])  # in mm
breite = 1000  # in mm
länge = 2000  # in mm

# Fläche berechnen (Breite * Länge) für jeden Dickenwert
fläche = breite * länge
volumen = fläche * dicke  # Volumen in Kubikmillimetern für jedes Blech

print("Volumen jedes Blechs:", volumen)

• Die Indizes in NumPy-Arrays beginnen mit 0, was bedeutet, dass das erste Element den Index 0 und das zweite den Index 1 hat. Ähnlich wie bei der Indizierung in einer Liste.​

• Das NumPy-Array-Objekt hat eine Eigenschaft namens dtype, die den Datentyp des Arrays zurückgibt --> array1.dtype​

• Um den Datentyp eines vorhandenen Arrays zu ändern, müssen Sie mit der Methode astype() eine Kopie des Arrays erstellen. -->array1.astype('i')​

• Für den booleschen dtype gibt es für alle Werte ungleich Null „false“ zurück.
  

-->      

Slicing in Arrays

 
In Python sind das Slicing und Reshaping von Arrays wichtige Techniken, die besonders nützlich sind, wenn man mit der NumPy-Bibliothek arbeitet. Diese Methoden ermöglichen den Zugriff auf spezifische Teile eines Arrays und das Ändern seiner Form, was in der Datenmanipulation, wissenschaftlichen Berechnungen und im maschinellen Lernen von Vorteil ist.

• start: Der Startindex (inklusive).
• stop: Der Endindex (exklusive).
• step: Der Abstand zwischen den Elementen (optional)

Beispiel für Slicing in 1D-Arrays

Für ein eindimensionales Array:

import numpy as np

array_1d = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print(array_1d[2:7])         # Ausgabe: [2 3 4 5 6]
print(array_1d[:5])          # Ausgabe: [0 1 2 3 4]
print(array_1d[::2])         # Ausgabe: [0 2 4 6 8]

Beispiel für Slicing in 2D-Arrays

Für ein zweidimensionales Array (Matrix):

array_2d = np.array([[10, 20, 30, 40], 
                     [50, 60, 70, 80], 
                     [90, 100, 110, 120]])

print(array_2d[1:, 1:])    # Ausgabe: [[ 60  70  80]
                           #          [100 110 120]]
print(array_2d[0:2, 2:])   # Ausgabe: [[30 40]
                           #          [70 80]]

Hier:

• array_2d[1:, 1:] schneidet ab Zeile 1 und Spalte 1 bis zum Ende.
• array_2d[0:2, 2:] schneidet die ersten beiden Zeilen und Spalten ab Index 2.

Reshaping eines Arrays

Mit Reshaping kann man die Form eines Arrays ändern, ohne die Daten zu ändern. Dies ist besonders nützlich, wenn das Array für bestimmte mathematische Operationen oder Visualisierungen angepasst werden muss.

Die Methode lautet:

array.reshape(new_shape)

Hier ist new_shape ein Tupel, das die gewünschte Form angibt, z.B. (Zeilen, Spalten). Die Gesamtanzahl der Elemente muss gleich bleiben.

Beispiel für Reshaping

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

array_reshaped = array_1d.reshape((3, 3))
print(array_reshaped)
# Ausgabe:
# [[1 2 3]
#  [4 5 6]
#  [7 8 9]]

In diesem Beispiel wird ein 1D-Array mit 9 Elementen in ein 3x3 2D-Array umgeformt.

Reshaping in höhere Dimensionen

Mit NumPy kann man auch in höhere Dimensionen umformen, sofern die Gesamtzahl der Elemente konsistent bleibt

Praktisches Beispiel: Reshaping und Slicing zusammen

Nehmen wir an, wir haben ein 1D-Array mit Dickenwerten und wollen es in einem strukturierten 3x3-Format analysieren:

thickness_values = np.array([1.2, 1.5, 2.0, 1.8, 2.3, 2.5, 1.9, 2.2, 2.4])

# Umformen in ein 3x3 Array
reshaped_thickness = thickness_values.reshape((3, 3))
print("Umgeformtes Array:\n", reshaped_thickness)

# Slicing, um die erste Zeile zu erhalten
print("Erste Zeile:", reshaped_thickness[0, :])

# Slicing, um die erste Spalte zu erhalten
print("Erste Spalte:", reshaped_thickness[:, 0])

Wichtige Punkte:

• Die reshape-Methode ist nützlich, wenn Daten für Matrixoperationen oder bestimmte Algorithmen eine spezifische Eingabeform erfordern.
• Slicing ermöglicht einen einfachen Zugriff und eine einfache Manipulation von Array-Teilen, was für das Filtern von Daten und das Fokussieren auf wichtige Abschnitte in größeren Datensätzen hilfreich ist. 

Iterating with Arrays in numpy
nditer ist eine Funktion in der NumPy-Bibliothek, die eine flexible und effiziente Möglichkeit bietet, durch Arrays beliebiger Dimensionen zu iterieren. Sie ermöglicht eine elementweise Iteration, was besonders nützlich ist, wenn wir komplexe Operationen auf jedem Element eines Arrays anwenden möchten.

Ähnlich wie beim Durchlaufen von Listen.

for element in np.nditer(array):
    # Führe Operationen mit 'element' durch

Zugriff auf Elemente mit bestimmten Modi

nditer unterstützt verschiedene Modi zur Steuerung, wie auf die Elemente zugegriffen wird, einschließlich Schreibzugriff und erweiterter Iterationsmethoden.

Bearbeiten der Elemente während der Iteration: Standardmäßig ist nditer schreibgeschützt. Um die Werte während der Iteration zu ändern, können wir den Modus op_flags=['readwrite'] verwenden.

Iterieren in einer bestimmten Reihenfolge: Falls die Reihenfolge der Iteration angepasst werden soll, wie beispielsweise eine "C"- oder "Fortran"-Speicheranordnung, können wir den Parameter order verwenden:

for element in np.nditer(array_2d, order='F'):  # Spaltenweise
    print(element)

Iterieren mit mehreren Arrays: nditer erlaubt auch die Iteration über mehrere Arrays gleichzeitig. Dies ist nützlich, wenn wir zwei Arrays der gleichen Größe haben und Operationen zwischen ihnen ausführen möchten.

Fazit

• nditer bietet eine einfache Möglichkeit zur iterativen Bearbeitung und zum Zugriff auf Elemente in Arrays.
• Es ermöglicht die gleichzeitige Bearbeitung mehrerer Arrays und das Steuern der Iterationsreihenfolge.
• Bearbeitung während der Iteration wird durch op_flags ermöglicht, was nditer zu einem vielseitigen Werkzeug für numerische Berechnungen macht.