En la lección anterior descubriste que una lista es una secuencia: elementos ordenados a los que se accede por índice. Lo que quizá no viste venir es que llevas usando otra secuencia desde el módulo 2 sin llamarla así. El texto —el tipo str— es exactamente eso: una secuencia de caracteres. Todo lo que aprendiste sobre índices, rebanadas y recorridos con for funciona igual sobre una cadena, con una diferencia decisiva: la cadena es inmutable.

Y esto no es un adorno teórico. En TareaFácil casi todo es texto: los títulos que teclea Marta, los nombres del equipo, las prioridades, las líneas que más adelante guardaremos en un fichero. Manejar bien las cadenas es lo que separa un programa que acepta « CARTEL feria » y «cartel Feria» como dos tareas distintas de uno que entiende que son la misma.

1. La cadena como secuencia inmutable
2. Índices, rebanadas y recorrido
3. Limpieza: strip, lstrip, rstrip
4. Mayúsculas y minúsculas
5. Búsqueda dentro del texto
6. Comprobación del contenido
7. Transformación y relleno
8. Partición y unión: el puente con las listas
9. Multilínea, escapes y cadenas crudas
10. f-strings, str() y Unicode
11. Comparar y ordenar textos
12. Aplicación: títulos y códigos de tarea en Estudio Alba
13. Errores comunes y consejos
14. Ejercicios
15. Conclusión

Una cadena es una secuencia de caracteres con un orden fijo. len(), los índices y el operador in funcionan igual que en una lista:

La diferencia está aquí:

Una cadena no se puede modificar. Ni un carácter. Todo lo que parece modificar texto en realidad crea una cadena nueva y deja la original intacta:

Retén esta idea, porque explica el error número uno con cadenas: si no guardas el resultado, no ha pasado nada. Y a cambio de la restricción hay una ventaja: al ser inmutables, las cadenas pueden usarse como claves de diccionario, cosa que verás en 05-03.

Todo lo de 05-01 se aplica sin cambios, salvo que aquí el resultado de una rebanada es otra cadena:

Para recorrer carácter a carácter, el for directo; y con enumerate si necesitas la posición:

El patrón contador de 03-02 funciona igual aquí: recorrer el texto sumando 1 cada vez que la letra cumple una condición. Casi siempre, eso sí, hay un método que lo resuelve en una línea —contar espacios a mano da lo mismo que titulo.count(" ")—, así que recorre carácter a carácter solo cuando la condición sea propia tuya.

Cuando el texto viene de input() o de un fichero, casi siempre trae basura alrededor: espacios, tabuladores o el salto de línea final. La familia strip la quita.

Con entrada = " Cartel feria del libro \n", f"[{entrada.strip()}]" imprime [Cartel feria del libro]. Ojo con un malentendido frecuente: .strip("abc") no borra la subcadena "abc", sino cualquier a, b o c que haya en los extremos. Y strip nunca toca el interior: " a b ".strip() deja "a b".

Los dos usos típicos son distintos y conviene no mezclarlos. Para comparar, se normaliza a minúsculas (nadie debería teclear «Marta» con la mayúscula exacta para que el programa lo acepte). Para mostrar, se elige la forma bonita:

.casefold() es la versión rigurosa de .lower() para comparaciones internacionales: en alemán convierte la ß en ss, cosa que .lower() no hace. Para español, ambas se comportan igual; usa .casefold() si comparas texto que puede venir en cualquier idioma.

La diferencia entre .find() y .index() es la misma que ya conoces de las listas: find devuelve -1 cuando no hay nada, mientras que index lanza ValueError. Usa find cuando «no estar» sea un caso normal, y recuerda que -1 es un índice válido en Python, así que nunca uses el resultado de find sin comprobar antes que no es -1.

Estos métodos devuelven True o False y sirven para validar antes de convertir, tal como hacías en 02-04.

Fíjate en las trampas: "3.5" no es isdigit (el punto no es un dígito), "-3" tampoco (el signo no lo es), y una cadena vacía devuelve False en todos ellos. Por eso if texto.isdigit(): antes de int(texto) sigue siendo la guarda correcta para enteros positivos, pero no vale para decimales ni negativos. La forma robusta de gestionar esos casos es try/except, y llega en Depuración y manejo de errores.

zfill es el atajo clásico para numerar: str(7).zfill(2) da "07", y así los códigos salen 01, 02, 03… en vez de 1, 2, 3. Los tres de alineación hacen lo mismo que los especificadores :<, :^ y :> de las f-strings; puedes usar cualquiera de las dos formas, aunque dentro de una f-string queda más limpio el especificador.

Aquí está la conexión directa con la lección anterior, y es de las cosas más útiles del lenguaje.

split(separador) parte una cadena y devuelve una lista de trozos. Sin argumentos, parte por espacios (agrupando los consecutivos).

