Python · Lección 23 de 27

Strings avanzado

En la lección 12 cubrimos los métodos básicos. Ahora vamos al nivel avanzado: slicing profundo, expresiones regulares con re, encoding, raw strings y f-strings con expresiones complejas. Estas herramientas son las que usás para limpiar datos realmente sucios.

90–110 min Prerrequisitos: 12 Métodos de strings, 18 Funciones

Concepto teórico

Slicing profundo de strings

Los strings en Python son secuencias de caracteres y soportan el mismo slicing que las listas: string[inicio:fin:paso]. Algunos patrones útiles que no vimos antes:

Slice	Resultado (con `"ABCDEFGH"`)	Uso
`s[::2]`	`"ACEG"`	Caracteres en posición par
`s[::-1]`	`"HGFEDCBA"`	Invertir un string
`s[2:5]`	`"CDE"`	Extraer subcadena
`s[-4:]`	`"EFGH"`	Últimos 4 caracteres
`s[:4]`	`"ABCD"`	Primeros 4 caracteres

Recordá: los strings son inmutables. No podés hacer s[0] = "Z". Cada operación de slicing devuelve un nuevo string.

Repetición y multiplicación de strings

El operador * repite un string: "─" * 40 genera una línea de 40 guiones. Muy útil para formatear reportes y separadores.

Multiline strings y raw strings

Triple comillas ("""...""" o '''...''') permiten strings que ocupan varias líneas, preservando saltos de línea y espacios:

consulta_sql = """
SELECT nombre, score, saldo
FROM clientes
WHERE score >= 650
ORDER BY saldo DESC
"""

Raw strings (r"...") no interpretan escapes. Son esenciales para regex y paths de Windows:

normal = "C:\nueva\carpeta"   # \n se interpreta como salto de línea!
raw = r"C:\nueva\carpeta"     # se mantiene literal
regex = r"\d{2}-\d{8}-\d"     # patrón de CUIT sin escapar

Encoding: UTF-8, Latin-1 y el caos de la Ñ

Los strings de Python 3 son Unicode nativamente. Pero cuando leés archivos de otras fuentes (Excel viejos, CSVs de sistemas legacy), podés encontrarte con encodings distintos:

UTF-8: estándar universal. Soporta todos los caracteres. Siempre preferí UTF-8.
Latin-1 (ISO 8859-1): viejo estándar europeo. Muchos CSVs argentinos vienen en Latin-1 porque los sistemas legacy lo usaban. La Ñ, las tildes y los signos de peso funcionan, pero otros caracteres no.
ASCII: solo inglés básico. Sin tildes, sin Ñ, sin ñ. Limitadísimo.

Error clásico de encoding: UnicodeDecodeError al leer un CSV. Esto pasa cuando el archivo está en Latin-1 pero Python intenta leerlo como UTF-8. Solución: pd.read_csv("archivo.csv", encoding="latin-1"). En datos argentinos, esto pasa MUY seguido con exports de MERCAP, SINENSUP y sistemas bancarios legacy.

Expresiones regulares (regex) con el módulo re

Las expresiones regulares son patrones que describen texto. Son la herramienta más poderosa para buscar, extraer y reemplazar patrones complejos en strings. El módulo re de Python las implementa.

Patrón	Significado	Ejemplo match
`\d`	Un dígito (0-9)	`"5"`
`\d{8}`	Exactamente 8 dígitos	`"12345678"`
`\w`	Letra, dígito o _	`"a"`, `"3"`, `"_"`
`\s`	Espacio, tab, newline	`" "`
`.`	Cualquier carácter (excepto newline)	`"x"`
`+`	1 o más del anterior	`\d+` → `"123"`
`*`	0 o más del anterior	`\d*` → `""` o `"5"`
`?`	0 o 1 del anterior	`\d?` → `""` o `"5"`
`[abc]`	Cualquiera de a, b, c	`"a"`
`(grupo)`	Captura un grupo	Extraer partes del match
`^`	Inicio del string	—
`$`	Fin del string	—

Las funciones principales de re:

re.search(patron, texto) — busca la primera coincidencia en cualquier parte
re.match(patron, texto) — busca solo al INICIO del string
re.findall(patron, texto) — devuelve TODAS las coincidencias como lista
re.sub(patron, reemplazo, texto) — reemplaza todas las coincidencias
re.compile(patron) — pre-compila un patrón para uso repetido (más rápido)

