Procesamiento básico de Texto

Por Jose R. Zapata

Ultima actualización: 14/Oct/2025

En los proyectos de procesamiento de texto, es común realizar operaciones básicas de manipulación y limpieza de Strings. Pandas proporciona un conjunto de métodos muy útiles para este propósito a través del modulo .str, que permite aplicar funciones de cadena a cada elemento de una Series o Index.

Estos métodos son similares a los métodos de strings estándar de Python, pero están optimizados para trabajar con datos en estructuras de pandas.

Los métodos de procesamiento básico son muy útiles para:

• Limpiar y preprocesar texto (eliminar espacios en blanco, convertir a minúsculas, etc.).
• Extraer información relevante (como fechas, números, etc.) utilizando expresiones regulares.
• Realizar búsquedas y reemplazos de texto de manera eficiente.
• Dividir y unir cadenas de texto según sea necesario.

Se presentan los métodos mas usados del modulo (.str) de pandas agrupados por tipo de procesamiento (formato, búsqueda, sustitución, unión, división, etc.).

Nota:

• .str funciona sobre Series e Index con datos de texto y omite automáticamente valores faltantes.
• Muchas funciones aceptan expresiones regulares (regex).

import pandas as pd
import numpy as np

pd.__version__

Métodos de strings de pandas

Datos de ejemplo

Definimos varias Series que reutilizaremos en los ejemplos para que puedas ejecutar todas las celdas sin preparar datos adicionales.

# Serie de texto general
s = pd.Series(
    [
        "pandas",
        "NumPy",
        "  data-science  ",
        None,
        "123",
        "abc123",
        "México",
        "foo_bar",
        "2025-10-15",
        "Café con leche",
    ],
    dtype="string",
)

# Serie con separadores y listas
s_sep = pd.Series(["a,b,c", "x|y", "uno dos", None, "foo-bar", "a|b|c"], dtype="string")

# Serie con correos / patrones
s_pat = pd.Series(["a@x.com", "b@y.org", "no-email", "c@z.io", None], dtype="string")

# Serie con números/mixta para 'is*' y conteos
s_num = pd.Series(["42", "007", "NaN", "3.14", "", "abc", None], dtype="string")

# Serie con acentos y unicode
s_uni = pd.Series(["Café", "México", "naïve", "straße", None], dtype="string")


# DataFrame auxiliar para algunos ejemplos
df = pd.DataFrame({"col": s})
df

1) Formato / normalización

Métodos para transformar el formato del texto: mayúsculas/minúsculas, título, capitalización, intercambio de mayúsculas y minúsculas, normalización Unicode y traducciones de caracteres.

Estos métodos son útiles para estandarizar el texto antes de realizar análisis o comparaciones.

lower()

Convierte a minúsculas.

s.str.lower()

upper()

Convierte a mayúsculas.

s.str.upper()

capitalize()

Primera letra en mayúscula y el resto en minúsculas.

s.str.capitalize()

title()

Convierte cada palabra a Title Case (Letra Inicial de cada Palabra en Mayúscula).

s.str.title()

swapcase()

Invierte mayúsculas/minúsculas.

s.str.swapcase()

casefold()

Normaliza para comparaciones case-insensitive robustas (Unicode). este método es más agresivo que lower(). por ejemplo, convierte la letra alemana “ß” a “ss”. esto sirve para comparaciones de cadenas que ignoran mayúsculas/minúsculas y otras diferencias de formato.

s_uni.str.casefold()

normalize()

Aplica normalización Unicode (por ejemplo, ‘NFKD’).

La normalizacion NFKD descompone caracteres compuestos en sus componentes básicos. Por ejemplo, la letra ‘é’ se descompone en ’e’. Esto es útil para comparar cadenas de texto que pueden tener diferentes representaciones Unicode pero que son visualmente idénticas.

s_uni.str.normalize("NFKD")

translate()

Traduce caracteres usando una tabla (p. ej., reemplazar vocales).

tabla = str.maketrans({"á": "a", "é": "e", "í": "i", "ó": "o", "ú": "u"})
s_uni.str.translate(tabla)

2) Alineación y relleno

Relleno a izquierda/derecha/ambos, centrado y relleno con ceros para ancho fijo.

Estos métodos son útiles para formatear texto para su presentación o para asegurarse de que las cadenas tengan una longitud uniforme.

pad()

Rellena a izquierda/derecha/ambos hasta un ancho dado.

s.str.strip().str.pad(15, fillchar="-")

center()

Centra cada string al ancho dado.

s.str.strip().str.center(20, fillchar="-")

ljust()

Rellena a la derecha (alineado a la izquierda).

s.str.strip().str.ljust(12, fillchar=".")

rjust()

Rellena a la izquierda (alineado a la derecha).

s.str.strip().str.rjust(12, fillchar=".")

zfill()

Rellena con ceros por la izquierda.

pd.Series(["7", "42", "1234"], dtype="string").str.zfill(5)

3) Limpieza de espacios y prefijos/sufijos

