viernes, 15 de mayo de 2026

DATOS. Tratamiento de datos

Limpieza de datos (II)

Normalización de datos

Cuando en la tabla-formulario de un documento de texto cabe la posibilidad de que los datos se expresen de diferentes maneras, existe una elevada probabilidad de que así sea. Aunque predomine una determinada forma, vamos a decir que canónica, es altamente probable que también se empleen otras formas que no lo son tanto. Un buen ejemplo de ello lo tienes en la tabla que sigue.

Como puedes ver en este ejemplo ficticio, que no lo es en este aspecto de la variabilidad de expresión de la fecha, junto a la forma canónica (círculo naranja), nos encontramos con otras forma diferentes (por ejemplo, pero no sólo, la marcada con el círculo verde). Aunque para un análisis visual de los datos esto no supone ningún problema (salvo en casos muy concretos), para el tratamiento automatizado de los datos se convierte en un serio problema: esas fecha no-canónicas no son reconocidas como tales fechas. Para evitar la pérdida de datos que esto implica, es necesario convertir estos datos al formato fecha. Podemos hacerlo manualmente, con ayuda de las funciones de formato de Calc (o Excel), aunque esto nos llevará tiempo. También contamos con la opción de automatizar el reajuste de formato mediante un script Python como el que sigue.



# 0. Bibliotecas y módulos ---

import pandas as pd
import re
from datetime import datetime

# 1. Funciones ---

# 1.a Función secundaria. Transforma string en fechas ---

def normalizar_fecha(texto):

    if pd.isna(texto) or str(texto).strip() == "":
        return None
    
    dato = str(texto).lower().strip()
    
    meses_map = {
        'enero': 1, 'febrero': 2, 'marzo': 3, 'abril': 4, 'mayo': 5, 'junio': 6,
        'julio': 7, 'agosto': 8, 'septiembre': 9, 'octubre': 10, 'noviembre': 11, 'diciembre': 12
    }

    try:
        return pd.to_datetime(dato, dayfirst=True).date()     # Intento 1: Formato numérico completo (ej. 2/02/2026)
    except:
        pass
    anio_detectado = re.search(r'(\d{4})', dato)               # Intento 2: Formato parcial (ej. enero 2014)
    if anio_detectado:
        anio = int(anio_detectado.group(1))
        for mes_nombre, mes_numero in meses_map.items():
            if mes_nombre in dato:
                return datetime(anio, mes_numero, 1).date()      # Retornamos siempre el día 1 del mes encontrado
    return None                                                  # Si llega aquí, no se pudo convertir y devolvemos None

# 1.b Función principal ---

def procesar_limpieza(ruta_entrada, columna_objetivo, ruta_salida):
    
    try:
        print(f"Cargando archivo: {ruta_entrada}...")
        df = pd.read_csv(ruta_entrada, sep=';', encoding='utf-8')
        df['fecha_corregida'] = df[columna_objetivo].apply(normalizar_fecha)                # Aplicamos la normalización (funcion 1a)
        df['fecha_corregida'] = pd.to_datetime(df['fecha_corregida'], errors='coerce')      # Convertimos a datetime Pandas (AAAA-MM-DD)
        df.to_csv(ruta_salida, sep=';', index=False, encoding='utf-8')                      # Exportamos el resultado (csv)
        print(f"Éxito: Archivo '{ruta_salida}' generado con fechas estandarizadas.")
        
    except Exception as e:
        print(f"Error durante el proceso de código: {e}")

# 2. Script principal (Llamada a la función principal) ---

if __name__ == "__main__":

    archivo_origen = r''            # Aquí la ruta del archivo csv de trabajo
    columna_fechas = 'fecha'        # Aquí el nombre de la columna a procesar
    archivo_destino = r''      		# Aquí el nombre del csv resultante
    
    procesar_limpieza(archivo_origen, columna_fechas, archivo_destino) # Llamada a la función


La estructura del script es relativamente simple: dos funciones y un script. El script llama a la función principal pasando parámetros (procesar_limpieza(archivo_origen, columna_fechas, archivo_destino)) que el profesional asigna a variables (vg. archivo_origen = r'') y la función principal hace uso de la secundaria para tratar el contenido textual del campo y devolver un formato fecha del módulo datetime en formato Pandas (AAA-MM-DD).

La función principal es sumamente importante: (1) Carga el csv de trabajo, (2) Llama a la función secundaria para normalizar el formato (3) convierte el dato devuelto por esa función al formato datetime de Pandas y (4) genera el scv de salida.

  1. df = pd.read_csv(ruta_entrada, sep=';', encoding='utf-8')
  2. df['fecha_corregida'] = df[columna_objetivo].apply(normalizar_fecha)
  3. df['fecha_corregida'] = pd.to_datetime(df['fecha_corregida'], errors='coerce')
  4. df.to_csv(ruta_salida, sep=';', index=False, encoding='utf-8')

Pero la función secundaria no es menos interesante, como veremos a continuación. Recordemos:



def normalizar_fecha(texto):

    if pd.isna(texto) or str(texto).strip() == "":
        return None
    
    dato = str(texto).lower().strip()
    
    meses_map = {
        'enero': 1, 'febrero': 2, 'marzo': 3, 'abril': 4, 'mayo': 5, 'junio': 6,
        'julio': 7, 'agosto': 8, 'septiembre': 9, 'octubre': 10, 'noviembre': 11, 'diciembre': 12
    }

    try:
        return pd.to_datetime(dato, dayfirst=True).date()     # Intento 1: Formato numérico completo (ej. 2/02/2026)
    except:
        pass
    anio_detectado = re.search(r'(\d{4})', dato)               # Intento 2: Formato parcial (ej. enero 2014)
    if anio_detectado:
        anio = int(anio_detectado.group(1))
        for mes_nombre, mes_numero in meses_map.items():
            if mes_nombre in dato:
                return datetime(anio, mes_numero, 1).date()      # Retornamos siempre el día 1 del mes encontrado
    return None                                                  # Si llega aquí, no se pudo convertir y devolvemos None



En esta función podemos diferenciar varias partes:
  • Primero un procedimiento de control para cuando la variable texto está vacía o no es válida
  • A continuación la variable texto se convierte a str y se normaliza a minúscula, pasando esta doble conversión a la varible dato
  • Después construímos una diccionario de meses:numerales meses_map para capturar el contenido del campo que procesamos y que a esta función hemos pasado como parámetro def normalizar_fecha(texto)

Lo que viene a continuación es el núcleo central de la función, que se desarrolla dentro de una estructura de control de excepciones try...except, en la que la parte try controla la presencia en dato de la formulación de la fecha según el formato dd/mm/aaaa y la transformar una entrada un objeto de fecha puro Año-Mes-Día de la librería Pandas. La parte except controla la posible comisión de errores

Si la primera solución no resolvió el procesamiento de la variable, la segunda utiliza la expresión regular re.search(r'(\d{4})', dato) para localizar y obtener el dato año (4 dígitos dentro del texto) y si lo encuentra recorre el listado de meses para ver si el término nombre del mes está escrito en dato. Si lo está, sobre el dato año y la conversión numérica del dato mes se construye una fecha, usando 1 como dato día.

Con este script hemos normalizado reformulandolo el campo fecha para que sea posible trabajar con esta variable en la fase de análisis de datos. El resultado es una nueva columna o campo (fecha_corregida). Cierto que que no todos los datos se han podido modificar según lo esperado debido a que el dato original no se ajusta a las formas esperadas. esto puede dar lugar a una nueva pérdida de datos, aunque al ser una circunstancia controlada y de relativa poca importancia, también podemos optar por realizar una última revisión "manual" a fin de evitar una pérdida de datos innecesaria y no deseada. Llegados a este punto, no es una mala solución.

sábado, 9 de mayo de 2026

DATOS. Tratamiento de datos

Limpieza de datos (I)

Datos faltantes

Es muy frecuente que en una colección de datos de cierta entidad se observen campos en blanco o con una marca sustituta (ver tabla abajo), a consecuencia de diversos motivos, incluídos los errores de recogida de datos y la simple ausencia de éstos por no producirse determinada respuesta. Lo que en realidad importa para su tratamiento posterior es que las ausencias sean razonablemente escasas; en caso contrario, la calidad del conjunto de datos se ve muy seriamente comprometida.

Entorno Elemento
Python puro None
Data Science (Pandas/NumPy) NaN
Base de datos (SQL) NULL
Lenguaje R NA

Las opciones disponibles para hacer frente a esta realidad son varias, desde la eliminación del registro hasta el relleno del campo con determinado valor, resultante de algún tipo de cálculo. Para conocer cuales son esas alternativas, además de consultar a la IA, que lo que hace es resumir el conjunto de posibilidades disponibles, sustituyendo así a una simple búsqueda web, también podemos consultar alguna página específicamente pensada para tratar este tema. Yo aquí te ofrezco un ejemplo de la segunda opción; la primera corre de tu cuenta.

