Scinder un fichier Excel >5 Mo : méthodes manuelles, VBA, PowerShell et Python pour découper sous 5 Mo

Vous devez envoyer un classeur Excel de plus de 5 Mo ? La limite de nombreux services (e‑mail, CRM, formulaires web) bloque souvent les fichiers imposants. Voici un guide complet pour scinder proprement un fichier Excel volumineux en plusieurs volets indépendants de moins de 5 Mo, sans perdre de données ni de mises en forme.

Sommaire

Vue d’ensemble du problème

Excel fonctionne selon un modèle « workbook » qui agrège feuilles, mises en forme, images et formules dans une seule archive compressée. Sur des volumes importants (milliers de lignes, dizaines de feuilles, tableaux croisés dynamiques, graphiques intégrés, etc.), la taille finale peut dépasser les 5 Mo fixés par votre canal de diffusion. Au lieu d’exporter le fichier en PDF (qui gèle les données) ou de le compresser (souvent inefficace car *.xlsx* est déjà un conteneur ZIP), la meilleure solution consiste à découper le classeur.

Solutions proposées

Approche	Quand l’utiliser	Étapes essentielles	Points d’attention
Méthode manuelle (sans code)	Fichiers ponctuellement trop gros, volume de données modéré	1. Sélectionner un bloc cohérent de lignes ou de colonnes. 2. `Ctrl`+`C` pour copier. 3. Créer un nouveau classeur (`Ctrl`+`N`). 4. `Ctrl`+`V` pour coller. 5. Enregistrer et vérifier que le fichier < 5 Mo. 6. Répéter jusqu’à épuisement des données.	✔️ Aucun code à apprendre. ❌ Fastidieux si le classeur comporte de nombreuses feuilles ou des centaines de milliers de lignes.
Automatisation VBA	Tâche récurrente, besoin d’un contrôle précis sur la découpe	1. Ouvrir l’Éditeur VBA (`Alt`+`F11`). 2. Créer une macro qui : • calcule la taille courante du fichier ; • parcourt les feuilles ou lignes ; • copie les lots dans de nouveaux classeurs ; • sauvegarde chaque classeur dès qu’il atteint ≈ 4,8 Mo. 3. Exécuter, puis tester.	✔️ Automatisable à 100 %. ✔️ Peut inclure des noms de fichiers dynamiques (« Lot_01.xlsx », etc.). ❌ Plus lent si le classeur contient beaucoup d’objets (images, graphiques).
Outils tiers (add‑ins ou logiciels dédiés)	Recherche d’une solution prête à l’emploi, sans écrire de code	Exemples : compléments « Kutools for Excel » ou applications « Excel Splitter ». L’assistant permet de définir : • nombre maximal de lignes/feuilles ; • taille cible en Mo ; • dossier de destination.	✔️ Interface conviviale. ❌ Souvent payants ou limités dans leur version d’essai. ❌ Peut nécessiter un droit d’installation local.
Scripts externes (PowerShell, Python, CSVKit)	Très gros volumes de données ou automatisation serveur (CI/CD, tâches planifiées)	1. Exporter les feuilles Excel en CSV. 2. Découper les CSV en blocs de n lignes (commande `split` ou `csvsplit`). 3. Facultatif : reconvertir chaque bloc en `.xlsx`. 4. Supprimer les fichiers temporaires.	✔️ Performances élevées. ✔️ Intégrable dans un pipeline DevOps. ❌ Nécessite des compétences en scripting.

Méthode manuelle : le pas‑à‑pas détaillé

Si vous n’avez qu’un classeur unique à traiter et que vous préférez éviter le code :

Faites une copie de sauvegarde du fichier original.
Déterminez le critère logique de découpe : onglet par onglet, ou plage de 50 000 lignes, etc.
Sélectionnez la plage → Ctrl+C.
Ctrl+N pour créer un nouveau fichier, collez (Ctrl+V).
Supprimez les feuilles vides (clic droit → Supprimer).
Enregistrez en .xlsx (compression native) et vérifiez la taille : Fichier > Infos > Taille.
Répétez jusqu’à ce que tout le contenu soit réparti.

