Módulo 1: Texto profesional y funciones integradas

Muchos programas reales reciben información escrita por personas, copiada desde formularios o importada desde otros sistemas. Esa información rara vez llega perfecta:

"  ana   solís "
" ANA.SOLIS@EJEMPLO.COM "
"Python, lógica, python"
"coa-0007"

Los datos contienen espacios sobrantes, capitalización inconsistente, valores repetidos y formatos que deben comprobarse. Una solución apresurada puede corregir algunos casos y dañar otros. Una solución profesional necesita distinguir tres operaciones:

LIMPIAR             TRANSFORMAR             VALIDAR
Quitar ruido   →    Aplicar un formato   →  Comprobar las reglas

En este módulo aprenderás a realizar esas operaciones con métodos de cadenas, funciones integradas y una introducción concreta a las expresiones regulares.

No volverás a estudiar qué es una variable, un condicional, un ciclo o una función. Utilizarás esos conocimientos para escribir soluciones más claras y aprovechar herramientas que Python ya incluye.

Principio del módulo: limpiar un dato no significa adivinarlo. Toda transformación debe responder a una regla clara y debe permitir comprobar qué cambió.

Al completar el módulo serás capaz de:

• Diferenciar limpieza, transformación y validación.
• Normalizar espacios y capitalización sin perder información útil.
• Dividir texto con split(), rsplit(), partition() y splitlines().
• Reconstruir texto mediante join().
• Validar contenido con métodos de str, any() y all().
• Presentar datos mediante f-strings, alineación, ancho y formato numérico.
• Utilizar repr() para descubrir espacios, tabulaciones y saltos de línea invisibles.
• Aplicar len(), abs(), round(), divmod(), sum(), min(), max(), sorted() y reversed().
• Personalizar búsquedas y ordenamientos mediante el parámetro key.
• Utilizar expresiones regulares sencillas cuando los métodos normales de cadenas no sean suficientes.
• Construir un programa que normalice, valide y audite registros de texto.

Para realizar las prácticas necesitas:

• Python 3.10 o una versión posterior.
• Un editor de código.
• Una carpeta llamada python_practico_modulo_1.
• Un archivo inicial llamado practicas.py.

Comprueba tu versión desde la terminal:

python --version

En algunos sistemas el comando puede ser python3 --version.

No copies todas las demostraciones en un único bloque. Separa cada práctica con funciones y nombres claros para que puedas volver a ejecutarla.

Al final del módulo desarrollarás un programa que reciba registros como este:

" COA-0001 |  ana   solís | ANA.SOLIS@EJEMPLO.COM | Python, lógica, python "

Y produzca información normalizada y auditable:

Código:       COA-0001
Nombre:       Ana Solís
Correo:       ana.solis@ejemplo.com
Etiquetas:    python, lógica
Estado:       CORREGIDO

El programa también deberá identificar los registros que no pueden aceptarse:

Código:       COA-00A3
Estado:       INVÁLIDO
Problemas:    el código debe tener el formato COA-0000

La meta no es producir la menor cantidad posible de líneas. La meta es construir un flujo que otra persona pueda leer, probar y modificar.

Los tiempos son orientativos. Detén el contenido cuando necesites probar un caso adicional, comparar resultados o corregir un error.

Diagnosticar antes de transformar

Observa estos nombres:

"  ana solís  "
"ANA SOLÍS"
"Ana Solís"

Los tres podrían referirse a la misma persona. Sin embargo, no toda diferencia debe eliminarse automáticamente. Por ejemplo:

"María del Mar"
"McDonald"
"COA-Pro"

Aplicar .title() a cualquier texto produce uniformidad, pero no garantiza que el nombre quede escrito como la persona lo utiliza. Debes conocer la regla del sistema antes de transformar.

Una regla válida para una práctica puede ser:

