Zeichenketten in Python

https://bildung.social/@oerinformatik/

https://oer-informatik.de/python_zeichenketten

Python, Zeichenkette, String, Literal, Escape-Sequenz, Konkatenation, Slicing, String-Methoden, immutable

tl/dr; (ca. 6 min Lesezeit): Eine Kurzübersicht der wesentlichen Operatoren, Funktionen und Methoden, die Python für Zeichenketten bietet: Literale und Sonderzeichen, Verketten, Zugriff auf einzelne Zeichen und Ausschnitte, Suchen, Ersetzen, Zerlegen und Zusammenfügen [AI-Assisted]. (Zuletzt geändert am 13.11.2026)

Schon fit in diesem Thema? Nutze die Kann-Liste und die Leitfragen unter dem Artikel als Checkliste, ob Du die relevanten Kompetenzen bereits hast.

Als Python-Grundlagen kann ich nach Durchlesen des Artikels…

… Zeichenketten-Literale in einfachen oder doppelten Anführungszeichen notieren und den Typ str mit type() ermitteln.
… Sonderzeichen wie Zeilenumbruch, Tabulator, Backslash und Anführungszeichen maskieren.
… Zeichenketten verketten, vervielfachen und prüfen, ob ein Teilstring enthalten ist.
… über den Index auf einzelne Zeichen und per Slicing auf Ausschnitte einer Zeichenkette zugreifen.
… die Länge einer Zeichenkette ermitteln und häufige Methoden wie lower(), find(), replace(), strip() und split() anwenden.

Darüber hinaus kann ich als Python-Expertenwissen…

… erklären, warum String-Methoden eine neue Zeichenkette zurückgeben und die ursprüngliche unverändert lassen.
… mit help() in der Python-Shell die Beschreibung einer String-Methode nachschlagen.

Texte werden in Zeichenketten (Strings, Typ str) erfasst. Die Literale von Zeichenketten können entweder zwischen einfachen oder doppelten Anführungszeichen notiert werden. Die Mindmap fasst zusammen, was dieser Artikel vorstellt:

Mindmap zu Zeichenketten in Python: Literale, Sonderzeichen, Operatoren, Zugriff per Index und Slicing, Funktionen und Methoden sowie Unveränderlichkeit (mit KI erstellt)

Beispiel

>>> name = "Martina Mustermann"
>>> type(name)
<class 'str'>
>>> name
'Martina Mustermann'

Besondere Zeichen

Um Sonderzeichen als Literal darstellen zu können, müssen diese mit einem Backslash maskiert werden (Escape-Sequenz):

Sonderzeichen	Maskierung	Beispiel
Zeilenumbruch	`\n`	`print("Hallo\nWelt")`
Tabulator	`\t`	`print("Hallo\tWelt")`
Backslash	`\\`	`print('HomeDir H:\\')`
Anführungszeichen	`\"`, `\'`	`print("Hallo \"Welt\"")` `print('Hallo "Welt"')` `print('Hallo \'Welt\'')`

Operatoren

Operator	Name	Beispiel
`text + text`	Verkettung (Konkatenation)	`"Hallo"+'Welt'`
`text*zahl`	Vervielfachung	`"Ha "*3`
`teilstring in text`	Prüft, ob `teilstring` enthalten ist	`"Martina" in "Martina Mustermann"`
`text[i]`	Zugriff auf das Zeichen mit dem Index `i` (beginnend bei 0, negative Werte zählen von hinten)	`"abc"[2]` `"abc"[-1]`
`text[start:ende]`	Ausschnitt (Slicing) von Index `start` bis vor Index `ende`; fehlende Grenzen bedeuten Anfang bzw. Ende	`"Martina Mustermann"[0:7]` `"Martina Mustermann"[8:]`

Funktionen und Methoden für Zeichenketten

Funktion/Methode	Beschreibung	Beispiel
`len(text)`	Länge des Strings `text`	`len("Martina Mustermann")`
`str(variable)`	Wandelt `variable` in einen String um	`str(4+5)`
`text.lower()` `text.upper()`	Wandelt den String `text` in Klein- bzw. Großbuchstaben um	`"GmbH".lower()`
`text.startswith(teilstring)` `text.endswith(teilstring)`	Prüft Anfang und Ende des Strings	`"Windows".startswith("Win")`
`text.count(teilstring)`	Zählt die Vorkommen von `teilstring`	`"Bananenmarmelade".count("an")`
`text.find(teilstring [, startpos])`	Gibt die Position des ersten Vorkommens von `teilstring` zurück (ggf. ab `startpos`)	`"Bananenmarmelade".find("ma")`
`text.replace(suchtext, ersetztext)`	Ersetzt `suchtext` durch `ersetztext`	`"Hihihi".replace("i","a")`
`text.strip()`	Entfernt Leerzeichen und Zeilenumbrüche am Anfang und Ende	`" Hallo ".strip()`
`text.split(trenner)`	Zerlegt `text` an `trenner` in eine Liste von Teilstrings	`"Herz,Karo,Pik".split(",")`
`trenner.join(liste)`	Fügt die Strings einer Liste mit `trenner` zu einem String zusammen	`"-".join(["2026","11","13"])`