join hace lo contrario: une los elementos de una lista en una sola cadena. Se llama sobre el separador, que es lo que despista al principio:

Se lee así: «coge la lista y pégala usando esta cadena como pegamento». La tercera línea recuerda que join solo funciona con listas de cadenas: si hay números, hay que convertirlos antes, normalmente con una comprensión de 05-01.

split y join son la pareja que convierte texto en datos y datos en texto. Cuando en 05-05 leamos un fichero de tareas, cada línea se convertirá en campos con split; y para escribirla, los campos volverán a ser una línea con join.

Para un texto de varias líneas están las comillas triples, que respetan los saltos tal cual se escriben:

Dentro de una cadena normal, algunos caracteres se escriben con una secuencia de escape, que empieza por barra invertida:

La última línea usa el prefijo r de cadena cruda (raw), que desactiva los escapes y resulta comodísimo con rutas de Windows. Cuidado con la trampa clásica: "C:\tareas" no es lo que parece, porque \t es un tabulador; con r"C:\tareas" no hay sorpresa.

Las f-strings de 02-03 son la forma normal de construir texto con valores dentro, y sus especificadores de anchura son los que dan a TareaFácil sus tablas alineadas:

str(valor) convierte cualquier valor en su representación textual, y es imprescindible antes de concatenar con + o de usar join. Recuerda que "Dias: " + 3 da TypeError, mientras que "Dias: " + str(3) funciona y f"Dias: {3}" funciona sin conversión explícita.

Una idea sobre Unicode, que basta por ahora. Cada carácter de una cadena de Python es un carácter, no un byte: len("Panadería") vale 9 aunque la í lleve tilde, y "ñ"[0] es "ñ". Pero cuando ese texto sale del programa —a un fichero, a la red— hay que codificarlo en bytes, y ahí es donde entra UTF-8, la codificación estándar que sabe representar tildes, ñ, ç y prácticamente cualquier alfabeto. Si abres un fichero con la codificación equivocada verás cosas como Panadería. Por eso en Guardar datos en archivos escribiremos siempre encoding="utf-8".

Las cadenas se comparan con <, > y == carácter a carácter, según el número que cada carácter tiene asignado en la tabla Unicode. Y ahí aparece una sorpresa:

"Zapato" < "abeto" es True porque todas las mayúsculas van antes que todas las minúsculas: la Z es el carácter 90 y la a el 97. No es un capricho: es el orden de la tabla, no el del diccionario de la RAE. La consecuencia práctica es que sorted(["nuria", "Luis", "Marta"]) pone primero todo lo que empiece por mayúscula. La solución, que ya viste en 04-05 y 05-01, es ordenar por una clave normalizada:

Lo mismo vale para comparar: normaliza los dos lados antes de comparar. entrada.strip().lower() == "marta" acepta " Marta ", "MARTA" y "marta". Las tildes añaden otro escalón ("Alvaro" < "Álvaro"), y su tratamiento correcto requiere bibliotecas de intercalación que quedan fuera de este curso.

Tres utilidades de texto para TareaFácil, escritas con lo de esta lección. La estructura del programa no cambia todavía —la tarea sigue siendo un puñado de variables hasta 05-03—, pero estas funciones entrarán en la sección de lógica.

Probémoslas:

Comentario de lo importante:

• " ".join(texto.split()) es el idioma clásico para colapsar espacios: split() sin argumentos parte por cualquier bloque de blancos y descarta los vacíos; join los vuelve a unir con exactamente un espacio. Resuelve de golpe los espacios de los extremos, los dobles y los tabuladores.
• cliente.replace(" ", "")[:3].upper() construye las siglas: quita los espacios, coge tres caracteres con una rebanada y los pasa a mayúsculas. Si el cliente tuviera menos de tres letras, la rebanada devuelve lo que haya sin error.
• str(numero).zfill(2) convierte primero a texto (zfill es un método de cadena, no de entero) y luego rellena con ceros.
• partir_linea devuelve None si el número de campos no es el esperado, aplicando la cláusula de guarda de 04-02, y normaliza cada campo con las convenciones del programa: título capitalizado, responsable capitalizado, prioridad en minúsculas y días convertidos a entero.

Esa función partir_linea es, de hecho, media lección 05-05: leer un fichero de tareas consistirá en aplicarla a cada línea.

Olvidar que los métodos no modifican. titulo.upper() sin asignar no hace nada visible; si el texto no cambia, comprueba que has escrito titulo = titulo.upper(). Y titulo[0] = "M" da TypeError, porque la cadena es inmutable: para cambiar un carácter hay que reconstruir, "M" + titulo[1:].

Usar el resultado de .find() sin comprobarlo. Si no encuentra nada devuelve -1, y texto[-1] es el último carácter, así que el programa seguirá adelante con un dato erróneo en vez de fallar.

