Tutorial Excel in Python: guida completa con openpyxl

TL;DR

• Installa openpyxl con pip install openpyxl

• Carica qualsiasi file .xlsx con openpyxl.load_workbook('file.xlsx'); accedi ai fogli con wb.active o wb['SheetName']

• Leggi i valori delle celle con ws['A1'].value; itera le righe con ws.iter_rows(values_only=True)

• Scrivi nelle celle con ws['A1'] = 'value' e salva le modifiche con wb.save('file.xlsx')

• Crea formule Excel, grafici a barre, grafici a linee e formattazione condizionale interamente da Python — non c'è bisogno di aprire Excel 

Prerequisiti

Per seguire il tutorial, ti serviranno:

• Python 3.8 o successivo installato sulla tua macchina

• Conoscenze di base di Python (variabili, cicli, funzioni)

• openpyxl installato (pip install openpyxl)

• Un visualizzatore di fogli di calcolo (Excel, Google Sheets o LibreOffice Calc) per ispezionare i file di output

Scarica il dataset sulle vendite di videogiochi usato in questo tutorial da questo repository GitHub.

Introduzione a Openpyxl

Openpyxl è una libreria Python che permette di leggere file Excel e scriverci.

Questo framework può aiutarti a scrivere funzioni, formattare fogli di calcolo, creare report e costruire grafici direttamente in Python senza nemmeno dover aprire un'applicazione Excel.

Openpyxl ti consente anche di iterare tra i fogli e di eseguire la stessa analisi su più dataset in un solo passaggio.

Questo rende semplice automatizzare il lavoro ripetitivo in Excel su qualsiasi numero di fogli.

Openpyxl vs. Pandas: scegliere lo strumento giusto

Una domanda frequente è se usare openpyxl o pandas per lavorare con Excel. La risposta dipende da ciò che devi fare.

Usa openpyxl quando ti serve controllare l'aspetto e la struttura di un file Excel — formattazione, grafici, formule. Usa pandas quando devi filtrare, aggregare o rimodellare i dati. Il nostro tutorial su pandas in Python copre in profondità il lato dell'analisi dei dati.

Come installare Openpyxl

Per installare openpyxl, apri il terminale o PowerShell ed esegui:

pip install openpyxl

Dovresti vedere comparire un messaggio che indica che il pacchetto è stato installato correttamente:

Lettura di file Excel in Python con Openpyxl

In questo tutorial useremo il dataset di Kaggle sulle vendite di videogiochi. Questo dataset è stato preprocessato dal nostro team per il fine di questo tutorial, e puoi scaricare la versione modificata da questo link. Puoi importare Excel in Python seguendo il processo qui sotto:

Caricare la cartella di lavoro

Dopo aver scaricato il dataset, importa la libreria Openpyxl e carica la cartella di lavoro in Python:

import openpyxl 

wb = openpyxl.load_workbook('videogamesales.xlsx')

Ora che il file Excel è caricato come oggetto Python, devi dire alla libreria a quale foglio accedere. Ci sono due modi per farlo:

Il primo metodo è semplicemente chiamare il foglio attivo, cioè il primo foglio nella cartella di lavoro, usando la seguente riga di codice:

ws = wb.active

In alternativa, se conosci il nome del foglio, puoi accedervi anche per nome. In questa sezione del tutorial useremo il foglio “vgsales”:

ws = wb['vgsales']

Contiamo ora il numero di righe e colonne in questo foglio:

print('Total number of rows: '+str(ws.max_row)+'. And total number of columns: '+str(ws.max_column))

Il codice sopra dovrebbe restituire il seguente output:

Total number of rows: 16328. And total number of columns: 10

Ora che conosciamo le dimensioni del foglio, passiamo a vedere come leggere i dati dalla cartella di lavoro.

Lettura efficiente di file grandi

Per cartelle di lavoro con molte righe, apri in modalità sola lettura per evitare di caricare l'intero file in memoria:

import openpyxl

wb = openpyxl.load_workbook('videogamesales.xlsx', read_only=True)
ws = wb.active

for row in ws.iter_rows(values_only=True):
    print(row)

La modalità sola lettura esegue lo streaming delle righe una alla volta invece di mantenere l'intera cartella di lavoro in RAM. Non puoi scrivere su una cartella di lavoro aperta in questo modo, quindi riservala a pipeline in lettura su dataset grandi.

Leggere dati da una cella

Ecco uno screenshot del foglio attivo con cui lavoreremo in questa sezione:

Per recuperare i dati da una cella specifica con Openpyxl, puoi digitare il valore della cella così:

print(f"The value in cell A1 is: {ws['A1'].value}")

Dovresti ottenere il seguente output:

The value in cell A1 is: Rank

Leggere dati da più celle

Ora che sappiamo leggere i dati da una cella specifica, e se volessimo stampare tutti i valori di cella in una determinata riga del foglio?

Per farlo, puoi scrivere un semplice ciclo for per iterare tutti i valori in una riga specifica:

values = [ws.cell(row=1,column=i).value for i in range(1,ws.max_column+1)]
print(values)

Il codice sopra stamperà tutti i valori nella prima riga:

['Rank', 'Name', 'Platform', 'Year', 'Genre', 'Publisher', 'NA_Sales', 'EU_Sales', 'JP_Sales', 'Other_Sales']

Successivamente, proviamo a stampare più righe in una colonna specifica.

Creeremo un ciclo for per visualizzare come elenco le prime dieci righe nella colonna “Name”. Dovremmo ottenere i nomi evidenziati nel riquadro rosso qui sotto:

data=[ws.cell(row=i,column=2).value for i in range(2,12)]
print(data)

Il codice sopra genererà il seguente output:

['Wii Sports', 'Super Mario Bros.', 'Mario Kart Wii', 'Wii Sports Resort', 'Pokemon Red/Pokemon Blue', 'Tetris', 'New Super Mario Bros.', 'Wii Play', 'New Super Mario Bros. Wii', 'Duck Hunt']

Infine, stampiamo le prime dieci righe in un intervallo di colonne del foglio di calcolo:

# reading data from a range of cells (from column 1 to 6)

my_list = list()

for value in ws.iter_rows(
    min_row=1, max_row=11, min_col=1, max_col=6, 
    values_only=True):
    my_list.append(value)
    
