Mit Zeichenketten in Python arbeiten

Eine Zeichenkette ist eine Folge von Zeichen mit dem Datentyp str. Sie kann einen Namen, einen Satz, einen Code oder auch gar keine Zeichen enthalten. Python behält die Reihenfolge der Zeichen einschließlich Leerzeichen und Satzzeichen bei.

Schreibe den Wert zwischen passende Anführungszeichen

Einfache und doppelte Anführungszeichen erzeugen dieselbe Art von Wert: 'hello' und "hello" sind gleich. Die äußeren Anführungszeichen markieren die Grenzen; sie sind keine Zeichen des Werts. Wähle Anführungszeichen so, dass solche innerhalb des Textes gut lesbar bleiben:

message = "It's late"
reply = 'She said "yes"'
empty = ""

In 'It's late' schließt der Apostroph die Zeichenkette zu früh und verursacht einen SyntaxError. Doppelte Anführungszeichen lösen das Problem, oder du kannst 'It\'s late' schreiben. Verwende im Code gerade Anführungszeichen.

Speichere Zeilenumbrüche und umgekehrte Schrägstriche

Eine Escape-Sequenz beginnt mit einem umgekehrten Schrägstrich. Python liest \n als einen Zeilenumbruch, \t als einen Tabulator und \\ als einen umgekehrten Schrägstrich. Maskierte Anführungszeichen, \' und \", setzen Anführungszeichen in den Text.

text = "a\nb"
print(len(text))  # 3
print(text)

Der letzte Aufruf gibt a und b in getrennten Zeilen aus. Der Wert hat drei Zeichen: a, einen Zeilenumbruch und b. Escape-Sequenzen werden verarbeitet, wenn Python das Literal liest. Die Shell zeigt eine Darstellung mit Anführungszeichen und, wo nötig, Escape-Sequenzen; print() zeigt die Zeichen selbst. Beispielsweise wird "\x41" zu "A", sodass die Shell die ursprüngliche Escape-Sequenz nicht anzeigen muss.

Dreifache Anführungszeichen erlauben Literale über mehrere Zeilen. Jeder Zeilenumbruch darin wird zu einem Zeilenumbruchzeichen:

notice = """Door closed
Use side entrance"""

Eine rohe Zeichenkette hat ein r vor ihren Anführungszeichen. In r"C:\new" bleiben der umgekehrte Schrägstrich und n getrennt, sodass sich sechs Zeichen ergeben. In "C:\new" wird \n zu einem Zeilenumbruch, sodass sich fünf ergeben. Rohe Literale sind nützlich, wenn umgekehrte Schrägstriche zum Text gehören.

Ermittle die Länge von Text und kombiniere Text

len() zählt jedes Zeichen einschließlich Leerzeichen: len("Hi there!") ist 9 und len("") ist 0. Genauer zählt die Funktion Unicode-Codepunkte. len("café") ist 4, wenn é ein Codepunkt ist; len("👍🏽") ist 2, obwohl das Emoji wie ein Symbol aussieht.

Verwende +, um Zeichenketten zu verketten, und *, um eine Zeichenkette zu wiederholen:

first = "Ada"
last = "Lovelace"
full = first + " " + last  # "Ada Lovelace"
rule = "-" * 10           # ten dashes

Die Verkettung fügt nichts von selbst ein. Ohne " " werden die Namen zu "AdaLovelace". Wird "ab" nullmal wiederholt, ergibt sich die leere Zeichenkette.

Entscheide, ob Ziffern Text oder Zahlen sind

Beide Operanden einer Zeichenkettenverkettung müssen Zeichenketten sein. "Age: " + 30 löst einen TypeError aus; "Age: " + str(30) ergibt "Age: 30". Umgekehrt gibt input() Text zurück: "3" + "4" ergibt "34". Um ihre Zahlenwerte zu addieren, wandle sie zuerst um: int("3") + int("4") ergibt 7.

Ein Index wählt ein Zeichen anhand seiner Position aus. Python beginnt bei null zu zählen, daher ist die Position eines Zeichens um eins kleiner als sein Platz bei einer gewöhnlichen Zählung von links.

Zeichne die Positionen auf

Für word = "Python" hat jedes Zeichen einen nicht negativen und einen negativen Index:

word = "Python"
print(word[0])   # P
print(word[1])   # y
print(word[-1])  # n

Die eckigen Klammern nach der Zeichenkette wählen das Zeichen aus. Das Ergebnis ist eine Zeichenkette der Länge eins: Python hat keinen eigenen Datentyp für einzelne Zeichen. Du kannst ausgewählte Zeichen zusammenfügen, daher ergibt word[0] + word[-1] den Wert "Pn".

Bei der Länge n reichen die gültigen Indizes von -n bis n - 1, wenn n > 0 gilt. Nicht negative Indizes zählen vom Anfang, negative vom Ende. Ein Index -k wählt dasselbe Zeichen wie n - k; in diesem Wort aus sechs Zeichen wählen sowohl -2 als auch 4 das Zeichen "o".

Unterscheide die Länge vom letzten Index

len(word) ist 6, aber word[6] löst einen IndexError aus: Es gibt kein siebtes Zeichen. Das letzte Zeichen ist word[len(word) - 1], oder einfach word[-1]. Ein zu weiter Zugriff von einem der beiden Enden aus schlägt fehl; auch word[-7] löst einen IndexError aus.

Ein Index muss eine ganze Zahl sein. word[1.0] löst einen TypeError aus, obwohl die Gleitkommazahl einen ganzzahligen Wert hat. Verwende //, wenn du eine Position in der Mitte berechnest:

word = "Pyt"
middle = len(word) // 2  # 1
print(word[middle])      # y