Eliminar espacios o caracteres en los bordes y quitar prefijos/sufijos cuando existan.

Estos métodos son útiles para limpiar datos de texto que pueden tener espacios o caracteres no deseados al inicio o al final.

strip()

Elimina espacios/caracteres al inicio y fin.

s.str.strip()

lstrip()

Elimina espacios/caracteres al inicio.

# datos string con espacios y tabulaciones

pd.Series(["  hola", "\t\n adios"], dtype="string").str.lstrip()

rstrip()

Elimina al final.

pd.Series(["hola   ", "adios\n\t  "], dtype="string").str.rstrip()

removeprefix()

Quita el prefijo solo si está presente.

pd.Series(["pre_data", "data", "pre_model"], dtype="string").str.removeprefix("pre_")

removesuffix()

Quita el sufijo solo si está presente.

pd.Series(["file.csv", "file.txt", "logs.csv"], dtype="string").str.removesuffix(".csv")

4) Unión y concatenación

Concatenar valores de la serie o unir elementos de listas dentro de cada celda.

Estos métodos son útiles para combinar texto de diferentes fuentes o para crear cadenas a partir de listas de palabras.

cat()

Concatena valores (con sep une todo en un único string).

Este método es útil para combinar texto de diferentes filas o columnas en una sola cadena, con un separador opcional.

pd.Series(["a", "b", "c"], dtype="string").str.cat(sep="|")

join()

Une elementos de cada lista con un separador.

Este método es útil cuando cada celda de la serie contiene una lista de palabras y se desea unir esas palabras en una sola cadena utilizando un separador específico.

s_sep.str.split("[,| -]").str.join("•")

5) División, partición y slicing

Operaciones para dividir y segmentar cadenas, así como extraer posiciones específicas.

Estos métodos son útiles para separar texto en partes manejables o para extraer subcadenas basadas en posiciones o patrones.

split()

Divide por separador (devuelve listas).

Este método es útil para dividir cadenas en partes basadas en un separador específico, lo que facilita el análisis y la manipulación de datos de texto.

s_sep

s_sep.str.split("[,| ]+", regex=True)

rsplit()

Divide desde el final.

pd.Series(["a_b_c", "x_y", "uno_dos_tres"], dtype="string").str.rsplit("_", n=1)

partition()

Divide en una tupla (antes, sep, después).

Este método es útil para dividir una cadena en tres partes basadas en la primera aparición de un separador específico, lo que permite un análisis más detallado del texto.

pd.Series(["a=b", "x=y", "no-sep"], dtype="string").str.partition("=")

rpartition()

Como partition pero desde el final.

pd.Series(["a=b=c", "x=y", "no-sep"], dtype="string").str.rpartition("=")

slice()

Extrae por posición [start:stop:step].

Este método es útil para obtener subcadenas basadas en posiciones específicas, similar al slicing estándar de Python.

s.str.slice(0, 4)

slice_replace()

Reemplaza un corte posicional por otro texto.

Este método es útil para modificar partes específicas de una cadena basándose en posiciones, permitiendo reemplazar segmentos de texto con nuevo contenido.

pd.Series(["abcdef", "123456", "----"], dtype="string").str.slice_replace(2, 5, "XYZ")

get()

Índice dentro de cada elemento (útil tras split). Este método es útil para acceder a elementos específicos dentro de listas o tuplas almacenadas en cada celda de una serie, facilitando la extracción de datos después de operaciones como split().

s_sep.str.split("[,| ]+", regex=True).str.get(1)

6) Búsqueda, coincidencia y conteo (regex incluidas)

Pruebas de pertenencia, coincidencias parciales/totales, inicio/fin, encontrar posiciones y contar apariciones.

Estos métodos son útiles para buscar patrones específicos en texto, verificar la presencia de ciertos caracteres o palabras, y contar ocurrencias de patrones.

contains()

¿Contiene el patrón (regex por defecto)?

Este método es útil para filtrar datos de texto basándose en la presencia de patrones específicos, lo que facilita el análisis y la limpieza de datos.

s_pat.str.contains(r"^[\w.]+@[\w.-]+\.[a-z]{2,}$", case=False, na=False)

match()

¿Coincide desde el inicio de la cadena?

Este método es útil para verificar si una cadena comienza con un patrón específico, lo que es importante en muchas aplicaciones de procesamiento de texto.

pd.Series(["123abc", "abc123", "123"], dtype="string").str.match(r"\d+")

fullmatch()

¿Coincidencia del string completo con el patrón?

Este método es útil para validar que una cadena completa coincide exactamente con un patrón específico, lo que es crucial en tareas de validación de datos.

pd.Series(["123", "123abc", "abc"], dtype="string").str.fullmatch(r"\d+")

startswith()

¿Empieza con el patrón dado?

Este método es útil para verificar si una cadena comienza con un patrón específico, lo que es importante en muchas aplicaciones de procesamiento de texto.

s

s.str.strip().str.startswith("data")

endswith()

¿Termina con el patrón dado?

Este método es útil para verificar si una cadena termina con un patrón específico, lo que puede ser importante en ciertas aplicaciones de procesamiento de texto.

