Skip to content

Python String Replace: Vollständige Anleitung zu str.replace() und mehr

Soren Atelier
Name
Soren Atelier

Updated on

Das Ersetzen von Zeichenketten ist eine der häufigsten Operationen bei der Textverarbeitung. Sie müssen Benutzereingaben bereinigen, Datenformate normalisieren, sensible Informationen schwärzen oder Template-Strings transformieren. Pythons str.replace() bewältigt einfache Fälle in einer Zeile, stößt aber an seine Grenzen, wenn Sie Groß-/Kleinschreibung-unabhängigen Abgleich, Regex-Muster oder bedingte Ersetzungen benötigen. Das falsche Werkzeug zu wählen bedeutet entweder einfache Aufgaben unnötig zu verkomplizieren oder fragilen Code für komplexe Aufgaben zu schreiben.

Diese Anleitung behandelt jeden Ansatz zur String-Ersetzung in Python -- vom einfachen str.replace() über regex-basiertes re.sub(), zeichenweises translate() bis hin zu praktischen Mustern für reale Textverarbeitung.

📚

    str.replace(old, new, count)

    Die einfachste und gebräuchlichste Methode. Ersetzt alle Vorkommen von old durch new. Ein optionaler count begrenzt die Anzahl der Ersetzungen.

    text = "Hello World, Hello Python, Hello Everyone"
 
# Alle Vorkommen ersetzen
print(text.replace("Hello", "Hi"))
# Hi World, Hi Python, Hi Everyone
 
# Nur die ersten 2 Vorkommen ersetzen
print(text.replace("Hello", "Hi", 2))
# Hi World, Hi Python, Hello Everyone
 
# Einen Teilstring entfernen (durch leeren String ersetzen)
messy = "  extra   spaces   here  "
print(messy.replace(" ", ""))
# extraspaceshere

    Wichtiges Verhalten

    • Gibt einen neuen String zurück (Strings sind in Python unveränderlich)
    • Standardmäßig Groß-/Kleinschreibung-sensitiv
    • Ersetzt alle Vorkommen, es sei denn count ist angegeben
    • Gibt den ursprünglichen String unverändert zurück, wenn old nicht gefunden wird
    original = "Python is great"
new = original.replace("great", "awesome")
print(original)  # Python is great (unverändert)
print(new)       # Python is awesome

    Groß-/Kleinschreibung-unabhängiges Ersetzen

    str.replace() ist immer Groß-/Kleinschreibung-sensitiv. Für Groß-/Kleinschreibung-unabhängiges Ersetzen verwenden Sie re.sub() mit dem re.IGNORECASE-Flag.

    import re
 
text = "Python is Great, python is Fun, PYTHON is Everywhere"
 
# Groß-/Kleinschreibung-unabhängiges Ersetzen
result = re.sub(r'python', 'Java', text, flags=re.IGNORECASE)
print(result)
# Java is Great, Java is Fun, Java is Everywhere

    Regex-Ersetzung mit re.sub()

    re.sub(pattern, replacement, string, count, flags) ersetzt Übereinstimmungen eines Regex-Musters.

    import re
 
# Ziffern durch '#' ersetzen
text = "Call 555-1234 or 555-5678"
print(re.sub(r'\d', '#', text))
# Call ###-#### or ###-####
 
# Ganze Telefonnummern ersetzen
print(re.sub(r'\d{3}-\d{4}', '[GESCHWÄRZT]', text))
# Call [GESCHWÄRZT] or [GESCHWÄRZT]
 
# Mehrere Leerzeichen durch einzelnes ersetzen
messy = "too    many     spaces   here"
print(re.sub(r'\s+', ' ', messy))
# too many spaces here

    Erfassungsgruppen verwenden

    import re
 
# Vor- und Nachname tauschen
names = "Smith, John\nDoe, Jane\nBrown, Bob"
swapped = re.sub(r'(\w+), (\w+)', r'\2 \1', names)
print(swapped)
# John Smith
# Jane Doe
# Bob Brown
 
