Suddividere file Excel in parti da massimo 5 MB: guida completa con macro VBA, Python e PowerShell

Hai un workbook Excel gigantesco e devi consegnarlo in pezzi più piccoli sotto il limite di invio o di caricamento? In questa guida trovi strategie pratiche, macro pronte, script e consigli per spezzare in modo sicuro un file Excel in più file con dimensione massima di 5 MB, senza perdere dati né tempo.

Indice

Perché la dimensione conta

Molte piattaforme limitano gli allegati a pochi megabyte. Anche sistemi di ticketing, portali SaaS e messaggistica aziendale impongono soglie severe. Un workbook può gonfiarsi per formattazioni ripetute, formule voluminose, pivot cache, immagini, componenti OLE o query annidate. Spezzarlo in più file è spesso l’unica alternativa per consegnare i dati in sicurezza, mantenendo al contempo leggibilità e tracciabilità.

Cosa determina davvero il peso di un file

Contenuto delle celle: testo, numeri, date, errori; i valori ripetuti si comprimono bene nel formato .xlsx.
Formule e formattazioni condizionali: aumentano i metadati e la complessità.
Oggetti: immagini, forme, grafici, elementi SmartArt, commenti moderni.
Pivot e Power Query: pivot cache e query cache possono occupare molto spazio.
Versione e formato: .xlsb spesso salva spazio rispetto a .xlsx, ma potrebbe non essere accettato da procedure standard o sistemi esterni.

Criteri per scegliere il metodo

Prima di iniziare, rispondi a due domande pratiche:

I fogli sono indipendenti? Se i dati non si riferiscono tra loro, dividere per foglio è immediato.
Serve rispettare rigorosamente il limite di dimensione? Se sì, occorre misurare il peso dopo ogni salvataggio ed eventualmente ridurre i blocchi di righe in modo adattivo.

Confronto rapido degli approcci

Approccio	Procedura essenziale	Pro	Contro
Metodo manuale copia e incolla	1. Seleziona righe o colonne. 2. Copia. 3. Incolla in un nuovo workbook. 4. Salva e verifica che resti sotto 5 MB. 5. Ripeti fino a coprire tutto.	Nessun software aggiuntivo; immediato per divisioni semplici.	Lento e soggetto a errori; rischi di rompere collegamenti; controlli manuali di dimensione.
Macro VBA	Una macro cicla su fogli o righe, crea nuovi file, copia blocchi finché la dimensione ≤ limite e salva con nome incrementale.	Automatizzabile e ripetibile; integra la logica di controllo con `FileLen()`.	Richiede confidenza con macro; possibili restrizioni di sicurezza; debug talvolta complesso.
Strumenti di terze parti	Add‑in e utility con funzione di split, ad esempio soluzioni note che includono opzioni per dividere per fogli o per righe.	Wizard guidati; impostazioni per mantenere formattazioni, formule, nomi fogli; molto rapide.	Licenze a pagamento; compatibilità da verificare; comportamento variabile su file complessi.

Preparazione consigliata prima dello split

Pulisci il workbook: rimuovi fogli inutili, aree vuote piene di formati, stili duplicati, dati definitivi con formule convertite in valori ove possibile.
Riduci oggetti pesanti: comprimi immagini, elimina grafici superflui, valuta di rimuovere commenti e note ridondanti.
Calcolo manuale: imposta il calcolo su manuale durante l’operazione per accelerare (File > Opzioni > Formule).
Stabilisci una convenzione di nomi: ad esempio Vendite2024part001.xlsx, Vendite2024part002.xlsx.
Conosci il limite: per sicurezza considera 5 1024 1024 = 5.242.880 byte come soglia.

Procedura manuale passo per passo

Apri il file originale e identifica cosa separare (per foglio, per clienti, per mese, per intervalli di righe).
Seleziona il blocco da estrarre, copia e incolla in un nuovo workbook.
Salva nel formato richiesto (tipicamente .xlsx) e verifica la dimensione dal file system.
Ripeti la procedura seguendo la tua convenzione di nomi.

