Cadenas en Python: métodos split, replace, strip, join, cortes y f-strings

Las cadenas aparecen en cualquier programa: lo que escribe el usuario, los nombres de archivo, las líneas de un CSV, las respuestas de una API. El tipo str guarda el texto en Unicode, así que las letras acentuadas y los emojis funcionan sin configuración adicional. Los métodos más usados son split, replace, strip y join, y para mostrar valores lo más cómodo son las f-strings. A continuación lo vemos con ejemplos.

Cómo es una cadena en Python

Una cadena se escribe entre comillas simples o dobles, sin diferencia: 'café' y "café" son lo mismo. Las comillas triples crean una cadena de varias líneas en la que los saltos se conservan tal cual.

nombre = "Café"
nota = """Primera línea
Segunda línea"""
print(len(nombre))  # 4 — longitud de la cadena en caracteres

La propiedad principal de las cadenas es la inmutabilidad. Un método no modifica la cadena, sino que devuelve una nueva. Por eso s.replace("a", "b") sin asignación no sirve de nada: hay que escribir s = s.replace("a", "b"). Es el error más frecuente entre los principiantes.

Caracteres especiales, salto de línea y cadenas crudas

El salto de línea se escribe \n, el tabulador \t y la barra invertida \\. El prefijo r convierte la cadena en «cruda»: las barras invertidas no se procesan. Es cómodo para las rutas de Windows y las expresiones regulares.

print("Total:\n350 €")
ruta = r"C:\nuevo\tabla.csv"   # \n y \t no se convierten en caracteres especiales

Una expresión larga puede pasar a la línea siguiente si se encierra entre paréntesis: Python une por sí mismo las cadenas literales contiguas dentro de los paréntesis.

split: dividir una cadena en una lista

El método split() divide la cadena según un separador y devuelve una lista. Sin argumentos, corta por cualquier espacio en blanco e ignora los espacios repetidos, lo que resulta cómodo para analizar comandos.

"add  Café 250".split()        # ['add', 'Café', '250']
"2026-10-16".split("-")        # ['2026', '10', '16']
"a,b,,c".split(",")            # ['a', 'b', '', 'c']
"clave=valor=x".split("=", 1)  # ['clave', 'valor=x']

Fíjese en la diferencia: con un separador explícito, los fragmentos vacíos se conservan. El segundo argumento maxsplit limita el número de cortes, y rsplit() corta por la derecha. Para dividir un texto en líneas use splitlines(): reconoce tanto \n como \r\n y no deja un elemento vacío al final.

texto = "café\ntaxi\n"
texto.split("\n")     # ['café', 'taxi', '']
texto.splitlines()    # ['café', 'taxi']

join: unir una lista en una cadena

join() es la operación inversa. Se llama desde la cadena que actúa como separador y recibe como argumento una lista de cadenas:

items = ["café", "taxi", "comida"]
print(", ".join(items))   # café, taxi, comida
print("\n".join(items))   # cada elemento en una línea nueva

Todos los elementos deben ser cadenas; de lo contrario se produce TypeError: sequence item 0: expected str instance, int found. Los números hay que convertirlos antes: ", ".join(str(x) for x in importes).

Concatenación y unión de cadenas

Dos cadenas se suman con + y se repiten con *: "-" * 20. Pero pegar cientos de fragmentos en un bucle con += es lento, porque en cada paso se crea una cadena nueva. Reúna las partes en una lista y únalas con un único join(). Además, no se puede sumar directamente una cadena y un número: "Total: " + 5 provoca un TypeError; hace falta la función str() o una f-string.

replace: sustituir un fragmento

replace(viejo, nuevo) sustituye todas las apariciones de un fragmento. El tercer argumento limita el número de sustituciones.

precio = "1 250,50"
precio = precio.replace(" ", "").replace(",", ".")
print(float(precio))                  # 1250.5

"a-b-c".replace("-", "+", 1)          # 'a+b-c'

El método distingue mayúsculas y minúsculas y busca coincidencias exactas. Para sustituciones por patrón (por ejemplo, «todos los dígitos») hace falta el módulo re y la función re.sub().

strip, lstrip, rstrip: recortar una cadena

strip() elimina los espacios, tabulaciones y saltos de línea de ambos extremos. lstrip() limpia solo por la izquierda y rstrip() solo por la derecha. Es lo primero que conviene hacer con lo que escribe el usuario y con las cadenas que llegan de un archivo.

bruto = "  Café \n"
bruto.strip()       # 'Café'
bruto.rstrip()      # '  Café'
"xxCaféxx".strip("x")   # 'Café'

El argumento es un conjunto de caracteres, no una subcadena: "abcTextocba".strip("abc") elimina todas las letras a, b y c de los extremos en cualquier orden. Para quitar exactamente un prefijo o un sufijo, use removeprefix() y removesuffix() (desde Python 3.9).

Otros métodos útiles de las cadenas

Para saber si una cadena contiene una subcadena, lo más sencillo es el operador in: if "café" in texto.lower():. Las cadenas se comparan con == carácter a carácter y distinguiendo mayúsculas; para comparar sin tener en cuenta las mayúsculas, convierta ambas con casefold().

Cortes de cadenas

Una cadena es una secuencia, así que a sus caracteres se accede por índice empezando en cero, y un índice negativo cuenta desde el final. El corte s[inicio:fin:paso] devuelve una subcadena; el límite derecho no se incluye.

