Zeichenketten - str (A*)

7.3.4. Zeichenketten - str (A*)#

Eine Zeichenkette (engl. String) str ist eine Sequenzen von Zeichen. Wie ein Tupel, ist auch eine Zeichenkette unveränderlich (engl. immutable). So kann eine Zeichenkette als ein besonderes Tupel, welches nur Zeichen enthält, gedeutet werden.

Python bietet uns viele nützliche Funktionen um auf Zeichenketten zu operieren. Zeichenketten können durch einfache oder doppelte Anführungszeichen umschlossen sein.

text = 'Hello World!'
text = "Hello World!"

Was wir bereits exzessive genutzt haben ist die Ausgabe von Zeichenketten durch die built-in Funktion print.

text = 'Hello World!'
print(text)

Hello World!

Um Variablen oder Werte anderer Datentypen mit print auszugeben, mussten wir diese immer mit der built-in Funktion str in eine Zeichenkette umwandeln. Da dies so häufig gemacht werden muss, haben die Entwicklerinnen von Python sich etwas einfallen lassen. Stellen wir vor unsere Zeichenkette ein f, so handelt es sich um eine sog. formatierte Zeichenkette. Diese helfen uns Variablen oder Werte direkt in eine Zeichenkette einzufügen. Vergleichen Sie folgenden Code:

x = 5
y = 10
print('x + y = ' + str(x) + ' + ' + str(y) + ' = ' + str(x+y)) # ugly
print(f'x + y = {x} + {y} = {x+y}')                            # beautiful

x + y = 5 + 10 = 15
x + y = 5 + 10 = 15

Das vereinfacht das Schreiben und Lesen solcher Ausgaben ungemein. Sie können formatierte Zeichenketten auch ohne print verwenden.

x = 5
y = 10
formatted_str = f'x + y = {x} + {y} = {x+y}'
formatted_str

'x + y = 5 + 10 = 15'

Zwei Zeichenketten lassen sich mit dem +-Operator verketten.

prefix = 'Hello'
suffix = ' Welt!'
text = prefix + suffix
print(prefix)
print(suffix)
print(text)

Hello
 Welt!
Hello Welt!

Bestimmte Zeichen kontrollieren die Darstellung des Textes, z.B. ob eine Leerzeile ein Leerzeichen oder ein Tab eingefügt werden soll.

space = ' '
space_line = '\n'

print('Hello' + space + 'World' + space_line + '!')

Hello World
!

Die leere Zeichenkette verändert bei der Verkettung eine andere Zeichenkette nicht. Es ist das neutrale Element der Zeichenverkettung.

empty_str = ''

print('The correct answer is 42!')
print('The correct' + empty_str + empty_str + empty_str + ' answer is 42!')

'Hello' == 'Hello' + empty_str

The correct answer is 42!
The correct answer is 42!

True

Zeichenketten lassen sich wie Listen und Tupel indexieren, Mit der built-in Funktion len, kann man die Länge einer Zeichenkette erfragen. Folgender Code gibt jedes einzelne Zeichen einer Zeichenkette aus.

text = 'Hello World!'

for i in range(len(text)):
  print(text[i])

H
e
l
l
o
 
W
o
r
l
d
!

Das lässt sich jedoch auch einfacher schreiben:

text = 'Hello World!'

for char in text:
  print(char)

H
e
l
l
o
 
W
o
r
l
d
!

Auch bei Zeichenketten können wir negative Indices verwenden. text[-1] gibt uns das letzte und text[-2] das vorletzte Zeichen.

text = 'Zeichensalat'

print(text[-1])
print(text[-2])

t
a

Lassen Sie uns eine Zeichenkette umdrehen:

text = 'Zeichensalat'
reverse_text = ''

for i in range(len(text)):
  reverse_text += text[-(i+1)]

print(text)
print(reverse_text)

Zeichensalat
talasnehcieZ

