# Cadenas en Python: métodos split, replace, strip, join, cortes y f-strings URL: https://skillaria.top/es/guides/python/cadenas-python En Python, una cadena (tipo str) es una secuencia inmutable de caracteres Unicode. split() divide una cadena en una lista, join() vuelve a unir una lista, replace() sustituye un fragmento y strip() elimina los espacios de los extremos; cada método devuelve una cadena nueva. Para insertar valores lo más cómodo es una f-string: f"{nombre}: {precio:.2f}". 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 | Método | Qué hace | Ejemplo → resultado | | --- | --- | --- | | `lower()`, `upper()` | cambia las mayúsculas | `"Café".lower()` → `'café'` | | `startswith()`, `endswith()` | comprueba el inicio y el final | `"a.csv".endswith(".csv")` → `True` | | `find()` | posición de la subcadena o -1 | `"café".find("é")` → `3` | | `count()` | número de apariciones | `"plátano".count("a")` → `2` | | `isdigit()` | ¿solo dígitos? | `"250".isdigit()` → `True` | | `zfill()` | rellena con ceros | `"7".zfill(3)` → `'007'` | 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: | Expresión | Resultado | Significado | | --- | --- | --- | | `f"{3.14159:.2f}"` | `3.14` | redondeo a 2 decimales | | `f"{1250000:,}"` | `1,250,000` | separador de miles | | `f"{1250000:_}"` | `1_250_000` | guion bajo en lugar de coma | | `f"{0.256:.1%}"` | `25.6%` | porcentaje | | `f"{'café':<10}|"` | `café |` | alineado a la izquierda, ancho 10 | | `f"{250:>8}"` | ` 250` | alineado a la derecha | | `f"{7:03d}"` | `007` | relleno con ceros | 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.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 = "" plantilla = t"Hola, {nombre}!" print(plantilla.strings) # ('Hola, ', '!') print(plantilla.values) # ('',) ``` ¿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. ## FAQ **¿Cómo saber la longitud de una cadena en Python?** La función len(s) devuelve el número de caracteres. En cirílico, acentos y emojis se cuentan caracteres Unicode, no bytes; el tamaño en bytes se obtiene con len(s.encode("utf-8")). **¿Cómo convertir un número en cadena y viceversa?** str(250) da '250', y int("250") y float("2.5") hacen la conversión inversa. Si la cadena no es un número, int() provoca un ValueError, por eso conviene validar la entrada. **¿Por qué replace no cambia mi cadena?** Las cadenas son inmutables y replace devuelve una cadena nueva. Asigne el resultado: s = s.replace("a", "b"). **¿Cómo comprobar si una cadena está vacía?** La cadena vacía es falsa, así que basta con if not s:. Si la cadena puede contener solo espacios, compruebe if not s.strip():. **¿En qué se diferencia una t-string de una f-string?** Una f-string devuelve enseguida un str ya terminado, mientras que una t-string (Python 3.14 o superior) es un objeto Template con los fragmentos de texto y los valores por separado. Así se pueden escapar de forma segura los datos para HTML y SQL. --- Source: Skillaria.Top (https://skillaria.top)