Python · Lección 12 de 27

Métodos de strings

Los strings tienen más de 40 métodos incorporados para transformar, buscar, dividir, unir y validar texto. En análisis de datos, limpiar texto es fácilmente el 30% de tu trabajo. Esta lección te da todas las herramientas.

90–120 min Prerrequisitos: 03 Tipos de datos, 04 Variables

Concepto teórico

¿Qué es un método?

Un método es una función que pertenece a un objeto. Se invoca con la sintaxis objeto.metodo(). Los strings tienen decenas de métodos incorporados que te permiten transformarlos sin necesidad de importar nada. Como los strings son inmutables, cada método devuelve un nuevo string — el original no se modifica.

Regla de oro de strings: como son inmutables, nombre.upper() NO modifica nombre. Devuelve un nuevo string. Si querés guardar el resultado, tenés que reasignar: nombre = nombre.upper().

Métodos de transformación de mayúsculas/minúsculas

Método	Qué hace	Ejemplo	Resultado
`.upper()`	Todo a mayúsculas	`"hola".upper()`	`"HOLA"`
`.lower()`	Todo a minúsculas	`"HOLA".lower()`	`"hola"`
`.title()`	Primera letra de cada palabra en mayúscula	`"hola mundo".title()`	`"Hola Mundo"`
`.capitalize()`	Solo la primera letra del string	`"hola mundo".capitalize()`	`"Hola mundo"`
`.swapcase()`	Intercambia mayúsculas y minúsculas	`"HoLa".swapcase()`	`"hOlA"`
`.casefold()`	Minúsculas agresivo (para comparaciones)	`"straße".casefold()`	`"strasse"`

En limpieza de datos: los campos de texto vienen en formatos caóticos: "GARCÍA", "garcía", "García", " garcía ". Normalizar con .strip().title() o .strip().upper() es el primer paso de cualquier pipeline de limpieza. En pandas: df["nombre"] = df["nombre"].str.strip().str.title().

Métodos de limpieza (strip)

Método	Qué hace	Ejemplo	Resultado
`.strip()`	Elimina espacios al inicio y final	`" hola ".strip()`	`"hola"`
`.lstrip()`	Elimina espacios a la izquierda	`" hola ".lstrip()`	`"hola "`
`.rstrip()`	Elimina espacios a la derecha	`" hola ".rstrip()`	`" hola"`
`.strip("$")`	Elimina carácter específico	`"$$100$$".strip("$")`	`"100"`

Error común: los datos de CSV/Excel suelen tener espacios invisibles al inicio o final. Si comparás "García" con "García " (con espacio), Python dice que son distintos. .strip() es la primera defensa contra este problema.

Métodos de búsqueda y reemplazo

Método	Qué hace	Devuelve
`.find(sub)`	Posición de la primera ocurrencia	`int` (o `-1` si no existe)
`.rfind(sub)`	Posición de la última ocurrencia	`int` (o `-1`)
`.index(sub)`	Como find, pero da error si no existe	`int` (o `ValueError`)
`.count(sub)`	Cuántas veces aparece	`int`
`.replace(old, new)`	Reemplaza todas las ocurrencias	Nuevo string
`.startswith(prefix)`	¿Empieza con este texto?	`True/False`
`.endswith(suffix)`	¿Termina con este texto?	`True/False`

Split y Join: dividir y unir

Probablemente los dos métodos de string más importantes para análisis de datos:

.split(separador) — divide un string en una lista usando el separador. Si no pasás separador, divide por cualquier espacio en blanco.
separador.join(lista) — une los elementos de una lista en un string usando el separador. Es el opuesto de split.

Estos dos métodos son la base de todo parseo de texto: leer líneas de un CSV, extraer campos, reconstruir strings formateados.

Métodos de validación (is...)

Método	True cuando…	Uso típico
`.isdigit()`	Solo dígitos (0-9)	Validar que un campo es numérico
`.isalpha()`	Solo letras	Validar nombres sin números
`.isalnum()`	Letras y/o dígitos	Validar códigos alfanuméricos
`.isspace()`	Solo espacios/tabs/newlines	Detectar campos "vacíos" con espacios
`.isupper()`	Todo mayúsculas	Verificar formato de constantes
`.islower()`	Todo minúsculas	Verificar normalización

f-strings avanzado