# Datumsformatierung hinzufügen
dates = "Meeting on 2026-02-10 and 2026-03-15"
formatted = re.sub(r'(\d{4})-(\d{2})-(\d{2})', r'\2/\3/\1', dates)
print(formatted)
# Meeting on 02/10/2026 and 03/15/2026

    Eine Funktion für dynamische Ersetzung verwenden

    Übergeben Sie eine Funktion anstelle eines Strings für bedingte Ersetzungen:

    import re
 
def censor_word(match):
    word = match.group()
    return word[0] + '*' * (len(word) - 1)
 
text = "The password is secret and the code is hidden"
censored = re.sub(r'secret|hidden', censor_word, text)
print(censored)
# The password is s***** and the code is h*****
    import re
 
# Nur bestimmte Wörter in Titelschreibung umwandeln
def smart_capitalize(match):
    word = match.group()
    minor_words = {'a', 'an', 'the', 'and', 'or', 'but', 'in', 'on', 'at', 'to'}
    if word.lower() in minor_words:
        return word.lower()
    return word.capitalize()
 
title = "the quick BROWN fox AND the lazy DOG"
result = re.sub(r'\b\w+\b', smart_capitalize, title)
print(result)
# the Quick Brown Fox and the Lazy Dog

    Mehrfache Ersetzungen

    replace()-Aufrufe verketten

    text = "Hello World! How are you?"
result = text.replace("Hello", "Hi").replace("World", "Earth").replace("you", "they")
print(result)  # Hi Earth! How are they?

    Wörterbuch-basiertes Ersetzen

    Für viele Ersetzungen verwenden Sie ein Wörterbuch mit re.sub():

    import re
 
def multi_replace(text, replacements):
    """Mehrere Teilstrings mit einem Wörterbuch ersetzen."""
    pattern = re.compile('|'.join(re.escape(k) for k in replacements))
    return pattern.sub(lambda m: replacements[m.group()], text)
 
text = "The cat sat on the mat with another cat"
replacements = {
    'cat': 'dog',
    'mat': 'rug',
    'sat': 'stood',
}
 
print(multi_replace(text, replacements))
# The dog stood on the rug with another dog

    Zeichenweises Ersetzen mit translate()

    Zum Ersetzen einzelner Zeichen ist str.translate() mit str.maketrans() die schnellste Option:

    # Zeichen ersetzen: a->@, e->3, o->0
table = str.maketrans('aeo', '@30')
text = "Hello World"
print(text.translate(table))
# H3ll0 W0rld
 
# Bestimmte Zeichen entfernen
remove_vowels = str.maketrans('', '', 'aeiouAEIOU')
print("Hello World".translate(remove_vowels))
# Hll Wrld
 
# In einem Aufruf ersetzen UND entfernen
table = str.maketrans({'a': '@', 'e': '3', ' ': None})
print("apple pie".translate(table))
# @ppl3pi3

    Methodenvergleich

    MethodeAm besten fürRegexGeschwindigkeitFlexibilität
    str.replace()Einfache, literale ErsetzungenNeinAm schnellstenNiedrig
    re.sub()Musterabgleich, komplexe RegelnJaMittelAm höchsten
    str.translate()Einzelne ZeichenzuordnungNeinSehr schnellNiedrig
    Verkettetes .replace()Wenige literale ErsetzungenNeinSchnellNiedrig
    Dict + re.sub()Viele gleichzeitige ErsetzungenJaMittelHoch

    Praktische Beispiele

    Text bereinigen und normalisieren

    import re
 
def clean_text(text):
    """Text für die Verarbeitung normalisieren."""
    text = text.strip()
    text = re.sub(r'\s+', ' ', text)           # Leerzeichen zusammenfassen
    text = re.sub(r'[^\w\s.,!?-]', '', text)   # Sonderzeichen entfernen
    text = text.lower()
    return text
 
raw = "  Hello!!!   This is    MESSY @#$ text...  "
print(clean_text(raw))
# hello!!! this is messy text...

    Template-String-Ersetzung

    template = "Dear {name}, your order #{order_id} ships on {date}."
 