No es por comodidad, pero en este caso voy a optar por la forma más simple de resolver el problema: eliminando el registro. No es precisamente la mejor solución, especialmente cuando no disponemos de muchos registros, pero sí la más adecuada para un caso como el que nos ocupa en el que no hay la pretensión de representatividad estadística ni interés por crear un procedimiento de (aprendizaje automático (AA). Además, en este caso, en la mayoría de los registros faltan todos los datos que pueden faltar, dado que son resultado de una opción de tratamiento del documento que ahora no me intersa comentar; sirva con decir que las tablas simplemente no están cumplimentadas, por lo que es hasta coherente eliminar estos registros. Puede que no lo sea tanto en los casos en que sólo falta la fecha, pero son muy escasos y el riesgo real de pérdida de información es mínimo.



import pandas as pd
import os
import numpy as np

# --- Función ---

def limpiar_tabla_especifica(ruta_absoluta):
    if not os.path.exists(ruta_absoluta):
        print(f"Error: No se localiza el archivo en {ruta_absoluta}")
        return

    try:
        df = pd.read_csv(ruta_absoluta, sep=';', engine='python')   # 1. Carga los datos con el separador identificado (sep=';')
        total_inicial = len(df)                                     # Conteo inicial para calcular los registros afectados

        df = df.replace(r'^\s*$', np.nan, regex=True)               # 2. Convertir espacios vacíos (" ") en nulos reales (NaN)

        columnas_a_validar = ['fecha', 'SEO', 'OE']                 # 3. Eliminar registros si falta dato en fecha-SEO-OE
        df_limpio = df.dropna(subset=columnas_a_validar)

        total_final = len(df_limpio)                                # 4. Cálcular los registros eliminados
        eliminados = total_inicial - total_final

        ruta_directorio = os.path.dirname(ruta_absoluta)            # 5. Exportar el resultado a csv
        nombre_salida = "lista_t1_sin_nulos.csv"
        ruta_salida = os.path.join(ruta_directorio, nombre_salida)

        df_limpio.to_csv(ruta_salida, sep=';', index=False)

        print("-" * 30)                                              # 6. Informe a mostrar por consola
        print("INFORME DE PROCESAMIENTO")
        print("-" * 30)
        print(f"Registros analizados: {total_inicial}")
        print(f"Registros eliminados (faltaba fecha, SEO o OE): {eliminados}")
        print(f"Registros válidos restantes: {total_final}")
        print(f"Archivo generado: {ruta_salida}")

    except Exception as e:
        print(f"Se produjo un error durante la ejecución: {e}")

# --- Llamada a la función ---

ruta_csv = r"" 														# Aqui la ruta de tu archivo csv
limpiar_tabla_especifica(ruta_csv)                                  # Llamada a la función


Mediante este script eliminamos los registros que carecen de datos en las columnas (variables) de interés columnas_a_validar = ['fecha', 'SEO', 'OE'], cosa que sucede gracias al uso de la función df.dropna() de Pandas (df_limpio = df.dropna(subset=columnas_a_validar)). Al especificar el identificador de las columnas hacemos que el script sea dependiente de la tabla, a la vez que nos permite identificar lo que deberemos cambiar si cambiamos de tabla.

Y hablando de especificidades, debo decir que para que el script funcione ha sido necesario especificar el separador de campos de la tabla (df = pd.read_csv(ruta_absoluta, sep=';', engine='python')), ya que el csv-base utiliza ; en vez del esperado (,) por defecto por Pandas.

El resultado tiene una doble expresión: archivo como csv (comentario 5 del script) se muestra una síntesis por consola (comentario 6). No proporciono ninguna prueba por innecesaria; es suficiente con que pienses en la última tabla de esta entrada sin el registro INF_003.dot.

viernes, 8 de mayo de 2026

DATOS. Tratamiento de datos

Organización de datos

Datos semi-estructurados

Cuando trabajamos con tablas-formulario (en documentos .odt en nuestro caso, aunque podrían estar ubicadas en otro tipos de documentos) fuimos capaces de extraer todos los datos que contenían, pero, como quedó dicho en ese momento, obtenemos tanto las etiquetas (identificadores de los campos) como los datos propiamente dicho. Esto conlleva que las tablas no sean directamente utilizables dentro de un planteamiento de automatización de ese uso, ya que estaríamos considerando una etiqueta como dato. Por ello es necesario reorganizarlas, dando a cada contenido su función específica, lo que equivale a convertir a estos datos de semi-estructurados a estructurados.

Para concretar lo que significa esta reorganización de los datos, vamos a trabajar con una tabla resultante del procedimiento de extracción desarrollado en entradas precedentes (por ejemplo). Por motivos que entenderás óbvios, me limitaré a mostrar únicamente unos pocos registros anonimizados para que quede claro cómo se presenta la tabla inicialmente y cómo debería quedar al finalizar el procedimiento. En este punto, ese procedimiento ha sido realizado manualmente, pero la idea es que se ejecute de forma automatizada, mediante un script Python.

Pero recordemos antes el origen de los datos:

... para visualizar a continuación la tabla que deberemos reorganizar:

Detengámonos un momento en analizar ambas imágenes (que es lo que son, capturas de pantalla modificadas) para concretar lo que dijimos al inicio de esta entrada: aunque capturamos integralmente el contenido de la tabla de formacorrecta, el resultado (precisamente por ello) no es directamente utilizable o, lo que es lo mismo, estos datos se presentan como datos estructurados (filas-columnas) pero no están debidamente organizados ni limpios. Pero por ahora nos centraremos en la primera cuestión, que tiempo habrá para tratar la segunda.

Las tres primeras columnas son directamente válidas, pero las que restan necesitan ser reorganizadas. En otro tipo de tablas, es posible que ni siquuera pasáramos de las dos primeras, y eso porque han sido generadas mediante el script, al margen de la recuperación de datos propiamente dicha. Es por eso que, en esta tabla, todo lo que no son datos identicativos del registro es necesario mapearlo para reconocer su naturaleza como etiquetas o como datos. Pero para hacer esto debemos fijarnos en dos cuestiones: la variedad de estructuras que presenta la tabla y las etiquetas que haya generado el script.

No existe una única estructura aunque visualamente no observemos, en algunos casos, esas diferencias. La tabla-formulario que mostramos (informe, no dictamen, por ajustarse a los datos obtenidos que mostramos) sólo permite identificar 6 celdas y una estructura de 2x3, pero en la tabla resultante comprobamos primero que existe una diversidad de estructuras (2x4, 2x3, 3x3) con un predomino de una de ellas (2x4), que es lo que explica las etiquetas (o campos): A1 - B1 - D1 - A2 - B2 - C2. Al ser la estructura predominante es a la que se adapta la tabla resultante; en ella no se recoge la celda B1, pero tampoco la celda D2, como sería de esperar según la diversidad de estructuras. Esto facilita, en términos generales, la reorganizar la tabla, ya que deberemos ajustarnos a los identificadores y no a la diversidad de estructuras detectadas, pero tampoco a lo que visualmente observamos, sino a lo que debemos inferir en función de las etiquetas establecidas por el script: C1 es asimilable a D1, lo que resuelve la reorganización de la mayoría de los registros (tipos 2x3 y 2x4), aunque es posible que algunos de los que se ajustan a la estructura 3x3 deberán ser objeto de una atención específica. Esta estructura responde a tablas en las que se diferencia la intervención de al menos dos profesionales, quedando el segundo fuera del esquema de la tabla. Realmente no se contempló en el procedimiento de reorganización que aquí se expone, lo que implica que éste deberá desarrollarse en al menos dos fases.

Con todos esos conocimientos, el profesional que realiza la reestructuración de la tabla, si lo hace manualmente (cosa que aquí no es especialmente costoso), deberá identificar qué campos (columnas) contienen etiquetas [A1(C) - B1(D) - B2(G)] y cuáles datos [D1(E) - A2(F) -C2(H)]. LO que resta es reformular las etiquetas que corresponden y reubicar esos bloques de forma lógica, según se espera en una colección (tabla) de datos estructurados. Este sería el resultado (lo que se aprecia en el documento INF_003 corresponde a la realidad: ese documento carece de datos):

Si queremos automatizar este mismo procedimiento, el script que sigue nos permitirá hacerlo para los registros cuya estructura se ajuste a los modelos 2x4 y 2x3, pero no para los esquemas 3x3.



import csv
import os
from datetime import datetime

# --- Función secundaria 1. Registro de errores ---

def registrar_error_log(ruta_log, nombre_fichero, mensaje_error):

    fecha_hora = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    try:
        with open(ruta_log, mode='a', encoding='utf-8') as f_log:
            f_log.write(f"[{fecha_hora}] FICHERO: {nombre_fichero} | ERROR: {mensaje_error}\n")
    except Exception as e:
        print(f"Error crítico: No se pudo escribir en el log de errores: {e}")

# --- Función secundaria 2. Reestructuración de BD (csv)

def registrar_en_csv_rev(ruta_salida, datos_mapeados):

    campos = ['ARCHIVO_ORIGEN', 'ESTRUCTURA', 'fecha', 'SEO', 'OE']
    archivo_existe = os.path.exists(ruta_salida)
    
    try:
        with open(ruta_salida, mode='a', encoding='utf-8', newline='') as f_rev:
            escritor = csv.DictWriter(f_rev, fieldnames=campos, delimiter=';')
            if not archivo_existe:
                escritor.writeheader()
            escritor.writerow(datos_mapeados)
        return True, None
    except Exception as e:
        return False, str(e)

# --- Función principal ---

def ejecutar_procesamiento_batch(ruta_csv, filtro_nombre, filtro_estruc):
    
    if not os.path.exists(ruta_csv):
        print(f"Error: No se encuentra el archivo maestro en {ruta_csv}")
        return

    dir_name = os.path.dirname(ruta_csv)                                                # Rutas de salida
    base_name = os.path.splitext(os.path.basename(ruta_csv))[0]
    ruta_rev = os.path.join(dir_name, f"{base_name}_REV.csv")
    ruta_log = os.path.join(dir_name, f"{base_name}_ERRORES.txt")

    try:
        with open(ruta_csv, mode='r', encoding='utf-8-sig') as f:
            muestra = f.read(2048)
            dialecto = csv.Sniffer().sniff(muestra)
            f.seek(0)
            
            lector = csv.DictReader(f, dialect=dialecto)
            
            print(f"--- INICIANDO PROCESAMIENTO AUTOMÁTICO ---")
            
            for fila in lector:
                orig = (fila.get('ARCHIVO_ORIGEN') or "DESCONOCIDO").strip()
                tipo = (fila.get('ESTRUCTURA') or "").strip()

                if filtro_nombre in orig and tipo == filtro_estruc:
                    registro_rev = {                                        # Mapeo de datos
                        'ARCHIVO_ORIGEN': orig,
                        'ESTRUCTURA': tipo,                                 # Datos ajustados para tabla 3x3
                        'fecha': (fila.get('A2') or "").strip(),            #  'fecha': (fila.get('C2') or "").strip()
                        'SEO': (fila.get('D1') or "").strip(),              #  'SEO': (fila.get('D1') or "").strip()
                        'OE': (fila.get('C2') or "").strip()                #  'OE': (fila.get('B2') or "").strip()
                    }
                    
                    exito, error_msg = registrar_en_csv_rev(ruta_rev, registro_rev)     # Proceso de guardado (función secundaria 2)
                    
                    if exito:
                        print(f"[OK] {orig} procesado correctamente.")
                    else:
                        print(f"[AVISO] Fallo en {orig}. Registrando en log...")
                        registrar_error_log(ruta_log, orig, error_msg)				# Llamada (condicionada) a la función secundaria 1

            print(f"--- PROCESAMIENTO FINALIZADO ---")

    except Exception as e:
        print(f"Error general en la lectura del CSV maestro: {e}")

# --- Llamada a la función principal ---

if __name__ == "__main__":
    
    RUTA_SISTEMA = r"ruta_de_mi_archivo.csv"           # Aquí la ruta absoluta (incluido nombre) de la tabla CSV a reestructurar
    TIPO_DOC = "INF"                                   # Aquí el identificador del tipo de archivo (DE vs. INF)
    ESTRUCTURA = "2x4"                                 # Aquí el identificador del tipo de estructura (2x3, 2x4)
    
    ejecutar_procesamiento_batch(RUTA_SISTEMA, TIPO_DOC, ESTRUCTURA)


El resultado para los registros 2x3 y 2x4 es el positivo, ya que el script de extracción previo asimiló las celdas, según expliqué en el párrafo anterior a la presentación del script, así que la tabla de reformulación automatizada de la estructura es la misma que la resultante del procedimiento manual. Así que nos ahorramos repetirla.

Por explicar el script, decir que, como se puede ver, está compuesto por tres funciones, dos secundarias y la principal, y el ejecutor de la función princial. Empezando por éste, se diferencian en él las variables que el usuario deberá adaptar a su caso (siempre con la limitación de la tabla original, tanto de los documentos de informe como de dictamen de los modelos asturianos): ruta del csv a reformular, identificador del tipo de documento e identificador del modelo de tabla. Este script llama a la función principal pasando los datos anteriores como parámetros y esta función, además de ejecutar su cometido, llama a las funciones secundarias o auxiliares (ver los comentarios). Destacar en esta función principal el segmento de código encargado del mapeo de los datos, entre otras cosas, porque es el que deberemos adaptar a nuestras necesidades, por ejemplo para procesar los registro 3x3 (en comentarios se concreta esa alternativa)

La función secundaria 1 se activa de forma condicionada, por lo que no necesariamente se ejecuta. Tiene como objetivo crear un regisgtro (txt) de errores en el proceso, pero no he observado que se ejecute. La que sí se ejecuta (afortunadamente) es la función secundaria 2ª, ya que su comentido es crear el archivo csv de reestructuración de la tabla.

miércoles, 6 de mayo de 2026

DATOS. Archivos de texto

Archivos de texto

Acceso a contenidos específicos

No tengo muy claro si esta entrada debe situarse en esta subsección (Acceso a datos) o si debería ubicarse en la que sigue (Limpieza de datos), entendida en sentido amplio, pero posiblemente esto no es lo más importante. Lo que interesa es el concepto que se trata en ella y lo que implica. Antes de decir algo más al respecto, es necesario advertir que, en cualquier caso, ahora sólo trataremos estas cuestiones en términos muy básicos y limitados, ya que será necesario retomar el tema cuando hablemos de organización y limpieza de los datos no estructurados y, como no puede ser de otro modo, también en la subsección Uso de datos.

En las entradas anteriores hemos estado tratando cuestiones relativas al acceso a los datos de los textos como un todo, diferenciando si este contenido se encuentra ubicado en tablas o si conforma párrafos más o menos extensos. Esta diferención lo es también de datos vs. textos, o si se preferie (y yo sí lo prefiero) entre datos semi-estructurados frente a datos no estructurados. En sentido estricto, ningun documento contiene datos estructurados, así que lo más parecido a éstos son los datos semi-estructurados que encontramos en las tablas y en las tablas-formulario de los documentos. Pero ahora nos hemos alejado de estos entornos y nos hemos enfrentado al texto en sentido estricto, lo que equivale a decir a los datos no estructurados; y ante estos el mero acceso (y "captura") sólo puede ser una primera (y muy necesaria) fase de un proceso considerablemente complejo que requiere varios subprocesos. Lo que ahora abordamos sería un intento de concretar una opción de posible segunda fase.

Y es que de poco sirve capturar un texto si no obtenemos información de él. Pasa lo mismo cuando hablamos del tratamiento analógico de los textos, pero es mucho más definitorio (y difícil de llevar a cabo) cuando el tratamiento es digital. Podemos concretarlo de muchas formas, así que la que ahora voy a proponer es sólo una de ellas, y no precisamente de las de mayor complejidad.

En el marco del acceso al contenido de los textos de una colección de informes psicopedagógicos, deseamos identificar si en ellos se hace alguna mención al uso del test (batería) WISC. Esto implica interés por saber si este recurso se ha empleado, con qué peso cuantitativo en la muestra documental y qué información se asocia con ese uso.

El objetivo simple, identificar uso vs. no-uso del WISC, no parece ofrecer mayor dificultad, pero acceder al contenido textual asociado a esta etiqueta conlleva cierto nivel de complejidad, que nos proponemos abordar de la forma más directa y simple posible, lo que no garantiza que sea la mejor, aunque según cual sea nuestro objetivo puede ser suficiente. Sí lo es para el objetivo que nos planteamos en esta entrada.



import os
import csv
from odf.opendocument import load
from odf import text

# --- Función secundaria 1: Extracción lineal de párrafos ignorando tablas. ---

def extraer_parrafos_no_tablas(ruta_archivo):

    try:
        doc = load(ruta_archivo)
        parrafos_limpios = []
        for p in doc.getElementsByType(text.P):
            parent = p.parentNode					 # Filtro de tablas por ancestros
            dentro_de_tabla = False
            while parent is not None:
                if parent.tagName == "table:table":
                    dentro_de_tabla = True
                    break
                parent = parent.parentNode
            
            if not dentro_de_tabla:
                contenido = "".join(node.data for node in p.childNodes if node.nodeType == 3)	 # Unimos todos los nodos de texto
                if contenido.strip():
                    parrafos_limpios.append(contenido.strip())
        return parrafos_limpios
    except Exception as e:
        print(f"   [!] Error de lectura en {os.path.basename(ruta_archivo)}: {e}")
        return []

# --- Función secundaria 2: Captura el párrafo del hallazgo y los N siguientes para asegurar el contexto. . ---

def extraer_segmento_contiguo(lista_parrafos, termino, num_posteriores=4):
   
    segmentos_completos = []
    indices_ya_incluidos = set()

    for i, texto in enumerate(lista_parrafos):
        if termino.lower() in texto.lower() and i not in indices_ya_incluidos:
            rango_fin = min(i + num_posteriores + 1, len(lista_parrafos))		# Iniciamos bloque
            bloque = lista_parrafos[i:rango_fin]
            
            for j in range(i, rango_fin):		 # Marcamos para no repetir si el término aparece en los párrafos de este bloque
                indices_ya_incluidos.add(j)
            
            segmentos_completos.append("\n\n".join(bloque))
            
    return segmentos_completos

# --- Función principal ---

def procesar_informes(dir_entrada, csv_salida, palabra_clave):
    if not os.path.exists(dir_entrada):
        print(f"La ruta {dir_entrada} no existe.")
        return

    archivos = [f for f in os.listdir(dir_entrada) if f.lower().endswith('.odt')]
    resultados = []

    print(f"Procesando {len(archivos)} archivos...\n")

    for nombre in archivos:
        ruta = os.path.join(dir_entrada, nombre)
        parrafos = extraer_parrafos_no_tablas(ruta)		# Llamada a función secundaria 1
        
        hallazgos = extraer_segmento_contiguo(parrafos, palabra_clave, num_posteriores=4)	 # Llamada a función secundaria 2
        
        estado = "PRESENTE" if hallazgos else "AUSENTE"
        print(f"[{estado}] {nombre}")
        
        resultados.append({
            'Archivo': nombre,
            'Hallazgo': estado,
            'Texto': " |SECCIÓN SIGUIENTE| ".join(hallazgos) if hallazgos else "N/A"
        })

    try:
        with open(csv_salida, mode='w', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=['Archivo', 'Hallazgo', 'Texto'])
            writer.writeheader()
            writer.writerows(resultados)
        print(f"\nCSV generado con éxito en: {csv_salida}")
    except Exception as e:
        print(f"Error al escribir CSV: {e}")

# --- Llamada a función ---

if __name__ == "__main__":
    RUTA_ARCHIVOS = r"ruta_de_directiro_de_documentos"		# Ruta de acceso a la colección de documento
    RUTA_CSV = r"ruta_destino_y_nombre_archivo.csv"			# Ruta para ubicación de csv e identificador del archivo
    TERMINO = "WISC"										# Término objeto de estudio

    procesar_informes(RUTA_ARCHIVOS, RUTA_CSV, TERMINO)


Lo que hacemos con este script es, en primer lugar prescindir de las tablas del documento y de los datos que éstas contienen para centrarnos en la extracción de los textos (párrafos). Dentro de ellos, buscamos la aparición del término-diana (aquí WISC) y lo relacionamos con su contexto (texto inmediatamente próximo al término-diana) para capturar el contenido que se asocia al mismo- Esto nos permite acceder no sólo a información sobre la presencia vs. ausencia del término-diana en el documento, sino también al contenido asociado a dicho término, lo que supone una mayor complejidad del procedmiento de automatización, pero también que el script es capaz de facilitar información que incrementa significativamente nuestra capacidad de análisis de los documentos. No estamos en condiciones para asegurar que esto sea suficiente para objetivos complejos, pero sí para muchos otros más simples. En todo caso sólo estamos ante un procedimiento básico. En otras subsecciones trataremos cómo desarrollar otras.

Presento también el primer script de una serie de tres (el anterior es el tercero) como punto de referencia para comprender la línea de desarrollo que se pretende explictar y que se concreta fundamentalmente como incremento del contexto textual que rodea al término-diana.



import os
import csv
from odf.opendocument import load
from odf import text

#--- Función secundaria. Filtar tablas ---

def extraer_parrafos_no_tablas(ruta_archivo):
    try:
        doc = load(ruta_archivo)
        parrafos_validos = []
        for p in doc.getElementsByType(text.P):
            dentro_de_tabla = False
            parent = p.parentNode
            while parent is not None:
                if parent.tagName == "table:table":
                    dentro_de_tabla = True
                    break
                parent = parent.parentNode
            if not dentro_de_tabla:
                contenido = "".join(node.data for node in p.childNodes if node.nodeType == 3)
                if contenido.strip():
                    parrafos_validos.append(contenido.strip())
        return parrafos_validos
    except Exception as e:
        print(f"Error al leer el archivo {ruta_archivo}: {e}")
        return []
        
# --- Función principal --- 

def procesar_coleccion_odt(directorio_entrada, ruta_csv, termino):
    print(f"Buscando en: {directorio_entrada}...")
    
    if not os.path.exists(directorio_entrada):
        print(f"ERROR: La carpeta no existe: {directorio_entrada}")
        return

    archivos = [f for f in os.listdir(directorio_entrada) if f.lower().endswith('.odt')]
    print(f"Se han encontrado {len(archivos)} archivos .odt")

    if len(archivos) == 0:
        print("No hay nada que procesar. Revisa la extensión de los archivos.")
        return

    resultados = []
    for nombre_archivo in archivos:
        ruta_completa = os.path.join(directorio_entrada, nombre_archivo)
        parrafos = extraer_parrafos_no_tablas(ruta_completa)
        hallazgos = [p for p in parrafos if termino.lower() in p.lower()]
        
        presencia = "PRESENTE" if hallazgos else "AUSENTE"
        print(f"Procesado: {nombre_archivo} -> {presencia}")
        
        resultados.append({
            'Nombre del Archivo': nombre_archivo,
            'Presencia Termino': presencia,
            'Contenido Extraído': " | ".join(hallazgos) if hallazgos else "N/A"
        })

    try:
        with open(ruta_csv, mode='w', newline='', encoding='utf-8') as f:
            writer = csv.DictWriter(f, fieldnames=['Nombre del Archivo', 'Presencia Termino', 'Contenido Extraído'])
            writer.writeheader()
            writer.writerows(resultados)
        print(f"\nÉXITO: Archivo creado en {ruta_csv}")
    except Exception as e:
        print(f"ERROR al crear el CSV: {e}")

# --- LLAMADA AL SCRIPT ---

if __name__ == "__main__":
    RUTA_DOCS = r"ruta_archivos_a_procesar"				 # Definición de variables de configuración
    RUTA_OUT  = r"ruta_del_archivo.csv"
    OBJETIVO  = "WISC"

    procesar_coleccion_odt(RUTA_DOCS, RUTA_OUT, OBJETIVO)
    

Para comprender lo que conseguimios con estos archivos, nada mejor que un breve estudio de resultados, aunque sin ninguna pretensión de representatividad; tan sólo a nivel de indicio. Analizo a continuación los 14 primeros archivos de una colección significativamente más amplia, pero que ahora no interesa ya que en esta entrada no pretendo realizar ningún estudio (cosa que puede quedar pendiente para otro momento).

De estos 14 archivos, sólo en tres se identifica el término-diana (WISC), lo que ahora es prácticamente irrelevante, pero que dejaría de serlo en un estudio orientado a valorar el grado de uso de un determinado recurso como es la escala WISC en sus diferentes versiones. Lo que sí es relevante ahora es comprender las diferencias que se aprecian en términos de recuperación de la información asociada al término-diana entre el primero y el tercero de los script que se desarrollaron para logar esta meta. De paso, es necesario destacar que existe una diferencia importante entre este modelo de trabajo y lo que sería la mera identificación de la presencia del término. Veamos esa evolución:

Vemos que existen notables diferencias entre los tres archivo, las cuales se deben fundamentalmente al peso real de los datos asociados al término-diana en cada uno de los documento (otra parte se puede entender asociada al mayor o menos éxito del procedimiento de obtención de datos); pero lo que resulta más importante es la evolución entre el primer y el tercer script, que en este gráfico se presenta en términos absolutos (número de palabras por segmento textual y versión del script.

Si lo expresamos en términos porcentuales, algunos datos pueden contribuir a la mejor comprensión del resultado:

  1. Salvo en el primer documento, en los otros dos el incremento obedece al esquema [Tv1 menor que Tv2 menor que Tv3]. En ese primer documento, se aprecia una ligera disminución del número de palabras, pero también es ese documento el que mayor incremento presenta entre el Tv1 y Tv2 (concretamente algo más del 466%)
  2. Esto quiere decir que el script que mejores resultados ofrece (como cabe esperar) el tercero (salvo para el primer documento, que es el segundo script).
  3. La ganancia que se obtiene con este tercer script respecto al primero es evidente: más del 400% en el documento de menos impacto, pero por encima del 700% en los otros dos, concretamente el 788% en uno y algo más del 900% en el otro.

Dado que no se trata de un estudio con intención de ser representativo, estos datos no se deben extrapolar, pero son suficientemente reveladores que lo que interesa mostrar aquí: podemos desarrollar procedimientos que facilitan el acceso selectivo a datos relativos a determinado término, aunque faltan datos que permitan identificar con propiedad la calidad de estos resultados. También esta importante cuestión queda para un análisis específico y para el desarrollo de otros procedimientos alternativos.

DATOS. Archivos de texto

Archivos .odt

Acceso a tablas y textos

Aunque no aporte mucho a lo que ya sabemos, no podemos dejar de exponer los procedimientos que nos permiten acceder al contenido de los archivos .odt, dada la frecuencia con la que trabajamos con estos archivos en este blog. Así vamos a replicar aquí lo que ya hicimos en esta entrada con los archivos .docx.



import os
import sys
import io
from odf import text, table, teletype
from odf.opendocument import load

sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

# --- Función ----

def leer_contenido_odt(ruta_archivo):
    if not os.path.exists(ruta_archivo):				    # Controla que existe el archivo
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return

    try:
        doc = load(ruta_archivo)				    		# Cargar el documento ODT
    except Exception as e:
        print(f"Error al cargar el archivo: {e}")
        return
    
    print(f"--- INICIO DEL CONTENIDO: {ruta_archivo} ---\n")

    contenido_principal = doc.text				 		 # Accedemos al texto

    for elemento in contenido_principal.childNodes:
        
        if elemento.tagName in ["text:p", "text:h"]:		# 1. Párrafos y Encabezados (h = heading, p = paragraph)
            texto = teletype.extractText(elemento).strip()
            if texto:
                etiqueta = "TÍTULO" if elemento.tagName == "text:h" else "PÁRRAFO"  # Diferenciamos si es título o párrafo
                print(f"[{etiqueta}]: {texto}")
        elif elemento.tagName == "table:table":				# 2. Tablas
            filas = elemento.getElementsByType(table.TableRow)
            nombre_tabla = elemento.getAttribute("name") or "Tabla"
            
            print(f"\n[--- INICIO {nombre_tabla} ---]")
            for fila in filas:
                celdas = fila.getElementsByType(table.TableCell)					# Extraemos el texto de cada celda
                contenido_fila = [teletype.extractText(celda).strip() for celda in celdas]
                if any(contenido_fila):												# Solo imprimimos la fila si tiene algún contenido
                    print(" | ".join(contenido_fila))
            print(f"[--- FIN {nombre_tabla} ---]\n")

    print(f"\n--- FIN DEL DOCUMENTO ---")

# --- Llamada a función ---

if __name__ == "__main__":
    nombre_archivo = r"ruta_de_mi_archivo.odt"  # Aquí el nombre del archivo .odt
    leer_contenido_odt(nombre_archivo)			# Llamada a la función


Ahora toca identificar sólo las tablas...


  
import os
import sys
import io
from odf import table, teletype
from odf.opendocument import load

# Configuración para que la consola de Windows maneje correctamente caracteres especiales
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

# --- Función de extracción de tablas ---

def extraer_tablas_odt(ruta_archivo):

    if not os.path.exists(ruta_archivo):							# Nombre del archivo a procesar
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return
    
    try:															# Cargar el documento ODT
        doc = load(ruta_archivo)
    except Exception as e:
        print(f"Error al cargar el archivo: {e}")
        return
    
    print(f"--- EXTRACCIÓN DE TABLAS: {ruta_archivo} ---\n")

    # Buscamos todas las tablas en el documento mediante getElementsByType()
    tablas = doc.getElementsByType(table.Table)

    if not tablas:
        print("No se encontraron tablas en el documento.")
        return

    for i, t in enumerate(tablas):
        nombre_tabla = t.getAttribute("name") or f"Tabla {i+1}"
        print(f"[--- INICIO {nombre_tabla} ---]")
        
        filas = t.getElementsByType(table.TableRow)
        for fila in filas:
            celdas = fila.getElementsByType(table.TableCell)
            
            contenido_fila = [teletype.extractText(celda).strip() for celda in celdas]	# Extraemos el texto de cada celda
            
            if any(contenido_fila):														# Imprimimos la fila solo si contiene algún texto
                print(" | ".join(contenido_fila))
        
        print(f"[--- FIN {nombre_tabla} ---]\n")

    print(f"--- FINALIZADO ---")
    
# --- Llamada a la función ---

if __name__ == "__main__":
    nombre_archivo = r"ruta_de_mi_archivo.odt" 	# Aquí la ruta del archivo
    extraer_tablas_odt(nombre_archivo)			# Llamada a la función
    

Para finalizar vamos a mostrar el script que únicamente accede a los párrafos del documento, omitiendo el contenido de las tablas y de tablas-formulario.



import os
import sys
import io
from odf import text, teletype
from odf.opendocument import load

# Configuración para que la consola de Windows maneje correctamente caracteres especiales
sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')

# --- Función de extracción de texto (párrafos) ---

def leer_solo_parrafos_odt(ruta_archivo):
  
    if not os.path.exists(ruta_archivo):							 # Verificar si el archivo existe
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return

    try:
        doc = load(ruta_archivo)									# Cargar el documento ODT
    except Exception as e:
        print(f"Error al cargar el archivo: {e}")
        return
    
    print(f"--- CONTENIDO TEXTUAL (SIN TABLAS): {ruta_archivo} ---\n")

    contenido_principal = doc.text									# Accedemos al elemento de texto del cuerpo

    for elemento in contenido_principal.childNodes:					# Iteramos sobre los elementos del cuerpo
        
        if elemento.tagName in ["text:p", "text:h"]:				# Filtramos: Solo nos interesan párrafos (p) y encabezados (h)
            texto = teletype.extractText(elemento).strip()
            
            if texto:												# Solo imprimimos si el párrafo no está vacío
                # Opcional: puedes quitar la etiqueta [PÁRRAFO] si quieres el texto limpio
                etiqueta = "TÍTULO" if elemento.tagName == "text:h" else "PÁRRAFO"
                print(f"[{etiqueta}]: {texto}")

    print(f"\n--- FIN DEL DOCUMENTO ---")

# --- Llamada a la función ---

if __name__ == "__main__":
    nombre_archivo = r"ruta_de_mi_archivo.odt" 		# Aquí la ruta del archivo a trabajar 
    leer_solo_parrafos_odt(nombre_archivo)			# Llamada a la función


martes, 5 de mayo de 2026

DATOS. Archivos de texto

Archivos .docx

Acceso a tablas y textos

Dado que ya hemos hablado de los archivos de texto .docx (por ejemplo, aquí), resulta un poco complicado plantear esta entrada sin que resulte repetitiva, aunque el intento no carece de sentido. En aquel momento hablamos de los documentos .docx desde una perspectiva de generación de los mismos (aunque se trataran también otros temas), y ahora nuestro interés se centra en la obtención de datos de documentos ya creados, fundamentalmente datos textuales y contenidos contenidos en tablas, lo que equivale a decir datos no estructurados y datos que aspiran a ser considerados como datos estructurados, pero que aun no alcanzan este nivel de organización (datos semi-estructurados).

La biblioteca python-docx, ya presentada en relación con la temática antes señalada será también la herramienta que nos ayude a acceder al contenido de los documentos .docx, que son una evolución compleja de los .doc primitivos, implementando la arquitectura XML, lo que facilita el manejo del contenido mediate script Python, que se hace precisamente manejando esos componentes xml.

A nosotros lo que realmente nos importa ahora, desde la perspectiva de esta subsección, es el acceso al contenido, diferenciando si este se presenta en formato de tabla (mejor tabla-formulario), que, como dije, se considera como dato semi-estructurado, aunque no siempre lo sea, frente al texto no-tabla (párrafos), que se consideran datos no estructurados. Respecto a las tablas, dado que también se emplean para formatear la presentación del contenido, en algunas ocasiones éste no es en realidad un dato semi-estructurado; se trata de un segmento textual no estructuardo y como tal debe ser tratado. A veces esta diferencia es de detalle, lo que da lugar a confusiones en el planeamiento de cómo debe ser tratado en los procesos de limpieza y de análisis.

No es esta una cuestión que sólo afecte a los documentos .docx, pero lo trataremos aquí para avanzar propuestas, dado que es una cuestión de importancia dentro de la subsección en la que nos encontramos en este punto.Pero antes de abordar esta cuestión resolvamos primero las más básicas: el acceso al contenido en su conjunto y el acceso al contenido de forma diferenciada: tablas y textos.



import docx
import os

def leer_contenido_docx(ruta_archivo):
    if not os.path.exists(ruta_archivo):			    		# Verificar si el archivo existe
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return
    doc = docx.Document(ruta_archivo)					  		# Cargar el documento

    print(f"--- INICIO DEL CONTENIDO: {ruta_archivo} ---\n")
    
    for elemento in doc.element.body:							# Acceso secuencial a todos los elementos del cuerpo del documento
        if isinstance(elemento, docx.oxml.text.paragraph.CT_P): # 1. Si el elemento es un párrafo (CT_P)
            p = docx.text.paragraph.Paragraph(elemento, doc)
            if p.text.strip(): # Evitar mostrar líneas vacías si se desea
                print(f"[PÁRRAFO]: {p.text}")
        elif isinstance(elemento, docx.oxml.table.CT_Tbl):		# 2. Si el elemento es una tabla (CT_Tbl)
            tabla = docx.table.Table(elemento, doc)
            print(f"\n[TABLA INICIO - {len(tabla.rows)} filas x {len(tabla.columns)} columnas]")
            for fila in tabla.rows:
                contenido_fila = [celda.text.strip() for celda in fila.cells]  # Extraemos el texto de cada celda
                print(" | ".join(contenido_fila))
            print("[TABLA FIN]\n")

    print(f"\n--- FIN DEL DOCUMENTO ---")
    
# --- Llamada a la función ---

if __name__ == "__main__":
    nombre_archivo = r"Directorio_de_mi_archivo.docx" 	# Aquí la ruta de tu_archivo.docx'
    leer_contenido_docx(nombre_archivo)


Este script permite acceder a un documento .docx, identifica su contenido, diferenciando tablas de párrafos y muestra todo ese contenido en el CMD señalando la diferencia entre el procedente de una tabla del identificado como párrafo. Esta diferenciación ya señala la posibilidad de acceder a datos semi-estructurado (tablas y tablas-formulario) y a datos no estructurados (párrafos) de forma diferenciada. El siguiente script permite el acceso a las tablas del documento y a su contenido. A partir de aquí podríamos desarrollar procedimientos específicos de acceso a datos concretos. La idea a posteriori es facilitar la transformación de estos datos semi-estructurados en datos estructurados, para tratarlo con los procedimiento del organización y limpieza, y de análisis acordes con los datos de esa naturaleza.



import docx
import os

#Función principal: exploración de las tablas del documento

def leer_tablas_docx(ruta_archivo):
    if not os.path.exists(ruta_archivo):
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return

    doc = docx.Document(ruta_archivo)

    print(f"--- RELACIÓN DE TABLAS ENCONTRADAS ---")
    
    tablas_limpias = []
    
    for i, tabla in enumerate(doc.tables):
        # Extraemos el nombre/título desde las propiedades XML de la tabla (tblPr)
        nombre_tabla = None
        try:
            # Buscamos en el elemento XML de la tabla el tag de título (tblCaption)
            nombre_tabla = tabla._element.xpath('.//w:tblCaption/@w:val')
            if nombre_tabla:
                nombre_tabla = nombre_tabla[0]
            else:
            # Intentamos con la descripción si el título falla
                nombre_tabla = tabla._element.xpath('.//w:tblDescription/@w:val')
                if nombre_tabla: nombre_tabla = nombre_tabla[0]
        except:
            nombre_tabla = None

        if not nombre_tabla:
            nombre_tabla = f"Tabla_{i+1}"
        
        tablas_limpias.append((nombre_tabla, tabla))
        print(f"ID: {i+1} | Nombre en Navegador: {nombre_tabla}")
    
    print("-" * 40 + "\n")

    for nombre, tabla in tablas_limpias:		# Mostramos el contenido de las tablas
        print(f"\n[CONTENIDO TABLA]: {nombre}")
        print("-" * (18 + len(nombre)))
        
        for fila in tabla.rows:
            textos_celdas = []			# Usamos un set para evitar celdas duplicadas en caso de celdas combinadas
            for celda in fila.cells:
                texto = celda.text.strip().replace('\n', ' ')
                textos_celdas.append(texto) 
            print(" | ".join(textos_celdas))
        print("-" * 20)
        
# --- Llamada a la función ---

if __name__ == "__main__":
    nombre_archivo = r"ruta_de_tu_archivo.docx" 	# Aquí tu ruta de archivo
    leer_tablas_docx(nombre_archivo)				# Llamada a la función


Mediante este otro script mostramos los párrafos (datos no estructurados), los cuales posteriormente deberan ser tratados con los procedimientos correspondiente. Es interesante observar que cada párrafo queda identificado por su posición, lo que puede facilitar su localización, aunque como procedimiento es poco funcional si pensamos en una obtención masiva de determinado contenido. De momento, algo es algo.



import docx
import os

def leer_texto_no_tabular(ruta_archivo):
    if not os.path.exists(ruta_archivo):				# Verificar si el archivo existe
        print(f"Error: El archivo '{ruta_archivo}' no existe.")
        return

    doc = docx.Document(ruta_archivo)		 			# Cargar el documento

    print(f"--- INICIO DEL CONTENIDO NO TABULAR: {ruta_archivo} ---\n")

    contador_parrafos = 0						 		# doc.paragraphs solo itera por los párrafos
    
    for i, para in enumerate(doc.paragraphs):
        texto = para.text.strip()						# Limpiamos espacios en blanco al inicio y final
        
        if texto:										# Omitir párrafos vacíos para una salida más limpia en CMD
            contador_parrafos += 1
            print(f"[{contador_parrafos}]: {texto}")	# Mostramos el índice del párrafo para facilitar el seguimiento
            print("-" * 10) # Separador visual opcional

    if contador_parrafos == 0:
        print("No se encontró texto fuera de tablas en este documento.")

    print(f"\n--- FIN DEL DOCUMENTO (Total párrafos: {contador_parrafos}) ---")

# --- Llamada a la función ---

if __name__ == "__main__":
    nombre_archivo = r"ruta_de_mi_documento.docx" 	 # Aquí tu archivo
    leer_texto_no_tabular(nombre_archivo)			 # Llamada a la función


DATOS. Directorios y archivos

Subdirectorios

En cuanto un directorio contiene un determinado número de archivos, y éstos se pueden diferenciar por algún criterio, es habitual que el directorio se divida, generándose una estructura de subdirectorios. Un caso concreto de esto son los expedientes SEO. Además de ser una tendencia lógica, que esto se produzca es una medida de la madurez del expediente y de la funcionalidad que éste tiene como recurso de intervención del SEO. Por ello el estudio de la estructura debe ser parte del análisis de los expedientes SEO. Este estudio se puede automatizar mediante script.

Voy a presentar en esta entrada algunos script dirigidos a facilitar la automatización en este nivel, empezando por la identificación del número de subdirectorios que contiene un listado de directorios.



from pathlib import Path
import csv
from collections import Counter

#Función secundaria. Guarda el listado detallado en un archivo CSV.

def crear_csv(datos, ruta_destino):
    nombre_archivo = Path(ruta_destino) / "listado_directorios.csv"
    try:
        with open(nombre_archivo, mode='w', newline='', encoding='utf-8') as f:
            escritor = csv.writer(f)
            escritor.writerow(["Directorio", "Num_Subcarpetas"])
            for fila in datos:
                escritor.writerow([fila['nombre'], fila['subs']])
        print(f"\n[SISTEMA] Archivo guardado en: {nombre_archivo}")
    except Exception as e:
        print(f"\n[ERROR] No se pudo crear el CSV: {e}")

# Función secundaria. Calcula y muestra la frecuencia de subdirectorios.

def generar_sintesis(datos):
    total_directorios = len(datos)
    if total_directorios == 0:
        return
    frecuencias = Counter(d['subs'] for d in datos)
    
    print("\n--- RESUMEN ESTADÍSTICO DE FRECUENCIAS ---")
    for num_subs, cantidad in sorted(frecuencias.items()):
        porcentaje = (cantidad / total_directorios) * 100
        print(f"CARPETAS con {num_subs} subdirectorios : {cantidad} carpetas -- {porcentaje:.2f}% sobre total")

# Función principal: Coordina el listado, el CSV y la estadística.

def procesar_ruta(ruta_analizar, ruta_guardado):
    path_base = Path(ruta_analizar)
    
    if not path_base.exists() or not path_base.is_dir():
        print("La ruta proporcionada no es válida.")
        return

    resultados = []

    print(f"\nListado de directorios en: {path_base.resolve()}\n")
    
    for item in path_base.iterdir():
        if item.is_dir():
            try:
                conteo = sum(1 for sub in item.iterdir() if sub.is_dir())   # Contamos subdirectorios inmediatos
                resultados.append({'nombre': item.name, 'subs': conteo})
                print(f"[DIRECTORIO] {item.name}: {conteo} subcarpetas")	# Visualización solicitada
            except PermissionError:
                continue 
    crear_csv(resultados, ruta_guardado)	 								# Llamada a funciones secundarias
    generar_sintesis(resultados)

# --- LLAMADA A LA FUNCIÓN ---

if __name__ == "__main__":
    # Define aquí tus rutas
    ruta_objetivo = r""      		# Ruta a explorar
    ruta_donde_archivar = r""       # Ruta para guardar el CSV
    
    procesar_ruta(ruta_objetivo, ruta_donde_archivar)


Este script lee un conjunto de directorios y genera un listado CSV en el que se recoge el número de subdirectorios que contiene cada uno. Para ello utiliza dos funciones secundarias y una principal. La funcionalidad de cada una de ellas queda explicada en los comentarios del script.

Este otro script añade al anterior el conteo de todos los archivos que contie el directorio.


  
from pathlib import Path
import csv
from collections import Counter

#Función secundaria. Guarda el listado detallado en un archivo CSV.

def crear_csv(datos, ruta_destino):
    nombre_archivo = Path(ruta_destino) / "listado_completo_directorios.csv"
    try:
        with open(nombre_archivo, mode='w', newline='', encoding='utf-8') as f:
            escritor = csv.writer(f)
            # Añadimos la nueva columna de archivos totales
            escritor.writerow(["Directorio", "Num_Subcarpetas_Directas", "Num_Archivos_Totales"])
            for fila in datos:
                escritor.writerow([fila['nombre'], fila['subs'], fila['archivos']])
        print(f"\n[SISTEMA] Archivo guardado en: {nombre_archivo}")
    except Exception as e:
        print(f"\n[ERROR] No se pudo crear el CSV: {e}")

#Función secundaria. Calcula y muestra la frecuencia de subdirectorios.

def generar_sintesis(datos):
    total_directorios = len(datos)
    if total_directorios == 0:
        return
    frecuencias = Counter(d['subs'] for d in datos)
    print("\n" + "="*50)
    print("--- RESUMEN ESTADÍSTICO DE FRECUENCIAS ---")
    for num_subs, cantidad in sorted(frecuencias.items()):
        porcentaje = (cantidad / total_directorios) * 100
        print(f"CARPETAS con {num_subs} subdirectorios : {cantidad} carpetas -- {porcentaje:.2f}% sobre total")
    print("="*50)

#Función principal. oordina el análisis profundo de la ruta.

def procesar_ruta(ruta_analizar, ruta_guardado):
    path_base = Path(ruta_analizar)
    if not path_base.exists() or not path_base.is_dir():
        print(f"Error: '{ruta_analizar}' no es una ruta válida.")
        return
    resultados = []
    print(f"\nAnalizando contenido en: {path_base.resolve()}\n")
    print(f"{'DIRECTORIO':<25} | {'SUBS':<6} | {'ARCHIVOS (TOTAL)'}")
    print("-" * 60)
    
    for item in path_base.iterdir():
        if item.is_dir():
            try:
                conteo_subs = sum(1 for sub in item.iterdir() if sub.is_dir())	 # 1. Contar subdirectorios directos (primer nivel)
                conteo_archivos = sum(1 for f in item.rglob('*') if f.is_file()) # 2. Contar TODOS los archivos rglob('*')
                resultados.append({
                    'nombre': item.name, 
                    'subs': conteo_subs, 
                    'archivos': conteo_archivos
                })
                print(f"[DIRECTORIO] {item.name:<12}: {conteo_subs:>3} subs | {conteo_archivos:>5} archivos")	# Visualización por CMD 
            except PermissionError:
                print(f"[!] Sin permiso para acceder a: {item.name}")
                continue
    crear_csv(resultados, ruta_guardado)	    								# Ejecución de reportes
    generar_sintesis(resultados)

# --- SECCIÓN DE LLAMADA A LA FUNCIÓN ---

if __name__ == "__main__":
    # Ajusta estas rutas según tu necesidad
    ruta_objetivo = r""      					# Ruta a explorar
    ruta_donde_archivar = r""                   # Ruta para guardar el CSV
    
    procesar_ruta(ruta_objetivo, ruta_donde_archivar)


Finalmente, en este script cambiamos el enfoque y en vez de trabajar con colecciones de directorios lo vamos a hacer con un directorio en concreto, pero incrementando el detalle del estudio de su estructura (subdirectorios) y de su contenido (archivos), generando un informe útil para el estudio estructural del expediente.



from pathlib import Path
import csv
from collections import Counter

#Función secundaria. Guarda el desglose detallado en un archivo CSV.

def crear_csv(datos, ruta_destino):
    nombre_archivo = Path(ruta_destino) / "estructura_analizada.csv"
    try:
        with open(nombre_archivo, mode='w', newline='', encoding='utf-8') as f:
            escritor = csv.writer(f)
            escritor.writerow([
                "Entrada", 
                "Subcarpetas_Directas", 
                "Archivos_Raiz", 
                "Archivos_en_Subdirs", 
                "Total_Archivos"
            ])
            for fila in datos:
                escritor.writerow([
                    fila['nombre'], 
                    fila['subs'], 
                    fila['archivos_raiz'], 
                    fila['archivos_sub'], 
                    fila['total_archivos']
                ])
        print(f"\n[SISTEMA] Reporte CSV generado en: {nombre_archivo}")
    except Exception as e:
        print(f"\n[ERROR] No se pudo crear el CSV: {e}")

# Función secundaria. Muestra la estadística de frecuencias por consola.

def generar_sintesis(datos):
    total_entradas = len(datos)
    if total_entradas == 0:
        return
    frecuencias = Counter(d['subs'] for d in datos
    print("\n" + "="*85)
    print("--- RESUMEN ESTADÍSTICO DE FRECUENCIAS (Basado en Subdirectorios Directos) ---")
    for num_subs, cantidad in sorted(frecuencias.items()):
        porcentaje = (cantidad / total_entradas) * 100
        print(f"ENTRADAS con {num_subs} subdirectorios directos: {cantidad} unidades -- {porcentaje:.2f}%")
    print("="*85)

# Función principal. Analiza la ruta e incluye el conteo del directorio raíz

def procesar_estructura_principal(ruta_objetivo):
    path_base = Path(ruta_objetivo)
    if not path_base.exists() or not path_base.is_dir():
        print(f"\n[ERROR] La ruta '{ruta_objetivo}' no es válida.")
        return
    resultados = []
    print(f"\nExplorando: {path_base.resolve()}")
    header = f"{'ENTRADA/CARPETA':<25} | {'SUBS':<5} | {'RAIZ':<7} | {'EN SUBS':<8} | {'TOTAL'}"
    print(header)
    print("-" * len(header))
    
    # --- PARTE 1: Analizar la propia carpeta raíz introducida ---
    try:
        subs_raiz = sum(1 for x in path_base.iterdir() if x.is_dir())
        archivos_totales_raiz = sum(1 for x in path_base.rglob('*') if x.is_file())
        archivos_directos_raiz = sum(1 for x in path_base.iterdir() if x.is_file())
        resultados.append({						 # Añadimos la entrada de la carpeta principal
            'nombre': f"RAIZ ({path_base.name})",
            'subs': subs_raiz,
            'archivos_raiz': archivos_directos_raiz,
            'archivos_sub': archivos_totales_raiz - archivos_directos_raiz,
            'total_archivos': archivos_totales_raiz
        })
        print(f"{'-- DIRECTORIO RAIZ --':<25} | {subs_raiz:>5} | {archivos_directos_raiz:>7} | {archivos_totales_raiz - archivos_directos_raiz:>8} | {archivos_totales_raiz:>5}")
    except PermissionError:
        print(f"{'RAIZ':<25} | [!] Acceso denegado")

    # --- PARTE 2: Analizar los subdirectorios internos (si los hay) ---
    for item in path_base.iterdir():
        if item.is_dir():
            try:
                conteo_subs = sum(1 for x in item.iterdir() if x.is_dir())
                total_archivos = sum(1 for x in item.rglob('*') if x.is_file())
                if conteo_subs == 0:
                    archivos_raiz = total_archivos
                    archivos_en_subdirs = 0
                else:
                    archivos_raiz = sum(1 for x in item.iterdir() if x.is_file())
                    archivos_en_subdirs = total_archivos - archivos_raiz
                resultados.append({
                    'nombre': item.name, 
                    'subs': conteo_subs, 
                    'archivos_raiz': archivos_raiz,
                    'archivos_sub': archivos_en_subdirs,
                    'total_archivos': total_archivos
                })  
                print(f"{item.name[:25]:<25} | {conteo_subs:>5} | {archivos_raiz:>7} | {archivos_en_subdirs:>8} | {total_archivos:>5}")
            except PermissionError:
                continue
    if resultados:
        crear_csv(resultados, path_base)
        generar_sintesis(resultados)

# --- SEGMENTO DE LLAMADA A LA FUNCIÓN ---

if __name__ == "__main__":
    ruta_input = input("Introduce la ruta del directorio a analizar: ").strip().replace('"', '')
    procesar_estructura_principal(ruta_input)


lunes, 4 de mayo de 2026

DATOS. Tratamiento de datos

Tablas complejas (.odt) (VI)

Optención automátizada de todos los datos de las tablas del documento

Con esta entrada finalizo la presentación de script de recuperación de datos semi-estructurados de tablas-formulario soportadas sobre archivos .odt. En este caso vamos a generar un procedimiento cuyo objetivo es obtener todos los datos de un conjunto de tablas del mismo documento, en teoría de todos los datos de todas las tablas, aunque en la práctica no es necesario y la mayoría de las veces puede que tampoco conveniente, abarcarlas todas.

Puede considerarse que este script es complementario del expuesto en la entrada anterior, y lo es en cuanto que ahora lo que pretendemos es obtener todos los datos de un único documento, mientras que antes lo que pretendíamos era obtener los mismos datos de muchos documentos diferentes. La cuestión es que este cambio de objetivo tiene varias implicaciones: en lugar de dirigir nuestros esfuerzos al estudio de una realida concreta y su manifestación colectiva en documentos individuales; ahora pretendemos recopilar exhaustivamete los datos de un único documento, aunque estos documentos comparten contener tablas-formulario y no tablas de datos en sentido estricto. De ahí que estemos hablando de datos semi-estructurados, frente a los datos estructurados que presentan las grandes (aunque no necesariamente, sí con frecuencia) bases de datos, como las que se manejan en la minería de datos y en la IA.

Una diferencia fácilmente observable que deriva del nuevo planteamiento es que antes el objetivo era obtener un archivo CSV por cada tabla que se analiza en la que cada registro (fila) es el contenido de dicha tabla en un documento; ahora vamos a generar un archivo .xlsx que contiene varias hojas, una por cada tabla del documento .odt. La elección de este soporte está justificada por nuestro interés por mantener todos los datos en un único archivo, y no tenerlos dispersos en varios, como obligaría el uso del formato csv. Esto facilita el manejo de los archivos, su consulta y posterior manipulación desde el servicio excel o Calc.



# --- 0. BIBLIOTECAS ---
import os
import pandas as pd
from odf.opendocument import load
from odf.table import Table, TableRow, TableCell
from odf import teletype

# --- 1. MOTOR DE LIMPIEZA ---
def limpiar_texto_odt(texto_bruto):
    if not texto_bruto: return ""
    texto = texto_bruto.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ')
    return " ".join(texto.split()).lower()

# --- 2. TRADUCTOR DE COORDENADAS ---
def obtener_referencia_celda(fila_idx, col_idx):
    letras = ""
    temp_col = col_idx
    while temp_col >= 0:
        letras = chr(65 + (temp_col % 26)) + letras
        temp_col = (temp_col // 26) - 1
    return f"{letras}{fila_idx + 1}"

# --- 3. ANALIZADOR DE ESTRUCTURA (MEJORADO) ---
def extraer_datos_tabla(tabla):
    filas_xml = tabla.getElementsByType(TableRow)
    if not filas_xml: return [], [], "0x0"

    max_cols = 0
    for celda in filas_xml[0].getElementsByType(TableCell):
        span = int(celda.getAttribute("numbercolumnsspanned") or 1)
        max_cols += span
    
    total_filas = len(filas_xml)
    # MODIFICACIÓN (1): Generar el dato de estructura
    tipo_tabla = f"{total_filas}x{max_cols}"
    
    ocupada = [[False for _ in range(max_cols)] for _ in range(total_filas)]
    ids, contenidos = [], []

    for r_idx, fila in enumerate(filas_xml):
        celdas_xml = fila.getElementsByType(TableCell)
        c_xml_cursor = 0 
        for c_idx in range(max_cols):
            if ocupada[r_idx][c_idx]: continue
            if c_xml_cursor < len(celdas_xml):
                celda_actual = celdas_xml[c_xml_cursor]
                c_span = int(celda_actual.getAttribute("numbercolumnsspanned") or 1)
                r_span = int(celda_actual.getAttribute("numberrowsspanned") or 1)
                
                texto = teletype.extractText(celda_actual).strip()
                ids.append(obtener_referencia_celda(r_idx, c_idx))
                contenidos.append(texto)
                
                for i in range(r_span):
                    for j in range(c_span):
                        if r_idx + i < total_filas and c_idx + j < max_cols:
                            ocupada[r_idx + i][c_idx + j] = True
                c_xml_cursor += 1
    return ids, contenidos, tipo_tabla

# --- 4. FUNCIÓN MAESTRA EVOLUCIONADA ---
def ejecutar_extraccion_a_excel(ruta_odt, mapa_claves):
    if not os.path.exists(ruta_odt):
        print(f"[!] El archivo no existe en: {ruta_odt}"); return

    directorio_salida = r"C:\PROCESAMIENTO_DATOS_SEO\TABLAS_DOC"
    if not os.path.exists(directorio_salida):
        os.makedirs(directorio_salida, exist_ok=True)

    doc = load(ruta_odt)
    tablas = doc.body.getElementsByType(Table)
    
    nombre_base = os.path.splitext(os.path.basename(ruta_odt))[0]
    ruta_excel = os.path.join(directorio_salida, f"{nombre_base}_EXTRAIDO.xlsx")
    
    # Control de duplicados por clave normalizada
    claves_encontradas = {limpiar_texto_odt(item['termino']): False for item in mapa_claves}
    
    with pd.ExcelWriter(ruta_excel, engine='openpyxl') as writer:
        for t in tablas:
            filas = t.getElementsByType(TableRow)
            if not filas: continue
            celdas_xml = filas[0].getElementsByType(TableCell)
            if not celdas_xml: continue
            
            # MODIFICACIÓN (2): Comprobar contra el mapa de claves y su posición (0 o 1)
            for configuracion in mapa_claves:
                termino_original = configuracion['termino']
                posicion_busqueda = configuracion['posicion'] # 0 o 1
                termino_norm = limpiar_texto_odt(termino_original)
                
                # Seguridad: verificar que la tabla tenga la celda solicitada
                if len(celdas_xml) <= posicion_busqueda: continue
                
                valor_celda_ancla = limpiar_texto_odt(teletype.extractText(celdas_xml[posicion_busqueda]))
                
                if termino_norm in valor_celda_ancla and not claves_encontradas[termino_norm]:
                    ids, valores, tipo_tabla = extraer_datos_tabla(t)
                    
                    # Insertar tipo_tabla como primer campo (Punto 1)
                    final_ids = ["tipo_tabla"] + ids
                    final_valores = [tipo_tabla] + valores
                    
                    df = pd.DataFrame([final_valores], columns=final_ids)
                    
                    nombre_hoja = termino_original[:30]
                    df.to_excel(writer, sheet_name=nombre_hoja, index=False)
                    
                    claves_encontradas[termino_norm] = True
                    print(f"[OK] Tabla '{termino_original}' ({tipo_tabla}) guardada.")
                    break 

    print(f"\nPROCESO COMPLETADO. Ruta: {ruta_excel}")

# --- Llamada a la función principal ---

if __name__ == "__main__":

    ARCHIVO_TRABAJO = r""						#Introduce aquí la ruta absoluta del documento a procesar 
    
    MAPA_CLAVES = [								# Lista de diccionarios con término y posición (0=A1, 1=B1). Adáptala a tus necesidades
        {'termino': 'fecha', 'posicion': 0},
        {'termino': 'nie', 'posicion': 0},
        {'termino': 'escolarizado', 'posicion': 1},
        {'termino': 'admisión', 'posicion': 0},
        {'termino': 'padre', 'posicion': 0},
        {'termino': 'anteriores', 'posicion': 0},
        {'termino': 'nueva', 'posicion': 1},
        {'termino': 'discapacidad', 'posicion': 0},
        {'termino': 'ordinario', 'posicion': 1},
        {'termino': 'tipo', 'posicion': 0},
        {'termino': 'personales', 'posicion': 0}
    ]
    
    ejecutar_extraccion_a_excel(ARCHIVO_TRABAJO, MAPA_CLAVES)


Obsérvese que este script comparte la mayor parte de la estructura y la lógica con el precedente, pero presenta una diferencia de mucha importancia para el funcionamiento del script: el uso de la lista de diccionarios MAPA_CLAVES = [] que contiene la colección de términos de referencia para identificar la tabla y el código que establece la celda en la que buscar el término. La lista que aquí se presenta debe ser adaptada a las necesidades concretas que derivan del documento a procesar.

A pesar de que ahora obtenemos un .xlsx, tampoco obtenemos unas tablas que se puedan manejar directamente, siendo necesario procesarlas desde el servicio de hoja de cálculo que se desee o mediante código, aunque presentan una formulación compatible con lo que consideramos datos estructurados, lo que no impide que sea necesario organizarlos y proceder a su limpieza, si se da el caso.

Por último debo repetir aqui lo que dije al presentar el script complementario visto en su momento respecto al uso de la IA y a sus condiciones y limitaciones.

DATOS. Tratamiento de datos

Tablas complejas (.odt) (V)

Volcado masivo de datos de una tabla

Además de acceder a una celda concreta, podemos acceder también al conjunto de los datos de una tabla determinada, sea de un documento en concreto o de una collección de documentos.

Sabemos que es posible acceder a una tabla por su identificador en el navegador del procesador de texto, pero este procedimiento tiene una limitación y es que en la colección de documento, todos ellos deben tener la misma estructura de tablas, y la misma denominación, al menos para la tabla que nos interesa, lo que viene a implicar, normalmente, que todos comparten el mismo orden de las tablas. El problema es que todas estas coincidencias no son frecuentes ni fáciles de observar, lo que limita y complica el procedimiento de estracción de datos.

Para sortear estas limitaciones y ampliar el funcionalidad real del script, facilitando la obtención masiva de datos de documentos que pueden no compartir aspectos formales, pero que sí comparten contenidos (tal es el caso de los diferentes modelos de, por ejemplo, informe de evalauación psicopedagógica), una opción es identificar previamente a la extracción de datos y como condición para ella, esa tabla mediante la identificación de, por ejemplo, un concepto que de identidad a la tabla como conjunto.

Para que se entienda mejor lo que quiero decir y sus implicaciones, vamos a valorar su incidencia en un ejemplo real: la obtención de los datos de la que podría ser la Tabla1 que podría identificar el navegador.

Lo que muestra esta imagen es la tabla situada visualmente en primer lugar tanto en uno de los modelos de dictamen y otro de informe. Aunque se trata de modelos concretos, otros comparten la presencia de esta tabla en términos de estructura y de contenido, aunque se puedan observar algunas diferencias que generan (a posteriori) ciertos problemas de compatibilidad. Lo ya desde el principio no comparten es el identificador de la tabla según muestra el navegador, incluyendo que como tales no son necesariamente la Tabla1. Esto complica la viabilidad de la estrategia empleada en el script de la entrada anterior.

Cierto que podríamos utilizar determinadas estrategias para dar cabida a la variedad de identificadores de las tablas en función del documento (tipo y modelo), pero esto exige la revisión detallada de la variedad documental objeto de interés. Pero disponemos de una alternativa que evita esa revisión. La base es la siguiente: si observamos ambas tablas comprobaremos que en su celda A1 (0,0) ambas presentan un texto que es de hecho una etiqueta de la base de datos que es la tabla en su conjunto; ese texto contiene y comparte, en ambos casos, el término 'fecha'. Si, como ya sabemos, recorremos las tablas del documento, accedemos a su celda A1 y a su contenido, y realizamos una identificación en función del texto que nos interesa (en este caso 'fecha') podremos acceder al contenido de cualquiera de las celdas de esta tabla o al conjnuto de ellas. Este es el comentido del script que se muestra a continuación.



# ---0. BIBLIOTECAS NECESARIAS ---

from odf.opendocument import load
from odf.table import Table, TableRow, TableCell
from odf import teletype
import os
import csv
import sys

# --- 1. MOTOR DE LIMPIEZA ---
def limpiar_texto_odt(texto_bruto):
    if not texto_bruto: return ""
    texto = texto_bruto.replace('\n', ' ').replace('\r', ' ').replace('\t', ' ')
    return " ".join(texto.split()).lower()

# --- 2. TRADUCTOR DE COORDENADAS ---
def obtener_referencia_celda(fila_idx, col_idx):
    letras = ""
    temp_col = col_idx
    while temp_col >= 0:
        letras = chr(65 + (temp_col % 26)) + letras
        temp_col = (temp_col // 26) - 1
    return f"{letras}{fila_idx + 1}"

# --- 3. ANALIZADOR DE TABLA ---
def extraer_datos_tabla(tabla):
    filas_xml = tabla.getElementsByType(TableRow)
    if not filas_xml: return [], [], "0x0"

    max_cols = 0
    for celda in filas_xml[0].getElementsByType(TableCell):
        span = int(celda.getAttribute("numbercolumnsspanned") or 1)
        max_cols += span
    
    total_filas = len(filas_xml)
    dato_estructura = f"{total_filas}x{max_cols}"
    
    ocupada = [[False for _ in range(max_cols)] for _ in range(total_filas)]
    ids, contenidos = [], []

    for r_idx, fila in enumerate(filas_xml):
        celdas_xml = fila.getElementsByType(TableCell)
        c_xml_cursor = 0 
        for c_idx in range(max_cols):
            if ocupada[r_idx][c_idx]: continue
            if c_xml_cursor < len(celdas_xml):
                celda_actual = celdas_xml[c_xml_cursor]
                c_span = int(celda_actual.getAttribute("numbercolumnsspanned") or 1)
                r_span = int(celda_actual.getAttribute("numberrowsspanned") or 1)
                
                texto = limpiar_texto_odt(teletype.extractText(celda_actual))
                ids.append(obtener_referencia_celda(r_idx, c_idx))
                contenidos.append(texto)
                
                for i in range(r_span):
                    for j in range(c_span):
                        if r_idx + i < total_filas and c_idx + j < max_cols:
                            ocupada[r_idx + i][c_idx + j] = True
                c_xml_cursor += 1
    return ids, contenidos, dato_estructura

# --- 4. FUNCIÓN PRINCIPAL ---
def procesar_coleccion(directorio_origen, termino_busqueda, col_ancla_idx=0):
    ruta_salida_base = r"" 						# Aquí tu ruta del archivo de salida
    if not os.path.exists(ruta_salida_base):
        os.makedirs(ruta_salida_base)

    csv_maestro = os.path.join(ruta_salida_base, "") #Aquí (entre comillas) el nombre de la tabla CSV de salida
    datos_totales = []
    encabezados_globales = None
    termino = limpiar_texto_odt(termino_busqueda)

    if not os.path.exists(directorio_origen):
        print(f"[ERROR] No existe la carpeta: {directorio_origen}", flush=True)
        return

    archivos = [f for f in os.listdir(directorio_origen) if f.endswith('.odt')]
    
    print(f"\n>>> INICIO: Detectados {len(archivos)} archivos.", flush=True)	 # flush=True fuerza a mostrar el texto

    for nombre_archivo in archivos:
        ruta_completa = os.path.join(directorio_origen, nombre_archivo)
        try:
            doc = load(ruta_completa)
            tablas = doc.body.getElementsByType(Table)
            encontrado = False
            
            for t in tablas:
                filas = t.getElementsByType(TableRow)
                if not filas: continue
                celdas = filas[0].getElementsByType(TableCell)
                
                if len(celdas) <= col_ancla_idx: continue
                
                valor_ancla = limpiar_texto_odt(teletype.extractText(celdas[col_ancla_idx]))
                
                if termino in valor_ancla:
                    ids, valores, estructura = extraer_datos_tabla(t)
                    if encabezados_globales is None:
                        encabezados_globales = ["ARCHIVO_ORIGEN", "ESTRUCTURA"] + ids
                    
                    datos_totales.append([nombre_archivo, estructura] + valores)
                    print(f" [OK] {nombre_archivo} | Estructura: {estructura}", flush=True)
                    encontrado = True
                    break
        except Exception as e:
            print(f" [ERR] Error en {nombre_archivo}: {e}", flush=True)

    if datos_totales:
        with open(csv_maestro, mode='a', newline='', encoding='utf-8-sig') as f:
            escritor = csv.writer(f)
            escritor.writerow(encabezados_globales)
            escritor.writerows(datos_totales)
        print(f"\n>>> ÉXITO: CSV generado en {csv_maestro}", flush=True)
    else:
        print("\n>>> AVISO: No se encontraron coincidencias.", flush=True)

# --- Llamada a la función ---

if __name__ == "__main__":
    CARPETA = r""		# Aquí el directorio de los archivos a trabajar
    TERMINO = ""		# Aquí el término de identificación
    # 0 = A1, 1 = B1	# Identificadores de celda de referencia
    procesar_coleccion(CARPETA, TERMINO, 0)


Este script es suficientemente complejo como para necesitar una explicación con cierto detalle. Tenemos un script que desarrolla un sistema automatizado de extracción de datos jerarquizado que utiliza la biblioteca odfpy. Consta o requiere unas funciones que identificamos como secundarias, una función principal y el código de llamada a la función.

Las funciones secundarias realizan tareas de limpieza def limpiar_texto_odt(texto_bruto):, cálculo de coordenadas para la identificación de las celdas def obtener_referencia_celda(fila_idx, col_idx): y para la reconstrucción de celdas combinadas def extraer_datos_tabla(tabla):.

def procesar_coleccion(directorio_origen, termino_busqueda, col_ancla_idx=0): es la función principal, la que gestiona el flujo de archivos, la búsqueda del término identificador y el almacenamiento de los datos como CVS. Esta función es la que llama a las funciones secundarias y es llamada, a su vez, por el script principal.

Este script contiene la identificación de variables (ruta de archivos, término de búsqueda y celda de referencia para la búsqueda) y la llamada a la función principal. Sobre la doble opción de celda, decir que se ha implementado para evitar la dificultad que presentan aquellas tablas cuya celda A1 puede resultar inapropiada por diversos motivos, por ejemplo, por estar vacía sin que ello implique algún tipo de irregularidad.

Sin la ayuda de IA-Gemini no habría sido posible desarrollarla, pero incluso con ella me resultó de gran dificultad, dado que fue necesario reformular el procedimiento varias veces, reconstruirlo paso a paso y controlar que el funcionamiento de cada una de las partes y del conjunto se ajustar a lo esperado y se alcanzara objetivo final: obtener un archivo CSV que contenga el texto de cada una de las celdas de la tabla de dos conjuntos de documentos que comparten (como se aprecia en la imagen superior) la estructura y el contenido de esa tabla identificada por el string 'fecha'.

No se prevé, no obstante, que ese documento resultante sea de utilidad inmediata, ya que se precisa cierto tratamiento que puede ejecutarse, eso sí, manualmente sobre el servico de hoja de cálculo o mediante código. Pero este es un proceso que deriva a una segunda fase del tratamiento de datos: el de la organización y limpieza de datos obtenidos mediante procedimientos de extracción.

DATOS. Tratamiento de datos

Tablas complejas (.odt) (IV)

Acceso al contenido de celdas

En la entrada anterior conseguimos acceder a una tabla concreta y a una celda determinada. Aprovechando estas funcionalidades, en ésta el objetivo es convertir ese conociento en una utilidad de interés: la obtención de un dato determinado (podrían ser varios) de un grupo de documentos iguales (comparten tipología .odt, tabla y estructura de la tabla).

Este script es el primero de una serie de tres que tratarán sobre la obtención masiva y automatizada de contenido de las tablas de los documentos .odt.



# --- 0. BIBLIOTECAS ---
import os
import csv
from odf import opendocument, table, teletype

# --- 1. CONFIGURACIÓN ---
ruta_directorio_fuente = r"mi_directorio" 			# Carpeta con los .odt
nombre_tabla_objetivo = "mi_tabla"		  			# Tabla elegida
fila_destino = 1						  			# Referencias de la celda
columna_destino = 1

directorio_destino = r"directorio_de_escritura_csv"	# Configuración de salida (Rutas solicitadas)
nombre_archivo_csv = "extraccion_tabla_celda.csv"	# Configuración del nombre del CSV (e. extraccion_tabla4_A1)
ruta_completa_csv = os.path.join(directorio_destino, nombre_archivo_csv)

# --- 2. PREPARACIÓN DEL ENTORNO ---
if not os.path.exists(directorio_destino):		# Crear el directorio de destino si no existe
    os.makedirs(directorio_destino)
    print(f"Directorio creado: {directorio_destino}")

datos_acumulados = []		# Lista para almacenar los resultados de la consulta

# --- 3. PROCESAMIENTO DE ARCHIVOS ---
if not os.path.exists(ruta_directorio_fuente):
    print("Error: El directorio fuente no existe.")
    exit()

archivos = [f for f in os.listdir(ruta_directorio_fuente) if f.endswith(".odt")]

print(f"--- Procesando {len(archivos)} archivos ---")

for archivo in archivos:
    ruta_archivo = os.path.join(ruta_directorio_fuente, archivo)
    
    try:
        doc = opendocument.load(ruta_archivo)
        tablas = doc.getElementsByType(table.Table)
        tabla_encontrada = None

        for t in tablas:
            if t.getAttribute("name") == nombre_tabla_objetivo:
                tabla_encontrada = t
                break

        if tabla_encontrada:
            filas = tabla_encontrada.getElementsByType(table.TableRow)
            if fila_destino < len(filas):
                celdas = filas[fila_destino].getElementsByType(table.TableCell)
                if columna_destino < len(celdas):
                    contenido = teletype.extractText(celdas[columna_destino])
                    datos_acumulados.append([archivo, contenido])
                    print(f"[OK] {archivo} -> Extraído")
                else:
                    print(f"[Error] {archivo} -> Columna {columna_destino} no existe.")
            else:
                print(f"[Error] {archivo} -> Fila {fila_destino} no existe.")
        else:
            print(f"[Error] {archivo} -> Tabla '{nombre_tabla_objetivo}' no encontrada.")

    except Exception as e:
        print(f"[Error] {archivo} -> No se pudo procesar: {e}")

# --- 4. GENERACIÓN DEL ARCHIVO CSV ---
if datos_acumulados:
    try:
        with open(ruta_completa_csv, mode='a', newline='', encoding='utf-8-sig') as archivo_csv:
            escritor = csv.writer(archivo_csv, delimiter=';') 	# Usamos ';' por compatibilidad con Excel en español
            escritor.writerow(["Nombre del Archivo", "Contenido de la Celda"])	# Escribir cabeceras
            escritor.writerows(datos_acumulados)								# Escribir los datos
        print(f"\n--- PROCESO FINALIZADO ---")
        print(f"Archivo guardado en: {ruta_completa_csv}")
    except Exception as e:
        print(f"\nError al intentar crear el archivo CSV: {e}")
else:
    print("\nNo se encontraron datos para guardar en el CSV.")


Este script requiere el conocimiento previo del documento para ser concretado, dado que es encesario que el directorio contenga documentos que compartan características, estructura y contenidos. De no ser así los datos que se obtengan dificilmente satisfarán el objetivo con el que se creó este script. Este conocimiento se basa, en lo concreto, en el estudio de la estructura de tablas del documento y de las celdas de la tabla elgida según el objetivo del estudio, especialmente de la naturaleza de ese contenido textual.

Además de acceder al documento, a la tabla y a la celda seleccionadas por el usuario, y capturar su contendio, se muestra por pantalla el proceso de extracción de datos y después se genera un archivo CSV (nombre_archivo_csv = "extraccion_tabla_celda.csv") en el directorio que el usuario decida (directorio_destino = r"directorio_de_escritura_csv"). Este archivo CSV se puede manipular mediante código, pero también visualizar y manipular directamente desde un servicio de hoja de cálculo (Excel o Calc).

Aunque aquí sólo ejemplificamos un procedimiento básico (extraer únicamente un dato) el script se puede modificar para la extracción de todos los datos que se consideren necesarios para un estudio concreto, por ejemplo, el estudio de la relación entre dos variables.

DATOS. Tratamiento de datos

Tablas complejas (.odt) (III)

Acceso a tablas

Sirva lo visto en la entrada anterior como base para un mejor conocimiento de la estructura de tablas de un documento .odt y ocupémonos en esta de cómo acceder a esa colección y a cada una de esas tablas mediante código Python.

Para manejar documentos .odt desde Python disponemos de varias bibliotecas que ahora únicamente menciono para que puedas conocerlas y estudiarlas con más detalle. Me refiero a:

  1. ODFPY, biblioteca de bajo nivel que permite controlar prácticamente cualquier aspecto de un archivo .odt
  2. EzODF, cuyo objetivo es que crear un documento sea mucho más intuitivo.
  3. Pypandoc, pensada para la conversión de archivos .odt (de Markdown a ODT o de ODT a PDF/HTML).
  4. y finalmente Relatorio, interesante para trabajar con plantillas.

Dado que nosotros nos centramos ahora en la extracción de datos, las bibliotecas que usaremos serán preferentemente las dos primeras, por lo que te sugiero que te centres en ellas en tus investigaciones.

El acceso al contenido de un documento .odt es, en realidad, el acceso a un archivo zip que contiene varios documentos XML, por lo que si conviertes un archivo .odt a .zip y accedes a su contenido podrás localizar, entre otros, un documento llamado content.xml; si lo abres verás todo el código de etiquetas xml entre las que están las que identifican a las tablas y su estructura.

Pero si lo que deseas es acceder a las tablas de forma mucho más funcional puedes aplicar este script al documento que tu elijas, siempre que sea un documento.odt y contega tablas.



from odf import opendocument, table

#Funciones de los módulos de la biblioteca odfpy
'''
1. opendocument. Permite la gestión del archivo como un "contenedor" completo
Cargar y guardar: Permite abrir archivos (opendocument.load()) y salvar los cambios (doc.save())
Crear documentos: Generar un documento nuevo desde cero
Acceso a la estructura: Administrador de todos los elementos del archivo (tablas, párrafos, estilos)

2. table. Trabajo con las hojas de cálculo y las tablas de los documentos de texto
Creación de tablas: Permite definir nuevas tablas (table.Table)
Gestión de filas y celdas: Proporciona los objetos necesarios: table.TableRow para las filas y table.TableCell para las celdas
Atributos de celda: Manejar propiedades como la unión de celdas (spans) y el nombre de la tabla
'''

doc = opendocument.load("mi_documento.odt")		# Cargar archivo

tablas = doc.getElementsByType(table.Table)		# Buscar todas las tablas (etiqueta )

for t in tablas:								# Recorrido y visualización del identificador o nombre de las tablas
    nombre_tabla = t.getAttribute("name")
    print(f"Encontrada: {nombre_tabla}")


Observa que estamos trabajando con la biblioteca ODFPY, concretamente los módulos opendocument, que permite acceder al documento (doc = opendocument.load("mi_documento.odt"), y table, que facilita el acceso a las tablas (tablas = doc.getElementsByType(table.Table)); de las cuales visualizamos su atributo "name" (nombre_tabla = t.getAttribute("name")), que es el mismo que nos permite ver el navegador del documento.

Hasta aquí hemos conseguido acceder al equivalente de visualización del listado de tablas del documento que proporciona la utilidad Navegador del procesador de texto (Writer), lo cual no deja de tener su interés, ya que refuerza la idea de que es útil conocer y manejar ese navegador. Pero la utilidad inmediata puede que aun no se constate, así que vamos a avanzar un poco más en esa línea, accediendo al contenido de una celda concreta de una tabla determinada.

Aquí nos interesa hablar de una cuestión que puede parecer obvia, pero que no deja de tener relevancia en el manejo de estas tablas-formulario: en ellas no existe nada que diferencie lo que en la lógica de la estructura de una tabla de datos (base de datos) se puede considerar una diferenciación fundamental y básica: no es lo mismo una etiqueta o nombre de campo que el campo (contenido del campo) en si mismo. En una tabla-formulario una determinada posición o celda (A1, por ejemplo) simplemente contiene texto (y siempre texto) o no lo contiene, sin importar si ese texto es el dato o es la etiqueta. El conocimiento de esa diferencia, con absoluta seguridad, sólo lo puede aportar la persona que trabaja con el documento.Pueden emplearse determinadas estrategias para inferir si estamos ante uno u otro contenido (ejemplo, si el texto de la celda finaliza en : (dos puntos), es de esperar que se trate de una etiqueta), pero no existe seguridad absoluta en que la inferencia sea viable ni cierta. De aquí quiero derivar la importancia de la implicación directa del programador en el diseño del procedimiento, por encima de la automatización y/o del uso de la IA.

Pero volvamos a retomar el desarrollo de código para acceder al contenido de las tablas, ahora con independencia de la naturaleza de este contenido, el cual es "etiquetado" como etiqueta o como dato por el programador. El código sólo puede facilitar la automatización del acceso, lo cual no es es poco.



from odf import opendocument, table, teletype, text 

#Funciones de los módulos nuevos de la biblioteca odfpy
'''
3. text. Facilita el trabajo con los elementos estructurales del documento
Párrafos (text.P): Crear los bloques de texto que se insertan en celdas o en el cuerpo del documento
Estilos de texto: Definir encabezados (text.H) y aplicar formatos a fragmentos de texto

4. teletype. Utilidad para facilitar el trabajo con los nodos XML
extractText(): Extrae todo el texto plano de un elemento (una celda o una tabla completa), ignorando las etiquetas internas. Necesario para leer contenido
addTextToElement(): Inserta una cadena de texto dentro de un elemento ODF, encargándose de convertir los caracteres originales

'''

# --- 1. CONFIGURACIÓN ---
ruta_archivo = r""                   #Aquí la ruta completa de tu documento
nombre_tabla_objetivo = ""    #Aquí la tabla elegida según nombre de el navegador
fila_destino = 0                     # Fila de interés
columna_destino = 0             # Columna de interés
nuevo_texto = ""                  #Aquí tu nuevo texto

# --- 2. ACCESO ----
doc = opendocument.load(ruta_archivo)   #Acceso al documento

# --- 3. LOCALIZACIÓN E INVENTARIO ---
tablas = doc.getElementsByType(table.Table)
tabla_encontrada = None

print("\n--- Inventario de tablas en el documento ---")

for i, t in enumerate(tablas):
    nombre_actual = t.getAttribute("name")
    if nombre_actual == nombre_tabla_objetivo:      # Verificamos si es la tabla que buscamos para añadir una marca visual
        tabla_encontrada = t
        print(f"  {i+1}. [X] {nombre_actual} <-- ¡TABLA IDENTIFICADA!")  # Marca visual (-->) y mayúsculas para resaltara
    else:
        print(f"  {i+1}. [ ] {nombre_actual}")      # Listamos el resto de tablas con un prefijo normal

print("-------------------------------------------\n")

if not tabla_encontrada:            # Si tras el bucle no se encontró, detenemos el proceso con un aviso
    print(f"Error: No se encontró la tabla '{nombre_tabla_objetivo}' en el listado anterior.")
    exit()                           # Aquí ponemos un exit()

# --- 4. ACCESO Y ESCRITURA CORREGIDA ---
if tabla_encontrada:
    filas = tabla_encontrada.getElementsByType(table.TableRow)
    if fila_destino < len(filas):
        celdas = filas[fila_destino].getElementsByType(table.TableCell)
        if columna_destino < len(celdas):
            celda_objetivo = celdas[columna_destino]
            contenido_viejo = teletype.extractText(celda_objetivo) # LEER: Esto sigue funcionando igual
            print(f"Contenido previo: '{contenido_viejo}'")
            													 	# ESCRIBIR: El procedimiento correcto
            celda_objetivo.childNodes = []                       	# 1. Limpiamos la celda de párrafos u objetos anteriores
            nuevo_parrafo = text.P()                             	# 2. Creamos un elemento párrafo
            teletype.addTextToElement(nuevo_parrafo, nuevo_texto)   # 3. Añadimos el texto al párrafo
            celda_objetivo.addElement(nuevo_parrafo)                # 4. Insertamos el párrafo dentro de la celda
            
# --- 5. GUARDADO ---
            doc.save(ruta_archivo)
            print(f"Éxito: Se ha escrito '{nuevo_texto}' en la celda.")
        else:
            print("Error: Columna no encontrada.")
    else:
        print("Error: Fila no encontrada.")
else:
    print(f"No se encontró la tabla '{nombre_tabla_objetivo}'.")


Este script, además de acceder y visualizar a las tablas, identifica y se centra en una de ellas (nombre_tabla_objetivo = "") que queda identificada en el listado (if nombre_actual == nombre_tabla_objetivo:). Sobre ella realizamos dos acciones:

  1. Capturar el texto que contiene la celda
  2. Escribir en ella, aunque de forma indirecta, pasando antes por el objeto párrafo

Sobre esta base es posible escribir contenido en las tablas, pero también (y es lo que nos interesa ahora) obtener el escrito en documentos trabajados manualmente. De ahí podemos derivar procedimientos de acceso a datos específicos, habiendo previamente dlimitado los documentos a analizar, la tabla según se muestra en el navegador y la celda identificada según vimos en la entrada correspondiente. Todo esto nos permite construir una utilidad de obtención de datos concretos de un documento o de una colección de documentos iguales.