Astuce : pour accélérer, créez d’abord un modèle (« split_template.xlsx ») contenant déjà le formatage souhaité, puis enregistrez chaque découpe sous un nom différent.

Automatisation VBA : exemple de macro

La macro suivante segmente la première feuille par blocs de 40 000 lignes ; elle crée un fichier dans le même dossier dès que la taille atteint ~4,8 Mo :

Sub SplitWorkbookByRows()
    Const CHUNK_SIZE As Long = 40000
    Const TARGET_SIZE As Long = 4800 ' en Ko
    Dim ws As Worksheet, rng As Range, destWB As Workbook
    Dim lastRow As Long, startRow As Long, fileIdx As Long

```
Set ws = ThisWorkbook.Worksheets(1)
lastRow = ws.Cells(ws.Rows.Count, 1).End(xlUp).Row
startRow = 1: fileIdx = 1

Do While startRow &lt;= lastRow
    Set destWB = Workbooks.Add(xlWBATWorksheet)
    ws.Rows(startRow &amp; ":" &amp; Application.Min(startRow + CHUNK_SIZE - 1, lastRow)).Copy _
         destWB.Worksheets(1).Range("A1")
    destWB.SaveAs ThisWorkbook.Path &amp; "\Lot_" &amp; Format(fileIdx, "00") &amp; ".xlsx", 51
    If FileLen(destWB.FullName) / 1024 &gt; TARGET_SIZE Then
        MsgBox "Attention : " &amp; destWB.Name &amp; " dépasse la taille cible.", vbExclamation
    End If
    destWB.Close False
    startRow = startRow + CHUNK_SIZE
    fileIdx = fileIdx + 1
Loop
```

End Sub

Sécurité macro : activez uniquement les macros provenant de sources fiables et signez votre projet VBA pour passer les contrôles administratifs.

Scripts externes : cas pratique avec Python

Quand votre service de BI ou votre pipeline CI doit éclater plusieurs fois par jour un export à 200 000 lignes, un script Python est imbattable. Exemple minimaliste :

import pandas as pd
from pathlib import Path

SOURCE = Path(r"C:\Data\rapport\_global.xlsx")
CHUNK = 50000  # lignes
DEST\_DIR = SOURCE.with\_suffix("").name + "\_splits"
Path(DEST\_DIR).mkdir(exist\_ok=True)

df\_iter = pd.read\_excel(SOURCE, sheet\_name=0, chunksize=CHUNK)

for idx, chunk in enumerate(df\_iter, 1):
out\_file = Path(DEST\_DIR) / f"lot\_{idx:02d}.xlsx"
chunk.to\_excel(out\_file, index=False)
size\_mb = out\_file.stat().st\_size / 1024\*\*2
if size\_mb > 5:
print(f"⚠️ {out\_file.name} fait {size\_mb:.2f} Mo, ajustez CHUNK.")

openpyxl est utilisé en arrière‑plan ; installez‑le avec pip install openpyxl pandas. Pour de très gros volumes, préférez le format .csv (écriture plus rapide) puis une reconversion ponctuelle en .xlsx si nécessaire.

Optimisations avant la découpe

Nettoyez les plages vides : sélectionnez la zone de travail réelle (Ctrl+Fin) ; si le curseur se trouve loin sous vos données, des lignes fantômes gonflent la taille.
Supprimez les noms définis inutiles (> Formules > Gestionnaire de noms).
Convertissez les images BMP/JPEG en PNG ou placez‑les dans un dossier séparé pour un envoi indépendant.
Basculer en .xlsb (binary workbook) peut réduire la taille de 20‑50 %, utile avant le split.

Stratégies de segmentation logique

Un découpage uniquement « à la louche » par taille est source de confusion ; donnez un sens métier à chaque fichier : Par feuilleUn onglet = un fichier (ex. Budget_2024.xlsx, Budget_2025.xlsx). Par périodeCoupez par trimestre ou par année pour respecter vos fenêtres de reporting. Par entité fonctionnelleService commercial, RH, Finances : chaque direction reçoit son extract.

Créer un index maître

