xlsx

Utilisez cette compétence chaque fois qu'un fichier tableur est l'entrée ou la sortie principale. Cela concerne toute tâche où l'utilisateur souhaite : ouvrir, lire, modifier ou corriger un fichier .xlsx, .xlsm, .csv ou .tsv existant (par exemple, ajouter des colonnes, calculer des formules, mettre en forme, créer des graphiques, nettoyer des données désordonnées) ; créer un nouveau tableur de zéro ou à partir d'autres sources de données ; ou convertir entre des formats de fichiers tabulaires. Déclenchez cette compétence en particulier lorsque l'utilisateur fait référence à un fichier tableur par son nom ou son chemin — même de manière informelle (comme « le xlsx dans mes téléchargements ») — et souhaite qu'une action soit effectuée dessus ou qu'un résultat en soit produit. Déclenchez-la également pour le nettoyage ou la restructuration de fichiers de données tabulaires désordonnées (lignes malformées, en-têtes mal placés, données parasites) en tableurs conformes. Le livrable doit être un fichier tableur. Ne déclenchez PAS cette compétence lorsque le livrable principal est un document Word, un rapport HTML, un script Python autonome, un pipeline de base de données ou une intégration de l'API Google Sheets, même si des données tabulaires sont impliquées.

npx skills add https://github.com/anthropics/skills --skill xlsx

Exigences pour les résultats

Tous les fichiers Excel

Police professionnelle

  • Utiliser une police cohérente et professionnelle (par ex., Arial, Times New Roman) pour tous les livrables, sauf instruction contraire de l'utilisateur