En este conjunto de ejemplo, los nombres se mostrarán con iniciales en mayúscula. La regla se documentará porque no representa correctamente todos los nombres posibles.

Una regla profesional debe ser explícita, comprobable y revisable.

Antes de escribir código, responde:

1. ¿Qué parte es ruido? Espacios exteriores, separadores repetidos o diferencias irrelevantes de mayúsculas.
2. ¿Qué formato necesita el sistema? Por ejemplo, códigos en mayúsculas y correos comparados sin distinguir mayúsculas.
3. ¿Cómo se determina si el valor es aceptable? Por ejemplo, un código que coincida exactamente con COA- seguido por cuatro dígitos.

No necesitas destruir el valor recibido para producir una versión normalizada:

valor_original = "  ana   solís "
valor_normalizado = " ".join(valor_original.split()).title()

print(f"Original:    {valor_original!r}")
print(f"Normalizado: {valor_normalizado!r}")

Salida:

Original:    '  ana   solís '
Normalizado: 'Ana Solís'

El modificador !r muestra la representación del texto. Las comillas permiten observar los espacios exteriores.

Dato original
     │
     ├── Guardar original
     │
     ▼
Limpieza segura
     │
     ▼
Transformación documentada
     │
     ▼
Validación
     │
     ├── Válido sin cambios
     ├── Válido corregido
     └── Inválido con explicación

Una auditoría útil no responde solamente “válido” o “inválido”. También informa qué regla no se cumplió.

Métodos profesionales de cadenas

Los métodos de texto no modifican la cadena original. Devuelven una nueva:

correo = "  ESTUDIANTE@EJEMPLO.COM  "
correo.strip().lower()

print(correo)

El valor de correo sigue conteniendo espacios y mayúsculas. Debes guardar el resultado:

correo = correo.strip().lower()
print(correo)

Salida:

estudiante@ejemplo.com

texto = "   Python práctico   "

print(texto.strip())
print(texto.lstrip())
print(texto.rstrip())

• strip() elimina espacios de ambos extremos.
• lstrip() elimina espacios del extremo izquierdo.
• rstrip() elimina espacios del extremo derecho.

No eliminan los espacios interiores:

nombre = "  ana    solís  "
print(nombre.strip())

Salida:

ana    solís

Para reducir cualquier grupo de espacios interiores a uno solo combina split() y join():

nombre_limpio = " ".join(nombre.split())
print(nombre_limpio)

Salida:

ana solís

split() sin argumento trata secuencias de espacios, tabulaciones o saltos de línea como separadores. Después, " ".join(...) reconstruye el texto con un solo espacio.

texto = "PyThOn PRÁCTICO"

print(texto.lower())
print(texto.upper())
print(texto.title())
print(texto.capitalize())
print(texto.casefold())

Para comparar categorías escritas de formas diferentes:

categoria_recibida = "PYTHON"
categoria_buscada = "python"

coinciden = categoria_recibida.casefold() == categoria_buscada.casefold()
print(coinciden)

No necesitas modificar el valor que mostrarás. Puedes crear una clave normalizada solo para comparar.

archivo = "reporte_final.txt"
codigo = "TEMP-COA-0042"

print(archivo.removesuffix(".txt"))
print(codigo.removeprefix("TEMP-"))

No confundas estos métodos con strip():

print("texto.txt".rstrip(".txt"))

rstrip(".txt") elimina del final cualquier combinación de ., t y x; no un sufijo exacto. Para un sufijo conocido utiliza removesuffix().

Para comprobar sin eliminar:

codigo = "COA-0042"
archivo = "reporte.csv"

print(codigo.startswith("COA-"))
print(archivo.endswith(".csv"))
print(archivo.endswith((".csv", ".json", ".txt")))

Una tupla de sufijos es más clara que varias comparaciones con or.

telefono = "8888-1234"
telefono_sin_guion = telefono.replace("-", "")
print(telefono_sin_guion)

