Los strings en Python no son solo texto plano: son objetos con un conjunto de métodos bien diseñados que resuelven exactamente los problemas que aparecen todos los días en código real. Limpiar entradas de usuario, parsear archivos, construir rutas, validar extensiones — todo eso pasa por estos métodos. Vamos a ver los más importantes, por qué funcionan como funcionan, y dónde te pueden morder si no los conoces bien.
Un string en Python es inmutable: ningún método modifica el string original. Todos devuelven un nuevo string (o un valor diferente). Esto es fundamental, porque si escribes texto.strip() sin asignar el resultado, nada cambia. Es el error más común con este tema, y lo veremos en detalle más adelante.
Limpieza: .strip(), .lstrip(), .rstrip()
.strip() elimina whitespace (espacios, tabs, saltos de línea) de ambos extremos. .lstrip() solo del lado izquierdo (left), .rstrip() solo del derecho. Los tres aceptan un argumento opcional: una cadena de caracteres a eliminar, no un prefijo literal sino cualquier combinación de esos caracteres.
" hola ".strip() # "hola"
"/ruta/carpeta/".strip("/") # "ruta/carpeta"
Cuando necesitas limpiar solo un lado tiene sentido: logs con timestamps al inicio que quieres conservar, o líneas de archivo donde el salto de línea final molesta pero los espacios iniciales son significativos (indentación en YAML, por ejemplo).
Separar: .split() y .rsplit()
.split() divide un string por un separador y devuelve una lista. Sin argumentos, divide por cualquier whitespace y descarta los vacíos — comportamiento especialmente útil para limpiar input de usuario. Con separador explícito, conserva los campos vacíos entre separadores consecutivos.
.rsplit() hace lo mismo pero empieza a cortar desde la derecha, y cobra sentido cuando combinas el parámetro maxsplit: útil para separar una ruta en “todo menos el último componente” sin necesidad de os.path.
Unir: .join()
.join() es la forma idiomática de construir un string desde una lista. La sintaxis parece invertida al principio — el separador llama al método, la lista es el argumento — pero tiene lógica: el separador conoce cómo unir, la lista es solo datos.
La razón para preferirlo sobre concatenación en bucle es eficiencia. Concatenar strings con + en un bucle crea un nuevo objeto en memoria en cada iteración. .join() calcula el tamaño total primero y hace una sola asignación.
Validar extremos: .startswith() y .endswith()
Ambos aceptan una tupla de strings como argumento, no solo uno. Esto los hace mucho más útiles de lo que parece en una primera lectura: puedes verificar múltiples prefijos o sufijos en una sola expresión limpia, sin or encadenados.
Buscar y reemplazar: .replace(), .find(), .index()
.replace(old, new) devuelve un nuevo string con todas las ocurrencias reemplazadas. Acepta un tercer argumento count para limitar cuántas reemplaza.
.find(sub) devuelve el índice de la primera ocurrencia, o -1 si no la encuentra. .index(sub) hace exactamente lo mismo, pero lanza ValueError si no encuentra nada. Úsalos según el contexto: si la ausencia es un caso válido, .find() es más seguro; si la ausencia sería un bug, .index() falla ruidosamente y eso es mejor.
Transformar capitalización: .upper(), .lower(), .title(), .capitalize()
.lower() y .upper() son los más usados — especialmente para comparaciones case-insensitive. .title() capitaliza la primera letra de cada palabra. .capitalize() solo la primera letra del string completo y pone el resto en minúsculas.
Codificar: .encode()
.encode(encoding) convierte un string a bytes. Lo necesitas cuando trabajas con archivos binarios, sockets, hashing (passwords, checksums), o cualquier API que espere bytes en lugar de str. El encoding por defecto es 'utf-8', que es correcto para el 99% de los casos modernos.
Ahora vamos al código completo que cubre todo esto en un contexto realista: procesamiento de un archivo CSV simple llegado de un sistema externo con datos sucios.
import hashlib
# Simula líneas de un archivo CSV con datos sucios del mundo real
raw_lines = [
" juan.perez@empresa.com , Juan Pérez , /uploads/foto.JPG \n",
" ANA.GARCIA@EMPRESA.COM , Ana García , /uploads/avatar.png\n",
" carlos@externo.net , Carlos López , /docs/contrato.PDF \n",
" \n", # línea vacía que hay que ignorar
]
ALLOWED_IMAGE_EXTENSIONS = (".jpg", ".jpeg", ".png", ".gif", ".webp")
ALLOWED_DOC_EXTENSIONS = (".pdf", ".docx", ".txt")
processed_users = []
for raw_line in raw_lines:
# .strip() sin args elimina whitespace incluyendo \n
line = raw_line.strip()
# línea vacía tras limpiar: la saltamos
if not line:
continue
# .split() con separador conserva campos vacíos entre comas;
# con maxsplit=2 nos protege si el nombre tiene comas internas
parts = line.split(",", maxsplit=2)
if len(parts) != 3:
continue
email_raw, name_raw, filepath_raw = parts
# Limpiar cada campo individualmente
email = email_raw.strip().lower() # normalizar email a minúsculas
name = name_raw.strip()
filepath = filepath_raw.strip()
# .title() para capitalizar nombre propio
display_name = name.title()
# .find() para ubicar el @ sin explotar si el dato es inválido
at_pos = email.find("@")
if at_pos == -1:
# email sin @ — dato corrupto, lo descartamos
continue
# .split() para separar usuario y dominio del email
username, domain = email.split("@", maxsplit=1)
# .endswith() con tupla: una sola expresión para múltiples extensiones
filepath_lower = filepath.lower()
if filepath_lower.endswith(ALLOWED_IMAGE_EXTENSIONS):
file_type = "image"
elif filepath_lower.endswith(ALLOWED_DOC_EXTENSIONS):
file_type = "document"
else:
file_type = "unknown"
# .rsplit() desde la derecha con maxsplit=1 para separar nombre de archivo
# sin importar cuántos directorios haya en la ruta
path_parts = filepath.rsplit("/", maxsplit=1)
filename = path_parts[-1] if len(path_parts) > 1 else filepath
# .replace() para sanear el nombre de archivo (espacios por guiones)
safe_filename = filename.replace(" ", "_")
# .startswith() con tupla para detectar dominios internos
is_internal = domain.startswith(("empresa.com", "empresa.es", "empresa.mx"))
# .encode() para hashear el email — hashlib requiere bytes, no str
email_hash = hashlib.sha256(email.encode("utf-8")).hexdigest()
# .join() para construir un path normalizado desde partes
# más eficiente y legible que concatenar con +
normalized_path = "/".join(["storage", file_type, safe_filename])
processed_users.append({
"email": email,
"username": username,
"domain": domain,
"display_name": display_name,
"file_type": file_type,
"normalized_path": normalized_path,
"is_internal": is_internal,
"email_hash": email_hash,
})
# Mostrar resultados
for user in processed_users:
status = "interno" if user["is_internal"] else "externo"
print(f"[{status.upper()}] {user['display_name']} <{user['email']}>")
print(f" Archivo: {user['normalized_path']} ({user['file_type']})")
print(f" Hash: {user['email_hash'][:16]}...")
print()
Qué hace cada decisión en el código
El primer .strip() sobre la línea completa es defensivo: los archivos del mundo real tienen \r\n en Windows, \n en Unix, y a veces espacios fantasma. Limpiarlo antes de procesar evita bugs silenciosos donde "campo \n".split(",") produce ["campo \n"] con el salto dentro del valor.
El split(",", maxsplit=2) es una decisión de robustez. Si un nombre contiene coma — "García, Juan" — sin maxsplit obtendrías cuatro partes en lugar de tres y el código fallaría silenciosamente al desempaquetar. Con maxsplit=2 el tercer campo absorbe todo lo que sobre.
El .find("@") antes del .split("@") es el patrón correcto cuando el dato puede ser inválido. Si usaras .index("@") directamente y el email estuviera corrupto, tendrías un ValueError sin contexto. Con .find() puedes decidir cómo manejar el caso: aquí simplemente descartamos el registro.
El .rsplit("/", maxsplit=1) es más fiable que split("/")[-1] para extraer el nombre de archivo porque es explícito en su intención: “dame las dos partes separando por la última barra”. El resultado es siempre una lista de exactamente dos elementos (o uno si no hay barra), sin iterar toda la ruta.
El .endswith(ALLOWED_IMAGE_EXTENSIONS) con una tupla reemplaza lo que sería un or de tres comparaciones. Python itera internamente por la tupla, y el código queda limpio y fácil de extender — solo agregas la extensión a la tupla.
El .encode("utf-8") antes del hash es obligatorio: hashlib.sha256() no acepta str, solo bytes. Este es uno de los contextos más frecuentes donde lo necesitarás en código real, junto con escritura en ficheros abiertos en modo binario ("wb") y comunicación por sockets.
El .join(["storage", file_type, safe_filename]) construye el path con una sola asignación de memoria. Si lo hicieras con "storage/" + file_type + "/" + safe_filename, Python crea tres objetos temporales intermedios. Con listas cortas la diferencia es imperceptible, pero el patrón con .join() escala bien y es la convención que cualquier Python developer reconoce inmediatamente.
Errores que debes conocer
Error: Olvidar que los métodos de string no modifican el original y descartamos el resultado.
# ❌ Wrong texto = " hola mundo " texto.strip() print(texto) # " hola mundo " — nada cambió # ✅ Right texto = " hola mundo " texto = texto.strip() print(texto) # "hola mundo"
Como los strings son inmutables, .strip() devuelve un nuevo objeto; el original queda intacto. Siempre asigna el resultado.
Error: Usar .index() cuando la ausencia del valor es un caso válido en los datos.
# ❌ Wrong
def get_domain(email: str) -> str:
pos = email.index("@") # ValueError si el email no tiene @
return email[pos + 1:]
# ✅ Right
def get_domain(email: str) -> str | None:
pos = email.find("@") # devuelve -1 si no encuentra
if pos == -1:
return None
return email[pos + 1:]
.index() es correcto cuando la ausencia es un bug que quieres que explote; .find() es correcto cuando la ausencia es datos sucios que quieres manejar.
Error: Pasar un string en lugar de una tupla a .startswith() o .endswith() cuando quieres verificar múltiples opciones.
# ❌ Wrong — verifica si empieza con la cadena literal ".jpg.png"
if filename.endswith(".jpg.png"):
...
# ✅ Right — verifica si termina con cualquiera de los dos
if filename.endswith((".jpg", ".png")):
...
Ambos métodos aceptan str o tuple[str, ...]. Un str se trata como una sola opción; para múltiples opciones necesitas la tupla explícitamente.
N° 37