for ele1,ele2,ele3,ele4,ele5,ele6 in my_list:
    (print ("{:<8}{:<35}{:<10}
             {:<10}{:<15}{:<15}".format(ele1,ele2,ele3,ele4,ele5,ele6)))

Dopo aver eseguito il codice sopra, verranno visualizzate le prime dieci righe di dati nelle prime sei colonne:

Scrivere su file Excel con Openpyxl

Ora che sappiamo come accedere e leggere dati dai file Excel, vediamo come scriverci usando Openpyxl.

Scrivere in una cella

Ci sono due modi per scrivere su un file con Openpyxl.

Per prima cosa, puoi accedere direttamente alla cella usando la sua chiave:

ws['K1'] = 'Sum of Sales'

In alternativa, puoi specificare la posizione di riga e colonna della cella su cui vuoi scrivere:

ws.cell(row=1, column=11, value = 'Sum of Sales')

Ogni volta che scrivi su un file Excel con Openpyxl, devi salvare le modifiche con la seguente riga di codice, altrimenti non verranno riflesse nel foglio:

wb.save('videogamesales.xlsx')

Se la cartella di lavoro è aperta quando provi a salvarla, incontrerai il seguente errore di autorizzazioni:

Assicurati di chiudere il file Excel prima di salvare le modifiche. Puoi poi riaprirlo per verificare che la modifica sia stata applicata al foglio:

Nota che è stata creata una nuova colonna chiamata “Sum of Sales” nella cella K1.

Creare una nuova colonna

Aggiungiamo ora la somma delle vendite in ogni regione e scriviamola nella colonna K.

Lo faremo per i dati di vendita nella prima riga:

row_position = 2
col_position = 7

total_sales = ((ws.cell(row=row_position, column=col_position).value)+
               (ws.cell(row=row_position, column=col_position+1).value)+
               (ws.cell(row=row_position, column=col_position+2).value)+
               (ws.cell(row=row_position, column=col_position+3).value))

ws.cell(row=2,column=11).value=total_sales
wb.save('videogamesales.xlsx')

Nota che il totale delle vendite è stato calcolato nella cella K2 per il primo gioco nel foglio:

Allo stesso modo, creiamo un ciclo for per sommare i valori di vendita in ogni riga:

row_position = 1

for i in range(1, ws.max_row):

    row_position += 1
    NA_Sales = ws.cell(row=row_position, column=7).value
    EU_Sales = ws.cell(row=row_position, column=8).value
    JP_Sales = ws.cell(row=row_position, column=9).value
    Other_Sales = ws.cell(row=row_position, column=10).value

    total_sales = (NA_Sales + EU_Sales + JP_Sales + Other_Sales)
    ws.cell(row=row_position, column=11).value = total_sales

wb.save("videogamesales.xlsx")

Il tuo file Excel dovrebbe ora avere una nuova colonna che riflette il totale delle vendite dei videogiochi in tutte le regioni:

Aggiungere nuove righe

Per aggiungere una nuova riga alla cartella di lavoro, crea semplicemente una tupla con i valori che vuoi includere e scrivila sul foglio:

new_row = (1,'The Legend of Zelda',1986,'Action','Nintendo',3.74,0.93,1.69,0.14,6.51,6.5)

ws.append(new_row)
    
wb.save('videogamesales.xlsx')

Puoi confermare che questi dati sono stati aggiunti stampando l'ultima riga della cartella di lavoro:

values = [ws.cell(row=ws.max_row,column=i).value for i in range(1,ws.max_column+1)]
print(values)

Verrà generato il seguente output:

[1, 'The Legend of Zelda', 1986, 'Action', 'Nintendo', 3.74, 0.93, 1.69, 0.14, 6.51, 6.5]

Eliminare righe

Per eliminare la nuova riga appena creata, puoi eseguire la seguente riga di codice:

ws.delete_rows(ws.max_row, 1) # row number, number of rows to delete

wb.save('videogamesales.xlsx')

Il primo argomento in delete_rows() è il numero di riga da eliminare. Il secondo è il numero di righe da rimuovere.

Creare formule Excel con Openpyxl

Puoi usare Openpyxl per scrivere formule esattamente come faresti in Excel. Ecco alcuni esempi di funzioni di base che puoi creare con Openpyxl:

AVERAGE()

Creiamo una nuova colonna chiamata “Average Sales” per calcolare la media delle vendite totali di videogiochi in tutti i mercati:

ws['P1'] = 'Average Sales'
ws['P2'] = '= AVERAGE(K2:K16220)'

wb.save('videogamesales.xlsx')

La vendita media in tutti i mercati è approssimativamente 0,19. Questo verrà stampato nella cella P2 del foglio.

COUNTA()

La funzione “COUNTA” in Excel conta le celle popolate all'interno di un intervallo specifico. Usiamola per trovare il numero di record tra E2 ed E16220:

ws['Q1'] = "Number of Populated Cells" 
ws['Q2'] = '=COUNTA(E2:E16220)'

wb.save('videogamesales.xlsx')

Ci sono 16.219 record in questo intervallo che contengono informazioni.

COUNTIF()

COUNTIF() è una funzione Excel comunemente usata che conta il numero di celle che soddisfano una specifica condizione. Usiamola per contare il numero di giochi in questo dataset con il genere “Sports”:

ws['R1'] = 'Number of Rows with Sports Genre'
ws['R2'] = '=COUNTIF(E2:E16220, "Sports")'

wb.save('videogamesales.xlsx')

Nel dataset ci sono 2.296 giochi sportivi.

SUMIF()

Ora, troviamo la “Sum of Sales” totale generata dai giochi sportivi usando la funzione SUMIF:

ws['S1'] = 'Total Sports Sales'
ws['S2'] = '=SUMIF(E2:E16220, "Sports",K2:K16220)'
 
wb.save('videogamesales.xlsx')

Il numero totale di vendite generato dai giochi sportivi è 454.

CEILING()

La funzione CEILING() in Excel arrotonda un numero per eccesso al multiplo specificato più vicino. Arrotondiamo per eccesso il totale delle vendite generate dai giochi sportivi usando questa funzione:

ws['T1'] = 'Rounded Sum of Sports Sales'
ws['T2'] = '=CEILING(S2,25)'

wb.save('videogamesales.xlsx')

Abbiamo arrotondato il totale delle vendite generate dai giochi sportivi al multiplo di 25 più vicino, ottenendo 475.

Gli snippet di codice sopra dovrebbero generare il seguente output nel tuo foglio Excel (dalle celle P1 a T2):

Per un riferimento rapido a formule, operatori e funzioni matematiche di Excel, vedi il nostro Cheat Sheet sulle basi di Excel.

Lavorare con i fogli in Openpyxl

Ora che sappiamo come accedere ai fogli e scriverci, vediamo come possiamo manipolarli, rimuoverli e duplicarli con Openpyxl.

Cambiare i nomi dei fogli

Per prima cosa, stampiamo il nome del foglio attivo su cui stiamo lavorando utilizzando l'attributo title di Openpyxl:

print(ws.title)

Verrà prodotto il seguente output:

vgsales

Ora, rinominiamo questo foglio usando le seguenti righe di codice:

ws.title ='Video Game Sales Data'

wb.save('videogamesales.xlsx')

Il nome del tuo foglio attivo dovrebbe ora essere cambiato in “Video Game Sales Data”.

Creare un nuovo foglio di lavoro

Esegui la seguente riga di codice per elencare tutti i fogli nella cartella di lavoro:

print(wb.sheetnames)

Vedrai un array con i nomi di tutti i fogli nel file:

['Video Game Sales Data', 'Total Sales by Genre', 'Breakdown of Sales by Genre', 'Breakdown of Sales by Year']

Creiamo ora un nuovo foglio vuoto:

wb.create_sheet('Empty Sheet') # create an empty sheet
print(wb.sheetnames) # print sheet names again

wb.save('videogamesales.xlsx')

Nota che è stato creato un nuovo foglio chiamato “Empty Sheet”:

['Video Game Sales Data', 'Total Sales by Genre', 'Breakdown of Sales by Genre', 'Breakdown of Sales by Year', ‘Empty Sheet’]

Eliminare un foglio

Per eliminare un foglio con Openpyxl, usa semplicemente l'attributo remove e stampa di nuovo tutti i nomi dei fogli per confermare che è stato eliminato:

wb.remove(wb['Empty Sheet'])
print(wb.sheetnames)

wb.save('videogamesales.xlsx')

Nota che il foglio “Empty Sheet” non è più disponibile:

['Video Game Sales Data', 'Total Sales by Genre', 'Breakdown of Sales by Genre', 'Breakdown of Sales by Year']

Duplicare un foglio

Infine, esegui questa riga di codice per creare una copia di un foglio esistente:

wb.copy_worksheet(wb['Video Game Sales Data'])
wb.save('vgsales_2.xlsx')

Stampando di nuovo tutti i nomi dei fogli, otteniamo il seguente output:

['Video Game Sales Data', 'Total Sales by Genre', 'Breakdown of Sales by Genre', 'Breakdown of Sales by Year', 'Video Game Sales Data Copy']
Aggiungere grafici a un file Excel con Openpyxl
Excel è spesso visto come lo strumento di riferimento per creare visualizzazioni e riassumere i dataset. In questa sezione impareremo a costruire grafici in Excel direttamente da Python usando Openpyxl.
Grafico a barre
Creiamo innanzitutto un semplice grafico a barre che mostri le vendite totali dei videogiochi per genere. Useremo il foglio “Total Sales by Genre” per farlo:

Questo foglio contiene una tabella pivot in cui la somma delle vendite è stata aggregata per genere, come si vede nello screenshot sopra.
Accediamo a questo foglio prima di iniziare a creare il grafico a barre:
ws = wb['Total Sales by Genre'] # access the required worksheet
Ora dobbiamo dire a Openpyxl i valori e le categorie che vogliamo rappresentare.
Valori:
I valori includono i dati “Sum of Sales” che vogliamo tracciare. Dobbiamo dire a Openpyxl dove trovare questi dati nel file Excel includendo l'intervallo in cui i valori iniziano e finiscono.
Quattro parametri in Openpyxl ti permettono di specificare dove si trovano i valori:


Min_column: la colonna minima che contiene dati


Max_column: la colonna massima che contiene dati


Min_row: la riga minima che contiene dati


Max_row: la riga massima che contiene dati


Ecco un'immagine che mostra come definire questi parametri:

Nota che la riga minima è la prima e non la seconda. Questo perché Openpyxl inizia a contare dalla riga che contiene un valore numerico.
# Values for plotting

from openpyxl.chart import Reference

values = Reference(ws,         # worksheet object   
                   min_col=2,  # minimum column where your values begin
                   max_col=2,  # maximum column where your values end
                   min_row=1,  # minimum row you’d like to plot from
                   max_row=13) # maximum row you’d like to plot from
Categorie
Ora dobbiamo definire gli stessi parametri per le categorie nel nostro grafico a barre:

Ecco il codice che puoi usare per impostare i parametri per le categorie del grafico:
cats = Reference(ws, 
                 min_col=1, 
                 max_col=1, 
                 min_row=2, 
                 max_row=13)
Creare il grafico a barre
Ora possiamo creare l'oggetto grafico a barre e includervi i valori e le categorie con le seguenti righe di codice:
from openpyxl.chart import BarChart

chart = BarChart()
chart.add_data(values, titles_from_data=True)
chart.set_categories(cats)
Impostare i titoli del grafico
Infine, puoi impostare i titoli del grafico e dire a Openpyxl dove desideri crearlo nel foglio Excel:
# set the title of the chart
chart.title = "Total Sales"

# set the title of the x-axis
chart.x_axis.title = "Genre"

# set the title of the y-axis
chart.y_axis.title = "Total Sales by Genre"

# the top-left corner of the chart
# is anchored to cell F2 .
ws.add_chart(chart,"D2")

# save the file 
wb.save("videogamesales.xlsx")
Puoi quindi aprire il file Excel e andare al foglio “Total Sales by Genre”. Dovresti vedere comparire un grafico come questo:

Grafico a barre raggruppate
Ora creiamo un grafico a barre raggruppate che mostri le vendite totali per genere e regione. Puoi trovare i dati per questo grafico nel foglio “Breakdown of Sales by Genre”:

Come abbiamo fatto per il grafico a barre, dobbiamo definire l'intervallo per valori e categorie:

Possiamo ora accedere al foglio e scriverlo in codice:
### Creating a Grouped Bar Chart with Openpyxl
ws = wb['Breakdown of Sales by Genre'] # access worksheet

# Data for plotting
values = Reference(ws,
                   min_col=2,
                   max_col=5,
                   min_row=1,
                   max_row=13)

cats = Reference(ws, min_col=1, 
                     max_col=1, 
                     min_row=2, 
                     max_row=13)
Ora possiamo creare l'oggetto grafico a barre, includervi valori e categorie e impostare i parametri del titolo esattamente come prima:
# Create object of BarChart class
chart = BarChart()
chart.add_data(values, titles_from_data=True)
chart.set_categories(cats)

# set the title of the chart
chart.title = "Sales Breakdown"

# set the title of the x-axis
chart.x_axis.title = "Genre"

# set the title of the y-axis
chart.y_axis.title = "Breakdown of Sales by Genre"

# the top-left corner of the chart is anchored to cell H2.
ws.add_chart(chart,"H2")

# save the file 
wb.save("videogamesales.xlsx")
Una volta aperto il foglio, dovrebbe apparire un grafico a barre raggruppate come questo:

Grafico a linee impilate
Infine, creeremo un grafico a linee impilate usando i dati nella scheda “Breakdown of Sales by Year”. Questo foglio contiene i dati delle vendite di videogiochi suddivisi per anno e regione:

Definiamo l'intervallo per i valori e le categorie di questo grafico:

Possiamo ora scrivere questi valori minimi e massimi in codice:
# Data for plotting
values = Reference(ws,
                   min_col=2,
                   max_col=6,
                   min_row=1,
                   max_row=40)

cats = Reference(ws, min_col=1, max_col=1, min_row=2, max_row=40)
Infine, creiamo l'oggetto grafico a linee e impostiamo titolo del grafico, asse x e asse y:
# Create object of LineChart class
from openpyxl.chart import LineChart

chart = LineChart()
chart.add_data(values, titles_from_data=True)
chart.set_categories(cats)

# set the title of the chart
chart.title = "Total Sales"

# set the title of the x-axis
chart.x_axis.title = "Year"

# set the title of the y-axis
chart.y_axis.title = "Total Sales by Year"

# the top-left corner of the chart is anchored to cell H2 
ws.add_chart(chart,"H2")

# save the file 
wb.save("videogamesales.xlsx")
Nel tuo foglio dovrebbe apparire un grafico a linee impilate come questo:

Formattare le celle con Openpyxl
Openpyxl consente di applicare stili alle celle nei file Excel. Puoi rendere il tuo foglio più gradevole cambiando dimensioni dei font, colori di sfondo e bordi delle celle direttamente in Python.
Ecco alcuni modi per personalizzare il tuo foglio Excel con Openpyxl:
Modificare dimensioni e stili dei font
Aumentiamo la dimensione del font nella cella A1 e mettiamo in grassetto il testo con le seguenti righe di codice:
from openpyxl.styles import Font

ws = wb['Video Game Sales Data']
ws['A1'].font = Font(bold=True, size=12)

wb.save('videogamesales.xlsx')
Nota che il testo nella cella A1 è ora leggermente più grande e in grassetto:

E se volessimo cambiare dimensione e stile del font per tutte le intestazioni di colonna nella prima riga?
Per farlo, possiamo usare lo stesso codice e creare semplicemente un ciclo for per iterare tutte le colonne nella prima riga:
for row in ws.iter_rows(min_row=1, max_row=1):
    for cell in row:
        cell.font = Font(bold=True, size=12)

wb.save('videogamesales.xlsx')
Quando iteriamo su ["1:1"], stiamo dicendo a Openpyxl l'inizio e la fine delle righe da attraversare. Se volessimo ciclare sulle prime dieci righe, per esempio, specificheremmo ["1:10"] al suo posto.
Puoi aprire il foglio Excel per controllare che le modifiche siano state applicate:

Cambiare il colore del font
Puoi cambiare i colori dei font in Openpyxl usando codici esadecimali:
from openpyxl.styles import colors

ws['A1'].font = Font(color = 'FF0000',bold=True, size=12) ## red
ws['A2'].font = Font(color = '0000FF') ## blue

wb.save('videogamesales.xlsx')
Dopo aver salvato la cartella di lavoro e riaperto il file, i colori dei font nelle celle A1 e A2 dovrebbero essere cambiati:


Cambiare il colore di sfondo della cella
Per cambiare il colore di sfondo di una cella, puoi usare il modulo PatternFill di Openpyxl:
## changing background color of a cell
from openpyxl.styles import PatternFill

ws["A1"].fill = PatternFill('solid', start_color="38e3ff") # light blue background color
wb.save('videogamesales.xlsx')
La seguente modifica dovrebbe riflettersi nel tuo foglio:

Aggiungere bordi alle celle
Per aggiungere un bordo a una cella con Openpyxl, esegui le seguenti righe di codice:
## cell borders
from openpyxl.styles import Border, Side

my_border = Side(border_style="thin", color="000000")

ws["A1"].border = Border(
    top=my_border, left=my_border, right=my_border, bottom=my_border
)

wb.save("videogamesales.xlsx")
Dovresti vedere comparire un bordo come questo attorno alla cella A1:

Formattazione condizionale
La formattazione condizionale è il processo di evidenziare valori specifici in un file Excel in base a un insieme di condizioni. Consente agli utenti di visualizzare meglio i dati e comprendere più facilmente i valori nei propri fogli.
Usiamo Openpyxl per evidenziare in verde tutti i valori di vendita dei videogiochi maggiori o uguali a 8:
from openpyxl.formatting.rule import CellIsRule

fill = PatternFill(
    start_color='90EE90',
    end_color='90EE90',fill_type='solid') # specify background color

ws.conditional_formatting.add(
    'G2:K16594', CellIsRule(operator='greaterThan', formula=[8], fill=fill)) # include formatting rule

wb.save('videogamesales.xlsx')
Nel primo blocco di codice, specifichiamo il colore di sfondo delle celle che vogliamo formattare. In questo caso, il colore è un verde chiaro.
Poi creiamo una regola di formattazione condizionale che indica che qualsiasi valore maggiore di 8 deve essere evidenziato con il colore di riempimento specificato. Indichiamo anche l'intervallo di celle in cui applicare questa condizione.
Dopo aver eseguito il codice sopra, tutti i valori di vendita superiori a 8 dovrebbero essere evidenziati così:

Considerazioni finali
In questo tutorial abbiamo coperto molti aspetti, partendo dalle basi dell'uso della libreria Openpyxl fino a operazioni più avanzate come la creazione di grafici e la formattazione dei fogli in Python.
Da sole, Python ed Excel coprono parti diverse del flusso di lavoro dei dati. Excel gestisce reportistica e analisi ad hoc; Python gestisce modellazione, automazione e calcolo su larga scala.
Il più grande vantaggio di Excel è che lo usano praticamente tutti. Dai stakeholder non tecnici ai profili junior, i dipendenti di tutti i livelli comprendono i report presentati in un foglio Excel.
Python, invece, viene usato per analizzare e costruire modelli su grandi quantità di dati. Può aiutare i team ad automatizzare attività laboriose e a migliorare l'efficienza organizzativa.
Quando Excel e Python vengono usati insieme, puoi automatizzare ore di lavoro ripetitivo fornendo output in un formato che tutto il tuo team già conosce. Per approfondire queste competenze, ti consiglio il nostro corso Python for Spreadsheet Users, oppure consulta la nostra guida su Python in Excel per eseguire Python nativamente all'interno dei fogli Excel.