L'extraction de données à partir de fichiers Excel pour les intégrer dans des pipelines d'analyse de données est une tâche courante pour les développeurs Python. Bien que les feuilles de calcul soient pratiques pour le stockage humain, leur manipulation programmatique nécessite souvent une conversion vers des formats plus performants comme NumPy. Dans cet article, nous allons explorer comment utiliser la bibliothèque Aspose.Cells for Python via .NET pour transformer des classeurs Excel en tableaux NumPy (ndarrays) de manière efficace.

Pourquoi utiliser NumPy pour les données Excel ?

NumPy est la bibliothèque fondamentale pour le calcul scientifique en Python. Elle offre une structure de données optimisée, le ndarray, qui permet des opérations mathématiques rapides et une gestion mémoire bien plus efficace que les listes natives Python. En convertissant vos données Excel vers NumPy, vous facilitez l'intégration avec d'autres outils tels que Pandas, Scikit-learn ou TensorFlow.

Aspose.Cells simplifie cette transition en offrant une API capable de lire des fichiers Excel, CSV ou JSON sans dépendre de Microsoft Excel, peremttant d'extraire des structures de données complexes directement vers des tableaux exploitables.

Configuration de l'environnement

Pour commencer, installez la bibliothèque via le gestionnaire de paquets pip :

pip install aspose-cells-python

Ensuite, improtez les modules nécessaires dans votre script :

import aspose.cells as cells
import numpy as np

Convertir un classeur complet en tableau NumPy

Un fichier Excel peut contenir plusieurs feuilles de calcul. Pour capturer l'intégralité du document, nous devons itérer sur chaque feuille et extraire les valeurs des cellules.

def workbook_to_numpy(file_path):
    # Chargement du fichier Excel
    doc = cells.Workbook(file_path)
    sheets_collection = doc.worksheets
    full_data = []

    for sheet in sheets_collection:
        grid = sheet.cells
        rows_count = grid.max_data_row + 1
        cols_count = grid.max_data_column + 1
        
        sheet_matrix = []
        for r in range(rows_count):
            row_data = []
            for c in range(cols_count):
                item = grid.check_cell(r, c)
                row_data.append(item.value if item else "")
            sheet_matrix.append(row_data)
        full_data.append(sheet_matrix)

    # Conversion en tableau 3D (Feuilles, Lignes, Colonnes)
    return np.asarray(full_data, dtype=object)

# Exemple d'utilisation
# result = workbook_to_numpy("donnees_ventes.xlsx")

Extraire une feuille de calcul spécifique

Si vous n'avez besoin que d'un onglet précis, l'approche est plus directe. Voici comment transformer une seule feuille en un tableau 2D NumPy.

def sheet_to_ndarray(file_path, sheet_index=0):
    wb = cells.Workbook(file_path)
    active_sheet = wb.worksheets[sheet_index]
    cells_manager = active_sheet.cells
    
    total_rows = cells_manager.max_data_row + 1
    total_cols = cells_manager.max_data_column + 1
    
    data_store = []
    for i in range(total_rows):
        current_row = []
        for j in range(total_cols):
            val = cells_manager.get(i, j).value
            current_row.append(val if val is not None else "")
        data_store.append(current_row)
        
    return np.array(data_store, dtype=object)

Conversion d'une plage de cellules personnalisée

Dans certains cas, seule une zone spécifique de la feuille (par exemple, de la cellule B2 à D10) est pertinente pour votre analyse.

def range_to_numpy(file_path, area_str):
    doc = cells.Workbook(file_path)
    ws = doc.worksheets[0]
    
    # Définition de la plage (ex: "B2:D10")
    target_range = ws.cells.create_range(area_str)
    
    range_matrix = []
    for r_idx in range(target_range.row_count):
        row_content = []
        for c_idx in range(target_range.column_count):
            # Calcul de l'index absolu dans la grille
            cell_item = target_range.get(r_idx, c_idx)
            row_content.append(cell_item.value if cell_item.value is not None else "")
        range_matrix.append(row_content)
        
    return np.asarray(range_matrix, dtype=object)

Gestion des objets de liste (Tableaux Excel)

Les tableaux structurés dans Excel (ListObjects) facilitent l'extraction car ils délimitent déjà les données. Aspose.Cells permet d'y accéder par leur nom ou leur index.

def list_object_to_numpy(file_path, table_index=0):
    engine = cells.Workbook(file_path)
    sheet = engine.worksheets[0]
    table = sheet.list_objects[table_index]
    
    table_data = []
    for r in range(table.start_row, table.end_row + 1):
        row_buffer = []
        for c in range(table.start_column, table.end_column + 1):
            cell_val = sheet.cells.get(r, c).value
            row_buffer.append(cell_val if cell_val is not None else "")
        table_data.append(row_buffer)
        
    return np.array(table_data, dtype=object)

Extraction de vecteurs : Lignes et Colonnes

Parfois, l'analyse porte uniquementt sur une série temporelle située dans une colonne ou sur un enregistrement unique en ligne.

# Extraction d'une colonne spécifique
def get_column_vector(file_path, col_idx):
    wb = cells.Workbook(file_path)
    cells_grid = wb.worksheets[0].cells
    rows_limit = cells_grid.max_data_row + 1
    
    col_values = [cells_grid.get(r, col_idx).value for r in range(rows_limit)]
    return np.array(col_values, dtype=object)

# Extraction d'une ligne spécifique
def get_row_vector(file_path, row_idx):
    wb = cells.Workbook(file_path)
    cells_grid = wb.worksheets[0].cells
    cols_limit = cells_grid.max_data_column + 1
    
    row_values = [cells_grid.get(row_idx, c).value for c in range(cols_limit)]
    return np.array(row_values, dtype=object)

Considérations techniques pour l'intégration

• Types de données : Étant donné qu'Excel peut mélanger des chaînes de caractères, des nombres et des dates dans une même colonne, l'utilisation de dtype=object dans NumPy est recommandée pour éviter les erreurs de conversion automatique.
• Optimisation mémoire : Pour les fichiers volumineux, évitez de charger le classeur entier si vous n'avez besoin que d'une petite zone. Utilisez les méthodes de sélection de plage pour limiter l'empreinte mémoire.
• Valeurs manquantes : Les cellules vides sont extraites comme None par défaut. Il est souvent utile de les remplacer par une chaîne vide "" ou par np.nan selon les besoins de votre traitement statistique.