82 lines
7.7 KiB
Markdown
82 lines
7.7 KiB
Markdown
---
|
|
title: "Python String-Präfixe"
|
|
date: "2026-09-08"
|
|
---
|
|
|
|
# Python String-Präfixe
|
|
|
|
In Python gibt es verschiedene Präfixe für String-Literale, die bestimmen, wie der Interpreter den Inhalt des Strings verarbeitet. Suffixe für String-Literale existieren in Python nicht direkt (anders als in Sprachen wie C++), aber es gibt Methoden auf String-Objekten wie `.startswith()` und `.endswith()`.
|
|
|
|
Hier ist die Liste aller String-Präfixe in Python mit Beschreibung und logischen Beispielen:
|
|
|
|
| Präfix | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **Keines** | Standard-Unicode-String (UTF-8 in Python 3). Verarbeitet normale Escape-Sequenzen wie `\n` oder `\t`. | `text = "Zeile 1\nZeile 2"` |
|
|
| **`f` / `F`** | **Formatted String (f-string):** Ermöglicht die direkte Einbettung von Python-Ausdrücken und Variablen in geschweiften Klammern `{}`. | `name = "Welt"\nprint(f"Hallo {name}!")` *(Ausgabe: Hallo Welt!)* |
|
|
| **`r` / `R`** | **Raw String:** Behandelt Backslashes `\` als normale Zeichen und ignoriert Escape-Sequenzen. Ideal für reguläre Ausdrücke oder Dateipfade. | `pfad = r"C:\Users\Name\Documents"` |
|
|
| **`b` / `B`** | **Byte-String:** Erzeugt ein `bytes`-Objekt statt eines Standard-Strings. Erlaubt nur ASCII-Zeichen (Werte 0-127). | `daten = b"Hallo"` *(Typ ist `bytes`)* |
|
|
| **`u` / `U`** | **Unicode-String:** In Python 3 standardmäßig das Standardverhalten. Wird heute hauptsächlich für die Abwärtskompatibilität mit Python 2 verwendet. | `unicode_text = u"Café"` |
|
|
| **`fr` / `rf`** | **Kombination (Raw f-string):** Erlaubt sowohl die Formatierung mit `{}` als auch die Ignorierung von Escape-Sequenzen. | `ordner = "Bilder"\npfad = fr"C:\{ordner}\bild.png"` |
|
|
| **`br` / `rb`** | **Kombination (Raw Byte-string):** Erzeugt ein Byte-Objekt, bei dem Backslashes nicht als Escape-Sequenzen interpretiert werden. | `regex_bytes = rb"a\nb"` |
|
|
|
|
*(Hinweis: Die Groß- und Kleinschreibung der Präfixe ist beliebig, d. h. `f""` verhält sich identisch zu `F""`.)*
|
|
|
|
## Python String-Methoden
|
|
|
|
Hier ist eine Übersicht über die wichtigsten eingebauten Methoden von String-Objekten (`str`) in Python, sortiert nach ihrer Funktion:
|
|
|
|
### 1. Bereinigen und Ausrichten
|
|
| Methode | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **`strip([chars])`** | Entfernt führende und folgende Whitespaces (oder die angegebenen Zeichen in `chars`). | `" hallo ".strip()` *(Ergebnis: `"hallo"`)* |
|
|
| **`lstrip([chars])`** | Entfernt nur führende Whitespaces oder Zeichen. | `" hallo ".lstrip()` *(Ergebnis: `"hallo "`)* |
|
|
| **`rstrip([chars])`** | Entfernt nur folgende Whitespaces oder Zeichen. | `" hallo ".rstrip()` *(Ergebnis: `" hallo"`)* |
|
|
| **`ljust(width[, fillchar])`** | Richtet den String linksbündig in einem Feld der Breite `width` aus. | `"test".ljust(10, "-")` *(Ergebnis: `"test------"`)* |
|
|
| **`rjust(width[, fillchar])`** | Richtet den String rechtsbündig in einem Feld der Breite `width` aus. | `"test".rjust(10, "-")` *(Ergebnis: `"------test"`)* |
|
|
| **`center(width[, fillchar])`** | Zentriert den String in einem Feld der Breite `width`. | `"test".center(10, "-")` *(Ergebnis: `"---test---"`)* |
|
|
| **`zfill(width)`** | Füllt den String links mit Nullen auf, bis die Breite `width` erreicht ist. | `"42".zfill(5)` *(Ergebnis: `"00042"`)* |
|
|
|
|
### 2. Suchen und Ersetzen
|
|
| Methode | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **`replace(old, new[, count])`** | Ersetzt Vorkommen von `old` durch `new`. Optional wird die Anzahl durch `count` begrenzt. | `"A-B-C".replace("-", "/")` *(Ergebnis: `"A/B/C"`)* |
|
|
| **`find(sub[, start[, end]])`** | Gibt den niedrigsten Index zurück, an dem `sub` gefunden wird. Gibt `-1` zurück, wenn nicht gefunden. | `"hallo".find("ll")` *(Ergebnis: `2`)* |
|
|
| **`rfind(sub[, start[, end]])`** | Gibt den höchsten Index zurück, an dem `sub` gefunden wird. Gibt `-1` zurück, wenn nicht gefunden. | `"hallo".rfind("l")` *(Ergebnis: `3`)* |
|
|
| **`index(sub[, start[, end]])`** | Wie `find()`, wirft aber einen `ValueError`, wenn das Substring nicht gefunden wird. | `"hallo".index("x")` *(Ergebnis: `ValueError`)* |
|
|
| **`rindex(sub[, start[, end]])`** | Wie `rfind()`, wirft aber einen `ValueError`, wenn nicht gefunden. | `"hallo".rindex("l")` *(Ergebnis: `3`)* |
|
|
| **`count(sub[, start[, end]])`** | Zählt, wie oft das Substring `sub` im String vorkommt. | `"banane".count("an")` *(Ergebnis: `2`)* |
|
|
|
|
### 3. Aufteilen und Verbinden
|
|
| Methode | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **`split(sep=None, maxsplit=-1)`** | Teilt den String an Trennzeichen `sep` und gibt eine Liste zurück. | `"A,B,C".split(",")` *(Ergebnis: `['A', 'B', 'C']`)* |
|
|
| **`rsplit(sep=None, maxsplit=-1)`** | Teilt den String vom Ende her auf. | `"A,B,C".rsplit(",", 1)` *(Ergebnis: `['A,B', 'C']`)* |
|
|
| **`splitlines([keepends])`** | Teilt den String an Zeilenumbrüchen auf. | `"A\nB".splitlines()` *(Ergebnis: `['A', 'B']`)* |
|
|
| **`join(iterable)`** | Verbindet die Elemente eines Iterables (z.B. Liste) mit dem String als Trennzeichen. | `"-".join(["A", "B"])` *(Ergebnis: `"A-B"`)* |
|
|
| **`partition(sep)`** | Teilt den String beim ersten Vorkommen von `sep` in ein Tupel: `(vor, sep, nach)`. | `"A-B-C".partition("-")` *(Ergebnis: `('A', '-', 'B-C')`)* |
|
|
| **`rpartition(sep)`** | Teilt den String beim letzten Vorkommen von `sep`. | `"A-B-C".rpartition("-")` *(Ergebnis: `('A-B', '-', 'C')`)* |
|
|
|
|
### 4. Groß-/Kleinschreibung ändern
|
|
| Methode | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **`lower()`** | Konvertiert alle Zeichen in Kleinbuchstaben. | `"Hallo".lower()` *(Ergebnis: `"hallo"`)* |
|
|
| **`upper()`** | Konvertiert alle Zeichen in Großbuchstaben. | `"Hallo".upper()` *(Ergebnis: `"HALLO"`)* |
|
|
| **`capitalize()`** | Setzt das erste Zeichen auf Groß und den Rest auf Klein. | `"hallo welt".capitalize()` *(Ergebnis: `"Hallo welt"`)* |
|
|
| **`title()`** | Setzt den ersten Buchstaben jedes Wortes auf Groß. | `"hallo welt".title()` *(Ergebnis: `"Hallo Welt"`)* |
|
|
| **`swapcase()`** | Vertauscht Groß- und Kleinschreibung. | `"HAllo".swapcase()` *(Ergebnis: `"haLLO"`)* |
|
|
| **`casefold()`** | Ähnlich wie `lower()`, ist aber aggressiver beim Entfernen von Groß-/Kleinschreibungsunterschieden (gut für Caseless Matching in Unicode). | `"Straße".casefold()` *(Ergebnis: `"strasse"`)* |
|
|
|
|
### 5. Überprüfungsmethoden (Geben `True` oder `False` zurück)
|
|
| Methode | Beschreibung | Logisches Beispiel |
|
|
| :--- | :--- | :--- |
|
|
| **`startswith(prefix[, start[, end]])`** | Prüft, ob der String mit `prefix` beginnt. | `"hallo".startswith("ha")` *(Ergebnis: `True`)* |
|
|
| **`endswith(suffix[, start[, end]])`** | Prüft, ob der String mit `suffix` endet. | `"hallo".endswith("lo")` *(Ergebnis: `True`)* |
|
|
| **`isalnum()`** | Prüft, ob alle Zeichen alphanumerisch sind (Buchstaben und Zahlen) und mindestens ein Zeichen vorhanden ist. | `"Python3".isalnum()` *(Ergebnis: `True`)* |
|
|
| **`isalpha()`** | Prüft, ob alle Zeichen Buchstaben sind. | `"Python".isalpha()` *(Ergebnis: `True`)* |
|
|
| **`isdigit()`** | Prüft, ob alle Zeichen Ziffern sind (z. B. auch hochgestellte Zahlen). | `"123".isdigit()` *(Ergebnis: `True`)* |
|
|
| **`isnumeric()`** | Prüft, ob alle Zeichen numerisch sind (auch Brüche wie ½). | `"½".isnumeric()` *(Ergebnis: `True`)* |
|
|
| **`isspace()`** | Prüft, ob der String nur aus Whitespaces (Leerzeichen, Tabs, Zeilenumbrüchen) besteht. | `" \n".isspace()` *(Ergebnis: `True`)* |
|
|
| **`islower()`** | Prüft, ob alle buchstabenbasierten Zeichen kleingeschrieben sind. | `"hallo".islower()` *(Ergebnis: `True`)* |
|
|
| **`isupper()`** | Prüft, ob alle buchstabenbasierten Zeichen großgeschrieben sind. | `"HALLO".isupper()` *(Ergebnis: `True`)* |
|
|
| **`istitle()`** | Prüft, ob der String im Titlecase-Format vorliegt. | `"Hallo Welt".istitle()` *(Ergebnis: `True`)* |
|