Strings y formateo

Manipulación y métodos de strings

Los strings en Python ofrecen una amplia gama de métodos integrados que permiten manipular y transformar texto de forma eficiente. Estos métodos son fundamentales para el procesamiento de datos, la limpieza de entradas de usuario y la preparación de texto para diferentes propósitos.

Separación de texto con split()

El método split() divide un string en una lista de elementos basándose en un separador específico. Este método resulta especialmente útil cuando trabajamos con datos estructurados o necesitamos procesar texto por partes.

# Separar por espacios (comportamiento por defecto)
frase = "Python es un lenguaje versátil"
palabras = frase.split()
print(palabras)  # ['Python', 'es', 'un', 'lenguaje', 'versátil']

# Separar por un carácter específico
email = "usuario@empresa.com"
partes = email.split("@")
print(partes)  # ['usuario', 'empresa.com']

# Procesar una línea CSV simple
datos = "Juan,25,Madrid,Ingeniero"
campos = datos.split(",")
print(f"Nombre: {campos[0]}, Edad: {campos[1]}")  # Nombre: Juan, Edad: 25

El método split() también acepta un parámetro opcional que limita el número de divisiones:

texto = "uno-dos-tres-cuatro-cinco"
resultado = texto.split("-", 2)  # Máximo 2 divisiones
print(resultado)  # ['uno', 'dos', 'tres-cuatro-cinco']

Unión de elementos con join()

El método join() realiza la operación inversa a split(), combinando elementos de una lista en un único string utilizando un separador determinado. Este enfoque es más eficiente que la concatenación repetitiva para múltiples elementos.

# Unir palabras con espacios
palabras = ["Python", "es", "genial"]
frase = " ".join(palabras)
print(frase)  # "Python es genial"

# Crear rutas de archivo
carpetas = ["home", "usuario", "documentos", "proyecto"]
ruta = "/".join(carpetas)
print(ruta)  # "home/usuario/documentos/proyecto"

# Generar código HTML simple
elementos = ["<li>Inicio</li>", "<li>Productos</li>", "<li>Contacto</li>"]
menu = "\n".join(elementos)
print(menu)

Sustitución de texto con replace()

El método replace() permite sustituir todas las ocurrencias de una subcadena por otra. Es fundamental para la limpieza y normalización de datos textuales.

# Limpiar datos de entrada
telefono = "91-123-45-67"
telefono_limpio = telefono.replace("-", "")
print(telefono_limpio)  # "911234567"

# Normalizar texto
mensaje = "Hola, cómo estás???"
mensaje_limpio = mensaje.replace("???", "?").replace(",,", ",")
print(mensaje_limpio)  # "Hola, cómo estás?"

# Preparar texto para URLs
titulo = "Mi Primer Artículo en Python"
url_slug = titulo.replace(" ", "-").lower()
print(url_slug)  # "mi-primer-artículo-en-python"

El método replace() también acepta un tercer parámetro para limitar el número de reemplazos:

texto = "casa casa casa"
resultado = texto.replace("casa", "hogar", 2)  # Solo 2 reemplazos
print(resultado)  # "hogar hogar casa"

Eliminación de espacios con strip()

Los métodos de la familia strip() eliminan caracteres no deseados de los extremos de un string, siendo especialmente útiles para limpiar datos de entrada del usuario.

# Limpiar espacios en blanco
nombre = "   Ana García   "
nombre_limpio = nombre.strip()
print(f"'{nombre_limpio}'")  # 'Ana García'

# Limpiar solo del lado izquierdo
texto = "   Contenido importante"
texto_limpio = texto.lstrip()
print(f"'{texto_limpio}'")  # 'Contenido importante'

# Limpiar solo del lado derecho
texto = "Datos relevantes   "
texto_limpio = texto.rstrip()
print(f"'{texto_limpio}'")  # 'Datos relevantes'

También podemos especificar qué caracteres eliminar:

# Eliminar caracteres específicos
codigo = "###PYTHON###"
codigo_limpio = codigo.strip("#")
print(codigo_limpio)  # "PYTHON"

# Limpiar múltiples caracteres
datos = "...***Información importante***..."
datos_limpios = datos.strip(".*")
print(datos_limpios)  # "Información importante"

Transformaciones de caso

Los métodos de transformación de caso modifican la capitalización del texto, útiles para normalizar datos y mejorar la presentación.

# Conversiones básicas
texto = "Python Programming"
print(texto.lower())    # "python programming"
print(texto.upper())    # "PYTHON PROGRAMMING"
print(texto.swapcase()) # "pYTHON pROGRAMMING"

# Capitalización de títulos
titulo = "manual de python para principiantes"
print(titulo.title())       # "Manual De Python Para Principiantes"
print(titulo.capitalize())  # "Manual de python para principiantes"

