Indizierung und Slicing

Ein Element auswählen

Die Indizierung wählt ein Element über seine Position aus einer Zeichenfolge oder Liste aus. Ist zum Beispiel buchstaben = ["a", "b", "c"], dann liefert buchstaben[1] den Wert "b".

Python zählt Indizes ab $0$. Das erste Element hat den Index $0$, das zweite den Index $1$ und so weiter. Negative Indizes zählen vom Ende rückwärts.

Positive und negative Indizes

Positive Indizes beginnen mit $0$ am Anfang. Negative Indizes beginnen mit $-1$ am Ende.

Die Tabelle zeigt zwei Indizes für dasselbe Element. Sowohl 1 als auch -4 wählen e. Der Code verwendet repr(), damit Anführungszeichen und leere Strings in der Ausgabe sichtbar sind.

# Beispiel für die Indizierung einer Zeichenfolge
s = "Hello"

# Zugriff auf Zeichen mit positiven Indizes
print(repr(s[0]))    # Ausgabe: 'H'
print(repr(s[4]))    # Ausgabe: 'o'

# Zugriff auf Zeichen mit negativen Indizes
print(repr(s[-1]))   # Ausgabe: 'o'
print(repr(s[-5]))   # Ausgabe: 'H'

# Es wird versucht, auf einen nicht vorhandenen Index zuzugreifen
try:
  print(repr(s[5]))
except IndexError:
  print("IndexError: Index außerhalb des gültigen Bereichs")

Ein Index außerhalb des gültigen Bereichs löst einen IndexError aus. Python-Sequenzen prüfen diese Grenze und liefern keinen beliebigen Wert zurück.

Mehrere Elemente auswählen

Beim Slicing werden mehrere Elemente einer Zeichenfolge oder Liste ausgewählt. Dazu legst du einen Startindex, einen Endindex und bei Bedarf den Abstand zwischen den ausgewählten Elementen fest.

Slicing mit zwei Grenzen

Die Schreibweise [i:j] verwendet i als Startindex und j als Endindex. Das Element am Startindex gehört zum Ergebnis, das Element am Endindex nicht.

# Beispiel für Slicing eines Strings
s = "Hello"

# Slicing von Index 1 bis 3, ohne Index 3
print(repr(s[1:3]))    # Ausgabe: 'el'

# Slicing von Index 3 bis zum Ende
print(repr(s[3:]))     # Ausgabe: 'lo'

# Slicing vom Anfang bis Index 3
print(repr(s[:3]))     # Ausgabe: 'Hel'

# Slicing mit negativen Indizes
print(repr(s[-4:-2]))  # Ausgabe: 'el'
print(repr(s[-2:-4]))  # Ausgabe: ''

Ist der Startindex bei positiver Schrittweite größer als der Endindex, entsteht eine leere Zeichenfolge oder Liste. Eine negative Schrittweite wählt die Elemente in der Gegenrichtung aus.

Abstand zwischen ausgewählten Elementen

Der dritte Wert in [start:stop:schritt] legt den Abstand zwischen ausgewählten Elementen fest. Eine Schrittweite von $2$ wählt ein Element aus und überspringt das nächste.

# Beispiel für Slicing mit Schritt
s = "Hello World!"

# Jedes zweite Zeichen auswählen
print(repr(s[::2]))      # Ausgabe: 'HloWrd'

# Ab Index 1 jedes zweite Zeichen auswählen
print(repr(s[1::2]))     # Ausgabe: 'el ol!'

# String mit negativer Schrittweite umkehren
print(repr(s[::-1]))     # Ausgabe: '!dlroW olleH'

# Slicing ab einem bestimmten Index mit negativer Schrittweite
print(repr(s[-1:4:-1]))  # Ausgabe: '!dlroW '

Ein negativer Schritt kehrt die Auswahlrichtung um. s[::-1] lässt beide Grenzen weg und wählt alle Elemente vom Ende bis zum Anfang aus. Die Schrittweite darf nicht null sein, weil damit kein nächster Index erreicht wird.

Regeln für Slicing

Ein Slice wird als start:stop:step geschrieben. Der Startindex gehört zum Ergebnis, der Endindex nicht, und eine negative Schrittweite liest die Sequenz von rechts nach links.

Anzahl der ausgewählten Elemente

Sei $n$ die Länge von s. Im einfachen Fall $0 \le i \le j \le n$ mit der positiven Standardschrittweite hat s[i:j] die Länge $j-i$. Allgemeine Slices können ausgelassene, negative oder außerhalb liegende Grenzen und eine andere Schrittweite besitzen. Python normalisiert sie zunächst anhand der Sequenzlänge. Die genaue Anzahl ist len(range(*slice(i, j, step).indices(len(s)))).

# Berechnung der Slicing-Ergebnislänge
s = "Hello"

# Slicing s[1:4]
result = s[1:4]
print(f"Ergebnis: '{result}', Länge: {len(result)}")  # Ausgabe: Ergebnis: 'ell', Länge: 3

# Beweisen, dass s[:i] + s[i:] == s
i = 2
left_part = s[:i]
right_part = s[i:]
print(f"'{left_part}' + '{right_part}' = '{left_part + right_part}'")

# Slicing außerhalb der Grenzen löst keinen Fehler aus
print(repr(s[3:10]))   # Ausgabe: 'lo'
print(repr(s[10:]))    # Ausgabe: ''

Python begrenzt Indizes beim Slicing auf den gültigen Bereich der Zeichenfolge oder Liste. Deshalb bleibt s[3:10] gültig, auch wenn der Endindex größer als die Länge von s ist.