Générez un simple classeur Index_Split.xlsx contenant :

Nom du fichier découpé
Plage de lignes ou dates couvertes
Date/heure de création

Un VLOOKUP ou un Power Query pourra reconsolider plus tard toutes les coupes si besoin.

Contrôle qualité après découpe

Ouvrez 2 ou 3 fichiers choisis aléatoirement et vérifiez :
- Formules toujours actives (pas seulement valeurs collées).
- Références externes non rompues (onglets renommés ?).
- Mises en forme et formats de nombre corrects.
Recalculez (F9) pour lever d’éventuelles erreurs #REF!
Exécutez le correcteur d’accessibilité (Excel > Révision > Vérifier l’accessibilité) si les fichiers seront publiés.

Automatisation complète : workflow PowerShell + Planificateur

Sur un serveur Windows, un unique script PowerShell déclenché par le Planificateur de tâches gère l’export, la découpe et le dépôt dans SharePoint :

$excel = New-Object -ComObject Excel.Application
$wb = $excel.Workbooks.Open("C:\Data\RapportMensuel.xlsx")
$sheet = $wb.Sheets.Item(1)
$chunk = 40000
$lastRow = $sheet.UsedRange.Rows.Count
$start = 1; $i = 1

while (\$start -le \$lastRow) {
\$dest = \$excel.Workbooks.Add()
\$sheet.Rows("\$start:\$(\[Math]::Min(\$start+\$chunk-1,\$lastRow))").Copy()
\$dest.Sheets.Item(1).Paste()
\$path = "C:\Export\lot\_\$('{0\:d2}' -f \$i).xlsx"
\$dest.SaveAs(\$path, 51)
if ((Get-Item \$path).Length/1MB -gt 5) {
Write-Warning "\$path dépasse 5 Mo."
}
\$dest.Close(\$false)
\$i++; \$start += \$chunk
}
\$wb.Close(\$false)
\$excel.Quit()

Planifiez l’exécution après la génération du rapport principal et ajoutez une étape finale qui déplace les fichiers vers SharePoint / OneDrive via Move-Item ou l’API Graph.

Performance & limites techniques

Temps de copie VBA : 3 000 lignes/s environ sur un poste bureautique standard ; préférez un découpage par lignes plutôt qu’un Copy/Paste feuille par feuille pour réduire le trafic COM.
openpyxl vs. pandas : openpyxl écrit cellule par cellule (lent) ; pandas + xlsxwriter bat openpyxl de ~40 % sur de gros blocs tabulaires.
Fichiers .xls (format Excel 97‑2003) se limitent à 65 536 lignes ; évitez‑les.
Macros désactivées par défaut dans les environnements Microsoft 365 durcis ; prévoyez un plan B sans VBA.

FAQ minute

Comment connaître rapidement la taille d’une feuille individuelle ?

Copiez l’onglet dans un nouveau classeur, enregistrez et vérifiez la taille du fichier ; c’est le moyen le plus fiable.

Et si je veux tout reconstituer plus tard ?

Utilisez Power Query pour importer chaque lot et « Appended » (Ajouter des requêtes) en un seul tableau, ou concaténez les CSV via type *.csv > master.csv.

Existe‑t‑il un moyen sans installation d’outils ?

Oui : Power Automate (Cloud) dispose d’un connecteur Excel Online qui lit les lignes par lots ; combinez‑le avec « Create file » pour générer de nouveaux classeurs.

Conclusion

Que vous soyez analyste « Excel pur », développeur VBA aguerri ou ingénieur DevOps, il existe une stratégie de découpe adaptée à votre contexte : de la méthode 100 % manuelle aux scripts Python déployés sur serveur. En appliquant les bonnes pratiques d’optimisation, de segmentation logique et de contrôle qualité ci‑dessus, vous produirez des fichiers fiables, chacun sous la barre des 5 Mo, prêts à être partagés en toute sécurité et à répondre aux contraintes réglementaires ou techniques de votre organisation.

Scinder un fichier Excel >5 Mo : méthodes manuelles, VBA, PowerShell et Python pour découper sous 5 Mo