replace() sustituye todas las coincidencias de forma predeterminada. Puede limitarse:

texto = "uno, dos, tres"
print(texto.replace(",", ";", 1))

Antes de utilizarlo, comprueba si la sustitución puede cambiar una parte válida. Esta operación es peligrosa:

correo = correo.replace(" ", "")

Un correo con un espacio interno puede ser un dato inválido que debe rechazarse. Si eliminas el espacio automáticamente, ocultas el problema y quizá creas otra dirección existente.

registro = "COA-0001|Ana Solís|ana@ejemplo.com"
partes = registro.split("|")

print(partes)

Salida:

['COA-0001', 'Ana Solís', 'ana@ejemplo.com']

Puedes limitar la cantidad de divisiones:

ruta = "carpeta/subcarpeta/reporte.txt"
inicio, nombre = ruta.rsplit("/", 1)

rsplit() comienza por la derecha. Es útil cuando solo necesitas aislar la última parte.

No desempaques sin pensar en entradas incompletas:

partes = registro.split("|")

if len(partes) == 3:
    codigo, nombre, correo = partes
else:
    print("El registro no contiene exactamente tres campos")

partition() siempre devuelve tres elementos:

correo = "ana@ejemplo.com"
usuario, separador, dominio = correo.partition("@")

print(usuario)
print(separador)
print(dominio)

Si el separador no existe, la segunda y tercera parte quedan vacías:

usuario, separador, dominio = "correo-invalido".partition("@")
print((usuario, separador, dominio))

Salida:

('correo-invalido', '', '')

Esto permite validar un correo básico sin arriesgar un error de desempaquetado:

correo = "ana@ejemplo.com"
usuario, separador, dominio = correo.partition("@")

estructura_basica_valida = all([
    separador == "@",
    correo.count("@") == 1,
    bool(usuario),
    "." in dominio,
    not dominio.startswith("."),
    not dominio.endswith("."),
    " " not in correo,
])

print(estructura_basica_valida)

Esta validación es deliberadamente sencilla. Comprobar todos los casos permitidos por los estándares de correo es un problema más amplio. En un proyecto real debes definir el nivel de validación que realmente necesitas.

bloque = """COA-0001|Ana
COA-0002|Luis
COA-0003|María"""

for linea in bloque.splitlines():
    print(linea)

splitlines() reconoce distintos tipos de salto de línea y comunica mejor la intención que split("\n").

etiquetas = ["python", "texto", "validación"]
resultado = ", ".join(etiquetas)

print(resultado)

Salida:

python, texto, validación

El separador llama a join() porque es lo que se coloca entre las partes:

" | ".join(["COA-0001", "Ana Solís", "VÁLIDO"])

Todos los elementos deben ser cadenas. Si tienes números, conviértelos explícitamente:

numeros = [10, 20, 30]
texto = " - ".join(str(numero) for numero in numeros)
print(texto)

La expresión generadora aparece aquí únicamente como apoyo de join(). Se estudiará con mayor profundidad en el Módulo 2.

Si solo necesitas saber si un texto existe, utiliza in:

correo = "ana@ejemplo.com"

if "@" in correo:
    print("Contiene arroba")

Si necesitas la posición, utiliza find():

posicion = correo.find("@")
print(posicion)

find() devuelve -1 cuando no encuentra el texto. index() genera una excepción. Elige según el flujo que necesitas.

print("2026".isdigit())
print("Python".isalpha())
print("COA2026".isalnum())
print("   \t".isspace())

Estos métodos responden preguntas concretas, pero no sustituyen una regla completa. Por ejemplo, algunos dígitos Unicode también producen True con isdigit(). Si una regla exige exactamente caracteres del 0 al 9, un patrón [0-9] puede ser más preciso.

Formato y caracteres invisibles

Una f-string puede hacer más que insertar valores:

nombre = "Ana Solís"
progreso = 0.875
puntos = 12345

