# Stringobjekte

> For AI agents: use [llms.txt](https://nakafa.com/llms.txt) for the site index. Markdown versions are available by appending `.md` to content URLs or sending `Accept: text/markdown`.

URL: https://nakafa.com/de/faecher/ki-und-data-science/ki-programmierung/strings-als-objekte
Source: https://raw.githubusercontent.com/nakafaai/aksara/992eb09ded1422859aca3966c80b52a16b2832f4/packages/corpus/material/lesson/ai-ds/ai-programming/string-object/de.mdx

Stelle Text mit Python-Strings dar. Schreibe lange Stringliterale über mehrere Quellcodezeilen und verknüpfe Literale oder Variablen.

---

## Zeichen in einer festen Reihenfolge speichern

In Python ist ein String <Highlight>eine unveränderliche Folge von Unicode-Zeichen</Highlight>. 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.

File: string_definition.py
```python
# 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.

File: empty_string.py
```python
# 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.

File: str_function.py
```python
# 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.

File: line_continuation.py
```python
# 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.

File: parentheses_continuation.py
```python
# 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.

File: triple_quotes.py
```python
# 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.

File: literal_concatenation.py
```python
# 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.

File: plus_operator.py
```python
# Verwendung des +-Operators zur Verkettung
>>> 'hello ' + 'world'
'hello world'
```

### Multiplikationsoperator

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

File: multiplication_operator.py
```python
# 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**.

File: variable_concatenation.py
```python
# 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.

File: concatenation_errors.py
```python
# FEHLER: Variablen können nicht ohne Operatoren kombiniert werden
>>> text1 'world'
SyntaxError ...

>>> 'hello ' text2
SyntaxError ...

>>> text1 text2
SyntaxError ...
```