Los f-strings no son un método de string, pero son la herramienta de formato más poderosa y la vas a usar constantemente:

Formato	Ejemplo	Resultado	Uso
`:,.2f`	`f"${1234567.8:,.2f}"`	`$1,234,567.80`	Moneda
`:,.0f`	`f"${1234567:,.0f}"`	`$1,234,567`	Moneda sin decimales
`:.1%`	`f"{0.153:.1%}"`	`15.3%`	Porcentajes
`:>12`	`f"{'hola':>12}"`	`hola`	Alinear derecha
`:<12`	`f"{'hola':<12}"`	`hola`	Alinear izquierda
`:^12`	`f"{'hola':^12}"`	`hola`	Centrar
`:05d`	`f"{42:05d}"`	`00042`	IDs con padding
`:+.1f`	`f"{3.5:+.1f}"`	`+3.5`	Mostrar signo siempre

Tip profesional: el combo definitivo para limpieza de datos textuales es: .strip().lower() para normalizar, .replace() para limpiar caracteres no deseados, .split() para separar campos, y .join() para reconstruir. Con estos 4 métodos resolvés el 90% de los problemas de texto.

Ejemplos explicados paso a paso

Ejemplo 1: Transformación de mayúsculas y limpieza

ejemplo_01_transformar.pyPython

texto = "  ¡Hola Mundo! Esto es PYTHON  "

print(f"Original:    '{texto}'")
print(f"upper():     '{texto.upper()}'")
print(f"lower():     '{texto.lower()}'")
print(f"title():     '{texto.title()}'")
print(f"strip():     '{texto.strip()}'")

# Combo más común en limpieza de datos
dato_sucio = "  RODRIGO GONZÁLEZ  "
limpio = dato_sucio.strip().title()
print(f"\nSucio:  '{dato_sucio}'")
print(f"Limpio: '{limpio}'")

