2.5. String-Methoden und Formatierung

Zeichenketten bringen einen eingebauten Werkzeugkasten an Methoden zur Inspektion und Umformung mit. Da Zeichenketten unveränderlich sind, liefert jede Methode eine neue Zeichenkette – das Original bleibt unverändert.

2.5.1. Zeichenketten inspizieren

  • str.startswith() / str.endswith() – Test auf Präfix oder Suffix; liefert bool.

  • str.find() – Position des ersten Auftretens einer Teilzeichenkette oder -1, falls nicht vorhanden. str.index() macht dasselbe, löst aber bei Abwesenheit einen ValueError aus.

  • str.count() – Anzahl der nicht überlappenden Vorkommen.

  • Schlüsselwort in – "MV" in name liefert True, wenn die Teilzeichenkette irgendwo in der Zeichenkette vorkommt.

>>> name = "OpenMV Cam"
>>> name.startswith("Open")
True
>>> name.find("MV")
4
>>> name.count("m")
1
>>> "Cam" in name
True

2.5.2. Bereinigung und Groß-/Kleinschreibung

  • str.strip() – entfernt führenden und nachgestellten Leerraum. Übergib eine Zeichenkette aus Zeichen, um eine eigene Menge zu entfernen (s.strip("/")).

  • str.lower() / str.upper() – Umwandlung der Groß-/Kleinschreibung.

  • str.replace() – Ersetzung von Teilzeichenketten.

>>> "  hello  ".strip()
'hello'
>>> "abc-123".replace("-", "_")
'abc_123'
>>> "OpenMV".lower()
'openmv'

2.5.3. Aufteilen und Zusammenfügen

  • str.split() – zerlegt eine Zeichenkette an jedem Auftreten eines Trennzeichens in eine Liste (Standard: jede Folge von Leerraum).

  • str.join() – die Umkehrung: fügt eine Folge von Zeichenketten mit dem Empfänger als Trennzeichen zusammen. Dies ist die effiziente Methode, um eine lange Zeichenkette aus Teilen aufzubauen.

>>> "1,2,3".split(",")
['1', '2', '3']
>>> "hello world".split()
['hello', 'world']
>>> ", ".join(["a", "b", "c"])
'a, b, c'

2.5.4. f-Strings

Die einfachste Möglichkeit, Werte in eine Zeichenkette einzufügen, ist der f-String – ein String-Literal mit dem Präfix f. Jeder Ausdruck innerhalb von {} wird ausgewertet und eingesetzt:

>>> name = "OpenMV"
>>> count = 42
>>> f"{name} saw {count} blobs"
'OpenMV saw 42 blobs'