Búsqueda y verificación de contenido

Python proporciona métodos para buscar subcadenas y verificar características específicas del texto:

# Buscar posiciones
email = "contacto@empresa.com"
posicion = email.find("@")
print(posicion)  # 8

# Verificar si contiene una subcadena
if "empresa" in email:
    print("Es un email corporativo")

# Verificaciones de tipo de contenido
codigo = "ABC123"
print(codigo.isalnum())   # True (solo letras y números)
print(codigo.isalpha())   # False (contiene números)
print("12345".isdigit())  # True (solo dígitos)

Aplicación práctica: procesamiento de datos de usuario

Veamos un ejemplo que combina varios métodos para procesar información de entrada:

# Simulamos datos de entrada de un formulario
entrada_usuario = "  Juan Carlos,  Madrid , 28 años  "

# Limpieza y procesamiento
datos_limpios = entrada_usuario.strip()
campos = datos_limpios.split(",")

# Procesar cada campo
nombre = campos[0].strip().title()
ciudad = campos[1].strip().title() 
edad_texto = campos[2].strip().replace(" años", "")

# Resultado procesado
print(f"Nombre: {nombre}")     # Nombre: Juan Carlos
print(f"Ciudad: {ciudad}")     # Ciudad: Madrid
print(f"Edad: {edad_texto}")   # Edad: 28

Estos métodos de manipulación de strings forman la base para el procesamiento efectivo de texto en Python. Su dominio permite crear aplicaciones más robustas que manejan datos textuales de manera consistente y profesional, preparando el terreno para técnicas más avanzadas de formateo que veremos en las siguientes secciones.

Formateo con .format() y f-strings

El formateo de strings permite incrustar valores dentro de plantillas de texto de forma legible y controlada. Dominarlo acelera la generación de mensajes, informes o interfaces de línea de comandos, eliminando concatenaciones manuales propensas a errores.

Plantillas con .format()

El método .format() fue durante años la opción estándar en Python para combinar texto y variables. Funciona mediante marcadores de posición dentro de llaves.

plantilla = "Hola, {}. Bienvenido a {}."
mensaje = plantilla.format("Laura", "Python Universidad")
print(mensaje)  # "Hola, Laura. Bienvenido a Python Universidad."

Las llaves admiten índices o nombres que mejoran la claridad:

plantilla = "Producto: {0} | Precio: {1}€"
print(plantilla.format("Teclado", 29.99))

plantilla_nom = "Usuario: {nombre} | Ciudad: {ciudad}"
print(plantilla_nom.format(nombre="Ana", ciudad="Sevilla"))

Para controlar la presentación numérica se utilizan especificadores tras dos puntos.

unidades = 3
precio_unitario = 7.456
ticket = "Total: {0} × {1:.2f}€ = {total:.2f}€".format(
    unidades, precio_unitario, total=unidades * precio_unitario
)
print(ticket)  # "Total: 3 × 7.46€ = 22.37€"

Especificadores útiles:

• .2f → redondea a dos decimales.
• ,d → agrupa miles con comas.
• >10 → alinea a la derecha ocupando 10 caracteres.

Ejemplo de tabla alineada:

cabecera = "{:<10} {:>8}".format("Artículo", "Importe")
linea    = "{:<10} {:>8.2f}".format("Ratón", 12.5)
print(cabecera)
print(linea)

Evolución a f-strings

Desde Python 3.6, las f-strings ofrecen una sintaxis más concisa y veloz. Se antepone la letra f al string e incrustamos expresiones directamente.

nombre = "Carlos"
curso = "Python avanzado"
print(f"Hola, {nombre}. Disfruta de {curso}.")

Ventajas clave:

• Inserción directa de expresiones: f"{2 + 3=}" genera 2 + 3=5.
• Mismos especificadores que .format(), pero en línea.
• Mejor rendimiento al evitar búsquedas internas.

Formateo numérico y de texto

precio = 1999.9
iva = 0.21
print(f"Subtotal: {precio:,.2f}€")                # "1,999.90€"
print(f"IVA ({iva:%}): {(precio*iva):.2f}€")       # "IVA (21.000000%): 420.00€"

Para alinear columnas:

for i in range(1, 4):
    print(f"{i:<3} | {i**3:>5}")
# 1   |     1
# 2   |     8
# 3   |    27

Expresiones en tiempo real

Las f-strings permiten evaluar llamadas a funciones sin abandonar la plantilla.

def iniciales(nombre_completo: str) -> str:
    return "".join(p[0] for p in nombre_completo.split())

usuario = "María del Mar"
print(f"Identificador: {iniciales(usuario).upper()}_{len(usuario)}")

