Einführung in die Indizierung in NumPy

Einführung

Willkommen zurück! Nachdem Sie nun verstehen, wie man NumPy-Arrays erstellt, ist es an der Zeit zu lernen, wie man auf die Daten in ihnen zugreift und diese manipuliert. In diesem Lab werden Sie das Indexing erkunden – die primäre Methode für den Zugriff auf und die Modifikation von Daten in NumPy-Arrays.

Aufbauend auf dem Gelernten

Im vorherigen Lab haben Sie gelernt:

• Wie man Arrays mit verschiedenen NumPy-Funktionen erstellt
• Den Unterschied zwischen Arrays und Python-Listen
• Array-Dimensionen (1D, 2D, 3D) und Datentypen

Nun lernen Sie, wie Sie:

• Einzelne Elemente oder Gruppen von Elementen zugreifen
• Spezifische Zeilen, Spalten oder Regionen aus Arrays extrahieren
• Fortgeschrittene Auswahltechniken für komplexe Datenfilterung verwenden
• Array-Daten durch Indexing modifizieren

Warum Indexing wichtig ist

Indexing ist grundlegend für die Datenmanipulation, da es Ihnen ermöglicht:

• Teilmengen von Daten für die Analyse zu extrahieren
• Spezifische Werte in großen Datensätzen zu modifizieren
• Daten basierend auf Bedingungen zu filtern
• Vektorisierte Operationen auf ausgewählten Elementen durchzuführen

Diese Fähigkeiten sind für jede Datenanalyse- oder wissenschaftliche Computing-Aufgabe in Python unerlässlich.

Grundlegende Indizierung und Slicing in 1D-Arrays

Nachdem Sie nun wissen, wie man Arrays erstellt, lernen wir, wie man auf deren Inhalte zugreift. Ihre gesamte Arbeit in diesem Lab wird in der Datei indexing_practice.py stattfinden.

Verständnis von Array-Indexing

Nullbasierte Indizierung (Zero-Based Indexing)

Ähnlich wie Python-Listen verwendet NumPy-Arrays die nullbasierte Indizierung. Das bedeutet:

• Das erste Element befindet sich am Index 0
• Das zweite Element befindet sich am Index 1
• Und so weiter...

Visualisierung von Array-Indizes

Für ein Array x = [10, 20, 30, 40, 50]:

Index:  0   1   2   3   4
Wert:  10  20  30  40  50

Daher gibt x[0] 10 zurück, x[2] gibt 30 zurück usw.

Slicing-Syntax

Slicing ermöglicht es Ihnen, einen Bereich von Elementen mit der Syntax start:stop:step auszuwählen:

• start: Index, an dem der Slice beginnt (inklusive)
• stop: Index, an dem der Slice endet (exklusive)
• step: Anzahl der zu überspringenden Elemente (optional, Standard ist 1)

Gängige Slicing-Muster:

• x[1:4]: Elemente an den Indizes 1, 2, 3
• x[:3]: Die ersten 3 Elemente (Indizes 0, 1, 2)
• x[2:]: Vom Index 2 bis zum Ende
• x[::2]: Jedes zweite Element beginnend mit Index 0
• x[::-1]: Kehrt das gesamte Array um

Öffnen Sie zuerst die Datei indexing_practice.py im Editor. Ersetzen Sie dann deren gesamten Inhalt durch den folgenden Code. Dieser Code erstellt ein 1D-Array und demonstriert, wie auf ein einzelnes Element und einen Slice von Elementen zugegriffen wird.

import numpy as np

## Erstellen eines 1D-Arrays mit Zahlen von 0 bis 9
x = np.arange(10)
print("Original array:", x)

## Zugriff auf ein einzelnes Element am Index 2
element = x[2]
print("Element at index 2:", element)

## Slicing des Arrays vom Index 1 bis (aber nicht einschließlich) Index 7 mit einem Schritt von 2
a_slice = x[1:7:2]
print("Slice from 1 to 7 with step 2:", a_slice)

Nachdem Sie den Code zu indexing_practice.py hinzugefügt haben, speichern Sie die Datei. Führen Sie nun das Skript über das Terminal aus, indem Sie den folgenden Befehl eingeben:

python indexing_practice.py

Sie sollten die folgende Ausgabe sehen, die das ursprüngliche Array, das Element am angegebenen Index und den resultierenden Slice anzeigt.

Original array: [0 1 2 3 4 5 6 7 8 9]
Element at index 2: 2
Slice from 1 to 7 with step 2: [1 3 5]

Indizierung mehrdimensionaler Arrays

Lassen Sie uns nun Arrays bearbeiten, die mehr als eine Dimension haben. Hier glänzt NumPy wirklich im Vergleich zu Python-Listen!