Siempre usá raw strings para regex: r"\d{2}-\d{8}-\d". Sin el r, Python interpreta \d como un escape (que no existe) y puede dar resultados inesperados. Con r, el patrón llega intacto al motor de regex.

En análisis de datos: regex es indispensable para: (1) extraer CUITs, teléfonos, emails de texto libre, (2) limpiar montos con formatos mixtos ($1.500,00 vs 1500.00 vs $1,500), (3) validar formatos de datos, (4) parsear logs y archivos semi-estructurados. En pandas: df["col"].str.extract(r"patron") usa regex directamente.

Tip: no necesitás memorizar toda la sintaxis de regex. Lo que necesitás es saber que existe, y usar regex101.com para construir y testear patrones interactivamente. Es la herramienta más útil para regex.

Ejemplos explicados paso a paso

Ejemplo 1: Slicing avanzado y manipulación

ejemplo_01_slicing.pyPython

# Slicing avanzado
cbu = "2850590940090418135201"
print(f"CBU completo: {cbu}")
print(f"Banco (3 primeros): {cbu[:3]}")
print(f"Sucursal (4-6): {cbu[3:7]}")
print(f"Verificador (último): {cbu[-1]}")
print(f"Invertido: {cbu[::-1]}")

# Extraer partes de un CUIT
cuit = "20-12345678-9"
prefijo = cuit[:2]
cuerpo = cuit[3:11]
verificador = cuit[-1]
print(f"\nCUIT: {cuit}")
print(f"  Prefijo: {prefijo}, Cuerpo: {cuerpo}, Verificador: {verificador}")

# Verificar palíndromo
def es_palindromo(texto):
    limpio = texto.lower().replace(" ", "")
    return limpio == limpio[::-1]

palabras = ["reconocer", "Python", "anilina", "hola"]
for p in palabras:
    print(f"  '{p}' → {'✅ palíndromo' if es_palindromo(p) else '❌'}")