Debugging con el operador =

Python 3.8 introdujo el operador de depuración dentro de f-strings:

temperatura = 23.5678
print(f"{temperatura=:.1f}")  # "temperatura=23.6"

El intérprete muestra la expresión y su valor ya formateado, útil durante pruebas sin imprimir etiquetas manuales.

Caso práctico: plantilla de correo

Problema: enviar un correo de factura con total calculado dinámicamente.

cliente = "Silvia"
articulo = "Auriculares"
unidades = 2
precio_unit = 58.75

cuerpo = f"""
Hola, {cliente}:

Gracias por tu compra de {unidades} × {articulo}.
Importe neto : {unidades * precio_unit:.2f} €
IVA (21%)    : {(unidades * precio_unit)*0.21:.2f} €
Total        : {(unidades * precio_unit)*1.21:.2f} €

Saludos,
Tienda Electro
""".strip()

print(cuerpo)

Diagrama conceptual (texto):

[ variables ] ─▶ [ plantilla f-string multilínea ] ─▶ [ string final listo para envío ]

Este flujo muestra cómo los datos se inyectan en la plantilla para producir el mensaje completo sin pasos intermedios de concatenación.

Cuándo usar cada opción

• .format()

• Necesitas plantillas definidas antes de conocer los valores.
• Generas mensajes a partir de diccionarios o listas existentes.

• f-strings

• Prefieres claridad y menor código de soporte.
• Requieres expresiones evaluadas al vuelo o depuración con =.

En la mayoría de los casos actuales, f-strings son la elección recomendada por su legibilidad y prestaciones. Sin embargo, comprender .format() resulta valioso para mantener código legado o librerías que aún lo emplean.

Operaciones avanzadas con strings

Las operaciones avanzadas con strings van más allá de los métodos básicos, ofreciendo herramientas especializadas para el procesamiento complejo de texto. Estas técnicas resultan especialmente útiles cuando trabajamos con datos estructurados, análisis de contenido o preparación de texto para diferentes formatos.

Segmentación avanzada con slicing

El slicing permite extraer porciones específicas de un string usando índices y rangos. Esta técnica es fundamental para procesar datos con formatos fijos o extraer información de posiciones conocidas.

# Extraer partes específicas de códigos
codigo_producto = "PY2024-001-XL"
categoria = codigo_producto[:6]        # "PY2024"
numero = codigo_producto[7:10]         # "001" 
talla = codigo_producto[11:]           # "XL"

print(f"Categoría: {categoria}, Número: {numero}, Talla: {talla}")

El slicing con paso negativo permite invertir strings o extraer caracteres alternos:

# Invertir texto
texto = "Python"
texto_invertido = texto[::-1]          # "nohtyP"

# Extraer caracteres alternos
mensaje = "HoElLaO"
resultado = mensaje[::2]               # "HELa" (posiciones 0,2,4,6)
oculto = mensaje[1::2]                 # "oLO" (posiciones 1,3,5)

Partición inteligente con partition()

Los métodos partition() y rpartition() dividen un string en exactamente tres partes: antes del separador, el separador mismo, y después del separador. Esta aproximación es más predecible que split() cuando necesitamos un número fijo de elementos.

# Separar nombre de dominio
email = "soporte.tecnico@empresa.com"
usuario, separador, dominio = email.partition("@")
print(f"Usuario: '{usuario}', Dominio: '{dominio}'")
# Usuario: 'soporte.tecnico', Dominio: 'empresa.com'

# Procesar rutas de archivo
ruta = "/home/usuario/documentos/archivo.txt"
directorio, sep, archivo = ruta.rpartition("/")
print(f"Directorio: {directorio}")     # "/home/usuario/documentos"
print(f"Archivo: {archivo}")           # "archivo.txt"

La diferencia clave con rpartition() es que busca desde la derecha, útil cuando el separador aparece múltiples veces:

# Separar extensión de archivo
nombre_completo = "backup.datos.2024.tar.gz"
nombre, sep, extension = nombre_completo.rpartition(".")
print(f"Nombre: {nombre}")             # "backup.datos.2024.tar"
print(f"Extensión: {extension}")       # "gz"

Procesamiento de texto multilínea

El método splitlines() divide texto en líneas individuales, manejando automáticamente diferentes tipos de saltos de línea. Es especialmente útil para procesar archivos de configuración o datos estructurados.

# Procesar configuración multilínea
config_texto = """servidor=192.168.1.100
puerto=8080
debug=true
timeout=30"""

lineas = config_texto.splitlines()
configuracion = {}

for linea in lineas:
    if "=" in linea:
        clave, valor = linea.split("=", 1)  # Máximo 1 división
        configuracion[clave] = valor