Ausgewählte Indizes

Mit range() kannst du zeigen, welche Indizes ein Slice auswählt. Dieses Modell erklärt das Ergebnis, ohne Annahmen über die interne Umsetzung des jeweiligen Python-Typs zu treffen.

# Slicing als Schleife verstehen
s = "Hello World!"

# s[1:8:2] entspricht der folgenden Schleife:
result_manual = ""
for index in range(1, 8, 2):
  result_manual += s[index]

result_slicing = s[1:8:2]

print(f"Manual loop: '{result_manual}'")    # Ausgabe: 'el o'
print(f"Slicing: '{result_slicing}'")       # Ausgabe: 'el o'
print(f"Dasselbe Ergebnis? {result_manual == result_slicing}")  # Ausgabe: True

# Beispiel mit negativem Schritt
print("\nNegativer Schritt:")
print(f"s[::-2] = '{s[::-2]}'")            # Ausgabe: '!lo le'

# Äquivalente manuelle Schleife für negativen Schritt
result_negative = ""
for index in range(len(s)-1, -1, -2):
  result_negative += s[index]
print(f"Manual: '{result_negative}'")

Der Vergleich mit dem range()-Modell zeigt, wie Start, Stopp und Schrittweite zusammenwirken, besonders bei einer negativen Schrittweite.

Kurzformen beim Slicing

Ausgelassene Grenzen folgen der Richtung der Schrittweite. Bei positiver Schrittweite beginnt die Auswahl standardmäßig am Anfang und reicht bis hinter das letzte Element. Bei negativer Schrittweite beginnt sie am letzten Element und reicht bis vor das erste.

Vom Anfang oder bis zum Ende

Mit der positiven Standardschrittweite wählt s[:3] den Anfang und s[3:] das Ende aus. Bei s[::-1] folgen beide ausgelassenen Grenzen der negativen Richtung, sodass die Reihenfolge umgekehrt wird.

# Nützliche Slicing-Varianten
s = "Hello"

# Die ersten drei Zeichen auswählen
print(repr(s[:3]))     # Ausgabe: 'Hel'

# Zeichen vom Index 3 bis zum Ende übernehmen
print(repr(s[3:]))     # Ausgabe: 'lo'

# Alle Zeichen übernehmen
print(repr(s[:]))      # Ausgabe: 'Hello'

# Praxisbeispiel mit Liste
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Die ersten fünf Elemente auswählen
first_five = numbers[:5]
print(f"Die ersten fünf: {first_five}")

# Übernahme der letzten 5-Elemente
last_five = numbers[-5:]
print(f"Die letzten fünf: {last_five}")

# Mittlere Elemente nehmen (erstes 2 und letztes 2 überspringen)
middle = numbers[2:-2]
print(f"Mittelteil: {middle}")

Mit diesen Formen wählst du einen bestimmten Bereich oder regelmäßig verteilte Elemente aus einem größeren Datensatz aus, ohne eine eigene Schleife zu schreiben.

Teile von Strings und Listen verarbeiten

Die folgenden Beispiele verwenden Indizierung und Slicing, um Strings umzukehren, Telefonnummern zu formatieren, Initialen zu bilden und Palindrome zu prüfen. Das Beispiel mit der Dateiendung verwendet Path.suffix, weil Dateiendungen keine feste Länge haben.

# Praktische Beispiele für Indizierung und Slicing

# 1. Namen umkehren
first_name = "Ahmad"
last_name = "Wijaya"
reversed_name = (first_name + " " + last_name)[::-1]
print(f"Umgekehrter Name: {reversed_name}")

# 2. Eine Dateierweiterung zuverlässig ermitteln
from pathlib import Path

filename = "important_document.pdf"
extension = Path(filename).suffix
print(f"Erweiterung: {extension}")

# 3. Telefonnummer formatieren
number = "081234567890"
formatted = f"{number[:4]}-{number[4:8]}-{number[8:]}"
print(f"Formatierte Telefonnummer: {formatted}")

# 4. Initialen eines Namens bestimmen
full_name = "Siti Nurhaliza Binti Ahmad"
words = full_name.split()
initials = ""
for word in words:
  initials += word[0]
print(f"Initialen: {initials}")

# 5. Palindrome checker
def is_palindrome(text):
  cleaned = "".join(character for character in text.casefold() if character.isalnum())
  return cleaned == cleaned[::-1]

print(f"'katak' palindrome? {is_palindrome('katak')}")
print(f"'kasur rusak' palindrome? {is_palindrome('kasur rusak')}")

Verwende einen Index für ein Element an einer bekannten Position. Verwende Slicing für mehrere benachbarte oder regelmäßig verteilte Elemente. Die Form [::-1] kehrt ihre Reihenfolge um. Dateiendungen haben unterschiedliche Längen, daher liest Path.suffix sie aus der Pfadstruktur statt aus einer festen Anzahl von Zeichen.

Slice-Grenzen werden an die Länge der Daten angepasst. s[10:] liefert bei einem kürzeren String deshalb "". Die direkte Indizierung mit s[10] löst weiterhin einen IndexError aus. Verwende einen Slice nur, wenn ein leeres Ergebnis zulässig ist.

Negative Indizes zählen vom Ende. Verwende s[-1] für das letzte Element oder s[-3:] für die letzten drei Elemente. Diese Form passt, wenn eine Position bei der Dateiverarbeitung, Textanalyse oder Arbeit mit Datensätzen vom Ende aus bestimmt wird.