s = "Python"
s[0]      # 'P'
s[-1]     # 'n'
s[0:3]    # 'Pyt'
s[2:]     # 'thon'
s[::2]    # 'Pto'
s[::-1]   # 'nohtyP' — invertir la cadena

Un corte nunca provoca error al salirse de los límites: s[0:100] devuelve la cadena entera. En cambio, s[100] genera un IndexError. No se puede cambiar un carácter por su índice (s[0] = "J" da TypeError); hay que construir una cadena nueva: "J" + s[1:].

f-strings en Python

La letra f delante de una cadena indica que las expresiones entre llaves se evaluarán y se insertarán en el texto. Es la forma principal de dar formato a las cadenas desde Python 3.6: es más corta que format() y más rápida que el antiguo operador %.

producto = "Café"
precio = 250
print(f"{producto}: {precio} €")              # Café: 250 €
print(f"Con descuento: {precio * 0.9} €")     # Con descuento: 225.0 €
print(f"{producto=}")                          # producto='Café' — práctico para depurar

Formato de números y alineación

Después de los dos puntos dentro de las llaves se escribe un especificador de formato. Define el redondeo, los separadores de miles, el ancho y la alineación:

La alineación es útil para tablas en la terminal: f"{nombre:<12}{importe:>10.2f}" alinea las columnas con exactitud. Tenga en cuenta que el formato solo hace falta al mostrar datos. Guarde el dinero en céntimos (int) o en Decimal, no en float: 0.1 + 0.2 da 0.30000000000000004.

Comillas y saltos de línea dentro de una f-string

Desde Python 3.12 (PEP 701), las f-strings tienen una gramática formal: dentro de las llaves se pueden usar las mismas comillas que fuera, barras invertidas y saltos de línea, y el anidamiento ya no está limitado. Los errores dentro de las llaves muestran ahora la posición exacta. En versiones anteriores, use dentro un tipo de comillas distinto: f"{d['clave']}", y el salto de línea mediante una variable aparte o con chr(10).

Para texto de varias líneas sirve una f-string con comillas triples: f"""Total: {total}\nPosiciones: {cantidad}""".

format() y %: formas antiguas

En código ajeno aparecerán "{}: {}".format(producto, precio) y "%s: %d" % (producto, precio). Los especificadores de format() son los mismos que los de las f-strings. El método format() sigue siendo útil cuando la plantilla se guarda aparte de los datos, por ejemplo en un archivo de configuración.

Análisis de una cadena: ejemplo práctico

Juntemos los métodos. Supongamos que desde un archivo llegan líneas como " 2026-10-16; Café ; 250,50 \n", y hay que obtener la fecha, el nombre y el importe en céntimos. El orden habitual es: limpiar los extremos, dividir por el separador, limpiar cada parte y convertir los tipos.

linea = "  2026-10-16; Café ; 250,50 \n"

fecha, producto, importe_bruto = [p.strip() for p in linea.strip().split(";")]
importe_centimos = round(float(importe_bruto.replace(",", ".")) * 100)

print(fecha, producto, importe_centimos)            # 2026-10-16 Café 25050
print(f"{producto:<10}{importe_centimos / 100:>10.2f}")

Si las partes no son tres, la desempaquetación fallará con ValueError: not enough values to unpack o too many values to unpack. En código real conviene comprobar esas líneas de antemano o capturar la excepción. Para archivos CSV de verdad, con comillas y caracteres de escape, es mejor el módulo estándar csv que split.

Errores típicos con cadenas

• No guardar el resultado de un método: s.strip() sin asignación no cambia nada.
• join con una lista de números da TypeError; primero hay que aplicar map(str, ...).
• strip con una subcadena: el argumento es un conjunto de caracteres; para un prefijo se necesita removeprefix().
• Comparación con distinción de mayúsculas: "Café" == "café" es False.
• Barras de las rutas de Windows sin el prefijo r se convierten en caracteres especiales.

t-strings: una plantilla en lugar del texto final

En Python 3.14 aparecieron las t-strings. Se parecen a las f-strings, con el prefijo t, pero el resultado es otro: no una cadena terminada, sino un objeto string.templatelib.Template. En él se guardan por separado los fragmentos de texto (.strings) y los valores insertados (.values).

nombre = "<script>"
plantilla = t"Hola, {nombre}!"
print(plantilla.strings)   # ('Hola, ', '!')
print(plantilla.values)    # ('<script>',)

¿Para qué sirve? Una biblioteca recibe los valores antes de unirlos y puede procesarlos: escapar los signos de mayor y menor en HTML o pasar correctamente los parámetros a una consulta SQL. Una f-string no ofrece esa posibilidad, porque ya lo ha unido todo. Para mostrar texto de forma habitual, siga usando f-strings.

Resumen

Para el trabajo diario con cadenas en Python basta un conjunto pequeño de herramientas: split() y join() analizan y montan el texto, strip() limpia la entrada, replace() sustituye fragmentos, los cortes extraen subcadenas y las f-strings muestran los valores con el formato necesario. Recuerde la inmutabilidad: el método devuelve una cadena nueva, y hay que guardarla. Las cadenas, los números y las f-strings se practican en la lección del curso de Python con un registro de gastos.