Der Operator / würde 1.5 erzeugen; damit lässt sich nicht über einen Index auf eine Zeichenkette zugreifen. Bei ungerader Länge wählt len(word) // 2 das Zeichen in der Mitte. Bei gerader Länge wählt der Ausdruck das rechte der beiden Zeichen in der Mitte: "Python"[3] ist "h".

Bilde Initialen aus den ersten Zeichen

first = "Grace"
last = "Hopper"
initials = first[0] + last[0]
print(initials)  # GH

Jeder Name steuert sein Zeichen an Index 0 bei. Mit first[-1] würdest du "e" beitragen, den letzten Buchstaben. Diese Methode setzt voraus, dass jeder Name mindestens ein Zeichen hat.

Prüfe leere Eingaben vor dem Indexzugriff

Die leere Zeichenkette hat die Länge null und keinen gültigen Zeichenindex. ""[0] löst einen IndexError aus. Eine Längenprüfung kann verhindern, dass ein Programm ein Zeichen liest, das nicht existiert:

line = input("Comment: ")
if len(line) > 0 and line[0] == "#":
    print("Comment line")

Python wertet and von links nach rechts aus. Ist die Längenprüfung falsch, überspringt Python line[0]. Würdest du die beiden Prüfungen umkehren, käme der unsichere Indexzugriff zuerst. Wenn du nur wissen musst, ob eine Zeile mit "#" beginnt, funktioniert line.startswith("#") auch bei leerer Eingabe und gibt False zurück.

Ein Ausschnitt wählt eine zusammenhängende Folge von Zeichen aus und gibt sie als Zeichenkette zurück. Damit kannst du einen Anfangsteil auswählen, ein Ende entfernen oder Felder an festen Positionen trennen.

Der Start ist eingeschlossen, das Ende ausgeschlossen

Schreibe text[start:stop]. Mit s = "Monty Python" ergibt s[0:5] den Wert "Monty" und s[6:12] den Wert "Python". Das Leerzeichen steht an Index 5, daher beginnt der zweite Ausschnitt bei 6.

Stell dir die Zahlen eines Ausschnitts als Lücken vor. Lücke 0 liegt vor dem ersten Zeichen und Lücke 5 nach den ersten fünf. Nimmst du alles dazwischen, erhältst du fünf Zeichen. Für 0 <= start <= stop <= len(text) ist die Länge stop - start.

word = "Monty"
print(word[0:4])  # Mont
print(word[0:5])  # Monty

Die Endposition ist die erste ausgelassene Position. Addierst du eins zum gewünschten letzten Index, wird dieses letzte Zeichen eingeschlossen.

Lass eine Grenze weg

An jeder Trennposition k gibt s[:k] + s[k:] den Wert s zurück. Die Ausschnitte treffen an derselben Lücke aufeinander, ohne dass ein Zeichen fehlt oder wiederholt wird.

Ausschnittsgrenzen außerhalb der Enden werden auf die Enden begrenzt. "cat"[1:100] ist "at"; "cat"[5:] ist "". Bei einem Ausschnitt in Vorwärtsrichtung ergibt ein Start bei oder nach der Endgrenze eine leere Zeichenkette, wie bei s[4:2]. Anders als bei einem Indexzugriff auf ein einzelnes Zeichen löst ein Ausschnitt außerhalb des gültigen Bereichs keinen IndexError aus.

Wähle eine Schrittweite

Die dritte Stelle in text[start:stop:step] legt fest, wie weit zwischen ausgewählten Positionen gegangen wird:

letters = "abcdefgh"
print(letters[::2])   # aceg
print(letters[1::2])  # bdfh
print(letters[::-1])  # hgfedcba

Eine negative Schrittweite führt rückwärts. Sind beide Grenzen weggelassen, beginnt [::-1] beim letzten Zeichen und besucht jedes Zeichen in umgekehrter Reihenfolge. Eine Schrittweite von null löst einen ValueError aus. Die Richtung muss zu den Grenzen passen: Die obige Regel für ein leeres Ergebnis bei „Start bei oder nach der Endgrenze“ gilt für eine positive Schrittweite.

Wende Ausschnitte auf einen festen Aufbau an

d = "2026-07-04"
year = d[:4]
month = d[5:7]
day = d[8:10]
print(month + "/" + day + "/" + year)  # 07/04/2026

Die Positionen funktionieren, weil dieser Aufbau immer vier Ziffern für das Jahr und je zwei für Monat und Tag verwendet. Text mit unterschiedlichen Feldlängen benötigt eine Suche oder Aufteilung.

Die Umkehrung ermöglicht auch eine Palindromprüfung: word == word[::-1]. "level" besteht sie, "Level" aber nicht, weil Groß- und Kleinschreibung zählen. Weise clean = word.lower() zu und prüfe clean == clean[::-1], um Groß- und Kleinschreibung zu ignorieren.

Verwende eine Schleife, wenn für jedes Zeichen eine Entscheidung getroffen werden muss. Die Schleife kann Treffer zählen, ihre Positionen verwenden, beim ersten Treffer anhalten oder die Zeichen sammeln, die zu einem Ergebnis gehören.

Gehe Zeichen direkt durch

for ch in "hi!":
    print(ch)

Der Körper wird dreimal ausgeführt, wobei ch nacheinander "h", "i" und "!" ist. Bei der leeren Zeichenkette wird der Körper nullmal ausgeführt. Eine direkte Zeichenschleife braucht keinen Index, wenn du nur das aktuelle Zeichen verwendest.

Initialisiere zum Zählen den Zähler vor der Schleife und erhöhe ihn nur, wenn die Prüfung zutrifft:

text = "Programming in Python"
count = 0
for ch in text.lower():
    if ch in "aeiou":
        count += 1
print(count)  # 5

Durch das Kleinschreiben werden auch große Vokale erkannt. Die Prüfzeichenkette legt die gezählten Vokale fest; sie enthält kein y. Würdest du count innerhalb der Schleife zurücksetzen, ginge die Summe aus früheren Durchläufen verloren.