# Limpiar una lista completa de nombres
nombres_sucios = ["  ANA GARCÍA  ", "luis López", "MARTA   pérez ", "  carlos  "]
limpios = [n.strip().title() for n in nombres_sucios]
print(f"\nOriginales: {nombres_sucios}")
print(f"Limpios:    {limpios}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Búsqueda, reemplazo y conteo

ejemplo_02_buscar.pyPython

frase = "Python es genial, Python es poderoso, Python es libre"

# Buscar
print(f"find('poderoso'): posición {frase.find('poderoso')}")
print(f"find('Java'): {frase.find('Java')}")  # -1 = no encontrado
print(f"count('Python'): {frase.count('Python')} veces")

# Reemplazar
nueva = frase.replace("Python", "pandas")
print(f"\nReplace: {nueva}")

# Solo reemplazar N ocurrencias
parcial = frase.replace("Python", "🐍", 2)  # solo las primeras 2
print(f"Replace(2): {parcial}")

# Verificar inicio/final
archivo = "reporte_Q3_2025.csv"
print(f"\n¿Empieza con 'reporte'? {archivo.startswith('reporte')}")
print(f"¿Termina en '.csv'? {archivo.endswith('.csv')}")
print(f"¿Termina en '.xlsx'? {archivo.endswith('.xlsx')}")

# Limpiar montos financieros
monto_crudo = "$1,250,000.50"
monto_limpio = monto_crudo.replace("$", "").replace(",", "")
print(f"\nCrudo: {monto_crudo} → Limpio: {monto_limpio} → Float: {float(monto_limpio)}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Split y Join — parsear datos

La combinación split/join es la base de todo procesamiento de texto y parseo de CSV.

ejemplo_03_split_join.pyPython

# Split: dividir string en lista
csv_line = "García,35,Buenos Aires,720,$250,000"
campos = csv_line.split(",")
print(f"Split por coma: {campos}")

# Split sin argumento: divide por CUALQUIER espacio
texto = "  Python   es    genial  "
palabras = texto.split()  # sin argumento = por espacios
print(f"Split por espacio: {palabras}")

# Split con maxsplit: limitar la cantidad de divisiones
log = "2025-03-15 ERROR usuario no encontrado en base de datos"
partes = log.split(" ", 2)  # divide en máximo 3 partes
fecha, nivel, mensaje = partes
print(f"\nFecha: {fecha}, Nivel: {nivel}")
print(f"Mensaje: {mensaje}")

# Join: unir lista en string
nombres = ["García", "López", "Martínez"]
print(f"\nJoin con ', ': {', '.join(nombres)}")
print(f"Join con ' | ': {' | '.join(nombres)}")
print(f"Join con '\\n': ")
print('\n'.join(nombres))

# Caso real: reconstruir un nombre de archivo
partes_nombre = ["reporte", "ventas", "Q3", "2025"]
archivo = "_".join(partes_nombre) + ".csv"
print(f"\nArchivo: {archivo}")

# Splitlines: dividir por saltos de línea
multilinea = "Línea 1\nLínea 2\nLínea 3"
lineas = multilinea.splitlines()
print(f"\nSplitlines: {lineas}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Validación de datos con métodos is...

ejemplo_04_validacion.pyPython

# Validar tipo de dato textual
datos = ["12345", "abc", "abc123", "  ", "12.5", "", "CUIT-20-12345678-9"]

print("=== Validación de campos ===")
for d in datos:
    checks = []
    if d.isdigit(): checks.append("solo dígitos")
    if d.isalpha(): checks.append("solo letras")
    if d.isalnum(): checks.append("alfanumérico")
    if d.isspace(): checks.append("solo espacios")
    if not d: checks.append("vacío")
    print(f"  '{d}' → {', '.join(checks) if checks else 'mixto/especial'}")

# Caso práctico: validar un CUIT
def validar_cuit(cuit):
    partes = cuit.split("-")
    if len(partes) != 3:
        return False, "Debe tener 3 partes separadas por -"
    if not partes[0].isdigit() or len(partes[0]) != 2:
        return False, "Prefijo debe ser 2 dígitos"
    if not partes[1].isdigit() or len(partes[1]) != 8:
        return False, "Cuerpo debe ser 8 dígitos"
    if not partes[2].isdigit() or len(partes[2]) != 1:
        return False, "Verificador debe ser 1 dígito"
    return True, "CUIT válido"

cuits = ["20-12345678-9", "27-9876543-1", "abc-12345678-9", "20123456789"]
print("\n=== Validación de CUITs ===")
for c in cuits:
    ok, msg = validar_cuit(c)
    print(f"  {c}: {'✅' if ok else '❌'} {msg}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: f-strings avanzado — reportes profesionales

ejemplo_05_fstrings.pyPython

# Formato de números en reportes financieros
saldo = 2345678.9
tasa = 0.0725
cantidad = 42

print(f"Moneda:      ${saldo:,.2f}")
print(f"Sin decimal: ${saldo:,.0f}")
print(f"Porcentaje:  {tasa:.2%}")
print(f"Con signo:   {saldo:+,.0f}")
print(f"Padding:     ID-{cantidad:06d}")

# Tabla alineada
print(f"\n{'─'*45}")
print(f"{'Concepto':<20} {'Monto':>12} {'%':>8}")
print(f"{'─'*45}")

datos = [
    ("Sueldo bruto", 950000),
    ("Jubilación", -104500),
    ("Obra social", -28500),
    ("Ganancias", -161500),
]
bruto = datos[0][1]
for concepto, monto in datos:
    pct = abs(monto) / bruto * 100
    signo = "+" if monto >= 0 else "-"
    print(f"  {concepto:<18} {signo}${abs(monto):>10,} {pct:>7.1f}%")

neto = sum(m for _, m in datos)
print(f"{'─'*45}")
print(f"  {'NETO':<18} ${neto:>11,}")

# Expresiones dentro de f-strings
edad = 28
print(f"\n{edad} es {'par' if edad % 2 == 0 else 'impar'}")
print(f"En 10 años: {edad + 10}")
print(f"Nombre: {'RODRIGO':^20}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Categoría	Métodos	Uso principal
Mayúsculas	`upper lower title capitalize swapcase`	Normalizar texto
Limpieza	`strip lstrip rstrip`	Eliminar espacios/caracteres
Búsqueda	`find rfind index count`	Localizar subcadenas
Reemplazo	`replace`	Sustituir texto
Inicio/Fin	`startswith endswith`	Verificar prefijo/sufijo
Dividir/Unir	`split rsplit splitlines join`	Parsear y reconstruir
Validar	`isdigit isalpha isalnum isspace isupper islower`	Verificar contenido
Alinear	`center ljust rjust zfill`	Formatear ancho fijo

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Normalizar un nombre

Dado nombre = " RODRIGO GONZÁLEZ ", limpialo y convertilo a formato título. Debe incluir Rodrigo González.

ejercicio_01.pyDebe incluir "Rodrigo González"

nombre = "  RODRIGO GONZÁLEZ  "

# Limpiá y normalizá:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Contar ocurrencias

En "Python es genial. Python es libre. Python es rápido.", contá cuántas veces aparece "Python". Debe incluir 3.

ejercicio_02.pyDebe incluir "3"

texto = "Python es genial. Python es libre. Python es rápido."

# Contá las ocurrencias:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Split básico

Dado "García|35|Buenos Aires", splitteá por "|" e imprimí cada campo en una línea. Debe incluir Buenos Aires.

ejercicio_03.pyDebe incluir "Buenos Aires"

registro = "García|35|Buenos Aires"

# Split e imprimí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Limpiar monto financiero

Dado "$1,850,000.75", eliminá el $ y las comas, convertí a float e imprimí. Debe incluir 1850000.75.

ejercicio_04.pyDebe incluir "1850000.75"

monto_crudo = "$1,850,000.75"

# Limpiá y convertí:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Join para reconstruir

Dada partes = ["Buenos", "Aires", "Capital", "Federal"], unilas con espacio y con guión bajo. Debe incluir Buenos_Aires_Capital_Federal.

ejercicio_05.pyDebe incluir "Buenos_Aires_Capital_Federal"

partes = ["Buenos", "Aires", "Capital", "Federal"]

# Join con espacio y con _:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Verificar extensión de archivo

Dado archivo = "reporte_ventas_Q3.xlsx", verificá si es un archivo Excel (termina en .xlsx o .xls) e imprimí el resultado. Debe incluir Excel.

ejercicio_06.pyDebe incluir "Excel"

archivo = "reporte_ventas_Q3.xlsx"

# Verificá la extensión:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Limpiar lista de datos sucios

Tenés datos = [" GARCÍA ", "lópez", " Martínez", "PÉREZ ", " fernández "]. Normalizalos todos a formato título sin espacios extra. Debe incluir ['García', 'López', 'Martínez', 'Pérez', 'Fernández'].

ejercicio_07.pyDebe incluir "Fernández"

datos = ["  GARCÍA  ", "lópez", "  Martínez", "PÉREZ  ", "  fernández  "]

# Normalizá con list comprehension:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Parsear múltiples registros CSV

Dado este CSV como string multilínea, parseá cada línea en un diccionario. Debe incluir 720.

ejercicio_08.pyDebe incluir "720"

csv_data = """nombre,edad,score
García,35,720
López,42,680
Martínez,28,590"""

# Parseá en lista de diccionarios:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Reporte formateado con f-strings

Generá una tabla con estos datos alineados: 3 productos con nombre (izq, 20 chars), precio (der, $formato), y stock (der, 5 chars). Debe incluir Total:.

ejercicio_09.pyDebe incluir "Total:"

productos = [
    ("Notebook", 920000, 15),
    ("Mouse", 23000, 150),
    ("Teclado", 46000, 80),
]

# Generá la tabla formateada:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline de limpieza de datos completo

ejercicio_10_desafio.pyDebe incluir "pipeline"

registros_crudos = [
    "  GARCÍA|35|$150,000  ",
    "  López|42|$320,000",
    "martínez|28|$45,000  "
]

# Pipeline de limpieza completo:
print("=== Resultado del pipeline ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Los strings son inmutables — cada método devuelve un NUEVO string.
.strip().title() o .strip().lower() es el combo #1 de normalización.
.split() divide texto en lista, .join() une lista en texto — esenciales para parsear datos.
.replace() limpia caracteres no deseados ($, comas, espacios).
.find() busca sin error, .count() cuenta ocurrencias, .startswith()/.endswith() verifican.
f-strings con :,.2f (moneda), :.1% (porcentaje), :>12 (alineación) profesionalizan tus reportes.

En la siguiente lección (13 · Métodos de listas) vas a dominar todas las formas de agregar, eliminar, ordenar, buscar y transformar listas — incluyendo list comprehensions avanzadas.

Recursos: Python docs — String Methods · f-strings

Hecho con ❤️ por Rodri Gonzalez