Consiglio: se dividi per righe, mantieni in ogni file l’intestazione (riga titoli) per garantire leggibilità e importazioni successive senza sorprese.

Macro VBA pronta all’uso con controllo della dimensione

La macro seguente spezza il foglio attivo in più file. Stima quanti record inserire in ogni parte misurando il peso reale su un salvataggio temporaneo, quindi adatta il numero di righe per non superare la soglia. Mantiene formati e valori dell’intestazione e copia i dati come valori per ridurre il peso.

Premi Alt+F11, quindi Inserisci > Modulo.
Incolla il codice qui sotto e premi F5 per avviare SplitWorkbookBySize con il foglio che vuoi dividere attivo.

Option Explicit

Public Sub SplitWorkbookBySize()
    Dim srcWb As Workbook, srcWs As Worksheet
    Dim outFolder As String, baseName As String
    Dim limitBytes As Long
    Dim headerRow As Long, firstDataRow As Long
    Dim lastRow As Long, lastCol As Long
    Dim part As Long, r As Long, chunkRows As Long, rowsRemaining As Long
    Dim size As Long, outPath As String

    On Error GoTo CleanFail
    Application.ScreenUpdating = False
    Application.DisplayAlerts = False
    Application.Calculation = xlCalculationManual

    Set srcWb = ActiveWorkbook
    Set srcWs = ActiveSheet          ' Cambia se vuoi un foglio specifico: srcWb.Worksheets("Dati")

    headerRow = 1                     ' Modifica se l'intestazione è su un'altra riga
    firstDataRow = headerRow + 1
    limitBytes = 5  1024  1024      ' 5 MB in byte

    ' Trova l'ultima riga e colonna usate
    lastRow = srcWs.Cells.Find(What:="*", LookIn:=xlFormulas, LookAt:=xlPart, _
                SearchOrder:=xlByRows, SearchDirection:=xlPrevious, MatchCase:=False).Row
    lastCol = srcWs.Cells.Find(What:="*", LookIn:=xlFormulas, LookAt:=xlPart, _
                SearchOrder:=xlByColumns, SearchDirection:=xlPrevious, MatchCase:=False).Column

    outFolder = srcWb.Path & Application.PathSeparator & "Split"
    EnsureFolder outFolder
    baseName = GetBaseName(srcWb.Name) & "part"

    ' Stima dimensione base e costo per riga
    Dim overhead As Long, bytesPerRow As Double, sampleN As Long
    overhead = SizeWithRows(srcWs, headerRow, lastCol, firstDataRow, 0) ' solo intestazione
    sampleN = WorksheetFunction.Min(5000, lastRow - headerRow)
    If sampleN &lt; 1 Then sampleN = 1
    bytesPerRow = EstimateBytesPerRow(srcWs, headerRow, lastCol, firstDataRow, sampleN, overhead)

    ' Calcolo iniziale righe per file (con margine)
    chunkRows = CLng((limitBytes - overhead) / Application.Max(bytesPerRow, 1#))
    If chunkRows &lt; 500 Then chunkRows = 500

    part = 1
    r = firstDataRow

    Do While r &lt;= lastRow
        rowsRemaining = lastRow - r + 1
        If rowsRemaining &lt; chunkRows Then chunkRows = rowsRemaining

RetryChunk:
        Dim outWb As Workbook, outWs As Worksheet
        Set outWb = Workbooks.Add(xlWBATWorksheet)
        Set outWs = outWb.Worksheets(1)

        ' Copia intestazione: valori + formati
        srcWs.Range(srcWs.Cells(headerRow, 1), srcWs.Cells(headerRow, lastCol)).Copy
        outWs.Range("A1").PasteSpecial xlPasteValues
        outWs.Range("A1").PasteSpecial xlPasteFormats

        ' Copia dati come valori per ridurre peso
        srcWs.Range(srcWs.Cells(r, 1), srcWs.Cells(r + chunkRows - 1, lastCol)).Copy
        outWs.Range("A2").PasteSpecial xlPasteValues
        outWs.Range("A2").PasteSpecial xlPasteFormats
        Application.CutCopyMode = False

        outPath = outFolder & Application.PathSeparator & baseName & Format$(part, "000") & ".xlsx"
        outWb.SaveAs Filename:=outPath, FileFormat:=xlOpenXMLWorkbook
        size = FileLen(outPath)

        If size &gt; limitBytes And chunkRows &gt; 100 Then
            ' Riduci proporzionalmente e riprova
            outWb.Close SaveChanges:=False
            On Error Resume Next: Kill outPath: On Error GoTo 0
            chunkRows = CLng(chunkRows  (limitBytes / size)  0.9) ' margine di sicurezza
            If chunkRows &lt; 100 Then chunkRows = 100
            GoTo RetryChunk
        Else
            outWb.Close SaveChanges:=False
            part = part + 1
            r = r + chunkRows
        End If
    Loop

CleanExit:
    Application.Calculation = xlCalculationAutomatic
    Application.DisplayAlerts = True
    Application.ScreenUpdating = True
    MsgBox "Completato. File creati in: " & outFolder, vbInformation
    Exit Sub

CleanFail:
    Application.Calculation = xlCalculationAutomatic
    Application.DisplayAlerts = True
    Application.ScreenUpdating = True
    MsgBox "Errore: " & Err.Description, vbExclamation
End Sub

Private Sub EnsureFolder(ByVal p As String)
    If Dir$(p, vbDirectory) = vbNullString Then MkDir p
End Sub

Private Function GetBaseName(ByVal fullName As String) As String
    Dim i As Long: i = InStrRev(fullName, ".")
    If i &gt; 0 Then
        GetBaseName = Left$(fullName, i - 1)
    Else
        GetBaseName = fullName
    End If
End Function

Private Function SizeWithRows(ByVal ws As Worksheet, ByVal headerRow As Long, _
    ByVal lastCol As Long, ByVal startDataRow As Long, ByVal dataRows As Long) As Long

    Dim wb As Workbook, tmp As String, outWs As Worksheet
    Set wb = Workbooks.Add(xlWBATWorksheet)
    Set outWs = wb.Worksheets(1)

    ws.Range(ws.Cells(headerRow, 1), ws.Cells(headerRow, lastCol)).Copy
    outWs.Range("A1").PasteSpecial xlPasteValues
    outWs.Range("A1").PasteSpecial xlPasteFormats

    If dataRows &gt; 0 Then
        ws.Range(ws.Cells(startDataRow, 1), ws.Cells(startDataRow + dataRows - 1, lastCol)).Copy
        outWs.Range("A2").PasteSpecial xlPasteValues
        outWs.Range("A2").PasteSpecial xlPasteFormats
    End If
    Application.CutCopyMode = False

    tmp = Environ$("TEMP") & Application.PathSeparator & "tmp_split.xlsx"
    On Error Resume Next: Kill tmp: On Error GoTo 0
    wb.SaveAs Filename:=tmp, FileFormat:=xlOpenXMLWorkbook
    SizeWithRows = FileLen(tmp)
    wb.Close SaveChanges:=False
    On Error Resume Next: Kill tmp: On Error GoTo 0
End Function

Private Function EstimateBytesPerRow(ByVal ws As Worksheet, ByVal headerRow As Long, _
    ByVal lastCol As Long, ByVal firstDataRow As Long, ByVal sampleN As Long, _
    ByVal overhead As Long) As Double

    Dim s As Long
    s = SizeWithRows(ws, headerRow, lastCol, firstDataRow, sampleN)
    If s &lt;= overhead Or sampleN = 0 Then
        EstimateBytesPerRow = 1024# ' fallback prudenziale
    Else
        EstimateBytesPerRow = (s - overhead) / CDbl(sampleN)
    End If
End Function

Note operative

La macro crea una cartella Split accanto al file sorgente e salva lì le parti.
Il numero di righe per parte viene stimato e poi corretto se il salvataggio supera la soglia.
Se vuoi preservare le formule, sostituisci l’incolla valori con un semplice Copy dell’intervallo; sappi però che il peso potrebbe aumentare.

Procedura con Power Query

Power Query è eccellente per generare subset ripetibili (per esempio per cliente, per mese o per range di righe), ma non esporta nativamente in file separati in un solo clic. La soluzione pratica è usare Power Query per definire i blocchi e una macro breve per esportare ogni query in un file a parte verificandone il peso.

Definizione dei blocchi

Carica la tabella con Dati > Da tabella/intervallo.
Aggiungi una colonna indice da uno.
Crea una colonna Gruppo come Number.IntegerDivide([Indice]-1, ChunkSize), dove ChunkSize è un parametro intero (ad esempio 50 000 righe).
Raggruppa per Gruppo e genera le tabelle figlie.
Chiudi e carica come solo connessione.

A questo punto una macro può scorrere le tabelle figlie, esportarle una a una e ritentare con un ChunkSize minore qualora il salvataggio superi la soglia. Puoi riutilizzare la logica di misurazione vista nella macro principale.

Automazione con Python

Se gestisci flussi ricorrenti, Python offre controllo e portabilità. Di seguito due approcci: con pandas per comodità e con openpyxl in modalità streaming per file molto grandi.

Script con pandas (semplice e chiaro)

Valido per file medio‑grandi che rientrano nella memoria disponibile. L’idea è stimare il costo per riga, calcolare un blocco iniziale e adattarlo se il salvataggio supera il limite.

import os, math, tempfile
import pandas as pd

SOURCE = "origine.xlsx"
SHEET = 0               # oppure il nome del foglio
OUTDIR = "outsplit"
LIMIT = 5  1024  1024 # 5 MB in byte

os.makedirs(OUTDIR, existok=True)

df = pd.readexcel(SOURCE, sheetname=SHEET)

def saveandsize(sampledf, path):
    tmp = path
    if os.path.exists(tmp):
        os.remove(tmp)
    with pd.ExcelWriter(tmp, engine="xlsxwriter", options={"stringstoformulas": False}) as w:
        sampledf.toexcel(w, index=False)
    return os.path.getsize(tmp)

overhead: solo intestazione
empty_path = os.path.join(tempfile.gettempdir(), "hdr.xlsx")
overhead = saveandsize(df.iloc[:0], emptypath)

stima costo per riga su un campione
sample_n = min(5000, len(df))
sample_path = os.path.join(tempfile.gettempdir(), "sample.xlsx")
bytesperrow = 1024
if sample_n &gt; 0:
    s = saveandsize(df.iloc[:samplen], sample_path)
    delta = max(s - overhead, 1)
    bytesperrow = max(delta / sample_n, 1)

rowsperfile = max(int((LIMIT - overhead) / bytesperrow), 500)
part = 1
i = 0
while i &lt; len(df):
    take = min(rowsperfile, len(df) - i)
    while True:
        chunk = df.iloc[i:i+take]
        outpath = os.path.join(OUTDIR, f"part_{part:03d}.xlsx")
        size = saveandsize(chunk, outpath)
        if size &lt;= LIMIT or take &lt;= 100:
            break
        # riduci proporzionalmente con margine
        take = max(int(take  (LIMIT / size)  0.9), 100)
    part += 1
    i += take

print("Fatto. File creati in:", OUT_DIR)

Vantaggi: poche dipendenze, codice lineare. Limiti: carica l’intero foglio in memoria; per workbook multi‑foglio dovrai iterare su ciascun foglio.

Script con openpyxl in modalità streaming

Per dataset davvero grandi, usa lettura read‑only e scrittura write‑only. Si lavora riga per riga e ci si ferma prima della soglia stimata, poi si verifica il file generato.

import os, tempfile
from openpyxl import load_workbook, Workbook

SOURCE = "origine.xlsx"
OUTDIR = "outsplit_stream"
LIMIT = 5  1024  1024

os.makedirs(OUTDIR, existok=True)

wb = loadworkbook(SOURCE, readonly=True, data_only=True)
ws = wb.active

rows = ws.iterrows(valuesonly=True)
header = next(rows)

stima costo per riga con un piccolo campione
sample = []
for _ in range(5000):
    try:
        sample.append(next(rows))
    except StopIteration:
        break

def savechunk(rowsiterable, idx):
    outpath = os.path.join(OUTDIR, f"part_{idx:03d}.xlsx")
    outwb = Workbook(writeonly=True)
    outws = outwb.create_sheet()
    out_ws.append(header)
    for r in rows_iterable:
        out_ws.append(r)
    outwb.save(outpath)
    return out_path

calcola overhead e bytes per riga
tmphdr = os.path.join(tempfile.gettempdir(), "hdrstream.xlsx")
 = savechunk([], 0)  # crea file vuoto con sola intestazione
os.replace(os.path.join(OUTDIR, "part000.xlsx"), tmp_hdr)
overhead = os.path.getsize(tmp_hdr)

tmpsample = os.path.join(tempfile.gettempdir(), "samplestream.xlsx")
 = savechunk(sample, 0)
os.replace(os.path.join(OUTDIR, "part000.xlsx"), tmp_sample)
delta = max(os.path.getsize(tmp_sample) - overhead, 1)
bpr = max(delta / max(len(sample), 1), 1)

rowsperfile = max(int((LIMIT - overhead) / bpr), 500)

riparti da inizio dati
wb.close()
wb = loadworkbook(SOURCE, readonly=True, data_only=True)
ws = wb.active
datarows = ws.iterrows(minrow=2, valuesonly=True)

idx = 1
buffer = []
count = 0
for row in data_rows:
    buffer.append(row)
    count += 1
    if count &gt;= rowsperfile:
        path = save_chunk(buffer, idx)
        size = os.path.getsize(path)
        if size &gt; LIMIT:  # ritenta con meno righe
            step = max(int(count  (LIMIT / size)  0.9), 100)
            path = save_chunk(buffer[:step], idx)
            os.remove(path) if os.path.getsize(path) &gt; LIMIT else None
            save_chunk(buffer[:step], idx)  # salvataggio finale
        buffer.clear()
        count = 0
        idx += 1

ultimo blocco
if buffer:
    save_chunk(buffer, idx)

print("Fatto. File creati in:", OUT_DIR)

Nota: lo streaming riduce l’uso di memoria ma incrementa gli I/O. Per risultati stabili mantieni un margine di sicurezza sul numero stimato di righe per parte.

Automazione con PowerShell

In ambienti Windows senza Python, puoi usare l’automazione COM di Excel. Lo script seguente duplica la logica di stima e genera parti progressive. Richiede Excel installato sulla macchina di esecuzione.

$Source = "C:\dati\origine.xlsx"
$OutDir = "C:\dati\Split"
$Limit = 5  1024  1024  # 5 MB in byte
$HeaderRow = 1
$MinRows = 100

New-Item -ItemType Directory -Force -Path $OutDir | Out-Null

$excel = New-Object -ComObject Excel.Application
$excel.Visible = $false
$excel.DisplayAlerts = $false

function Get-UsedLast {
    param($ws)
    $lastCell = $ws.Cells.Find("*", $ws.Cells.Item(1,1), $null, $null, 1, 2, $false, $false, $false)
    $lastCol  = $ws.Cells.Find("*", $ws.Cells.Item(1,1), $null, $null, 2, 2, $false, $false, $false).Column
    return @{Row=$lastCell.Row; Col=$lastCol}
}
function Save-And-Size {
    param($wb, $path)
    if (Test-Path $path) { Remove-Item $path -Force }
    $wb.SaveAs($path, 51) # xlOpenXMLWorkbook
    return (Get-Item $path).Length
}
function Copy-HeaderAndRows {
    param($srcWs, $dstWs, $hdrRow, $lastCol, $startRow, $rows)
    $srcWs.Range($srcWs.Cells.Item($hdrRow,1), $srcWs.Cells.Item($hdrRow,$lastCol)).Copy()
    $dstWs.Range("A1").PasteSpecial(-4163) | Out-Null  # xlPasteValues
    $dstWs.Range("A1").PasteSpecial(-4122) | Out-Null  # xlPasteFormats
    if ($rows -gt 0) {
        $srcWs.Range($srcWs.Cells.Item($startRow,1), $srcWs.Cells.Item($startRow+$rows-1,$lastCol)).Copy()
        $dstWs.Range("A2").PasteSpecial(-4163) | Out-Null
        $dstWs.Range("A2").PasteSpecial(-4122) | Out-Null
    }
    $dstWs.Application.CutCopyMode = $false
}

$wb = $excel.Workbooks.Open($Source)
$ws = $wb.Worksheets.Item(1)
$u = Get-UsedLast $ws
$firstData = $HeaderRow + 1

overhead e stima
$tmp = Join-Path $env:TEMP "hdr.xlsx"
$draft = $excel.Workbooks.Add()
Copy-HeaderAndRows $ws $draft.Worksheets.Item(1) $HeaderRow $u.Col $firstData 0
$overhead = Save-And-Size $draft $tmp
$draft.Close($false)

$sampleN = [Math]::Min(5000, $u.Row - $HeaderRow)
$tmp2 = Join-Path $env:TEMP "sample.xlsx"
$draft = $excel.Workbooks.Add()
Copy-HeaderAndRows $ws $draft.Worksheets.Item(1) $HeaderRow $u.Col $firstData $sampleN
$sampleSize = Save-And-Size $draft $tmp2
$draft.Close($false)

$bytesPerRow = [Math]::Max(($sampleSize - $overhead) / [Math]::Max($sampleN,1), 1)
$chunkRows = [int][Math]::Max(($Limit - $overhead) / $bytesPerRow, 500)

$part = 1
$r = $firstData
while ($r -le $u.Row) {
    $remaining = $u.Row - $r + 1
    if ($remaining -lt $chunkRows) { $chunkRows = $remaining }
    :Retry do {
        $out = $excel.Workbooks.Add()
        Copy-HeaderAndRows $ws $out.Worksheets.Item(1) $HeaderRow $u.Col $r $chunkRows
        $outPath = Join-Path $OutDir ("part_{0:D3}.xlsx" -f $part)
        $size = Save-And-Size $out $outPath
        $out.Close($false)
        if ($size -gt $Limit -and $chunkRows -gt $MinRows) {
            $chunkRows = [int][Math]::Max($chunkRows  ($Limit / $size)  0.9, $MinRows)
            Remove-Item $outPath -Force
            $retry = $true
        } else { $retry = $false }
    } while ($retry)
    $part++
    $r += $chunkRows
}

$wb.Close($false)
$excel.Quit()
[System.Runtime.Interopservices.Marshal]::ReleaseComObject($excel) | Out-Null
Write-Host "Completato. File in $OutDir"

Uso di strumenti specializzati

Alcuni componenti aggiuntivi per Excel includono funzioni native per dividere workbook per foglio o per intervalli di righe, con opzioni per mantenere formati e formule. Sono ideali quando cerchi un’interfaccia guidata e devi operare su file molto pesanti senza scrivere codice. Valuta la compatibilità con la tua versione di Excel e prova sempre su una copia del file.

Strategie per mantenere integrità e riferimenti

Formule tridimensionali e collegamenti esterni: se suddividi, le formule che puntano ad altri fogli o cartelle di lavoro si romperanno. Decidi se convertire a valori prima dello split oppure ricostruire i riferimenti dopo.
Convalida dei dati e nomi intervallo: esporta anche i nomi necessari o convertili in ambito locale nel singolo file.
Formato cella coerente: mantieni le stesse impostazioni regionali e formati numerici in ogni parte per evitare discrepanze in importazioni successive.

Controllo qualità dopo lo split

Verifica dimensione: ogni file deve essere entro la soglia. Meglio mantenere un margine (ad esempio < 4,9 MB) per evitare sorprese su sistemi che calcolano i megabyte in modo diverso.
Somme di controllo: confronta totali, conteggi righe e chiavi univoche tra originale e parti sommate.
Coerenza intestazioni: controlla che l’ordine e i nomi delle colonne siano identici in tutte le parti.

Consigli pratici per ridurre il peso

Rimuovi stili duplicati: i file provenienti da molte copie e incolla possono contenere migliaia di stili inutili.
Elimina formattazioni condizionali ridondanti o convertili in formattazioni statiche quando non servono aggiornamenti automatici.
Comprimi o rimuovi immagini: anche poche immagini ad alta risoluzione possono superare la soglia.
Valuta il formato: se lo scenario lo consente, .xlsb può ridurre sensibilmente il peso. In caso contrario, resta su .xlsx per la massima compatibilità.

Domande frequenti

Conviene dividere per fogli o per righe? Se i fogli sono logicamente indipendenti, per fogli è rapidissimo. Se invece hai un unico foglio enorme, dividi per righe mantenendo l’intestazione in ogni file.

Posso mantenere le formule? Sì, ma i file pesano di più e le formule che referenziano altri fogli o cartelle si romperanno. Se i file sono destinati a caricamenti o importazioni, conviene spesso esportare solo valori.

In CSV i file sono più leggeri? Dipende. .xlsx è compresso; un CSV può risultare più grande per tabelle ampie. Se scegli CSV, valuta anche la compressione .zip e l’uso di separatore coerente con il sistema di destinazione.

Come gestire tabelle con righe molto pesanti? Alcune righe con celle piene di testo o oggetti possono falsare la stima. Le soluzioni automatiche qui proposte riducono dinamicamente i blocchi quando il salvataggio supera la soglia.

Risoluzione dei problemi

La macro si ferma per protezioni: rimuovi la protezione del foglio o del workbook prima di eseguire lo split.
Messaggi di sicurezza per macro: abilita temporaneamente le macro per la cartella attendibile o esegui da un percorso considerato sicuro dall’organizzazione.
Prestazioni lente: disattiva il calcolo automatico e l’anteprima stampa; chiudi altre applicazioni; evita salvataggi di rete durante la fase di prova.
Accavallamento di dati: usa sempre un indice univoco o un ordinamento deterministico prima di spezzare. Così potrai ricomporre in seguito con certezza.

Checklist finale

Backup del file originale.
Pulizia di stili, formati e oggetti superflui.
Scelta del criterio di split coerente con l’uso finale.
Definizione convenzione nomi e cartella di destinazione.
Automazione con macro o script e verifica dimensione ≤ 5 MB.
Conferma di totali e conteggi tra originale e parti.

Quando scegliere quale approccio

Intervento una tantum: metodo manuale o add‑in.
Processo ricorrente in ambito ufficio: macro VBA con controllo di dimensione e convenzione di esportazione.
Pipeline dati ripetitive o integrate: Python o PowerShell orchestrati da pianificatore con log di esecuzione.

Modello di naming consigliato

Usa un nome base chiaro, suffisso progressivo a tre cifre e, se utile, un identificatore del filtro logico:

ProgettoClienti2024part001.xlsx
ProgettoClienti2024part002.xlsx
ProgettoClienti2024ITpart_001.xlsx

In sintesi operativa

Per file piccoli o attività eccezionali, il copia‑incolla può bastare. Se devi ripetere l’operazione o il workbook è davvero grande, una macro VBA con stima e controllo del peso garantisce affidabilità e velocità. In ambienti IT o quando serve integrazione con altri sistemi, Python o PowerShell offrono automazione e tracciabilità. In tutti i casi, una pulizia preventiva del workbook e una convenzione di nomi chiara renderanno lo split più stabile, leggibile e conforme al limite.