Verwende Positionen, wenn benachbarte Zeichen wichtig sind

range(len(text)) liefert die Indizes von null bis zum letzten gültigen Index. Für eine Aufgabe, die Position und Zeichen benötigt, liefert enumerate(text) beide zusammen:

for i, ch in enumerate("abc"):
    print(i, ch)

Dies gibt zuerst 0 a, dann 1 b und dann 2 c aus. Die beiden Schleifenvariablen erhalten aus jedem Paar den Index und das Zeichen.

Um Nachbarn zu vergleichen, darf der letzte Index nicht die aktuelle Position sein, weil es danach kein nächstes Zeichen gibt:

text = "bookkeeper"
pairs = 0
for i in range(len(text) - 1):
    if text[i] == text[i + 1]:
        pairs += 1
print(pairs)  # 3

Die Treffer sind oo, kk und ee. Mit range(len(text)) würde der letzte Durchlauf auf text[len(text)] zugreifen und einen IndexError auslösen.

Verwalte eine Position mit while

i = 0
while i < len(text):
    print(text[i])
    i += 1

Die Prüfung verwendet strikt <: Die Position len(text) liegt hinter dem Ende. Das Inkrement führt die Schleife ihrem Ende näher; lässt du es weg, wird bei nicht leerem Text endlos dasselbe Zeichen gelesen. Für einen Rückwärtslauf beginne bei len(text) - 1, fahre fort, solange i >= 0 gilt, und ziehe bei jedem Durchlauf eins ab.

Suche oder sammle

Für die erste Ziffer in "Room 42B" beende die Schleife, sobald ein Treffer verwendet wurde:

for ch in "Room 42B":
    if ch.isdigit():
        print(ch)  # 4
        break

Ohne break würden beide Ziffern ausgegeben. Für eine einfache Prüfung auf Vorhandensein beantwortet "4" in text bereits die Ja-oder-nein-Frage.

Um Text zu sammeln, beginne mit result = "" und füge jedes gewünschte Zeichen hinzu. Für "a b c" entsteht "abc", wenn du nur bei ch != " " etwas hinzufügst. Die Zuweisung ch = ch.upper() innerhalb einer Schleife ändert nur die Schleifenvariable; sie verändert nicht die in text gespeicherten Zeichen.

Zeichenketten sind unveränderlich: Ihre Zeichen können nicht geändert werden, nachdem die Zeichenkette erstellt wurde. Ein Programm, das scheinbar Text bearbeitet, erstellt eine andere Zeichenkette und bestimmt, welche Variable darauf verweist.

Lies ein Zeichen, aber weise ihm nichts zu

name = "Jane"
name[0] = "D"  # TypeError

Über den Index lässt sich "J" lesen, aber er kann nicht das Ziel einer Zuweisung sein. Auch del name[0] löst einen TypeError aus. Um "Dane" zu erhalten, kombiniere das gewünschte erste Zeichen mit dem unveränderten Ende:

name = "Jane"
name = "D" + name[1:]
print(name)  # Dane

Python wertet zuerst die rechte Seite aus und erzeugt eine neue Zeichenkette. Anschließend lässt Python name auf dieses Ergebnis verweisen.

Ersetze oder füge an einer bekannten Position ein

Für einen gültigen nicht negativen Index i verwenden diese Ausdrücke unterschiedliche Ausschnitte auf der rechten Seite:

Beim Ersetzen wird das alte Zeichen übersprungen; beim Einfügen bleibt es erhalten. Mit text = "cat", i = 1 und new = "X" ergibt das Ersetzen "cXt", während das Einfügen "cXat" ergibt.

Wandle einen negativen Index in den entsprechenden nicht negativen Index um, bevor du dieses Ersetzungsmuster verwendest. Für das letzte Zeichen von "cat" ist i = len(text) - 1 gleich 2. Wenn du -1 direkt in text[i + 1:] einsetzt, wird daraus text[0:]. Dadurch wird die gesamte alte Zeichenkette angehängt und es entsteht "caXcat".

Halte das Ergebnis einer Methode fest

Umwandlungsmethoden folgen derselben Regel der Unveränderlichkeit:

msg = "hello"
msg.upper()
print(msg)       # hello
msg = msg.upper()
print(msg)       # HELLO

Der erste Aufruf berechnet ein Ergebnis, das das Programm verwirft. Die Zuweisung hält das zweite Ergebnis fest. Zeichenkettenmethoden ändern die ursprüngliche Zeichenkette nie, aber ihre Rückgabetypen unterscheiden sich: upper() gibt eine Zeichenkette zurück, find() eine ganze Zahl und isdigit() einen booleschen Wert.

Verfolge zwei Namen für einen Wert

Nach a = "cat" und b = a verweisen beide Variablen auf "cat". Die Ausführung von a = a + "s" gibt a den neuen Wert "cats"; b verweist weiterhin auf "cat". Kein Zeichen der gemeinsam referenzierten alten Zeichenkette wurde geändert. a += "s" führt bei einer Zeichenkette dieselbe Art erneuter Zuweisung aus.

Erstelle einen veränderten Wert in einer Schleife

word = "secret"
masked = ""
for ch in word:
    if ch in "aeiou":
        masked += "*"
    else:
        masked += ch
print(masked)  # s*cr*t
print(word)    # secret

Jeder Durchlauf erweitert masked um ein ausgewähltes Zeichen. Setzt du stattdessen jedes Zeichen mit result = ch + result an den Anfang, wird der Text umgekehrt: Die Durchläufe über "drawer" erzeugen "d", "rd", "ard", "ward", "eward" und "reward".

Wiederholte Verkettung ist für kurze Beispiele praktisch. Wenn die Teile bereits in einer Liste vorliegen, erstellt "".join(pieces) direkt ein Ergebnis und kann auch ein Trennzeichen dazwischen setzen.

