Strings verketten

String-Verkettung ist der Vorgang, zwei oder mehr Strings zu einem zusammenzufügen. Python bietet dafür verschiedene Ansätze – vom einfachen +-Operator bis zur effizienten join()-Methode – und die Wahl der richtigen Methode hat Auswirkungen auf Lesbarkeit und Performance.

Dieses Kapitel behandelt:

• Die Operatoren + und +=
• Das Zusammenfügen einer Liste von Strings mit join()
• Das Einbetten von Werten mit f-Strings
• Das Wiederholen eines Strings mit *
• Das Verketten von Nicht-String-Werten (und den häufigen TypeError-Fallstrick)
• Wann join() statt + verwendet werden sollte

Verwandte Kapitel: Python Strings · Strings ändern · Strings formatieren · String-Methoden

Den +-Operator verwenden

Der +-Operator ist der direkteste Weg, zwei Strings zu verbinden. Python erstellt einen neuen string, der alle Zeichen beider Operanden in der richtigen Reihenfolge enthält.

Zwei Strings mit + verketten

Hello World

Sie können beliebig viele Strings in einem einzelnen Ausdruck verketten:

greeting = "Good" + " " + "morning" + ", " + "Python!"
print(greeting)

Good morning, Python!

Fallstrick – nur Strings erlaubt. Der +-Operator konvertiert andere Typen nicht automatisch. Der Versuch, einen string und eine Zahl zu verketten, löst einen TypeError aus:

age = 30
# This raises TypeError: can only concatenate str (not "int") to str
# message = "I am " + age + " years old."

# Correct: convert the number to a string first
message = "I am " + str(age) + " years old."
print(message)

I am 30 years old.

Rufen Sie bei einem Nicht-String-Wert immer str() auf, bevor Sie + verwenden.

Den +=-Operator verwenden

Der +=-Operator hängt einen string an eine vorhandene Variable an. Er ist eine Kurzschreibweise für variable = variable + new_string und praktisch, wenn Sie einen string schrittweise aufbauen.

Einen Satz schrittweise mit += aufbauen

Hello, World!

Ein häufiger Anwendungsfall ist das Sammeln von Zeilen innerhalb einer Schleife:

words = ["one", "two", "three"]
result = ""
for word in words:
    result += word + " "
print(result.strip())

one two three

Hinweis zur Performance. Wiederholtes += innerhalb einer Schleife erstellt bei jeder Iteration ein neues string-Objekt. Bei kleinen Listen ist das in Ordnung, aber bei großen Sammlungen ist join() (siehe unten) deutlich schneller.

join() zum Verketten einer Liste von Strings verwenden

str.join(iterable) fügt alle Strings in einem Iterable zusammen und platziert den string, auf dem die Methode aufgerufen wird, zwischen jedem Paar. Dies ist der idiomatische Python-Weg, einen string aus einer Sammlung zu erstellen.

Wörter mit einem Leerzeichen als Trennzeichen verbinden

Hello World

Das Trennzeichen kann beliebig sein – ein Komma, ein Zeilenumbruch oder sogar ein leerer string:

letters = ["P", "y", "t", "h", "o", "n"]

print(", ".join(letters))   # comma-separated
print("".join(letters))     # no separator — merges into one word
print("\n".join(letters))   # one letter per line

P, y, t, h, o, n
Python
P
y
t
h
o
n

Warum join() gegenüber + in Schleifen bevorzugen?

Jeder +-Aufruf reserviert einen völlig neuen string. join() berechnet die Gesamtlänge einmal, reserviert den Speicher einmal und kopiert alle Teile in einem einzigen Durchlauf – was es für große Eingaben zu O(n) statt O(n²) macht.

# Slow for large collections
parts = ["a"] * 10_000
result = ""
for p in parts:
    result += p   # 10,000 allocations

# Fast — single allocation
result = "".join(parts)

f-Strings zum Verketten von Werten verwenden

f-Strings (verfügbar seit Python 3.6) ermöglichen es, Variablen und Ausdrücke direkt in ein string-Literal einzubetten, ohne explizite +- oder str()-Aufrufe.

first_name = "Ada"
last_name  = "Lovelace"
birth_year = 1815

bio = f"{first_name} {last_name} was born in {birth_year}."
print(bio)

Ada Lovelace was born in 1815.

f-Strings sind oft übersichtlicher als +, wenn Sie mehrere Variablen mit wörtlichem Text mischen. Weitere Informationen zur vollständigen f-String-Syntax und Formatierungsoptionen finden Sie im Kapitel Strings formatieren.

Einen String mit * wiederholen

Der *-Operator wiederholt einen string eine bestimmte Anzahl von Malen und ist eine kompakte Alternative zu einer Verkettungsschleife.

line = "-" * 20
print(line)

echo = "ha" * 3
print(echo)

--------------------
hahaha

Mehrzeilige String-Verkettung

Python verbindet automatisch benachbarte string-Literale, die auf aufeinanderfolgenden Zeilen innerhalb von Klammern stehen – ohne +. Dies ist nützlich für lange hartcodierte Strings.

message = (
    "This is the first part. "
    "This is the second part. "
    "And this is the third."
)
print(message)

This is the first part. This is the second part. And this is the third.

Sie können eine lange Verkettung auch mit einem Backslash über mehrere Zeilen aufteilen:

long_url = "https://example.com/products" \
           "?category=books" \
           "&sort=price"
print(long_url)

https://example.com/products?category=books&sort=price

Die richtige Methode wählen

Weitere String-Operationen finden Sie unter Strings ändern, Strings slicen und String-Methoden.

Übungen