Zeichenketten sind unveränderlich (immutable): Methoden wie upper() oder replace() ändern den ursprünglichen String nicht, sondern geben einen neuen zurück. Soll das Ergebnis erhalten bleiben, muss es zugewiesen werden. Auch die Zuweisung an ein einzelnes Zeichen ist nicht möglich:

>>> name = "Martina Mustermann"
>>> name.upper()
'MARTINA MUSTERMANN'
>>> name
'Martina Mustermann'
>>> name = name.upper()
>>> name[0] = "m"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment

Falls Du genauere Informationen benötigst, hilft die Python-Hilfe in der Pythonshell, z. B.:

>>> help(str.find)
Help on method_descriptor:

find(...)
    S.find(sub[, start[, end]]) -> int

    Return the lowest index in S where substring sub is found,
    such that sub is contained within S[start:end].  Optional
    arguments start and end are interpreted as in slice notation.

    Return -1 on failure.

Leitfragen

Wie notierst Du ein Zeichenketten-Literal, und wie maskierst Du ein Anführungszeichen darin?

Zwischen einfachen oder doppelten Anführungszeichen ('Hallo' bzw. "Hallo"). Ein Anführungszeichen derselben Art wird mit Backslash maskiert ("Hallo \"Welt\""), alternativ nutzt Du die andere Art außen ('Hallo "Welt"'). siehe Abschnitt „Besondere Zeichen“

Welche Operatoren gibt es für Zeichenketten?

+ verkettet zwei Strings, * vervielfacht einen String, in prüft, ob ein Teilstring enthalten ist. siehe Abschnitt „Operatoren“

Wie greifst Du auf ein einzelnes Zeichen und auf einen Ausschnitt zu?

Über den Index ab 0 (text[0], von hinten text[-1]) bzw. per Slicing text[start:ende], wobei das Zeichen an ende nicht mehr dazugehört. siehe Abschnitt „Operatoren“

Mit welchen Methoden suchst, ersetzt und zerlegst Du Text?

find() liefert die Position eines Teilstrings (oder -1), count() zählt Vorkommen, replace() ersetzt, split() zerlegt an einem Trenner in eine Liste und join() fügt eine Liste wieder zusammen. siehe Abschnitt „Funktionen und Methoden für Zeichenketten“

Warum ändert name.upper() die Variable name nicht?

Zeichenketten sind unveränderlich (immutable); die Methode gibt einen neuen String zurück, der zugewiesen werden muss: name = name.upper(). siehe Abschnitt „Funktionen und Methoden für Zeichenketten“

Links und weitere Informationen

als Nachschlagewerk: Python-Dokumentation: String-Methoden (englisch)
als Nachschlagewerk: Python-Tutorial: Text (englisch)
zum Weiterlesen: Datentypen in Python / Objektsammlungen in Python

Hinweis zur Nachnutzung als Open Educational Resource (OER)

Dieser Artikel und seine Texte, Bilder, Grafiken, Code und sonstiger Inhalt sind - sofern nicht anders angegeben - lizenziert unter CC BY 4.0. Nennung gemäß TULLU-Regel bitte wie folgt: “Zeichenketten in Python” von oer-informatik.de (H. Stein), Lizenz: CC BY 4.0. Der Artikel wurde unter https://oer-informatik.de/python_zeichenketten veröffentlicht, die Quelltexte sind in weiterverarbeitbarer Form verfügbar im Repository unter https://gitlab.com/oer-informatik/python-basics/erste-schritte-mit-python. Erstellt mit KI-Assistenz; von mir umfassend redaktionell überarbeitet, geprüft und freigegeben. Stand: 13.11.2026.

[Kommentare zum Artikel lesen, schreiben] / [Artikel teilen] / [gitlab-Issue zum Artikel schreiben]

Zeichenketten in Python