Eine Methode ist eine Funktion, die zu einem Wert gehört. Zeichenkettenmethoden übernehmen häufige Aufgaben wie das Ändern der Groß- und Kleinschreibung, das Bereinigen von Eingaben an den Rändern und das Ersetzen von Text. Jeder Aufruf gibt ein Ergebnis zurück und lässt die ursprüngliche Zeichenkette unverändert.

Rufe eine Methode mit Punktnotation auf

Schreibe value.method(arguments), wie in "hello".upper(). Die Klammern führen den Aufruf aus. name.upper ohne Klammern verweist auf die Methode selbst; es erzeugt keinen Text in Großbuchstaben. upper(name) findet keine eigenständige Funktion namens upper. Verwende dir(""), um Zeichenkettenmethoden aufzulisten, und help(str.upper), um etwas über eine davon zu lesen.

Wähle eine Operation für Groß- und Kleinschreibung

capitalize() ändert das erste Zeichen und schreibt den Rest klein; title() beginnt nach Zeichen, die keine Buchstaben sind, erneut Wörter. Dadurch wird "they're".title() zu "They'Re", sodass eine automatische Großschreibung von Wortanfängen möglicherweise geprüft werden muss.

Für Vergleiche ohne Unterschiede in der Groß- und Kleinschreibung berücksichtigt casefold() über verschiedene Sprachen hinweg mehr Fälle als lower(). "Straße".lower() ist "straße", während "Straße".casefold() gleich "strasse" ist. Vereinheitliche vor dem Vergleich bei beiden Zeichenketten die Groß- und Kleinschreibung auf diese Weise.

Bereinige die Enden von Text

strip() entfernt vorangestellte und abschließende Leerraumzeichen, darunter Leerzeichen, Tabulatoren und Zeilenumbrüche. Abstände im Inneren bleiben erhalten: " New York \n".strip() ist "New York". lstrip() bereinigt nur das linke Ende; rstrip() nur das rechte.

Mit einem Argument entfernt die Methode beliebige dieser Zeichen wiederholt von den Enden. Sie entfernt kein genaues Wort:

print("...Wow!!!".strip(".!"))          # Wow
print("report.txt".rstrip(".txt"))     # repor
print("report.txt".removesuffix(".txt"))  # report

Das letzte t in report gehört ebenfalls zur Menge der zu entfernenden Zeichen und verschwindet daher. removeprefix() und removesuffix() entfernen genauen Text an einem Ende; sie sind ab Python 3.9 verfügbar.

Ersetze Treffer und verkette Änderungen

replace(old, new) ersetzt jeden exakten Treffer. Ein drittes Argument begrenzt die Anzahl der geänderten Treffer: "a-b-c".replace("-", "", 1) ergibt "ab-c". Ein leerer Ersatz löscht Treffer. Groß- und Kleinschreibung zählen, daher ergibt "Cat cat".replace("cat", "dog") den Wert "Cat dog".

answer = "  YES \n"
answer = answer.strip().lower()
print(answer == "yes")  # True

Die Aufrufe laufen von links nach rechts: strip() gibt "YES" zurück, danach gibt lower() den Wert "yes" zurück. Eine Verkettung funktioniert, wenn die nächste Methode zum Datentyp des vorherigen Ergebnisses passt. Ein Suchergebnis ist eine ganze Zahl und unterstützt daher keine Methoden zur Bereinigung von Zeichenketten.

Zum Auffüllen ergibt "7".zfill(3) den Wert "007", "Total".ljust(8) fügt rechts drei Leerzeichen hinzu und "Hi".center(8, "*") ergibt "***Hi***". rjust() füllt links auf. Diese Breiten sind Mindestwerte; längerer Text bleibt vollständig erhalten.

Eine Suche kann drei verschiedene Fragen beantworten: ob Text vorkommt, wo er beginnt und wie oft er vorkommt. Wähle das Ergebnis, das zu der Entscheidung passt, die dein Programm treffen muss.

Wähle ein Suchergebnis

Eine Teilzeichenkette ist eine zusammenhängende Folge von Zeichen. "py" in "happy" ist True, aber "hpy" in "happy" ist False. Beim Abgleich zählt die Groß- und Kleinschreibung: "Py" in "python" ist False. not in kehrt die Prüfung auf Vorhandensein um. Die leere Zeichenkette kommt in jeder Zeichenkette vor.

Finde das richtige Vorkommen

text = "banana"
print(text.find("an"))     # 1
print(text.find("an", 2))  # 3
print(text.rfind("an"))    # 3

Die optionale Startposition überspringt frühere mögliche Treffer. Der zurückgegebene Index zählt weiterhin vom Anfang der ganzen Zeichenkette. index() gibt dieselbe Position zurück, wenn ein Treffer existiert. Der Fehler bei fehlendem Treffer macht die Methode nützlich, wenn das Fehlen auf ein unerwartetes Problem hinweist.

Prüfe eine Position vor dem Ausschneiden

email = "maria.lopez@example.org"
at = email.find("@")
if at != -1:
    user = email[:at]
    domain = email[at + 1:]
    print(user)    # maria.lopez
    print(domain)  # example.org

Die Suche gibt 11 zurück. Der erste Ausschnitt endet vor @; der zweite beginnt ein Zeichen danach. Wäre das Kennzeichen nicht vorhanden, wäre at gleich -1. Würdest du diesen Wert als Ausschnittsgrenze verwenden, würde unbemerkt Text nahe dem Ende ausgewählt. Behandle daher ein fehlendes Kennzeichen, bevor du Teile herausnimmst.