Genau wie Listen und Tupeln, lassen sich auch Zeichenketten zerschneiden (indexieren).

text = 'Zeichensalat'
print(text[0:2])
print(text[0:len(text)])   # take it all
print(text[0:-3])          # negative indexing
print(text[1:-1])          # skip first and last
print(text[-3:-1])         # negative indexing
print(text[2:])            # skip the first 2 and take the rest

Ze
Zeichensalat
Zeichensa
eichensala
la
ichensalat

Dabei ist text[2:] eine Kurzschreibweise für text[2:len(text)] und text[:2] für text[0:2].

Hin und wieder kann es vorkommen, dass Sie Zeichen schreiben möchten, welche bereits in Python mit einer Bedeutung belegt sind. Wie schreiben wir beispielsweise Anna sagte: 'Wie geht es dir'? Dafür müssen wir das '-Zeichen mit einem \ maskieren:

print('Anna sagte: \'Wie geht es dir\'')

Anna sagte: 'Wie geht es dir'

Zeichenketten sind Objekte die uns viele nützliche Funktionen anbieten. Zu beachten ist, dass Zeichenketten unveränderlich sind, d.h. die Funktionen liefern neue Zeichenkette zurück, die ursprüngliche bleibt unverändert.

Mit text.upper() können wir beispielsweise alle Zeichen einer Zeichenkette in Großbuchstaben transformieren.

text = 'Zeichensalat'
text_upper = text.upper()
print(text)
print(text_upper)

Zeichensalat
ZEICHENSALAT

Wir können die Vorkommnisse eines Zeichen in einer Zeichenkette zählen oder ganze Zeichenfolgen ersetzten:

text = 'Zeichensalat'
print(text.count('a'))
print(text.replace('salat', 'spinat'))

2
Zeichenspinat

Es würde zu weit gehen alle Funktionen zu besprechen – das wäre auch ziemlich langweilig. Schauen Sie sich einfach die Dokumentation an oder verwenden Sie die eingebaute Hilfe help(str).

Exercise 7.5 (Praxisaufgabe (PA3.11-Variante): Zeilen verarbeiten)

Sie lesen eine Textdatei Zeile für Zeile ein. Erweitern Sie das Grundgerüst so, dass Sie pro Zeile:

  • das Zeilenende entfernen (rstrip("\\n")),

  • leere Zeilen überspringen,

  • und am Ende ausgeben, wie viele nicht-leere Zeilen die Datei hatte.


## Formatierte Zeichenketten (f-Strings) - Vertiefung

Wie bereits oben erwähnt, sind **f-Strings** (formatted string literals) eine elegante Möglichkeit, Variablen und Ausdrücke direkt in Zeichenketten einzubetten. Das ``f`` vor der Zeichenkette aktiviert diese Funktionalität.

### Grundlegende Syntax

Innerhalb von geschweiften Klammern ``{}`` können Sie beliebige Python-Ausdrücke schreiben:

```{code-cell} python3
name = 'Anna'
alter = 25
print(f'Mein Name ist {name} und ich bin {alter} Jahre alt.')

7.3.4.1. Ausdrücke in f-Strings#

Sie können nicht nur Variablen, sondern auch komplexe Ausdrücke verwenden:

x = 10
y = 5
print(f'Das Ergebnis von {x} + {y} ist {x + y}')
print(f'Das Quadrat von {x} ist {x ** 2}')

Das Ergebnis von 10 + 5 ist 15
Das Quadrat von 10 ist 100

7.3.4.2. Methodenaufrufe#

Auch Methodenaufrufe sind innerhalb von f-Strings möglich:

text = 'Python'
print(f'Der Text "{text}" hat {len(text)} Zeichen.')
print(f'In Großbuchstaben: {text.upper()}')

Der Text "Python" hat 6 Zeichen.
In Großbuchstaben: PYTHON

7.3.4.3. Formatierung von Zahlen#

Für technische Anwendungen ist es oft wichtig, Zahlen in einem bestimmten Format darzustellen. f-Strings bieten hierfür mächtige Formatierungsoptionen:

Dezimalstellen begrenzen:

pi = 3.14159265359
print(f'Pi auf 2 Dezimalstellen: {pi:.2f}')
print(f'Pi auf 4 Dezimalstellen: {pi:.4f}')

Pi auf 2 Dezimalstellen: 3.14
Pi auf 4 Dezimalstellen: 3.1416

Wissenschaftliche Notation:

große_zahl = 1234567890
print(f'Wissenschaftliche Notation: {große_zahl:e}')
print(f'Wissenschaftliche Notation mit 2 Dezimalstellen: {große_zahl:.2e}')

Wissenschaftliche Notation: 1.234568e+09
Wissenschaftliche Notation mit 2 Dezimalstellen: 1.23e+09

Ausrichtung und Breite:

zahl = 42
print(f'Rechtsbündig (10 Zeichen): {zahl:>10}')
print(f'Linksbündig (10 Zeichen): {zahl:<10}')
print(f'Zentriert (10 Zeichen): {zahl:^10}')

Rechtsbündig (10 Zeichen):         42
Linksbündig (10 Zeichen): 42        
Zentriert (10 Zeichen):     42

Mit führenden Nullen:

zahl = 42
print(f'Mit führenden Nullen: {zahl:05d}')

Mit führenden Nullen: 00042

Tausender-Trennzeichen:

große_zahl = 1234567
print(f'Mit Tausender-Trennzeichen: {große_zahl:,}')

Mit Tausender-Trennzeichen: 1,234,567

7.3.4.4. Praktisches Beispiel für Maschinenbauer#

# Berechnung einer Kraft
masse = 10.5  # kg
beschleunigung = 9.81  # m/s²
kraft = masse * beschleunigung

print(f'Berechnung der Gewichtskraft:')
print(f'Masse: {masse} kg')
print(f'Erdbeschleunigung: {beschleunigung} m/s²')
print(f'Kraft: {kraft:.2f} N')
print(f'Kraft (wissenschaftlich): {kraft:.2e} N')

Berechnung der Gewichtskraft:
Masse: 10.5 kg
Erdbeschleunigung: 9.81 m/s²
Kraft: 103.01 N
Kraft (wissenschaftlich): 1.03e+02 N

7.3.4.5. Verschachtelte Anführungszeichen#

Bei f-Strings können Sie einfache oder doppelte Anführungszeichen verwenden, was hilfreich ist, wenn Sie Anführungszeichen im Text benötigen:

name = 'Anna'
print(f"Sie sagte: 'Hallo, {name}!'")
print(f'Er antwortete: "Guten Tag, {name}!"')

Sie sagte: 'Hallo, Anna!'
Er antwortete: "Guten Tag, Anna!"

7.3.4.6. Mehrzeilige f-Strings#

f-Strings können auch über mehrere Zeilen gehen:

name = 'Anna'
alter = 25
beruf = 'Ingenieurin'

text = f"""
Name: {name}
Alter: {alter}
Beruf: {beruf}
"""
print(text)

Name: Anna
Alter: 25
Beruf: Ingenieurin

Wichtig

  • f-Strings wurden in Python 3.6 eingeführt und sind die modernste und empfohlene Methode zur String-Formatierung.

  • Sie sind effizienter als die älteren Methoden (.format() oder %-Formatierung).

  • Die Ausdrücke in {} werden zur Laufzeit ausgewertet, was bedeutet, dass Sie auch Funktionen aufrufen können.

  • Für komplexe Formatierungen können Sie Format-Spezifikationen nach einem Doppelpunkt : verwenden (z.B. {zahl:.2f}).

f-Strings machen die String-Formatierung in Python deutlich lesbarer und einfacher zu verwenden, besonders wenn Sie Variablen und berechnete Werte in Textausgaben einbetten möchten.

Inhalt