print(f"{nombre:<20} {progreso:>7.1%} {puntos:>10,}")

Salida:

Ana Solís              87.5%     12,345

Ejemplo:

numero = 42
codigo = f"COA-{numero:04d}"
print(codigo)

Salida:

COA-0042

encabezado = f"{'CÓDIGO':<12} {'NOMBRE':<22} {'ESTADO':<12}"
separador = "-" * len(encabezado)

print(encabezado)
print(separador)
print(f"{'COA-0001':<12} {'Ana Solís':<22} {'VÁLIDO':<12}")
print(f"{'COA-0002':<12} {'Luis Méndez':<22} {'CORREGIDO':<12}")

El ancho no limita el texto. Si un nombre supera 22 caracteres, desplazará las columnas. En este módulo puedes definir anchos para el conjunto de práctica. En un sistema real podrías calcularlos o truncar solo si la especificación lo permite.

valor = "  Ana\tSolís\n"

print(valor)
print(repr(valor))
print(f"Valor recibido: {valor!r}")

La representación revela espacios exteriores, \t como tabulación y \n como salto de línea. Utiliza repr() para diagnosticar; normalmente no es el formato final para el usuario.

Funciones integradas de alto valor

Las funciones integradas están disponibles sin importar módulos. Conocer las más útiles evita volver a programar operaciones que Python ya resuelve.

codigo = "COA-0042"
campos = ["código", "nombre", "correo", "etiquetas"]

print(len(codigo))
print(len(campos))
print(abs(-4))
print(round(87.456, 2))

abs() devuelve la magnitud de una diferencia. No lo utilices para ocultar un signo que comunica información importante.

round() no siempre “sube el cinco”:

print(round(1.5))
print(round(2.5))

Salida:

2
2

Python utiliza redondeo al par en empates y los valores float pueden contener aproximaciones internas. Para cálculos monetarios se utilizará Decimal en el Módulo 5.

divmod(a, b) devuelve el cociente y el residuo:

segundos_totales = 3670
minutos_totales, segundos = divmod(segundos_totales, 60)
horas, minutos = divmod(minutos_totales, 60)

print(f"{horas:02d}:{minutos:02d}:{segundos:02d}")

Salida:

01:01:10

Es equivalente a calcular a // b y a % b, pero comunica que necesitas ambos resultados.

correcciones_por_registro = [2, 0, 3, 1]
total = sum(correcciones_por_registro)
print(total)

No utilices sum() para concatenar texto. join() comunica mejor esa intención y es más eficiente.

registros = [
    {"codigo": "COA-0001", "errores": 2},
    {"codigo": "COA-0002", "errores": 0},
    {"codigo": "COA-0003", "errores": 4},
]

mas_problematico = max(registros, key=lambda registro: registro["errores"])
menos_problematico = min(registros, key=lambda registro: registro["errores"])

print(mas_problematico)
print(menos_problematico)

El parámetro key indica qué valor debe compararse. La función devuelve el registro completo, no solamente la cantidad de errores.

Una colección vacía no tiene mínimo ni máximo. Puedes definir un valor predeterminado:

resultado = max([], default=None)

any() responde si al menos una condición es verdadera. all() responde si todas son verdaderas:

print(any([False, False, True]))
print(all([True, True, True]))

Aplicación práctica:

codigo = "COA-0042"

codigo_valido = all([
    codigo.startswith("COA-"),
    len(codigo) == 8,
    codigo[4:].isdigit(),
])

print(codigo_valido)

Ten presente dos resultados que pueden sorprenderte:

print(any([]))
print(all([]))

Salida:

False
True

all([]) devuelve True porque no existe ningún elemento que incumpla la condición. Si una lista vacía debe ser inválida, comprueba también que contenga elementos:

etiquetas_validas = bool(etiquetas) and all(
    etiqueta.strip() for etiqueta in etiquetas
)