Verwende if text.find("x"): nicht als Prüfung auf Vorhandensein. Ein Treffer bei Index 0 gilt in einer Bedingung als falsch, während der Wert -1 für ein fehlendes Ergebnis als wahr gilt. Verwende if "x" in text: oder vergleiche die Position ausdrücklich mit -1.

Suche ab einem bekannten Kennzeichen

Bei line = "Order #4521 shipped" folgt die Nummer auf # und endet beim nächsten Leerzeichen:

start = line.find("#") + 1
end = line.find(" ", start)
number = line[start:end]
print(number)  # 4521

Hier sind beide Kennzeichen vorhanden. Der Start der zweiten Suche bei start überspringt das frühere Leerzeichen nach Order. Falls Kennzeichen fehlen können, prüfe jedes unmittelbare Suchergebnis, bevor du eins addierst oder einen Ausschnitt bildest. Die Addition von eins zu -1 würde die fehlgeschlagene Suche verbergen, indem daraus 0 wird.

Zähle vollständige Treffer

"banana".count("a") ist 3 und "banana".count("ana") ist 1. Die beiden möglichen Treffer ana überlappen sich, daher zählt count() nicht beide. Ebenso ist "aaaa".count("aa") gleich 2.

Um Groß- und Kleinschreibung zu ignorieren, durchsuche eine umgewandelte Version, etwa mit "python" in sentence.lower(). Die Suche gleicht innerhalb dieser Version weiterhin exakt ab. Für Zählungen und Prüfungen auf Vorhandensein kannst du die umgewandelte Zeichenkette direkt verwenden; ein Index gehört zu der jeweils durchsuchten Zeichenkette.

Zeichenkettenprüfungen geben boolesche Werte zurück, die eine Bedingung steuern können. Sie helfen dir, Eingaben zu akzeptieren, die einer Regel entsprechen, und Text in einer einheitlichen Form zu vergleichen.

Prüfe die Enden oder die Zeichen

startswith() und endswith() prüfen genauen Text an den Enden. Mit einem Tupel kann eine Prüfung mehrere Endungen akzeptieren: name.endswith((".jpg", ".png")). Das großgeschriebene "photo.PNG" besteht diese Prüfung nur, wenn du es zuerst kleinschreibst.

Alle fünf geben für "" den Wert False zurück. Buchstaben müssen nicht englisch sein: "café".isalpha() ist True. Das Leerzeichen in "hello world" führt dazu, dass isalpha() falsch ergibt.

isupper() und islower() betrachten Zeichen mit Groß- und Kleinschreibung und setzen mindestens eines davon voraus. "ABC1".isupper() ist True; die Ziffer ändert nichts an den Großbuchstaben. "123" hat keine Zeichen mit Groß- und Kleinschreibung, daher sind beide Prüfungen falsch.

Validiere vor der Umwandlung

Eine Ziffernprüfung erfasst nicht jede Zahl, die Python lesen kann. "-5".isdigit(), "3.5".isdigit() und " 42".isdigit() sind falsch, weil ein Vorzeichen, ein Punkt oder ein Leerzeichen keine Ziffer ist. Außerdem ist "²".isdigit() wahr, obwohl int("²") fehlschlägt. isdecimal() lehnt die hochgestellte Ziffer ab und eignet sich für die Eingabe einer einfachen nicht negativen ganzen Zahl.

text = input("Tickets: ").strip()
if text.isdecimal() and int(text) > 0:
    print("Accepted")
else:
    print("Enter a positive whole number")

Die Zeichenkettenprüfung läuft zuerst. Ist sie falsch, überspringt and die Umwandlung und schützt so vor leeren oder nicht numerischen Eingaben. " 12 " wird zu "12" und besteht die Prüfung; "0" lässt sich sicher umwandeln, besteht aber die Prüfung auf einen positiven Wert nicht. Diese Regel lehnt Eingaben mit Vorzeichen oder Dezimalpunkt bewusst ab.

Eine Regel für Benutzernamen kann Längen- und Zeichenprüfungen kombinieren: 3 <= len(name) <= 12 and name.isalnum(). "ada99" besteht die Prüfung, "ada 99" besteht die Zeichenprüfung nicht und "ad" besteht die Längenprüfung nicht.

Vergleiche bereinigten Text

Gleichheit erfordert dieselben Zeichen in derselben Reihenfolge. "Yes" == "yes" und "yes " == "yes" sind falsch. Für Antworten, bei denen Groß- und Kleinschreibung sowie Leerraumzeichen an den Rändern ignoriert werden sollen, vergleiche typed.strip().casefold() mit expected.strip().casefold().

Die Sortierung erfolgt Zeichen für Zeichen. Der erste unterschiedliche Unicode-Codepunkt entscheidet. ord("A") ist 65, ord("Z") ist 90 und ord("a") ist 97; chr(97) ergibt "a". Daher ist "Zebra" < "apple" wahr. Ist eine Zeichenkette der Anfang der anderen, kommt die kürzere zuerst: "app" < "apple".

Auch Zeichenketten aus Ziffern verwenden die Zeichenreihenfolge: "10" < "9" ist wahr, weil "1" vor "9" kommt. Wandle beim Vergleich von Mengenangaben in Zahlen um. Auch bei Buchstaben mit Akzent ist Vorsicht nötig: ord("é") ist 233, daher ist "école" > "zoo" wahr. Diese eingebaute Reihenfolge folgt den Codepunkten, nicht der Wörterbuchreihenfolge einer Sprache.

split() wandelt eine Zeichenkette in eine Liste von Zeichenketten um. Eine Liste ist eine geordnete Sammlung, die in eckigen Klammern geschrieben wird. Du kannst ein Element über seinen Index lesen, die Elemente durchlaufen oder sie mit len() zählen.

Wähle Leerraumzeichen oder ein genaues Trennzeichen

Ohne Argument behandelt split() eine Folge von Leerraumzeichen als eine Grenze und ignoriert Leerraumzeichen an beiden Enden:

words = "  the quick  brown fox ".split()
print(words)       # ['the', 'quick', 'brown', 'fox']
print(len(words))  # 4
print(words[0])    # the

Bei einem ausdrücklich angegebenen Trennzeichen wird an jedem genauen Vorkommen getrennt. Aufeinanderfolgende Trennzeichen erhalten ein leeres Feld:

fields = "red,green,,blue".split(",")
# ["red", "green", "", "blue"]

Das leere dritte Element kann für einen Wert stehen, der leer gelassen wurde. Es zählt dennoch als Element der Liste.

Ein Trennzeichen kann mehrere Zeichen enthalten, die aber alle übereinstimmen müssen. Kommt kein Trennzeichen vor, enthält das Ergebnis die gesamte ursprüngliche Zeichenkette als ein Element. Das Aufteilen an Komma und Leerzeichen unterscheidet sich daher vom Aufteilen an einem Komma.

Begrenze die Aufteilung

Das zweite Argument, maxsplit, begrenzt die Anzahl der Aufteilungen, nicht die Anzahl der entstehenden Elemente:

print("key=value=more".split("=", 1))
# ["key", "value=more"]
print("archive.tar.gz".rsplit(".", 1))
# ["archive.tar", "gz"]

split() beginnt links; rsplit() beginnt rechts. Eine Aufteilung von rechts trennt die letzte Dateiendung ab, ohne an früheren Punkten zu trennen.

Lies Felder und wandle Mengenangaben um

line = "Lovelace,Ada,1815"
parts = line.split(",")
if len(parts) == 3:
    last = parts[0]
    first = parts[1]
    year = int(parts[2])
    print(f"{first} {last} was born in {year}.")

Die Ausgabe ist "Ada Lovelace was born in 1815.". Die Längenprüfung verhindert, dass ein fehlendes Element einen IndexError verursacht. Sie prüft nicht, ob das Jahr numerisch ist; dafür braucht es eine separate Eingaberegel, wenn die Daten ungültig sein könnten.

Jeder aufgeteilte Teil ist zunächst eine Zeichenkette. Um "3 14 15" zu summieren, initialisiere total = 0, durchlaufe line.split() und addiere int(part). Das Ergebnis ist 32; eine Verkettung der nicht umgewandelten Teile würde die Ziffern zusammenfügen.

Ein ausdrücklich angegebenes Trennzeichen erhält die umgebenden Leerzeichen. "a, b".split(",") ergibt ["a", " b"]. Rufe für jeden Teil strip() auf, wenn diese Leerzeichen unerwünscht sind.

Erkenne zwei verwandte Ergebnisse

splitlines() trennt an Zeilenumbrüchen: "line one\nline two".splitlines() ergibt zwei Zeichenketten. partition("=") gibt immer ein dreiteiliges Tupel zurück: den Text vor dem ersten Trennzeichen, das Trennzeichen und den Text danach. "user=ada".partition("=") ergibt ("user", "=", "ada"); für "user" ergibt die Methode ("user", "", "").

join() erstellt aus einer Folge von Zeichenketten eine Zeichenkette. Die Zeichenkette vor dem Punkt liefert das Trennzeichen, das zwischen benachbarten Elementen erscheint.

Setze das Trennzeichen an den Anfang

colors = ["red", "green", "blue"]
text = ", ".join(colors)
print(text)  # red, green, blue

Lies dies als „Füge die Farben mit Komma und Leerzeichen zusammen“. Vor dem ersten und nach dem letzten Element steht kein Trennzeichen. Du kannst den Aufbau der Ausgabe ändern, indem du nur das Trennzeichen änderst:

join() gehört zur Trennzeichenkette. ["a", "b"].join(",") löst einen AttributeError aus, weil die Liste keine Methode join hat. Ein einzelner Aufruf passt sich auch der Anzahl der Teile an; du musst für unterschiedliche Listenlängen keine neue Kette von +-Operationen schreiben.

Wandle Teile, die keine Zeichenketten sind, zuerst um

Alle Teile müssen bereits Zeichenketten sein. ", ".join([1, 2, 3]) löst einen TypeError aus. map(str, items) wendet str() auf jedes Element an, daher funktioniert dies:

items = [1, 2, 3]
text = " ".join(map(str, items))
print(text)  # 1 2 3

Das an map() übergebene str ist die Umwandlungsfunktion. join() erhält die umgewandelten Teile und gibt eine Zeichenkette zurück.

Eine Zeichenkette ist selbst eine Folge von einzeichenlangen Zeichenketten, daher ergibt " ".join("ABC") den Wert "A B C". Das kann nützlich sein. Übergibst du jedoch ein einzelnes Wort, obwohl du eine Liste von Wörtern meinst, werden Trennzeichen zwischen seine Zeichen gesetzt.

Forme Abstände und Trennzeichen um

text = "too   many    spaces"
cleaned = " ".join(text.split())
print(cleaned)  # too many spaces

Zuerst entstehen beim Aufteilen an Leerraumzeichen die drei Wörter. Das Zusammenfügen mit einem Leerzeichen legt einen einheitlichen Abstand fest und lässt keine Leerzeichen an den Rändern stehen. Die ursprünglichen Abstände gehen beim Aufteilen verloren.

Bei einem ausdrücklich angegebenen Trennzeichen erhalten die leeren Felder genügend Informationen, um den genauen Text wiederherzustellen. Ist s = "a,,b,", ergibt s.split(",") den Wert ["a", "", "b", ""], und ",".join(...) ergibt wieder "a,,b,". Für diese genaue Rekonstruktion muss das Trennzeichen dasselbe sein.

Ein anderes Trennzeichen ändert den Aufbau: "-".join("2026/07/04".split("/")) ergibt "2026-07-04". Hier ist auch replace("/", "-") eine direkte Lösung.