Comparar sin normalizar. entrada == "marta" falla con " Marta ". Aplica .strip().lower() a los dos lados, siempre en el mismo sitio del programa.

Creer que .strip("hola") borra la palabra «hola». Borra cualquier h, o, l o a de los extremos. Para quitar una palabra concreta, .replace("hola", "").

join con números. ", ".join([3, 5]) lanza TypeError. Convierte antes: ", ".join([str(d) for d in dias]).

Consejo: normaliza en la entrada, formatea en la salida. Guarda los datos ya limpios (una sola forma canónica) y decide la presentación al imprimir. Así nunca tendrás dos versiones de «Cartel feria» conviviendo en la misma agenda.

Di qué imprime cada línea y explica por qué.

Escribe resumen_titulo(titulo) que reciba un título y devuelva una cadena de una línea con: el título normalizado (sin espacios sobrantes y capitalizado), su número de caracteres, su número de palabras y sus iniciales en mayúsculas separadas por puntos. Para " cartel feria del libro " debe devolver Cartel feria del libro | 22 car. | 4 pal. | C.F.D.L.

Dada esta lista de líneas, escribe un programa que las parta, descarte las mal formadas (que no tengan cuatro campos o cuyos días no sean un entero) e imprima una tabla alineada con título, responsable capitalizado, prioridad en mayúsculas y días. Al final, imprime el total de días de las líneas válidas.

Solución 1.

strip().lower() limpia y baja todo. find("Sole") da -1 porque la búsqueda distingue mayúsculas y en el texto pone SOLE; find("SOLE") sí lo encuentra, en el índice 15 contando los dos espacios iniciales. split() sin argumentos ignora los espacios sobrantes. join pega los trozos con guiones. replace(" ", "") elimina todos los espacios, también los interiores. Y "SOLE" < "Sole" es True porque la O mayúscula (79) va antes que la o minúscula (111).

Solución 2.

La clave está en calcular limpio una sola vez y medir sobre él: si contaras los caracteres del original obtendrías 26 por culpa de los espacios sobrantes. Las iniciales combinan una comprensión de 05-01 (p[0].upper() para cada palabra) con join, y el punto final se añade aparte porque join solo pone separadores entre elementos.

Solución 3.

Salen dos filas válidas —«Cartel feria / Luis / ALTA / 3» y «Menu panaderia sole / Marta / MEDIA / 5», total 8 días— y dos descartes: la tercera línea solo tiene tres campos y la cuarta trae "dos" donde debería ir un número. Dos detalles que valen para cualquier lector de datos. La comprobación len(campos) != 4 or not campos[3].strip().isdigit() reúne las dos causas de descarte en una sola guarda, y el continue de 03-03 evita anidar el resto del cuerpo dentro de un if. Y cada campo se limpia con .strip() antes de usarlo, porque la segunda línea trae espacios alrededor de los puntos y comas: sin ese strip, " 5 ".isdigit() daría False y la línea buena se descartaría.

Una cadena es una secuencia inmutable de caracteres: acepta índices, rebanadas y recorridos con for igual que una lista, pero no se puede modificar, así que todos sus métodos devuelven una cadena nueva y hay que guardarla. Has recorrido las seis familias de métodos: limpieza (strip, lstrip, rstrip), mayúsculas y minúsculas (upper, lower, title, capitalize, casefold), búsqueda (in, find, rfind, index, count, startswith, endswith), comprobación (isdigit, isalpha, isalnum, isspace), transformación (replace, zfill, center, ljust, rjust) y partición y unión (split, rsplit, splitlines, join), que es el puente entre el texto y las listas. Sabes escribir textos multilínea con """, protegerte de los escapes con r"", alinear columnas con f-strings, y por qué "Zapato" < "abeto" obliga a comparar y ordenar sobre una versión en minúsculas. Y sabes que las tildes y la ñ son un carácter cada una, pero que al salir a disco el texto se codifica en bytes y por eso UTF-8 importa.

En Estudio Alba ya puedes normalizar los títulos para que « CARTEL feria » y «Cartel Feria» sean el mismo texto, generar códigos como ALB-PAN-01M y convertir una línea "Cartel feria;luis;alta;3" en cuatro campos listos para usar. Lo que sigue sin resolverse es el problema que 05-01 dejó abierto: esos cuatro campos siguen siendo cuatro variables sueltas, o peor, cuatro listas paralelas que hay que mantener sincronizadas a mano. La solución llega en Diccionarios y conjuntos: una estructura donde cada dato se guarda con su nombre —titulo, responsable, prioridad, dias, completada— en lugar de con un número de posición. Ahí TareaFácil dará el salto a la v0.9 y una tarea pasará a ser, por fin, una sola cosa.