Denken in mehreren Dimensionen

2D-Arrays als Tabellen

Ein 2D-Array ist wie eine Tabellenkalkulation oder Tabelle:

• Zeilen sind die erste Dimension (horizontal)
• Spalten sind die zweite Dimension (vertikal)
• Sie geben sowohl Zeilen- als auch Spaltenindizes an: array[Zeile, Spalte]

Visualisierung von 2D-Indexing

Für ein 2D-Array:

array = [[10, 20, 30],
         [40, 50, 60],
         [70, 80, 90]]

Indizes:     0,0  0,1  0,2
             1,0  1,1  1,2
             2,0  2,1  2,2

• array[0, 0] → 10 (erste Zeile, erste Spalte)
• array[1, 2] → 60 (zweite Zeile, dritte Spalte)
• array[2, 1] → 80 (dritte Zeile, zweite Spalte)

Auswahl ganzer Zeilen oder Spalten

• array[0] oder array[0, :] → gesamte erste Zeile [10, 20, 30]
• array[:, 1] → gesamte zweite Spalte [20, 50, 80]
• Das ist viel bequemer als verschachtelte Python-Listen!

Lassen Sie uns dies mit einem zweidimensionalen (2D) Array üben. Aktualisieren Sie Ihre Datei indexing_practice.py mit dem folgenden Code. Dieses Skript erstellt ein 3x4-Array und zeigt, wie auf ein einzelnes Element und eine ganze Zeile zugegriffen wird.

import numpy as np

## Erstellen eines 2D-Arrays (3 Zeilen, 4 Spalten)
x = np.arange(12).reshape(3, 4)
print("Original 2D array:\n", x)

## Zugriff auf das Element in Zeile 1, Spalte 2
element = x[1, 2]
print("\nElement at (1, 2):", element)

## Zugriff auf die gesamte erste Zeile (Zeilenindex 0)
first_row = x[0]
print("\nFirst row:", first_row)

Speichern Sie die Datei und führen Sie sie erneut vom Terminal aus:

python indexing_practice.py

Die Ausgabe zeigt das 2D-Array und die spezifischen Teile, die Sie ausgewählt haben.

Original 2D array:
 [[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]

Element at (1, 2): 6

First row: [0 1 2 3]

Erweiterte Indizierung

Einfaches Slicing funktioniert gut für zusammenhängende Bereiche, aber manchmal benötigen Sie komplexere Auswahlen. NumPy bietet zwei leistungsstarke fortgeschrittene Indexing-Techniken:

Integer-Array-Indexing

Wählen Sie beliebige Elemente aus, indem Sie ein Array von Indizes bereitstellen. Dies ist so, als würden Sie bestimmte Elemente aus einer Liste anhand ihrer Positionen auswählen.

Beispiel aus der Praxis: Sie haben Testergebnisse und möchten die Ergebnisse für Schüler an den Positionen 3, 7 und 12 überprüfen:

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93, 87, 90, 82])
student_positions = [3, 7, 12]  ## Schüler, an denen Sie interessiert sind
selected_scores = scores[student_positions]  ## [95, 89, 82]

Boolesches Array-Indexing (Maskierung)

Wählen Sie Elemente basierend auf Bedingungen aus. Erstellen Sie eine "Maske" aus True/False-Werten und verwenden Sie diese dann, um das Array zu filtern.

Beispiel aus der Praxis: Filtern Sie bestandene Noten (≥ 80) aus einer Klasse:

scores = np.array([85, 92, 78, 95, 88, 76, 91, 89, 84, 93])
passing_mask = scores >= 80  ## [True, True, False, True, True, False, True, True, True, True]
passing_scores = scores[passing_mask]  ## [85, 92, 95, 88, 91, 89, 84, 93]

Warum das wichtig ist

• Integer-Indexing: Perfekt für das Sampling spezifischer Datenpunkte
• Boolesches Indexing: Ideal für Datenfilterung und bedingte Auswahlen
• Beide erstellen Kopien (keine Views), daher wirken sich Änderungen nicht auf das ursprüngliche Array aus

Lassen Sie uns beides ausprobieren. Ersetzen Sie den Inhalt von indexing_practice.py durch den folgenden Code:

import numpy as np

## --- Integer Array Indexing ---
x = np.arange(10, 0, -1)
print("Array for integer indexing:", x)

## Wählen Sie Elemente an den Indizes 3, 3, 1 und 8 aus
selected_elements = x[np.array([3, 3, 1, 8])]
print("Selected elements with integer array:", selected_elements)


## --- Boolean Array Indexing ---
y = np.array([1., -1., -2., 3.])
print("\nArray for boolean indexing:", y)