# Repetición para formato
print(f"\n{'═' * 40}")
print(f"{'REPORTE':^40}")
print(f"{'═' * 40}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Raw strings, multiline y encoding

ejemplo_02_raw_multiline.pyPython

# Multiline string: SQL query
query = """
SELECT c.nombre, c.score, s.saldo
FROM clientes c
JOIN saldos s ON c.id = s.cliente_id
WHERE c.score >= 650
ORDER BY s.saldo DESC
LIMIT 10
"""
print("SQL Query:")
print(query)

# Raw string: path de Windows sin problemas
# Sin r, \n se interpreta como salto de línea
normal = "C:\\Users\\nombre\\datos"   # hay que escapar cada \
raw = r"C:\Users\nombre\datos"       # mucho más limpio
print(f"Normal: {normal}")
print(f"Raw: {raw}")

# Encoding: convertir entre bytes y string
texto = "¡Hola, señor González! — Ñandú café"
print(f"\nTexto original: {texto}")

# Codificar a bytes
utf8_bytes = texto.encode("utf-8")
latin1_bytes = texto.encode("latin-1")
print(f"UTF-8 bytes: {len(utf8_bytes)} bytes")
print(f"Latin-1 bytes: {len(latin1_bytes)} bytes")

# Decodificar
print(f"Decodificado: {utf8_bytes.decode('utf-8')}")

# Verificar si un string tiene caracteres especiales
for char in texto:
    if ord(char) > 127:
        print(f"  Carácter especial: '{char}' → Unicode {ord(char)}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Regex básico — search, findall, sub

ejemplo_03_regex_basico.pyPython

import re

# re.search: buscar la primera coincidencia
texto = "El cliente García tiene CUIT 20-30123456-9 y vive en BsAs"

# Buscar un patrón de CUIT
match = re.search(r"\d{2}-\d{8}-\d", texto)
if match:
    print(f"CUIT encontrado: {match.group()}")
    print(f"Posición: {match.start()}-{match.end()}")

# re.findall: encontrar TODAS las coincidencias
texto2 = "Montos: $1500, $3200, $800 y $12000"
numeros = re.findall(r"\d+", texto2)
print(f"\nNúmeros encontrados: {numeros}")
print(f"Como ints: {[int(n) for n in numeros]}")

# re.sub: reemplazar con patrón
# Limpiar todo lo que no sea dígito o punto
monto_sucio = "$1,250,000.50"
monto_limpio = re.sub(r"[^0-9.]", "", monto_sucio)
print(f"\nLimpiar '{monto_sucio}' → '{monto_limpio}' → {float(monto_limpio)}")

# Ocultar datos sensibles
dni = "El DNI es 30123456 del cliente"
oculto = re.sub(r"\d{8}", "XXXXXXXX", dni)
print(f"Original: {dni}")
print(f"Oculto: {oculto}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Regex con grupos — extraer datos estructurados

ejemplo_04_regex_grupos.pyPython

import re

# Extraer partes de un CUIT con grupos de captura
cuits = ["20-30123456-9", "27-28765432-1", "30-71234567-5", "abc-123-x"]

patron_cuit = re.compile(r"^(\d{2})-(\d{8})-(\d)$")

print("=== Validación de CUITs ===")
for cuit in cuits:
    match = patron_cuit.match(cuit)
    if match:
        prefijo, cuerpo, verif = match.groups()
        tipo = "Persona" if prefijo in ("20", "23", "24", "27") else "Empresa"
        print(f"  ✅ {cuit} → {tipo} (cuerpo: {cuerpo})")
    else:
        print(f"  ❌ {cuit} → Formato inválido")

# Extraer emails de texto libre
texto = """
Contactos: garcia@banco.com.ar, lópez123@gmail.com
Soporte: soporte@empresa.com — info@cia.net
"""
emails = re.findall(r"[\w.+-]+@[\w.-]+\.\w+", texto)
print(f"\nEmails encontrados:")
for email in emails:
    print(f"  📧 {email}")

# Extraer montos con formato AR$ o $
texto_montos = "Factura A: $1,500.00 — Factura B: AR$23,450 — Factura C: 8000"
montos = re.findall(r"(?:AR)?\$?([\d,]+\.?\d*)", texto_montos)
print(f"\nMontos extraídos: {montos}")
limpios = [float(m.replace(",", "")) for m in montos]
print(f"Como floats: {limpios}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: f-strings con expresiones complejas

ejemplo_05_fstrings_avanzado.pyPython

# f-strings con expresiones dentro
nombre = "García"
score = 720

# Operador ternario dentro de f-string
print(f"Categoría: {'Premium' if score >= 700 else 'Estándar'}")

# Llamada a función dentro de f-string
print(f"Nombre: {nombre.upper()}")
print(f"Largo: {len(nombre)} caracteres")

# f-string con = (debug mode, Python 3.8+)
x = 42
y = 3.14
print(f"{x = }")        # imprime "x = 42"
print(f"{y = :.1f}")    # imprime "y = 3.1"

# Expresiones complejas
saldos = [150000, 320000, 45000]
print(f"\nTotal: ${sum(saldos):,}")
print(f"Promedio: ${sum(saldos)/len(saldos):,.0f}")

# Formato condicional del signo
cambios = [5.2, -3.1, 0, 8.7, -1.5]
print(f"\nCambios:")
for c in cambios:
    color = "🟢" if c > 0 else "🔴" if c < 0 else "⚪"
    print(f"  {color} {c:+.1f}%")

# Multiline f-string para reportes
cliente = {"nombre": "García", "score": 720, "saldo": 150000}
reporte = f"""
╔══════════════════════════════╗
║  Cliente: {cliente['nombre']:<18} ║
║  Score: {cliente['score']:<20} ║
║  Saldo: ${cliente['saldo']:>18,} ║
╚══════════════════════════════╝"""
print(reporte)

Hacé clic en ▶ Ejecutar

Referencia rápida

Función re	Qué hace	Devuelve
`re.search(p, t)`	Busca primera coincidencia	Match object o None
`re.match(p, t)`	Busca solo al inicio	Match object o None
`re.findall(p, t)`	Todas las coincidencias	Lista de strings
`re.sub(p, r, t)`	Reemplaza coincidencias	Nuevo string
`re.split(p, t)`	Divide por patrón	Lista
`re.compile(p)`	Pre-compila patrón	Pattern object

Regex patrón	Significado	Ejemplo
`\d`	Dígito	`"5"`
`\d+`	1+ dígitos	`"123"`
`\d{8}`	Exactamente 8 dígitos	`"12345678"`
`\w+`	Palabra (letras/dígitos/_)	`"hola_42"`
`\s`	Espacio/tab	`" "`
`[^0-9]`	Todo excepto dígitos	`"$", ","`
`(grupo)`	Capturar grupo	`match.group(1)`
`^...$`	Inicio a fin (exacto)	Validación completa

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Invertir un string

Dado texto = "Python", invertilo con slicing. Debe incluir nohtyP.

ejercicio_01.pyDebe incluir "nohtyP"

texto = "Python"

# Invertí:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Extraer partes de un CBU

Dado cbu = "2850590940090418135201", extraé los 3 primeros dígitos (banco), los siguientes 4 (sucursal) y el último (verificador). Debe incluir 285.

ejercicio_02.pyDebe incluir "285"

cbu = "2850590940090418135201"

# Extraé con slicing:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: re.findall para extraer números

Dado "Ventas: $1500, $3200, $800", extraé todos los números con re.findall(). Debe incluir 3200.

ejercicio_03.pyDebe incluir "3200"

import re
texto = "Ventas: $1500, $3200, $800"

# Extraé números:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Validar CUIT con regex

Creá una función validar_cuit(cuit) que use regex para verificar formato XX-XXXXXXXX-X. Probá con "20-30123456-9" (válido) y "abc-123-x" (inválido). Debe incluir True.

ejercicio_04.pyDebe incluir "True"

import re

def validar_cuit(cuit):
    pass  # usá re.match con un patrón

print(validar_cuit("20-30123456-9"))
print(validar_cuit("abc-123-x"))

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: re.sub para limpiar montos

Dado "$1,250,000.50", usá re.sub() para eliminar todo excepto dígitos y punto. Convertí a float. Debe incluir 1250000.5.

ejercicio_05.pyDebe incluir "1250000.5"

import re
monto = "$1,250,000.50"

# Limpiá con re.sub:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Extraer emails con regex

Dado un texto con 3 emails, extraelos todos con re.findall(). Debe incluir @.

ejercicio_06.pyDebe incluir "@"

import re
texto = "Contactar a garcia@banco.com, info@empresa.com.ar o soporte@mail.net"

# Extraé emails:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Regex con grupos para parsear CUIT

Usá grupos de captura (\d{2})-(\d{8})-(\d) para extraer las 3 partes de "20-30123456-9". Debe incluir 30123456.

ejercicio_07.pyDebe incluir "30123456"

import re
cuit = "20-30123456-9"

# Extraé las partes con grupos:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Ocultar datos sensibles con re.sub

Dado "DNI 30123456, Tel +54-11-4567-8901", ocultar el DNI con X y los últimos 4 dígitos del teléfono con *. Debe incluir XXXXXXXX.

ejercicio_08.pyDebe incluir "XXXXXXXX"

import re
texto = "DNI 30123456, Tel +54-11-4567-8901"

# Ocultar datos sensibles:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Limpiar lista de montos con formatos mixtos

Tenés ["$1,500.00", "AR$23.450", "1500", "$-200", "N/A"]. Usá regex para extraer el valor numérico de cada uno, ignorando los inválidos. Debe incluir Total.

ejercicio_09.pyDebe incluir "Total"

import re
montos_crudos = ["$1,500.00", "AR$23.450", "1500", "$-200", "N/A"]

# Limpiá y sumá:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Parser de registros con regex completo

Dado un texto con registros semi-estructurados, extraé nombre, CUIT y monto de cada línea usando regex con grupos. Armá una lista de diccionarios. Debe incluir registros.

ejercicio_10_desafio.pyDebe incluir "registros"

import re

texto = """
Cliente: García, CUIT: 20-30123456-9, Monto: $150,000
Cliente: López, CUIT: 27-28765432-1, Monto: $320,000
Cliente: Pérez, CUIT: 20-40123456-7, Monto: $890,000
"""

# Parseá cada línea con regex:
print(f"=== {len(texto.strip().splitlines())} registros ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Slicing de strings: [::-1] invierte, [:3] primeros 3, [-4:] últimos 4.
Raw strings (r"...") son esenciales para regex y paths de Windows.
Multiline strings ("""...""") preservan saltos de línea — ideales para SQL queries.
Encoding: UTF-8 por defecto. Si un CSV falla, probá encoding="latin-1".
re.findall() extrae coincidencias, re.sub() reemplaza, re.match() valida.
Siempre usá raw strings para patrones regex: r"\d{2}-\d{8}-\d".
f-strings admiten expresiones, llamadas a funciones y operadores ternarios.

En la siguiente lección (24 · Archivos) vas a aprender a leer y escribir archivos: texto, CSV, JSON y Excel. El puente entre tu código y los datos del mundo real.

Recursos: Python docs — re · regex101.com (tester)

Hecho con ❤️ por Rodri Gonzalez