Ein Doppelpunkt innerhalb der geschweiften Klammern leitet eine Formatangabe ein, die steuert, wie der Wert dargestellt wird:

  • {x:.2f} – Gleitkommazahl mit 2 Nachkommastellen.

  • {x:>10} – rechtsbündig in einem 10 Zeichen breiten Feld.

  • {x:<10} – linksbündig.

  • {x:0>4} – mit führenden Nullen auf Breite 4 auffüllen.

  • {x:#x} – hexadezimal mit einem 0x-Präfix.

  • {x:b} – binäre Darstellung.

>>> f"pi is roughly {3.14159:.3f}"
'pi is roughly 3.142'
>>> f"reg = {0xAB:#x}"
'reg = 0xab'
>>> for i in range(3):
...     print(f"line {i:0>3}")
line 000
line 001
line 002

Ein einzelnes = nach dem Ausdrucksnamen gibt sowohl den Namen als auch den Wert aus – praktisch für schnelle Debug-Ausgaben:

>>> v = 3.14
>>> print(f"{v=}")
v=3.14

2.5.4.1. Umwandlungen zwischen Zahlenbasen für Ganzzahlen

Drei eingebaute Funktionen leisten dieselbe Arbeit wie die Formatangaben :b / :o / :x, liefern die umgewandelte Zeichenkette aber direkt:

  • bin() – Basis 2, mit einem "0b"-Präfix.

  • oct() – Basis 8, mit einem "0o"-Präfix.

  • hex() – Basis 16, mit einem "0x"-Präfix.

>>> hex(255)
'0xff'
>>> bin(10)
'0b1010'
>>> oct(8)
'0o10'

Die umgekehrte Richtung – eine Zeichenkette zur Basis N wieder in eine Ganzzahl umwandeln – verwendet den int-Konstruktor mit einer expliziten Basis:

>>> int("ff", 16)
255
>>> int("0b1010", 2)         # the "0b" prefix is allowed
10

Greife zu diesen, wenn du die rohe Zeichenkette für eine Ganzzahl möchtest (für eine Logzeile, eine Konfigurationsdatei, einen Register-Dump). Greife zur Formatangabe, wenn du Auffüllung, Breite oder das Mischen des Werts mit anderem Text im selben f-String möchtest.

2.5.5. Ältere Formatierungsstile

f-Strings sind der empfohlene Stil, aber zwei ältere Ansätze funktionieren weiterhin und tauchen in bestehendem Code auf:

str.format() – geschweifte Klammern mit positions- oder schlüsselwortbasierten Argumenten, die an die .format()-Methode auf einer Vorlagenzeichenkette übergeben werden:

>>> "Hello, {}".format(name)
'Hello, OpenMV'
>>> "{0} + {0} = {1}".format(2, 4)
'2 + 2 = 4'
>>> "{name}: {value}".format(name="frames", value=42)
'frames: 42'

Formatangaben ({:.2f}, {:>10}, …) funktionieren genauso wie in f-Strings; der einzige Unterschied besteht darin, wo der Wert bereitgestellt wird.

%-Formatierung (im printf-Stil) – ein einzelner %-Operator setzt Werte in Formatcodes ein, einen Wert pro Code. Übergib mehrere Werte als Tupel:

>>> "Hello, %s" % name
'Hello, OpenMV'
>>> "%d + %d = %d" % (2, 2, 4)
'2 + 2 = 4'
>>> "%.2f" % 3.14159
'3.14'

Die gängigsten Typcodes sind %s (Zeichenkette), %d (Ganzzahl), %f (Gleitkommazahl) und %x (Hexadezimal).

Jeder %-Code kann zwischen dem % und dem Typbuchstaben Modifikatoren tragen. Die vollständige Form lautet %[flags][width][.precision]type:

  • width – Mindestanzahl der Zeichen, die das Feld einnehmen muss. Kürzere Werte werden mit Leerzeichen aufgefüllt; längere Werte laufen über. %10d reserviert 10 Zeichen und richtet die Zahl rechtsbündig aus.

  • precision – die Bedeutung hängt vom Typ ab. Bei Gleitkommazahlen ist es die Anzahl der Nachkommastellen. %.2f ergibt zwei Dezimalstellen. Bei Zeichenketten ist es die maximale Anzahl der zu übernehmenden Zeichen (%.5s kürzt auf fünf).

  • Linksbündig – das --Flag setzt das Feld nach links. %-10d setzt die Ziffern auf die linke Seite mit nachgestellten Leerzeichen.

  • Mit Nullen auffüllen – das 0-Flag füllt mit führenden Nullen statt mit Leerzeichen auf (für numerische Typen). %05d füllt mit Nullen auf fünf Stellen auf.

  • Vorzeichen – das +-Flag zeigt bei Zahlen immer das Vorzeichen an, einschließlich eines + für positive Werte.

  • Alternative Form – das #-Flag. Bei %x wird die Ausgabe mit 0x versehen; bei %o mit 0o.

Flags, Breite und Präzision können kombiniert werden:

>>> "%10d" % 42
'        42'                 # width 10, space-padded, right-aligned
>>> "%-10d|" % 42
'42        |'                # width 10, left-aligned
>>> "%05d" % 42
'00042'                      # width 5, zero-padded
>>> "%8.2f" % 3.14159
'    3.14'                   # width 8, 2 decimal places
>>> "%08.2f" % 3.14159
'00003.14'                   # width 8, zero-padded
>>> "%+d" % 42
'+42'                        # explicit sign
>>> "%#06x" % 0xAB
'0x00ab'                     # 0x prefix, zero-pad to 6 chars total

Beide älteren Stile sind langsamer zu lesen und fehleranfälliger als f-Strings – greife in neuem Code zu f-Strings und erkenne die älteren Formen beim Lesen bestehenden Codes.