## Erstellen Sie eine boolesche Maske für negative Elemente
mask = y < 0
print("Boolean mask (y < 0):", mask)

## Wählen Sie Elemente aus, bei denen die Bedingung True ist
negative_elements = y[mask]
print("Elements where y < 0:", negative_elements)

Speichern Sie die Datei und führen Sie das Skript aus:

python indexing_practice.py

Ihre Ausgabe sollte zeigen, wie sowohl Integer- als auch Boolesches Indexing funktionieren, um spezifische Daten aus Ihren Arrays auszuwählen.

Array for integer indexing: [10  9  8  7  6  5  4  3  2  1]
Selected elements with integer array: [7 7 9 2]

Array for boolean indexing: [ 1. -1. -2.  3.]
Boolean mask (y < 0): [False  True  True False]
Elements where y < 0: [-1. -2.]

Wertezuweisung an indizierte Arrays

Indexing dient nicht nur zum Lesen von Daten – es ist auch mächtig zum Modifizieren von Daten. Sie können jede Indexing-Methode auf der linken Seite des Zuweisungsoperators (=) verwenden, um spezifische Elemente zu ändern.

Broadcasting: Formen kompatibel machen

Beim Zuweisen von Werten zu indizierten Arrays verwendet NumPy Broadcasting, um die Formen kompatibel zu machen. Dies ist eine der leistungsstärksten Funktionen von NumPy!

Broadcasting-Regeln

NumPy kann kleinere Arrays während der Zuweisung automatisch erweitern, um größere zu entsprechen, und folgt dabei diesen Regeln:

1. Einzelner Wert für mehrere Elemente: Ein Wert kann vielen Positionen zugewiesen werden
2. Kleines Array für größere Auswahl: Solange die Dimensionen kompatibel sind

Beispiele für Broadcasting bei der Zuweisung

## Einzelner Wert für einen Slice
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = 99  ## [1, 99, 99, 99, 5]

## Array für passenden Slice
arr = np.array([1, 2, 3, 4, 5])
arr[1:4] = [10, 20, 30]  ## [1, 10, 20, 30, 5]

## Boolesches Indexing mit Broadcasting
arr = np.array([1, 2, 3, 4, 5])
arr[arr % 2 == 0] = -1  ## Alle geraden Zahlen durch -1 ersetzen

Wichtige Hinweise

• Broadcasting funktioniert nur, wenn die Formen kompatibel sind
• Die Form des zugewiesenen Werts muss in die indizierte Auswahl "passen"
• Dies ist wesentlich effizienter als das manuelle Durchlaufen von Elementen

Aktualisieren Sie Ihre Datei indexing_practice.py mit dem folgenden Code, um dies in Aktion zu sehen.

import numpy as np

## --- Zuweisen eines einzelnen Werts zu einem Slice ---
x = np.arange(10)
print("Original array:", x)

## Weisen Sie den Wert 99 den Elementen vom Index 2 bis 4 zu
x[2:5] = 99
print("After assigning 99 to slice [2:5]:", x)


## --- Zuweisen von Werten basierend auf einer booleschen Bedingung ---
y = np.arange(10)
print("\nOriginal array:", y)

## Weisen Sie allen geraden Zahlen den Wert -1 zu
y[y % 2 == 0] = -1
print("After assigning -1 to even numbers:", y)

Speichern Sie die Datei und führen Sie sie vom Terminal aus:

python indexing_practice.py

Die Ausgabe zeigt die Arrays vor und nach der Änderung und demonstriert, wie leistungsfähig diese Funktion für die Datenmanipulation ist.

Original array: [0 1 2 3 4 5 6 7 8 9]
After assigning 99 to slice [2:5]: [ 0  1 99 99 99  5  6  7  8  9]

Original array: [0 1 2 3 4 5 6 7 8 9]
After assigning -1 to even numbers: [-1  1 -1  3 -1  5 -1  7 -1  9]

Zusammenfassung

In diesem Lab haben Sie die wesentlichen Techniken für das Indexing von NumPy-Arrays gelernt. Sie begannen mit dem grundlegenden Zugriff auf einzelne Elemente und dem Slicing in 1D-Arrays, ähnlich wie bei Python-Listen. Anschließend haben Sie das Indexing von mehrdimensionalen Arrays fortgesetzt, um spezifische Elemente und Teil-Arrays auszuwählen. Schließlich haben Sie fortgeschrittenes Indexing mit Integer- und Booleschen Arrays erkundet und gelernt, wie Sie diese leistungsstarken Auswahlmethoden zum Modifizieren von Daten innerhalb eines Arrays verwenden. Diese Fähigkeiten sind grundlegend für eine effektive Datenmanipulation und -analyse in Python mit NumPy.