data = {
    'name': 'Alice',
    'order_id': '12345',
    'date': 'Feb 15, 2026',
}
 
# str.format_map verwenden (besser als manuelles Ersetzen)
result = template.format_map(data)
print(result)
# Dear Alice, your order #12345 ships on Feb 15, 2026.

    Sensible Daten schwärzen

    import re
 
def redact_pii(text):
    """E-Mails, Telefonnummern und SSNs schwärzen."""
    text = re.sub(r'\b[\w.]+@[\w.]+\.\w+\b', '[EMAIL]', text)
    text = re.sub(r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b', '[TELEFON]', text)
    text = re.sub(r'\b\d{3}-\d{2}-\d{4}\b', '[SSN]', text)
    return text
 
msg = "Contact john@example.com or call 555-123-4567. SSN: 123-45-6789"
print(redact_pii(msg))
# Contact [EMAIL] or call [TELEFON]. SSN: [SSN]

    Textdaten in Jupyter verarbeiten

    Textbereinigung und -transformation ist iterative Arbeit -- Sie testen Muster gegen Beispieldaten, passen Regex an und überprüfen Ergebnisse. RunCell (opens in a new tab) ist ein KI-Agent für Jupyter, der Ihnen hilft, Textverarbeitungs-Pipelines interaktiv aufzubauen und zu debuggen und Ersetzungsmuster in Echtzeit gegen Ihre tatsächlichen Daten zu testen.

    FAQ

    Wie ersetze ich einen Teilstring in Python?

    Verwenden Sie str.replace(old, new) für einfache Ersetzungen: "hello world".replace("world", "python") gibt "hello python" zurück. Dies ersetzt alle Vorkommen. Fügen Sie ein drittes Argument hinzu, um Ersetzungen zu begrenzen: text.replace("a", "b", 2) ersetzt nur die ersten 2 Treffer.

    Wie führe ich eine Groß-/Kleinschreibung-unabhängige Ersetzung in Python durch?

    Verwenden Sie re.sub() mit dem re.IGNORECASE-Flag: re.sub(r'python', 'Java', text, flags=re.IGNORECASE). Die eingebaute Methode str.replace() unterstützt keinen Groß-/Kleinschreibung-unabhängigen Abgleich.

    Wie ersetze ich mehrere verschiedene Strings gleichzeitig?

    Erstellen Sie ein Regex-Muster aus einem Wörterbuch von Ersetzungen: Erstellen Sie ein kompiliertes Muster, das alle Schlüssel abgleicht, und verwenden Sie dann ein Lambda, um die Ersetzung für jeden Treffer nachzuschlagen. Alternativ können Sie .replace()-Aufrufe für eine kleine Anzahl literaler Ersetzungen verketten.

    Was ist der Unterschied zwischen str.replace() und re.sub()?

    str.replace() führt nur literalen String-Abgleich durch -- es ist schneller und einfacher. re.sub() verwendet reguläre Ausdrücke und unterstützt Musterabgleich, Erfassungsgruppen, Rückverweise und funktionsbasierte Ersetzungen. Verwenden Sie str.replace() für einfache literale Austausche und re.sub(), wenn Sie Musterflexibilität benötigen.

    Wie entferne ich Zeichen aus einem String in Python?

    Drei Ansätze: str.replace(char, "") entfernt alle Vorkommen eines bestimmten Teilstrings. str.translate(str.maketrans("", "", chars)) entfernt alle angegebenen Zeichen effizient. re.sub(r"[pattern]", "", text) entfernt Zeichen, die einem Regex-Muster entsprechen.

    Fazit

    Python bietet mehrere Werkzeuge für die String-Ersetzung, die jeweils für unterschiedliche Komplexitätsstufen geeignet sind. Verwenden Sie str.replace() für einfache literale Austausche, re.sub() für Musterabgleich und komplexe Regeln und str.translate() für schnelle zeichenweise Zuordnung. Für mehrere gleichzeitige Ersetzungen hält ein wörterbuchgesteuerter re.sub()-Ansatz Ihren Code sauber und wartbar.

    📚