print(configuracion)
# {'servidor': '192.168.1.100', 'puerto': '8080', 'debug': 'true', 'timeout': '30'}

Para formatear texto multilínea, podemos combinar splitlines() con otros métodos:

texto_crudo = """   Línea uno
    Línea dos con espacios
Línea tres   """

# Limpiar cada línea individualmente
lineas_limpias = [linea.strip() for linea in texto_crudo.splitlines() if linea.strip()]
texto_limpio = "\n".join(lineas_limpias)
print(texto_limpio)

Verificaciones múltiples con startswith() y endswith()

Estos métodos aceptan tuplas de opciones, permitiendo verificar múltiples condiciones simultáneamente:

# Filtrar archivos por extensión
archivos = ["documento.pdf", "imagen.jpg", "datos.csv", "backup.tar.gz", "script.py"]

documentos = [archivo for archivo in archivos 
              if archivo.endswith(('.pdf', '.doc', '.txt'))]

imagenes = [archivo for archivo in archivos 
            if archivo.endswith(('.jpg', '.png', '.gif'))]

print(f"Documentos: {documentos}")     # ['documento.pdf']
print(f"Imágenes: {imagenes}")         # ['imagen.jpg']

También funciona para prefijos:

# Clasificar URLs por protocolo
urls = ["https://ejemplo.com", "ftp://servidor.com", "http://sitio.org"]

seguras = [url for url in urls if url.startswith(('https://', 'sftp://'))]
print(f"URLs seguras: {seguras}")      # ['https://ejemplo.com']

Traducción de caracteres con translate()

El método translate() permite reemplazar caracteres individuales de forma eficiente usando una tabla de traducción creada con maketrans().

# Limpiar caracteres especiales de nombres de archivo
texto = "Mi Documento (versión 2.1).txt"
caracteres_problema = "()."
tabla = str.maketrans(caracteres_problema, "___")
nombre_limpio = texto.translate(tabla)
print(nombre_limpio)                   # "Mi Documento _versión 2_1__txt"

Para eliminar caracteres completamente, usamos el tercer parámetro:

# Eliminar acentos básicos para URLs
texto = "Artículo sobre programación"
acentos = "áéíóúüñ"
sin_acentos = "aeiouun"
tabla = str.maketrans(acentos, sin_acentos)
resultado = texto.translate(tabla)
print(resultado)                       # "Articulo sobre programacion"

Centrado y relleno de texto

Los métodos center(), ljust() y rjust() permiten alinear texto dentro de un ancho específico:

# Crear encabezados centrados
titulo = "REPORTE MENSUAL"
print(titulo.center(50, "="))          # "==================REPORTE MENSUAL=================="

# Formatear tabla de datos
productos = [("Teclado", "29.99"), ("Ratón", "15.50"), ("Monitor", "199.00")]

print("PRODUCTO".ljust(15) + "PRECIO".rjust(10))
print("-" * 25)

for nombre, precio in productos:
    linea = nombre.ljust(15) + f"{precio}€".rjust(10)
    print(linea)

Aplicación práctica: análisis de logs

Veamos un ejemplo que combina varias operaciones avanzadas para procesar registros de un servidor web:

# Simular líneas de log de servidor
log_entrada = """192.168.1.100 - - [10/Dec/2024:13:55:36] "GET /api/usuarios HTTP/1.1" 200 1234
192.168.1.101 - - [10/Dec/2024:13:55:42] "POST /api/login HTTP/1.1" 401 567
192.168.1.102 - - [10/Dec/2024:13:55:48] "GET /dashboard HTTP/1.1" 200 8901"""

estadisticas = {"GET": 0, "POST": 0, "errores": 0}

for linea in log_entrada.splitlines():
    # Extraer IP (hasta el primer espacio)
    ip, _, resto = linea.partition(" ")
    
    # Buscar método HTTP
    if '"GET' in linea:
        estadisticas["GET"] += 1
    elif '"POST' in linea:
        estadisticas["POST"] += 1
    
    # Detectar errores (códigos 4xx y 5xx)
    partes = linea.split()
    if len(partes) >= 9:  # Verificar formato válido
        codigo_estado = partes[8]
        if codigo_estado.startswith(('4', '5')):
            estadisticas["errores"] += 1

print("=== ESTADÍSTICAS DEL SERVIDOR ===".center(40))
for metrica, valor in estadisticas.items():
    print(f"{metrica.upper()}:".ljust(15) + str(valor).rjust(5))

Estas operaciones avanzadas proporcionan el control preciso necesario para manipular texto complejo, procesar datos estructurados y generar salidas formateadas profesionales. Su dominio permite crear herramientas de procesamiento de texto robustas que manejan casos especiales y formatos diversos de manera eficiente.