Zéro erreur de formule

  • Chaque modèle Excel DOIT être livré avec ZÉRO erreur de formule (#REF!, #DIV/0!, #VALUE!, #N/A, #NAME?)

Préserver les modèles existants (lors de la mise à jour)

  • Étudier et correspondre EXACTEMENT au format, au style et aux conventions existants lors de la modification de fichiers
  • Ne jamais imposer un formatage standardisé sur les fichiers avec des motifs établis
  • Les conventions du modèle existant REMPLACENT TOUJOURS ces directives

Modèles financiers

Normes de code couleur

Sauf indication contraire de l'utilisateur ou du modèle existant

Conventions de couleur standard de l'industrie

  • Texte bleu (RGB : 0,0,255) : Entrées codées en dur et nombres que les utilisateurs changeront pour les scénarios
  • Texte noir (RGB : 0,0,0) : TOUTES les formules et calculs
  • Texte vert (RGB : 0,128,0) : Liens tirés d'autres feuilles de calcul dans le même classeur
  • Texte rouge (RGB : 255,0,0) : Liens externes vers d'autres fichiers
  • Fond jaune (RGB : 255,255,0) : Hypothèses clés nécessitant attention ou cellules devant être mises à jour

Normes de formatage des nombres

Règles de format requises

  • Années : Formater comme des chaînes de texte (par ex., « 2024 » et non « 2 024 »)
  • Devise : Utiliser le format $#,##0 ; TOUJOURS spécifier les unités dans les en-têtes (« Chiffre d'affaires ($m) »)
  • Zéros : Utiliser le formatage des nombres pour afficher tous les zéros sous forme « - », y compris les pourcentages (par ex., « $#,##0;($#,##0);- »)
  • Pourcentages : Par défaut 0,0 % (une décimale)
  • Multiples : Formater comme 0,0x pour les multiples de valorisation (VE/EBITDA, P/E)
  • Nombres négatifs : Utiliser des parenthèses (123) et non le signe moins -123

Règles de construction de formules

Placement des hypothèses

  • Placer TOUTES les hypothèses (taux de croissance, marges, multiples, etc.) dans des cellules d'hypothèses séparées
  • Utiliser des références de cellules au lieu de valeurs codées en dur dans les formules
  • Exemple : Utiliser =B5*(1+$B$6) au lieu de =B5*1,05

Prévention des erreurs de formule

  • Vérifier que toutes les références de cellules sont correctes
  • Vérifier les erreurs de décalage d'une unité dans les plages
  • S'assurer que les formules sont cohérentes sur toutes les périodes de projection
  • Tester avec les cas limites (valeurs zéro, nombres négatifs)
  • Vérifier l'absence de références circulaires involontaires

Exigences de documentation pour les valeurs codées en dur

  • Commenter ou placer à côté (si fin de tableau). Format : « Source : [Système/Document], [Date], [Référence spécifique], [URL si applicable] »
  • Exemples :
    • « Source : 10-K de l'entreprise, AF2024, Page 45, Note Chiffre d'affaires, [URL SEC EDGAR] »
    • « Source : 10-Q de l'entreprise, Q2 2025, Exhibit 99.1, [URL SEC EDGAR] »
    • « Source : Terminal Bloomberg, 15/08/2025, AAPL US Equity »
    • « Source : FactSet, 20/08/2025, Écran d'estimations consensus »

Création, édition et analyse XLSX

Aperçu

Un utilisateur peut vous demander de créer, modifier ou analyser le contenu d'un fichier .xlsx. Vous disposez de différents outils et workflows pour les différentes tâches.

Exigences importantes

LibreOffice requis pour la recalculation de formules : Vous pouvez supposer que LibreOffice est installé pour recalculer les valeurs de formules en utilisant le script scripts/recalc.py. Le script configure automatiquement LibreOffice au premier lancement, y compris dans les environnements en sandbox où les sockets Unix sont restreints (gérés par scripts/office/soffice.py)

Lecture et analyse de données

Analyse des données avec pandas

Pour l'analyse de données, la visualisation et les opérations basiques, utilisez pandas qui fournit de puissantes capacités de manipulation de données :

import pandas as pd

# Lire Excel
df = pd.read_excel('file.xlsx')  # Par défaut : première feuille
all_sheets = pd.read_excel('file.xlsx', sheet_name=None)  # Toutes les feuilles comme dict

# Analyser
df.head()      # Aperçu des données
df.info()      # Info des colonnes
df.describe()  # Statistiques

# Écrire Excel
df.to_excel('output.xlsx', index=False)

Workflows de fichiers Excel

CRITIQUE : Utiliser les formules, pas les valeurs codées en dur

Toujours utiliser les formules Excel au lieu de calculer les valeurs en Python et les coder en dur. Cela garantit que la feuille de calcul reste dynamique et modifiable.

❌ FAUX - Codage en dur des valeurs calculées

# Mauvais : calculer en Python et coder le résultat en dur
total = df['Sales'].sum()
sheet['B10'] = total  # Code en dur 5000

# Mauvais : calculer le taux de croissance en Python
growth = (df.iloc[-1]['Revenue'] - df.iloc[0]['Revenue']) / df.iloc[0]['Revenue']
sheet['C5'] = growth  # Code en dur 0,15

# Mauvais : calcul Python pour la moyenne
avg = sum(values) / len(values)
sheet['D20'] = avg  # Code en dur 42,5

✅ CORRECT - Utiliser les formules Excel

# Bon : laisser Excel calculer la somme
sheet['B10'] = '=SUM(B2:B9)'

# Bon : taux de croissance en formule Excel
sheet['C5'] = '=(C4-C2)/C2'

# Bon : moyenne avec fonction Excel
sheet['D20'] = '=AVERAGE(D2:D19)'

Cela s'applique à TOUS les calculs - totaux, pourcentages, ratios, différences, etc. La feuille de calcul doit pouvoir recalculer quand les données source changent.

Workflow courant

  1. Choisir l'outil : pandas pour les données, openpyxl pour les formules/formatage
  2. Créer/Charger : Créer un nouveau classeur ou charger un fichier existant
  3. Modifier : Ajouter/modifier des données, formules et formatage
  4. Sauvegarder : Écrire dans le fichier
  5. Recalculer les formules (OBLIGATOIRE SI UTILISATION DE FORMULES) : Utiliser le script scripts/recalc.py
    python scripts/recalc.py output.xlsx
  6. Vérifier et corriger les erreurs :
    • Le script retourne JSON avec les détails d'erreur
    • Si status est errors_found, vérifier error_summary pour les types d'erreur spécifiques et les emplacements
    • Corriger les erreurs identifiées et recalculer
    • Erreurs courantes à corriger :
      • #REF! : Références de cellules invalides
      • #DIV/0! : Division par zéro
      • #VALUE! : Type de données incorrect dans la formule
      • #NAME? : Nom de formule non reconnu

Créer de nouveaux fichiers Excel

# Utiliser openpyxl pour les formules et le formatage
from openpyxl import Workbook
from openpyxl.styles import Font, PatternFill, Alignment

wb = Workbook()
sheet = wb.active

# Ajouter des données
sheet['A1'] = 'Hello'
sheet['B1'] = 'World'
sheet.append(['Row', 'of', 'data'])

# Ajouter une formule
sheet['B2'] = '=SUM(A1:A10)'

# Formatage
sheet['A1'].font = Font(bold=True, color='FF0000')
sheet['A1'].fill = PatternFill('solid', start_color='FFFF00')
sheet['A1'].alignment = Alignment(horizontal='center')

# Largeur de colonne
sheet.column_dimensions['A'].width = 20

wb.save('output.xlsx')

Modifier les fichiers Excel existants

# Utiliser openpyxl pour préserver les formules et le formatage
from openpyxl import load_workbook

# Charger le fichier existant
wb = load_workbook('existing.xlsx')
sheet = wb.active  # ou wb['SheetName'] pour une feuille spécifique

# Travailler avec plusieurs feuilles
for sheet_name in wb.sheetnames:
    sheet = wb[sheet_name]
    print(f"Feuille : {sheet_name}")

# Modifier les cellules
sheet['A1'] = 'Nouvelle valeur'
sheet.insert_rows(2)  # Insérer une ligne à la position 2
sheet.delete_cols(3)  # Supprimer la colonne 3

# Ajouter une nouvelle feuille
new_sheet = wb.create_sheet('NewSheet')
new_sheet['A1'] = 'Data'

wb.save('modified.xlsx')

Recalculer les formules

Les fichiers Excel créés ou modifiés par openpyxl contiennent les formules comme chaînes de caractères mais pas les valeurs calculées. Utiliser le script scripts/recalc.py fourni pour recalculer les formules :

python scripts/recalc.py <excel_file> [timeout_seconds]

Exemple :

python scripts/recalc.py output.xlsx 30

Le script :

  • Configure automatiquement la macro LibreOffice au premier lancement
  • Recalcule toutes les formules dans toutes les feuilles
  • Scanne TOUTES les cellules pour les erreurs Excel (#REF!, #DIV/0!, etc.)
  • Retourne JSON avec les emplacements d'erreur détaillés et les comptages
  • Fonctionne sur Linux et macOS

Liste de vérification de la vérification des formules

Vérifications rapides pour s'assurer que les formules fonctionnent correctement :

Vérification essentielle

  • [ ] Tester 2-3 références d'exemple : Vérifier qu'elles tirent les bonnes valeurs avant de construire le modèle complet
  • [ ] Mappage de colonnes : Confirmer que les colonnes Excel correspondent (par ex., colonne 64 = BL, pas BK)
  • [ ] Décalage de ligne : Se rappeler que les lignes Excel sont indexées à partir de 1 (ligne 5 de DataFrame = ligne 6 d'Excel)

Pièges courants

  • [ ] Gestion de NaN : Vérifier les valeurs null avec pd.notna()
  • [ ] Colonnes à droite : Les données AF se trouvent souvent dans les colonnes 50+
  • [ ] Correspondances multiples : Rechercher toutes les occurrences, pas seulement la première
  • [ ] Division par zéro : Vérifier les dénominateurs avant d'utiliser / dans les formules (#DIV/0!)
  • [ ] Références incorrectes : Vérifier que toutes les références de cellules pointent vers les cellules prévues (#REF!)
  • [ ] Références inter-feuilles : Utiliser le format correct (Sheet1!A1) pour lier les feuilles

Stratégie de test de formule

  • [ ] Commencer petit : Tester les formules sur 2-3 cellules avant d'appliquer largement
  • [ ] Vérifier les dépendances : Vérifier que toutes les cellules référencées dans les formules existent
  • [ ] Tester les cas limites : Inclure zéro, négatif et très grandes valeurs

Interprétation de la sortie scripts/recalc.py

Le script retourne JSON avec les détails des erreurs :

{
  "status": "success",           // ou "errors_found"
  "total_errors": 0,              // Nombre total d'erreurs
  "total_formulas": 42,           // Nombre de formules dans le fichier
  "error_summary": {              // Présent seulement si erreurs trouvées
    "#REF!": {
      "count": 2,
      "locations": ["Sheet1!B5", "Sheet1!C10"]
    }
  }
}

Bonnes pratiques

Sélection de bibliothèque

  • pandas : Meilleur pour l'analyse de données, les opérations en masse et l'export de données simple
  • openpyxl : Meilleur pour le formatage complexe, les formules et les fonctionnalités spécifiques à Excel

Travailler avec openpyxl

  • Les indices de cellule sont basés sur 1 (row=1, column=1 fait référence à la cellule A1)
  • Utiliser data_only=True pour lire les valeurs calculées : load_workbook('file.xlsx', data_only=True)
  • Avertissement : S'il est ouvert avec data_only=True et sauvegardé, les formules sont remplacées par les valeurs et perdues définitivement
  • Pour les gros fichiers : Utiliser read_only=True pour lire ou write_only=True pour écrire
  • Les formules sont préservées mais non évaluées - utiliser scripts/recalc.py pour mettre à jour les valeurs

Travailler avec pandas

  • Spécifier les types de données pour éviter les problèmes d'inférence : pd.read_excel('file.xlsx', dtype={'id': str})
  • Pour les gros fichiers, lire les colonnes spécifiques : pd.read_excel('file.xlsx', usecols=['A', 'C', 'E'])
  • Gérer les dates correctement : pd.read_excel('file.xlsx', parse_dates=['date_column'])

Directives de style de code

IMPORTANT : Lors de la génération de code Python pour les opérations Excel :

  • Écrire du code Python minimal et concis sans commentaires inutiles
  • Éviter les noms de variables verbeux et les opérations redondantes
  • Éviter les instructions print inutiles

Pour les fichiers Excel eux-mêmes :

  • Ajouter des commentaires aux cellules avec des formules complexes ou des hypothèses importantes
  • Documenter les sources de données pour les valeurs codées en dur
  • Inclure des notes pour les calculs clés et les sections du modèle

Skills similaires

docx
anthropics / skills

Créer, éditer et analyser des fichiers .docx avec scripts et JavaScript.

127 148
pptx
anthropics / skills

Créer, modifier et enrichir visuellement des présentations PowerPoint percutantes.

127 148
doc-coauthoring
anthropics / skills

Créer des documents collaboratifs structurés en guidant l'utilisateur étape par étape.

127 148
internal-comms
anthropics / skills

Rédiger des communications internes structurées selon leur type et format approprié.

127 148
theme-factory
anthropics / skills

Appliquer un thème visuel professionnel personnalisé à n'importe quel artefact ou présentation.

127 148