Sammle ein kurzes Ergebnis aus Wörtern

Für ein Akronym teile "portable network graphics" auf, beginne mit acronym = "" und füge für jedes Wort word[0].upper() hinzu. Das Aufteilen an Leerraumzeichen liefert nicht leere Wörter, deren erste Zeichen also existieren. So entsteht "PNG". Sind die Buchstaben bereits in einer Liste, erstellt ".".join(["P", "N", "G"]) den Wert "P.N.G" ohne abschließenden Punkt.

Ein f-String ist ein Zeichenkettenliteral mit f oder F vor seinem öffnenden Anführungszeichen. Darin stehen Ausdrücke in geschweiften Klammern, deren Werte in den Text eingesetzt werden.

Setze Variablen und Ausdrücke ein

name = "Ada"
age = 36
message = f"{name} is {age} years old."
print(message)  # Ada is 36 years old.

Zahlen werden innerhalb eines Felds automatisch zu Text. Dieselbe Nachricht ließe sich durch Verkettung und mit str(age) erzeugen, aber der f-String zeigt den endgültigen Aufbau an einer Stelle.

Die geschweiften Klammern können Rechnungen, Methodenaufrufe oder Funktionsaufrufe enthalten:

price = 4.5
qty = 3
print(f"Cost: {price * qty}")  # Cost: 13.5
print(f"Name: {name.upper()}")  # Name: ADA
word = "Python"
print(f"{len(word)} letters")  # 6 letters

Python wertet jeden Ausdruck aus, wenn die Zeile ausgeführt wird. Eine gespeicherte Zeichenkette bleibt nicht mit den Variablen verbunden, aus denen sie erstellt wurde. Ändert sich qty, nachdem message erstellt wurde, behält diese Zeichenkette ihre vorhandenen Zeichen.

Unterscheide gewöhnlichen Text von Feldern

Ohne das Präfix ist "Hello {name}" gewöhnlicher Text und behält seine geschweiften Klammern. Ein fehlendes f ist ein häufiger Grund dafür, dass ein Programm den Variablennamen statt seines Werts ausgibt. Mit Präfix löst ein Name, dem noch kein Wert zugewiesen wurde, bei der Ausführung des Ausdrucks einen NameError aus.

Um eine geschweifte Klammer als Zeichen anzuzeigen, verdopple sie:

x = 5
print(f"{{x}} = {x}")  # {x} = 5

Die verdoppelten geschweiften Klammern liefern den wörtlichen Text {x}. Das einfache Paar um das letzte x liefert seinen Wert.

Halte Ausdrücke mit Anführungszeichen lesbar

Verwende innerhalb eines Felds die andere Art von Anführungszeichen:

print(f"Shout: {'hi'.upper()}")  # Shout: HI

Diese Schreibweise funktioniert in allen Python-Versionen mit f-Strings, die mit 3.6 eingeführt wurden. Python 3.12 und neuer erlauben auch, die äußere Art von Anführungszeichen innerhalb des Felds erneut zu verwenden. Escape-Sequenzen funktionieren weiterhin in f-Strings: f"Name: {name}\nAge: {age}" gibt den Text in zwei Zeilen aus.

Für eine schnelle Anzeige bei der Fehlersuche akzeptieren Python 3.8 und neuer = nach einem Ausdruck. Mit x = 5 ergibt f"{x=}" den Wert "x=5"; mit total = 12 ergibt f"{total = }" den Wert "total = 12". Eingegebene Leerzeichen um den Ausdruck und das Gleichheitszeichen erscheinen in der Anzeige.

Lies ältere Formatierungsarten

Vorhandener Python-Code kann denselben Text auf andere Weise erstellen:

str.format() füllt Felder in geschweiften Klammern aus seinen Argumenten. Nummerierte Felder können ein Argument erneut verwenden: "{0} {1} {0}".format("a", "b") ergibt "a b a". Bei der Prozentformatierung setzt %s Text und %d eine ganze Zahl ein. Wenn du diese Felder erkennst, kannst du auch Programme lesen, die geschrieben wurden, bevor f-Strings üblich waren.

Eine Formatangabe steuert, wie ein Wert angezeigt wird. Setze nach dem Ausdruck einen Doppelpunkt und dann die Anweisungen: f"{value:spec}". Die Formatierung gibt Text zurück und lässt den ursprünglichen Zahlenwert unverändert.

Lege Nachkommastellen fest und verstehe die Rundung

.Nf zeigt genau N Ziffern nach dem Dezimalpunkt an. f"{3.14159:.2f}" ergibt "3.14", f"{2/3:.3f}" ergibt "0.667" und f"{5:.2f}" ergibt "5.00". .0f zeigt keinen Dezimalpunkt an: f"{7.6:.0f}" ergibt "8".

Beim Runden wird der tatsächlich gespeicherte Wert verwendet. Die meisten Dezimalbrüche werden als sehr nahe binäre Approximationen gespeichert. Die Gleitkommazahl 2.675 liegt geringfügig unter diesem exakten Dezimalwert, daher ergibt f"{2.675:.2f}" den Wert "2.67". Werte genau in der Mitte werden zur geraden letzten Ziffer gerundet: 0.125 wird bei zwei Nachkommastellen als "0.12" angezeigt, während 0.375 als "0.38" angezeigt wird. f"{2.5:.0f}" ergibt "2". Programme, die exakte Geldberechnungen benötigen, speichern oft ganze Centbeträge als ganze Zahlen.

Ergänze Gruppierung und Prozentangaben

Ein Komma gruppiert Tausender; der Punkt leitet die Genauigkeitsangabe für Nachkommastellen ein. Setze bei einem Dollarbetrag das Dollarzeichen außerhalb des Felds: Mit amount = 1250.5 ergibt f"${amount:,.2f}" den Wert "$1,250.50".

