Concatenar Strings

La concatenación de strings es el proceso de unir dos o más strings en uno solo. Python ofrece varios enfoques — desde el operador + simple hasta el eficiente método join() — y elegir el correcto importa para la legibilidad y el rendimiento.

Este capítulo cubre:

• Los operadores + y +=
• Unir una lista de strings con join()
• Insertar valores con f-strings
• Repetir un string con *
• Concatenar valores que no son strings (y el error TypeError frecuente)
• Cuándo usar join() en lugar de +

Capítulos relacionados: Python Strings · Modify Strings · Format Strings · String Methods

Uso del operador +

El operador + es la forma más directa de unir dos strings. Python crea un nuevo string que contiene todos los caracteres de ambos operandos en orden.

Concatenar dos strings con +

Hello World

Puedes encadenar tantos strings como necesites en una sola expresión:

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

Good morning, Python!

Error frecuente — solo se permiten strings. El operador + no convierte otros tipos automáticamente. Intentar concatenar un string con un número genera un TypeError:

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.

Siempre llama a str() sobre un valor que no sea string antes de usar +.

Uso del operador +=

El operador += agrega un string a una variable existente. Es una abreviatura de variable = variable + new_string y resulta útil cuando construyes un string paso a paso.

Construir una oración de forma incremental con +=

Hello, World!

Un uso habitual es acumular líneas dentro de un bucle:

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

one two three

Nota sobre el rendimiento. El uso repetido de += dentro de un bucle crea un nuevo objeto string en cada iteración. Para listas pequeñas esto no supone un problema, pero para colecciones grandes join() (ver más abajo) es significativamente más rápido.

Uso de join() para concatenar una lista de strings

str.join(iterable) une todos los strings de un iterable, colocando el string sobre el que se llama entre cada par. Es la forma idiomática en Python de construir un string a partir de una colección.

Unir palabras con un separador de espacio

Hello World

El separador puede ser cualquier cosa — una coma, una nueva línea o incluso un string vacío:

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

¿Por qué preferir join() sobre + en bucles?

Cada llamada a + asigna un string completamente nuevo. join() calcula la longitud total una sola vez, asigna memoria una sola vez y copia todas las partes en un único paso — lo que lo hace O(n) en lugar de O(n²) para entradas grandes.

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

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

Uso de f-Strings para concatenar valores

Las f-strings (disponibles desde Python 3.6) permiten insertar variables y expresiones directamente dentro de un string literal sin ninguna llamada explícita a + o str().

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.

Las f-strings suelen ser más claras que + cuando mezclas varias variables con texto literal. Consulta el capítulo Format Strings para conocer la sintaxis completa de f-strings y las opciones de formato.

Repetir un string con *

El operador * repite un string un número determinado de veces, lo que ofrece una alternativa concisa a un bucle de concatenación.

line = "-" * 20
print(line)

echo = "ha" * 3
print(echo)

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

Concatenación de strings multilínea

Python une automáticamente los literales de string adyacentes que aparecen en líneas consecutivas dentro de paréntesis — sin necesidad de +. Esto resulta útil para strings largos escritos directamente en el código.

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.

También puedes dividir una concatenación larga en varias líneas con una barra invertida:

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

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

Elegir el método adecuado

Para más operaciones con strings, consulta Modify Strings, Slicing Strings y String Methods.

Práctica