s

s.str.strip().str.endswith("science")

find()

Índice de la primera aparición (−1 si no hay).

Este método es útil para localizar la posición de la primera aparición de un patrón en una cadena, lo que facilita la extracción y manipulación de datos de texto.

s

s.str.find("a")

rfind()

Índice de la última aparición (−1 si no hay).

s

s.str.rfind("a")

index()

Como find, pero se genera un error si no existe (usa patrones que sí existan).

pd.Series(["data", "catalog"], dtype="string").str.index("a")

rindex()

Como rfind, pero error si no existe.

pd.Series(["data", "catalog"], dtype="string").str.rindex("a")

findall()

Lista de todas las ocurrencias del patrón.

Este método es útil para extraer todas las ocurrencias de un patrón específico en una cadena, lo que facilita el análisis detallado de datos de texto.

pd.Series(["a1b2c3", "xyz", "123"], dtype="string").str.findall(r"\d")

count()

Cuenta ocurrencias del patrón.

pd.Series(["banana", "bandana", "cabana"], dtype="string").str.count("ana")

7) Extracción de subcadenas con regex

Extrae grupos capturados a columnas (primera coincidencia) o todas las coincidencias.

Estos métodos son útiles para extraer información específica de texto utilizando patrones definidos por expresiones regulares.

extract()

Extrae grupos de la primera coincidencia a columnas.

pd.Series(["A1", "B2", "C3"], dtype="string").str.extract(r"([A-Z])(\d)", expand=True)

extractall()

Extrae todas las coincidencias y devuelve un DataFrame con índice jerárquico.

pd.Series(["a1a2", "b3", "c4c5"], dtype="string").str.extractall(r"([a-z])(\d)")

8) Longitud y repetición

Operaciones útiles de tamaño y duplicación

Estos métodos son útiles para medir la longitud del texto y repetir cadenas.

len()

Longitud de cada string.

s

s.str.len()

repeat()

Repite cada valor n veces.

Este método es útil para generar cadenas repetidas.

pd.Series(["ab", "XY"], dtype="string").str.repeat(3)

9) Sustitución de texto

Reemplazo directo (literal o regex) y traducciones (ver también translate en la sección de formato).

Estos métodos son útiles para limpiar y modificar texto, reemplazando patrones específicos con nuevos valores.

replace()

Reemplaza por patrón o regex.

Este método es útil para limpiar y modificar texto, reemplazando patrones específicos con nuevos valores.

# Con Regex
pd.Series(["2025-10-15", "2024/01/02", "15-10-2025"], dtype="string").str.replace(
    r"[-/]", "/", regex=True
)

# Sin Regex

pd.Series(["2025-10-15", "2024/01/02", "15-10-2025"], dtype="string").str.replace(
    "-", "/", regex=False
)

10) Comprobaciones is* (predicados)

Verificaciones vectorizadas sobre el contenido/caracteres de cada string.

Estos métodos son útiles para validar el contenido de texto, verificando si cumple con ciertos criterios como ser alfanumérico, numérico, etc.

isalnum()

¿Todos los caracteres son alfanuméricos?

pd.Series(["abc123", "abc!", ""], dtype="string").str.isalnum()

isalpha()

¿Solo letras?

pd.Series(["abc", "a1", ""], dtype="string").str.isalpha()

isdigit()

¿Solo dígitos (0–9)?

pd.Series(["123", "42a", ""], dtype="string").str.isdigit()

isnumeric()

¿Numérico Unicode (incluye dígitos y otros)?

el signo de número romano ‘Ⅻ’ son considerados numéricos y el signo ‘−’ (menos) no es un dígito.

será útil para validar entradas que pueden incluir números en formatos no estándar.

pd.Series(["Ⅻ", "42", "-1", "½"], dtype="string").str.isnumeric()

isdecimal()

¿Dígitos decimales estándar?

pd.Series(["123", "½", "-1", "Ⅻ"], dtype="string").str.isdecimal()

isspace()

¿Solo espacios en blanco?

pd.Series(["   ", "\t\n", " a "], dtype="string").str.isspace()

islower()

¿Todo en minúsculas?

pd.Series(["abc", "Abc", ""], dtype="string").str.islower()

isupper()

¿Todo en mayúsculas?

pd.Series(["ABC", "AbC", ""], dtype="string").str.isupper()

istitle()

¿Cada palabra en Title Case?

pd.Series(["Data Science", "data science", ""], dtype="string").str.istitle()

Bonus: Indexación con [] y encadenamiento de operaciones

• Puedes indexar posiciones con s.str[i] (devuelve el caracter i-ésimo o <NA> si no existe).
• Los métodos .str se pueden encadenar: s.str.strip().str.lower().str.replace(...).

s.str.strip().str.lower().str.replace(r"\s+", "-", regex=True)

Referencias

• Documentación oficial de pandas: String Methods

Jose R. Zapata

• https://joserzapata.github.io/
• https://www.linkedin.com/in/jose-ricardo-zapata-gonzalez/