nombres = ["Sofía", "ana", "Luis", "maría"]
ordenados = sorted(nombres, key=str.casefold)

print(nombres)
print(ordenados)

sorted() devuelve una lista nueva. No modifica la colección original.

Para ordenar registros por más de un criterio, devuelve una tupla desde key:

registros = [
    {"estado": "INVÁLIDO", "nombre": "Sofía"},
    {"estado": "VÁLIDO", "nombre": "Ana"},
    {"estado": "INVÁLIDO", "nombre": "Carlos"},
]

ordenados = sorted(
    registros,
    key=lambda registro: (
        registro["estado"],
        registro["nombre"].casefold(),
    ),
)

Las funciones lambda se utilizarán aquí solamente cuando sean breves y claras. Se estudiarán con mayor profundidad en el Módulo 2.

reversed() produce un recorrido inverso:

codigos = ["COA-0001", "COA-0002", "COA-0003"]

for codigo in reversed(codigos):
    print(codigo)

No confundas invertir el recorrido con ordenar de mayor a menor. Para ordenar utiliza sorted(..., reverse=True).

Expresiones regulares esenciales

Una expresión regular describe un patrón de texto. Es apropiada cuando la regla depende de posiciones, cantidades o grupos de caracteres.

Regla:

El código debe comenzar con COA- y terminar con exactamente cuatro dígitos del 0 al 9.

Patrón:

COA-[0-9]{4}

Para comprobar el valor completo utiliza fullmatch():

import re

codigo = "COA-0042"
coincidencia = re.fullmatch(r"COA-[0-9]{4}", codigo)

print(coincidencia is not None)

La letra r crea una cadena cruda. Es la forma recomendada de escribir patrones porque evita que Python interprete muchas barras invertidas antes de que lleguen al módulo re.

re.fullmatch()

Comprueba que todo el texto coincida:

es_valido = re.fullmatch(r"COA-[0-9]{4}", "COA-0042") is not None

re.search()

Busca una coincidencia en cualquier parte:

texto = "El código asignado es COA-0042"
resultado = re.search(r"COA-[0-9]{4}", texto)

if resultado:
    print(resultado.group())

re.findall()

Devuelve todas las coincidencias:

texto = "Revisar COA-0001, COA-0007 y COA-0042"
codigos = re.findall(r"COA-[0-9]{4}", texto)
print(codigos)

re.sub()

Sustituye coincidencias:

texto = "Ana     Solís"
texto_limpio = re.sub(r"\s+", " ", texto).strip()

Para este último caso, " ".join(texto.split()) es probablemente más fácil de leer. La expresión regular aporta valor si la regla crece o necesita distinguir tipos concretos de caracteres.

No necesitas aprender expresiones regulares avanzadas. Utiliza patrones breves, documentados y acompañados por ejemplos válidos e inválidos.

Una solución profesional no es la que utiliza la herramienta más compleja. Es la que expresa la regla con claridad y se comporta correctamente.

Videos recomendados

Detén la reproducción para ejecutar los ejemplos y evita convertir el video en una actividad pasiva.

• 📖Métodos para cadenas de texto en Python — Aprende a Programar
• 📖¿Qué son las f-strings y cómo funcionan? — Enrique Barros

Después del video sobre f-strings, modifica un ejemplo para incluir ancho, alineación y dos decimales.

Documentación y recursos de lectura

No intentes leer cada página completa. Busca la firma, los parámetros, el retorno, las excepciones y uno o dos ejemplos.

• 📖Métodos del tipo `str`
• 📖Funciones integradas
• 📖Formateo de salida

• 📖Minilenguaje de formato
• 📖Módulo `re`
• 📖Guía oficial de expresiones regulares

• 📖Guía de funciones integradas — Real Python
• 📖Python Tutor: ejecución paso a paso