Der Typ % multipliziert mit 100 und fügt % hinzu. Verwende einen Bruchteil wie 0.256, um 25.6% anzuzeigen. Wenn du 25.6 übergibst, wird der angezeigte Prozentwert erneut multipliziert. Ohne ausdrückliche Genauigkeitsangabe zeigt % sechs Nachkommastellen an.

Formatiere ganze Zahlen und Datumsteile

d ist für ganze Zahlen bestimmt. f"{42:d}" funktioniert, aber f"{3.0:d}" löst einen ValueError aus, weil eine Gleitkommazahl keine ganze Zahl ist. Eine vorangestellte Null vor einer Breite füllt mit Nullen auf; ein Pluszeichen fordert ein sichtbares Vorzeichen an:

print(f"{7:03d}")   # 007
print(f"{5:+d}")    # +5
print(f"{-5:+d}")   # -5

Für Monat 7, Tag 4 und Jahr 2026 erstellt f"{month:02d}/{day:02d}/{year}" den Wert "07/04/2026". Für Stunde 9 und Minute 5 erstellt f"{hour}:{minute:02d}" den Wert "9:05". Das Auffüllen mit Nullen verhindert, dass eine einstellige Minute als "9:5" erscheint.

Kombiniere Anweisungen in der richtigen Reihenfolge

Die Reihenfolge ist Füllzeichen, Ausrichtung, Vorzeichen, Null, Breite, Gruppierung, Genauigkeit, Typ. Nicht benötigte Teile kannst du weglassen. f"{12345.678:>12,.2f}" verwendet Rechtsausrichtung, Breite 12, Gruppierung mit Komma und zwei Nachkommastellen und ergibt " 12,345.68".

Die Genauigkeit kann aus einer anderen Variablen stammen: Mit places = 3 ergibt f"{3.14159:.{places}f}" den Wert "3.142". Dieselben Formatangaben funktionieren in format(value, spec) und Feldern von str.format(). Behalte die ursprüngliche Zahl für Berechnungen; round(value, 2) gibt eine gerundete Zahl zurück, wenn die Berechnung das verlangt.

Eine Feldbreite reserviert eine Mindestanzahl von Zeichenpositionen für einen Wert. Die Kombination von Breiten macht kurze Tabellen und Kassenbons in einem Terminal lesbar.

Wähle Breite und Ausrichtung

Zeichenketten werden standardmäßig linksbündig und Zahlen rechtsbündig ausgerichtet. f"{'cat':6}" ergibt "cat ", während f"{42:6}" den Wert " 42" ergibt. Verwende ein Ausrichtungszeichen für eine ausdrückliche Auswahl:

Wenn beim Zentrieren eine ungerade Anzahl von Leerzeichen bleibt, setzt die Ausrichtung im f-String das zusätzliche Leerzeichen nach rechts: f"{'hi':^7}" ergibt " hi ".

Die Breite ist ein Mindestwert. f"{'elephant':4}" ergibt weiterhin "elephant"; das Wort wird nicht abgeschnitten. Ein langer Eintrag kann daher spätere Spalten verschieben.

Ergänze ein Füllzeichen oder begrenze Text

Ein Füllzeichen steht unmittelbar vor dem Ausrichtungszeichen. f"{'hi':*^10}" ergibt "****hi****", und f"{7:0>3}" ergibt "007". Ein Füllzeichen benötigt ein Ausrichtungszeichen. f"{'':-^20}" füllt ein leeres Feld mit zwanzig Strichen.

Die Zeichenkettengenauigkeit begrenzt die Anzahl der angezeigten Zeichen:

place = "Washington"
print(f"{place:.4}")      # Wash
print(f"|{place:10.4}|")  # |Wash      |

Die Genauigkeit begrenzt den angezeigten Text zuerst auf vier Zeichen; anschließend füllt die Breite ihn auf zehn auf. Verwende passende Breite und Genauigkeit, wenn Text innerhalb einer festen Spalte bleiben muss. Das ursprüngliche place ist weiterhin "Washington".

Erstelle eine Kassenbonzeile

item = "Apples"
qty = 3
price = 4.50
row = f"{item:<8}{qty:>4}{qty * price:>9.2f}"
print(row)

Das Ergebnis ist "Apples 3 13.50". Das Artikelfeld enthält sechs Buchstaben und zwei Leerzeichen. Das Mengenfeld fügt drei Leerzeichen vor 3 hinzu. Das Betragsfeld fügt vier Leerzeichen vor 13.50 hinzu, das fünf Zeichen hat. Zusammen belegen die Felder 21 Zeichen.

Verwende diese Breiten erneut für Brot (1 zu 2,25) und Kaffee (2 zu 11,00). Ihre Zeilen lauten "Bread 1 2.25" und "Coffee 2 22.00". Eine Summenzeile kann die ersten beiden Felder kombinieren:

print(f"{'Total':<12}{37.75:>9.2f}")
# "Total           37.75"

Das Betragsfeld beginnt an derselben Position und hat dieselbe Anzahl von Nachkommastellen, sodass die Beträge untereinander stehen.

Passe den Aufbau an die Anzeige an

Wähle Breiten, die Platz für die längsten Einträge und Abstände lassen, oder kürze Text gezielt. Eine Variable kann eine Breite liefern: Mit w = 10 füllt f"{name:<{w}}" den Wert von name auf zehn Zeichen auf.

Zeichenbasierte Spalten brauchen eine nichtproportionale Schrift, wie sie ein Terminal verwendet. Für einfaches Auffüllen außerhalb eines f-Strings verhalten sich ljust() und rjust() wie < und >. center() und ^ zentrieren beide Text, können eine ungerade Auffüllung aber unterschiedlich aufteilen: "hi".center(7) ergibt " hi ", während f"{'hi':^7}" den Wert " hi " ergibt.