Stringobjekte

Zeichen in einer festen Reihenfolge speichern

In Python ist ein String eine unveränderliche Folge von Unicode-Zeichen. Ihre Reihenfolge ist wichtig: Jedes Zeichen hat eine Position, die etwa beim Indizieren und Slicen verwendet wird.

Strings haben drei Merkmale:

1. Geordnete Zeichenfolge: Jedes Zeichen hat eine feste Position.
2. Als Literal geschrieben: Einfache oder doppelte Anführungszeichen begrenzen den Text im Quellcode.
3. Typ str: Python speichert den entstandenen Wert als String.

Python zählt Positionen nach Unicode-Codepunkten, nicht immer nach sichtbaren Zeichen. Beispielsweise ergibt len("é") den Wert 1, aber len("e\u0301") den Wert 2: Die zweite Form besteht aus e und einem eigenen kombinierenden Akzent.

# Beispielzeichenfolge mit einfachen Anführungszeichen
>>> 'hello'
'hello'

# Beispielzeichenfolge mit doppelten Anführungszeichen
>>> "hello"
'hello'

# String mit print() ausgeben
>>> print("hello")
hello

# Zeichenfolge in einer Variablen speichern
>>> text = 'hello'
>>> text
'hello'

Die interaktive Eingabe zeigt die Repräsentation eines Strings. Python kann dafür einfache oder doppelte Anführungszeichen wählen, damit sie gut lesbar bleibt. print() gibt dagegen den Stringwert selbst ohne die Begrenzungszeichen des Literals aus.

Leere Strings und die Funktion Str

Python kann leere Strings erzeugen und Werte anderer Datentypen in Strings umwandeln. Ein leerer String enthält kein Zeichen und hat die Länge null, str() erzeugt dagegen die Textdarstellung eines beliebigen Werts.

Leere Strings

Ein leerer String enthält kein Zeichen und hat die Länge null. Du schreibst ihn als ein Paar Anführungszeichen ohne Inhalt.

# Leeren String erstellen
>>> empty_text = ""
>>> empty_text
''

Die Funktion Str

Die Funktion str() liefert eine gut lesbare Stringdarstellung eines Werts. Verwende sie, wenn ein Text eine Zahl oder einen anderen Wert enthalten soll, der noch kein String ist.

# Zahl in Zeichenfolge umwandeln
>>> str(5)
'5'

# Gleitkommazahl in einen String umwandeln
>>> xstr = str(3.4)
>>> print(xstr)
3.4

Mehrzeilige Zeichenfolgen

Python unterscheidet zwischen Quellcode, der über mehrere Zeilen verteilt ist, und tatsächlichen Zeilenumbrüchen in einem String. Eine Zeile lässt sich im Quellcode umbrechen, ohne dass ein Umbruch im Wert landet, während ein String mit dreifachen Anführungszeichen jeden Umbruch speichert.

Zeilenfortsetzungszeichen

Ein Backslash am Ende einer physischen Quellcodezeile setzt die Anweisung ausdrücklich fort. Im Beispiel enthält die fortgesetzte Anweisung zwei benachbarte Literale, die Python ohne Zeilenumbruch im Wert verbindet.

# Anweisung mit einem Backslash fortsetzen
>>> text = 'xxx' \
...     'yyy'

>>> text
'xxxyyy'

>>> print(text)
xxxyyy

Zeilenfortsetzung mit Klammern

Innerhalb von Klammern setzt Python eine Anweisung über den Zeilenumbruch hinweg fort, ohne dass ein Backslash nötig ist. Kommentare oder Leerzeichen am Zeilenende unterbrechen diese Fortsetzung nicht. Beim Verschieben einer Zeile muss außerdem kein Fortsetzungszeichen mitverschoben werden.

# Anweisung innerhalb von Klammern fortsetzen
>>> text = (
...     'xxx'
...     'yyy'
... )

>>> text
'xxxyyy'

>>> print(text)
xxxyyy

Dreifache Anführungszeichen

Literale mit drei Anführungszeichen können tatsächliche Zeilenumbrüche speichern. Diese erscheinen als \n-Zeichen im Stringwert.

# String mit drei Anführungszeichen und echten Zeilenumbrüchen
>>> text = '''xxx
... yyy
... zzz'''

>>> text
'xxx\nyyy\nzzz'

>>> print(text)
xxx
yyy
zzz

Drei doppelte Anführungszeichen funktionieren genauso. Wähle die Begrenzung, mit der sich der enthaltene Text am klarsten und mit möglichst wenigen Escape-Zeichen schreiben lässt.

Verknüpfung von Stringliteralen

Python kann Stringliterale bereits beim Lesen des Quellcodes oder Stringwerte während der Programmausführung verbinden. Benachbarte Literale werden ohne Operator zusammengefügt, Werte in Variablen brauchen dagegen einen Operator.

Angrenzende Literalverkettung

Python verbindet benachbarte Stringliterale beim Lesen des Quellcodes. Diese Kurzform funktioniert nur für Text, der direkt als Literal im Code steht.

# Benachbarte Zeichenfolgenliterale werden automatisch kombiniert
>>> 'hello ' 'world'
'hello world'

# Mehrere Strings gleichzeitig kombinieren
>>> "hel" 'lo' " world" '!'
'hello world!'

Plusoperator

Der Operator + verkettet zwei Stringwerte zur Laufzeit.

# Verwendung des +-Operators zur Verkettung
>>> 'hello ' + 'world'
'hello world'

Multiplikationsoperator

Der Operator * wiederholt einen String so oft, wie es die angegebene ganze Zahl bestimmt.

# String mit dem *-Operator wiederholen
>>> 3 * '+o+'
'+o++o++o+'

Verknüpfung von Stringvariablen

Variablen enthalten Werte und keine Literaltoken. Deshalb brauchen sie beim Verknüpfen einen Operator. Benachbarte Literale werden dagegen schon beim Lesen des Quellcodes zusammengefügt, und dieser Unterschied erklärt, warum "a" "b" funktioniert, name other aber nicht.

Operatoren verwenden

Verwende +, um Stringwerte zu verketten, und * mit einer ganzen Zahl, um einen String zu wiederholen. Variablennamen ohne Operator nebeneinander zu schreiben, ist ungültige Syntax.

# String-Variablen definieren
>>> text1 = 'hello'
>>> text2 = 'world!'
>>> text3 = '+o+'
>>> a = 3

# Kombination mit +-Operator
>>> text1 + ' world!'
'hello world!'

>>> 'hello ' + text2
'hello world!'

>>> text1 + ' ' + text2
'hello world!'

# Wiederholen mit *-Operator
>>> a * text3
'+o++o++o+'

>>> text3 * a
'+o++o++o+'

Häufige Fehler

Die folgenden Formen scheitern schon beim Einlesen des Codes, weil zwischen der Variablen und dem nächsten Ausdruck kein Operator steht.

# FEHLER: Variablen können nicht ohne Operatoren kombiniert werden
>>> text1 'world'
SyntaxError ...

>>> 'hello ' text2
SyntaxError ...

>>> text1 text2
SyntaxError ...