1. Abre la documentación de str.
2. Busca partition.
3. Identifica qué devuelve cuando el separador no existe.
4. Ejecuta el ejemplo en un archivo pequeño.
5. Modifica el separador y predice el resultado.
6. Escribe cuándo utilizarías el método.

Este proceso es más útil que memorizar una lista de métodos sin contexto.

Material descargable

El módulo incluye:

• datos_registros.py: registros del proyecto.
• plantilla_proyecto.py: estructura opcional con funciones pendientes.
• MATRIZ_VALIDACION.md: plantilla para definir reglas y casos.
• CHECKLIST_PROYECTO.md: comprobación previa a la entrega.

La plantilla no contiene la solución. Puedes empezar desde un archivo vacío si prefieres diseñar tu propia estructura.

⬇️Descargar todos los materiales del Módulo 1

⬇️Descargar datos_registros.py

⬇️Descargar plantilla_proyecto.py

⬇️Descargar MATRIZ_VALIDACION.md

⬇️Descargar CHECKLIST_PROYECTO.md

Errores comunes

texto.strip()

Las cadenas son inmutables. Guarda o devuelve el resultado.

title() aplica una regla mecánica. Documenta su uso y no asumas que representa correctamente todos los nombres.

rstrip() recibe un conjunto de caracteres finales; no un sufijo exacto.

Una limpieza agresiva puede ocultar un error. Corrige únicamente las diferencias autorizadas.

codigo, nombre, correo = registro.split("|")

La línea falla si el registro contiene otra cantidad. Comprueba len(partes) antes.

if texto.find("COA"):
    ...

Si la coincidencia comienza en la posición 0, el resultado se interpreta como falso. Si solo necesitas saber si existe, utiliza "COA" in texto.

Cuando una colección vacía no sea válida, combina bool(coleccion) con all(...).

Guarda el resultado devuelto o utiliza .sort() solo cuando quieras modificar la lista.

Los valores float son aproximados. Los cálculos monetarios se realizarán con Decimal en el Módulo 5.

Un patrón complejo puede ser más difícil de mantener que strip(), partition() o startswith().

Un sistema auditable conserva el valor original y comunica qué regla se incumplió.

Glosario

Resumen del módulo

Trabajar con texto profesionalmente no consiste en encadenar métodos al azar. Primero debes definir qué es ruido, qué transformación se permite y qué regla determina la validez.

Utilizaste métodos de cadenas para:

• limpiar espacios;
• normalizar comparaciones;
• comprobar prefijos y sufijos;
• dividir y reconstruir texto;
• validar características sencillas;
• conservar y mostrar el valor original.

También utilizaste funciones integradas para:

• calcular totales y extremos;
• comprobar reglas individuales y globales;
• ordenar sin modificar los datos originales;
• escribir soluciones más breves sin perder claridad.

Finalmente, aplicaste expresiones regulares a reglas donde un patrón exacto aporta valor y preferiste métodos normales cuando expresaban mejor la intención.

• Limpieza y normalización controlada de texto.
• Validación mediante reglas explícitas.
• Presentación alineada de resultados.
• Selección de funciones integradas.
• Uso esencial de expresiones regulares.
• Conservación de datos originales para auditoría.
• Diseño y prueba de un programa de procesamiento de registros.

• Puedo explicar la diferencia entre limpiar, transformar y validar.
• Puedo normalizar espacios sin destruir el valor original.
• Sé cuándo utilizar split() y cuándo partition().
• Puedo construir una salida alineada con f-strings.
• Comprendo los casos vacíos de any() y all().
• Puedo utilizar min(), max() y sorted() con key.
• Puedo explicar por qué round() puede sorprender.
• Sé cuándo una expresión regular aporta valor.
• Completé las actividades obligatorias.
• Obtuve al menos 70% en la evaluación.
• El proyecto fue aprobado.

Cuando cumplas estas condiciones, estarás preparado para el Módulo 2: Iteración y transformación expresiva.