Documentation – Tabelle Pivot

Pythonjava: Crea una tabella pivot

Mon, 01 Jan 0001 00:00:00 +0000

Crea una tabella pivot

Aspose.Cells per Python via Java fornisce la funzione per creare tabelle pivot. Per creare una tabella pivot utilizzando Aspose.Cells, segui i passaggi seguenti:

Aggiungi alcuni dati alle celle del foglio di lavoro utilizzando la proprietà setValue dell’oggetto Cell. Questi dati saranno utilizzati come origine dati per la tabella pivot.
Aggiungi una tabella pivot al foglio di lavoro chiamando il metodo add dell’oggetto PivotTableCollection incapsulato nell’oggetto Worksheet.
Accedi all’oggetto PivotTable dalla PivotTableCollection passando l’indice del PivotTable.
Utilizza uno qualsiasi degli oggetti tabella pivot (spiegati sopra) incapsulati nell’oggetto PivotTableCollection per gestire la tabella pivot.

Il seguente frammento di codice dimostra la creazione di una tabella pivot con l’API Aspose.Cells.

Pythonjava: Formattare le celle della tabella pivot

Mon, 01 Jan 0001 00:00:00 +0000

A volte si desidera formattare le celle della tabella pivot. Ad esempio, si desidera applicare un colore di sfondo alle celle della tabella pivot. Aspose.Cells fornisce due metodi PivotTable.formatAll() e PivotTable.format(), che è possibile utilizzare a questo scopo.

PivotTable.formatAll() applica lo stile all’intera tabella pivot mentre PivotTable.format() applica lo stile a una singola cella della tabella pivot.

Il codice di esempio seguente formatta l’intera tabella pivot con un colore blu chiaro e poi formatta la seconda riga della tabella con il colore giallo.

La tabella pivot di input, prima di eseguire il codice

La tabella pivot in uscita, dopo l’esecuzione del codice

Pythonjava: Aggiornare Tabelle Pivot e Cache Pivot in Aspose.Cells for Python via Java

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells fornisce un’API di aggiornamento a più livelli che consente di ricaricare i dati delle pivot in quattro ambiti diversi, dall’intera cartella di lavoro fino a una singola tabella pivot. A partire da Aspose.Cells for Python via Java v26.7, il metodo legacy PivotTable.refreshData() è contrassegnato come obsoleto e deve essere sostituito con le API più efficienti e consapevoli della cache descritte in questo articolo.

Introduzione

Aggiornare una tabella pivot raramente è un’operazione singola. Dietro le quinte, Aspose.Cells mantiene una catena di dati a più livelli che collega i dati di origine originali ai valori renderizzati visibili nel foglio di lavoro. Comprendere questa catena è la chiave per scegliere l’API di aggiornamento giusta per ogni situazione. La catena di dati a quattro livelli è:

Origine dati — gli intervalli originali del foglio di lavoro, la query del database o l’intervallo di consolidamento in cui risiedono i valori grezzi.
PivotCache — lo snapshot in memoria dei dati di origine. Ogni tabella pivot è costruita sopra un PivotCache; è qui che tutti i dati vengono raccolti e aggregati.
PivotTable — l’oggetto vista che definisce i campi riga, colonna, valore e filtro. Una PivotTable legge solo dal proprio PivotCache, mai direttamente dall’origine dati.
Cells — le Cells del foglio di lavoro in cui la PivotTable rende i valori calcolati e gli stili.

PivotCache.getSourceType() (enum PivotTableSourceType) indica da dove provengono i dati della cache. A partire da v26.7, PivotCache.refresh() supporta solo i tipi di origine SHEET e CONSOLIDATION, ovvero dati che risiedono negli intervalli del foglio di lavoro. Le origini esterne (database, connessioni esterne, ecc.) non sono ancora aggiornabili tramite l’API della cache.

A causa di questa catena, in Aspose.Cells esistono due percorsi fondamentali di aggiornamento:

PivotTable.calculateData() — ricalcola la visualizzazione di una PivotTable a partire dai dati già presenti nella cache, senza effettuare un round-trip verso l’origine dati. Tutti gli scenari in questo articolo utilizzano dati di origine provenienti da celle del foglio di lavoro, quindi il tipo di origine è SHEET e le operazioni di aggiornamento si comportano come descritto.

Avvio rapido

Se hai bisogno solo del codice più breve possibile che aggiorni ogni pivot nella cartella di lavoro, è sufficiente una singola chiamata:

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Crea una nuova cartella di lavoro
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Scrivi la riga di intestazione nelle celle A1:C1
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Scrivi le righe di dati nelle celle A2:C9 (8 righe di dati sulla frutta per il 2020 e il 2021)
worksheet.getCells().get("A2").putValue("grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(50)
worksheet.getCells().get("A3").putValue("blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(60)
worksheet.getCells().get("A4").putValue("kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(70)
worksheet.getCells().get("A5").putValue("cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(80)
worksheet.getCells().get("A6").putValue("grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(90)
worksheet.getCells().get("A7").putValue("blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(100)
worksheet.getCells().get("A8").putValue("kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(110)
worksheet.getCells().get("A9").putValue("cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(120)
# Aggiungi una tabella pivot: intervallo di origine "A1:C9", cella di destinazione "E3", nome "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Assegna i campi pivot: Frutta a Righe, Anno a Colonne, Importo a Dati
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modifica diversi valori di Importo nei dati di origine per simulare delle modifiche
worksheet.getCells().get("C2").putValue(55)
worksheet.getCells().get("C5").putValue(85)
worksheet.getCells().get("C9").putValue(125)
# Aggiorna ogni tabella pivot / cache pivot nella cartella di lavoro
workbook.refreshAll()
# Salva la cartella di lavoro
workbook.save("output.xlsx")
jpype.shutdownJVM()

Tutto il resto in questo articolo spiega quando scegliere invece un’API più specifica.

Importazioni richieste

Tutti gli esempi Python in questo articolo si basano sulle seguenti importazioni perché i tipi pivot risiedono nel namespace aspose.cells.pivot:

import jpype
import aspose.cells as cells Il modulo jpype viene utilizzato per avviare la JVM, mentre aspose.cells espone i tipi workbook/worksheet/cell/pivot usati in tutto il codice.

Aggiornare tutte le Tabelle Pivot nella cartella di lavoro

Quando hai bisogno di assicurarti che ogni cache pivot e ogni tabella pivot nella cartella di lavoro riflettano i dati di origine più recenti, l’API più semplice e completa è Workbook.refreshAll(). Una singola chiamata attraversa l’intera cartella di lavoro, aggiornando ogni PivotCache dalla propria origine e poi ricalcolando ogni PivotTable dipendente. Questo è l’approccio consigliato per gli aggiornamenti generali e completi del documento, quando le prestazioni non rappresentano un problema. L’esempio seguente costruisce una cartella di lavoro con un intervallo di origine Frutto/Anno/Importo, crea una tabella pivot, modifica alcuni valori di origine e poi utilizza refreshAll() per allineare il tutto in una singola chiamata.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
worksheet.getCells().get("A2").putValue("grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(100)
worksheet.getCells().get("A3").putValue("blueberry")
worksheet.getCells().get("B3").putValue(2021)
worksheet.getCells().get("C3").putValue(150)
worksheet.getCells().get("A4").putValue("kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(200)
worksheet.getCells().get("A5").putValue("cherry")
worksheet.getCells().get("B5").putValue(2021)
worksheet.getCells().get("C5").putValue(120)
worksheet.getCells().get("A6").putValue("grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(180)
worksheet.getCells().get("A7").putValue("blueberry")
worksheet.getCells().get("B7").putValue(2020)
worksheet.getCells().get("C7").putValue(130)
worksheet.getCells().get("A8").putValue("kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(220)
worksheet.getCells().get("A9").putValue("cherry")
worksheet.getCells().get("B9").putValue(2020)
worksheet.getCells().get("C9").putValue(140)
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
worksheet.getCells().get("C2").putValue(300)
worksheet.getCells().get("C5").putValue(250)
worksheet.getCells().get("C9").putValue(400)
worksheet.refreshPivotTables()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Aggiornare tutte le Tabelle Pivot su un singolo foglio di lavoro

A volte è necessario aggiornare solo le tabelle pivot che si trovano su un determinato foglio di lavoro, ad esempio quando le tabelle pivot presenti su altri fogli non sono correlate e non devono essere toccate. Per questo caso, Aspose.Cells fornisce Worksheet.refreshPivotTables(), che è limitato a una singola istanza di Worksheet.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Scrivi la riga di intestazione Frutto / Anno / Importo
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Scrivi 8 righe di dati (righe 2-9, corrispondenti all'intervallo di origine A1:C9)
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(100)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(200)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(300)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(400)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(150)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(250)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(350)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(450)
# Aggiungi una tabella pivot denominata "Pivot1" posizionata nella cella di destinazione E3, con origine da A1:C9
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Assegna i campi: Fruit a Riga, Year a Colonna, Amount a Dati
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modifica una proprietà di visualizzazione/layout — questa è una modifica solo di presentazione,
# quindi NON richiede di rileggere i dati di origine tramite PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(False)
# CalculateData() ridisegna la visualizzazione di QUESTA tabella pivot (dati + stile) dai
# dati già presenti nella PivotCache. Poiché i dati di origine non sono cambiati,
# non viene eseguito alcun round-trip verso l'origine — vengono ricalcolati solo i valori memorizzati nella cache
# nelle celle del foglio di lavoro.
pivotTable.calculateData()
# Salva la cartella di lavoro su disco
workbook.save("output.xlsx")
jpype.shutdownJVM()

Aggiornare una singola Tabella Pivot

Quando si desidera un controllo dettagliato su una singola tabella pivot, l’API basata sulla cache offre due opzioni. La scelta tra esse dipende da cosa è effettivamente cambiato: i dati di origine sottostanti oppure solo le impostazioni di vista/layout della tabella pivot stessa.

Dati di origine modificati — Usa `PivotCache.refresh()`

Se i dati di origine sottostanti sono cambiati, il punto di ingresso corretto è pivotTable.getPivotCache().refresh(). Questa chiamata rilegge i dati di origine nella cache e poi ricalcola ogni PivotTable che dipende da quella cache.

Cambiata solo la vista/layout — Usa `calculateData()`

Se i dati di origine non sono cambiati ma sono state modificate solo le impostazioni di vista o layout della tabella pivot (ad esempio, un campo è stato spostato in un’area diversa oppure è stata attivata/disattivata un’opzione di aggiornamento all’apertura), non è necessario tornare all’origine dati. La cache contiene già i dati corretti; solo la PivotTable renderizzata deve essere ricalcolata. In questo caso, pivotTable.calculateData() è la scelta giusta. L’esempio seguente modifica una proprietà non legata all’origine della tabella pivot e poi chiama calculateData() per renderizzarla nuovamente dalla cache esistente. Una cartella di lavoro spesso contiene molte tabelle pivot che poggiano tutte su una cache condivisa. Per enumerarle, ad esempio prima di eseguire un aggiornamento in batch o per diagnosticare l’impatto della cache condivisa, usa PivotCache.getPivotTables(). Questo metodo restituisce la raccolta di tutte le PivotTable che dipendono dalla cache indicata.

Migrazione dall’obsoleto `PivotTable.refreshData()`

Prima di Aspose.Cells for Python via Java v26.7, il modo standard per aggiornare una tabella pivot era chiamare PivotTable.refreshData() su ciascuna tabella pivot singolarmente. A partire da v26.7, quel metodo è contrassegnato come obsoleto e deve essere sostituito con le API consapevoli della cache descritte sopra. Ci sono due motivi per cui l’approccio refreshData() per singola tabella è problematico nelle cartelle di lavoro reali:

Rilegge i dati dall’origine ogni volta che viene chiamato, anche quando l’origine non è cambiata. Le sostituzioni consigliate sono: L’esempio seguente mostra il nuovo pattern efficiente per cartelle di lavoro con più tabelle pivot che condividono una singola cache.

Quale API di aggiornamento devo usare?

La tabella seguente riassume le API di aggiornamento disponibili e quando scegliere ciascuna di esse.

Obiettivo	API consigliata	Note
Aggiornare tutto nella cartella di lavoro	`Workbook.refreshAll()`	Una sola chiamata; copre tutte le cache e le tabelle.
Aggiornare solo le tabelle pivot su un singolo foglio	`Worksheet.refreshPivotTables()`	Limitato a un foglio di lavoro.
Dati di origine cambiati per una cache	`pivotTable.getPivotCache().refresh()`	Aggiorna TUTTE le tabelle pivot su quella cache condivisa.
Sono cambiate solo le impostazioni di vista/layout	`pivotTable.calculateData()`	Evita il round-trip non necessario verso l’origine.
Elencare tutte le tabelle pivot su una cache condivisa	`pivotCache.getPivotTables()`	Da usare per enumerare prima dell’aggiornamento in blocco.
In pratica, è preferibile usare le API basate sulla cache rispetto all’obsoleto `refreshData()` per tabella. Esse sono consapevoli delle cache condivise, evitano recuperi ridondanti dall’origine e consentono di scegliere l’ambito più piccolo che soddisfa il requisito di aggiornamento.

Insidie comuni

Dimenticare di aggiornare prima di salvare. Una tabella pivot scrive i propri valori renderizzati nel foglio di lavoro solo quando la catena di dati viene aggiornata. Se modifichi le celle di origine, chiama PivotCache.Refresh() (oppure Workbook.RefreshAll()) prima di Workbook.save(), altrimenti il file salvato conterrà ancora i vecchi valori aggregati.
Chiamare l’obsoleto RefreshData() per tabella. In v26.7, PivotTable.RefreshData() è contrassegnato come obsoleto e rilegge l’origine a ogni chiamata. Con più tabelle pivot che condividono una cache, ciò significa N recuperi ridondanti dall’origine. Sostituiscilo con una singola PivotCache.Refresh() seguita da CalculateData() per ogni tabella.
Aggiornare quando è cambiato solo il layout. Se hai modificato solo la vista di una tabella pivot (ordine delle colonne, ConsolidationFunction, ecc.) senza toccare i dati di origine, PivotCache.Refresh() non è necessario ed è lento. Chiama pivotTable.CalculateData() per renderizzare nuovamente dalla cache esistente.
Origine esterna non supportata da PivotCache.Refresh(). Se l’origine della tabella pivot proviene da una connessione esterna (database, cubo OLAP, ecc.), PivotCache.Refresh() non può aggiornarla in v26.7: attualmente supporta solo i tipi di origine Sheet e Consolidation. Per le origini esterne, riapri la cartella di lavoro oppure ricostruisci la cache dall’origine.

using Aspose.Cells;
Workbook workbook = new Workbook("input.xlsx");
workbook.RefreshAll();
workbook.Save("output.xlsx");

Pythonjava: Applica stili alle tabelle pivot in Aspose.Cells for Python via Java

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells supporta l’applicazione sia dei formati automatici legacy per le tabelle pivot (pensati per i file .xls) sia degli stili moderni denominati o personalizzati per le tabelle pivot (pensati per i file .xlsx, .xlsm e .xlsb). L’API da chiamare dipende dal formato di file con cui la cartella di lavoro viene salvata, non dal formato da cui è stata caricata.

Introduzione

Aspose.Cells espone due API di stile parallele per le tabelle pivot. La scelta tra di esse è determinata dal formato di file con cui salvi la cartella di lavoro, non dal formato da cui la leggi. Una cartella di lavoro caricata da un file .xls può essere salvata nuovamente come .xlsx e, in tal caso, si applica l’API di stile moderna anziché quella legacy.

pivotTable.setPivotTableStyleType(int) seleziona uno degli stili denominati predefiniti (temi chiari e scuri, inclusi gli stili aggiunti in Excel 2017). Questi preset sono di sola lettura.
pivotTable.setPivotTableStyleName(String) seleziona uno stile personalizzato che definisci tu stesso tramite workbook.getWorksheets().getTableStyles().addPivotTableStyle(String). Gli stili personalizzati sono necessari ogni volta che vuoi modificare colori, bordi o font oltre quanto offerto dai preset. Inoltre, pivotTable.formatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della tabella pivot, sovrascrivendo qualsiasi cosa impostata tramite le due API basate sul nome di stile sopra. È utile quando è richiesto un aspetto uniforme indipendentemente dal tema sottostante.

Applica un formato automatico predefinito legacy XLS

Il metodo setAutoFormatType su una tabella pivot accetta un valore dall’enumerazione com.aspose.cells.pivot.PivotTableAutoFormatType. I valori disponibili sono REPORT_1 fino a REPORT_10, CLASSIC e TABLE_1 fino a TABLE_10. L’esempio seguente carica una cartella di lavoro vuota, popola i dati di esempio Fruit/Year/Amount, aggiunge una tabella pivot, applica PivotTableAutoFormatType.REPORT_5 e salva il risultato come .xls.

Perché nessun campo di colonna? I formati automatici della serie Report (Report1 fino a Report10, Table1 fino a Table10) sono stati progettati nel classico Excel per tabelle pivot a dimensione singola con solo campi di riga e valori — non hanno alcuna formattazione predefinita per le intestazioni dei campi di colonna. Se la tua tabella pivot richiede campi di colonna, utilizza invece i preset moderni di PivotTableStyleType dallo Scenario 2, che sono progettati per il layout bidimensionale utilizzato da Excel moderno.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType, PivotTableAutoFormatType
# Scenario 1: Applica un formato automatico preimpostato XLS legacy
# API in uso: PivotTable.AutoFormatType
# Formato del file di destinazione: .xls (legacy)
# Per esempi completi e file di dati, visitare https://github.com/aspose-cells/Aspose.Cells-for-.NET
# Crea una nuova cartella di lavoro
workbook = Workbook()
# Ottieni il primo foglio di lavoro
sheet = workbook.getWorksheets().get(0)
# Popola i dati di origine con la riga di intestazione (Fruit, Year, Amount)
# e 9 righe di dati che coprono grape, blueberry, kiwi, cherry negli anni 2020 e 2021
sheet.getCells().get(0, 0).putValue("Fruit")
sheet.getCells().get(0, 1).putValue("Year")
sheet.getCells().get(0, 2).putValue("Amount")
sheet.getCells().get(1, 0).putValue("grape")
sheet.getCells().get(1, 1).putValue(2020)
sheet.getCells().get(1, 2).putValue(50)
sheet.getCells().get(2, 0).putValue("blueberry")
sheet.getCells().get(2, 1).putValue(2020)
sheet.getCells().get(2, 2).putValue(30)
sheet.getCells().get(3, 0).putValue("kiwi")
sheet.getCells().get(3, 1).putValue(2020)
sheet.getCells().get(3, 2).putValue(25)
sheet.getCells().get(4, 0).putValue("cherry")
sheet.getCells().get(4, 1).putValue(2020)
sheet.getCells().get(4, 2).putValue(40)
sheet.getCells().get(5, 0).putValue("grape")
sheet.getCells().get(5, 1).putValue(2021)
sheet.getCells().get(5, 2).putValue(60)
sheet.getCells().get(6, 0).putValue("blueberry")
sheet.getCells().get(6, 1).putValue(2021)
sheet.getCells().get(6, 2).putValue(35)
sheet.getCells().get(7, 0).putValue("kiwi")
sheet.getCells().get(7, 1).putValue(2021)
sheet.getCells().get(7, 2).putValue(28)
sheet.getCells().get(8, 0).putValue("cherry")
sheet.getCells().get(8, 1).putValue(2021)
sheet.getCells().get(8, 2).putValue(45)
sheet.getCells().get(9, 0).putValue("grape")
sheet.getCells().get(9, 1).putValue(2020)
sheet.getCells().get(9, 2).putValue(45)
# Aggiungi una tabella pivot nella cella di destinazione E3, denominata "Pivot1", usando l'intervallo di origine A1:C10
pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Assegna i campi: Fruit -> Righe, Amount -> Dati
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Applica il formato automatico preimpostato XLS legacy "Report5"
# Nota: questa proprietà ha significato solo quando si salva come .xls.
# Quando viene salvato come .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
# e utilizza qualsiasi PivotTableStyleType / PivotTableStyleName specificato.
pivotTable.setAutoFormatType(PivotTableAutoFormatType.Report5)
# Salva la cartella di lavoro nel formato legacy .xls
workbook.save("output.xls")
jpype.shutdownJVM()

Applica uno stile di tabella pivot predefinito denominato moderno

Definisci e applica uno stile personalizzato di tabella pivot

I preset predefiniti non possono essere modificati. Ogni volta che hai bisogno di sovrascrivere colori, bordi o font, devi definire uno stile personalizzato per la tabella pivot. Il flusso di lavoro prevede tre passaggi:

Aggiungi uno stile personalizzato alla raccolta TableStyles della cartella di lavoro tramite workbook.getWorksheets().getTableStyles().addPivotTableStyle(String name). Questo restituisce l’indice dello stile appena creato.
Configura lo stile aggiungendo elementi (come WHOLE_TABLE o GRAND_TOTAL_ROW) tramite tableStyle.getTableStyleElements().add(TableStyleElementType), quindi assegna uno Style a ciascun elemento tramite tableStyleElement.setElementStyle(Style).
Applica lo stile personalizzato alla tabella pivot chiamando pivotTable.setPivotTableStyleName(String) con il nome dello stile. Non utilizzare qui setPivotTableStyleType, poiché quel metodo seleziona i preset predefiniti.

setPivotTableStyleName e setPivotTableStyleType non sono intercambiabili. Usa setPivotTableStyleType per i preset predefiniti e setPivotTableStyleName per gli stili personalizzati che hai definito tramite addPivotTableStyle. Impostarli entrambi è innocuo, ma viene reso solo quello corrispondente alla sorgente prevista.

I valori disponibili di TableStyleElementType includono WHOLE_TABLE, FIRST_ROW, LAST_ROW, FIRST_COLUMN, LAST_COLUMN, GRAND_TOTAL_ROW, GRAND_TOTAL_COLUMN, PAGE_FIELD_LABELS e PAGE_FIELD_VALUES. L’esempio seguente definisce uno stile personalizzato di tabella pivot con un bordo sottile nero su WHOLE_TABLE e un font rosso in grassetto su GRAND_TOTAL_ROW, quindi lo applica tramite setPivotTableStyleName e salva come .xlsx.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat
from asposecells.api import PivotFieldType, TableStyleElementType, BorderType, CellBorderType
from java.awt import Color
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Popola i dati sorgente: riga di intestazione + 9 righe di dati (A1:C10)
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(100)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(200)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(300)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(400)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(500)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(600)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(700)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(800)
worksheet.getCells().get("A10").putValue("Grape")
worksheet.getCells().get("B10").putValue(2021)
worksheet.getCells().get("C10").putValue(900)
# Aggiungi una tabella pivot con origine A1:C10, ancorata in E3, denominata "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Passo 1: registra un nuovo stile di tabella pivot personalizzato e memorizza il suo indice
styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle")
tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex)
# Passo 2: aggiungi un elemento WholeTable e applica bordi neri sottili su tutti e quattro i lati
wholeTableElementIndex = tableStyle.getTableStyleElements().add(TableStyleElementType.WHOLE_TABLE)
wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex)
wholeTableStyle = workbook.createStyle()
wholeTableStyle.getBorders().get(BorderType.TOP_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.TOP_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.BOTTOM_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.BOTTOM_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.LEFT_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.LEFT_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.RIGHT_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.RIGHT_BORDER).setColor(Color.BLACK)
wholeTableElement.setElementStyle(wholeTableStyle)
# Passo 3: aggiungi un elemento GrandTotalRow e applica un font rosso in grassetto
grandTotalElementIndex = tableStyle.getTableStyleElements().add(TableStyleElementType.GRAND_TOTAL_ROW)
grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex)
grandTotalStyle = workbook.createStyle()
grandTotalStyle.getFont().setBold(True)
grandTotalStyle.getFont().setColor(Color.RED)
grandTotalElement.setElementStyle(grandTotalStyle)
# Passo 4: applica lo stile personalizzato per nome (NON tramite PivotTableStyleType, che è riservato ai preset predefiniti)
pivotTable.setPivotTableStyleName("CustomPivotStyle")
workbook.save("output.xlsx")
jpype.shutdownJVM()

Applica uno stile a ogni cella della tabella pivot con FormatAll

pivotTable.formatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della tabella pivot, inclusi l’area dei dati, le intestazioni di riga e colonna e i totali. Qualsiasi cosa precedentemente impostata tramite setPivotTableStyleType o setPivotTableStyleName viene sovrascritta.

formatAll sovrascrive sia setPivotTableStyleType sia setPivotTableStyleName. Usalo solo quando è richiesto un aspetto uniforme e indipendente dal tema in tutta la tabella pivot.

L’esempio seguente crea uno Style con un riempimento giallo pieno, un font blu scuro in grassetto e bordi sottili neri su tutti i lati, quindi lo applica con formatAll e salva come .xlsx.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, Style
from asposecells.api import Color
from asposecells.api import PivotTable, PivotFieldType
from asposecells.api import BorderType, CellBorderType, BackgroundType
# Scenario 4: Applica un singolo stile a ogni cella della tabella pivot usando FormatAll
# API in uso: PivotTable.FormatAll(Style)
# Formato di destinazione: .xlsx
# Riferimento GitHub: vedi il repository Aspose.Cells-for-.NET — esempi di stile delle tabelle pivot
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Popola i dati sorgente: riga intestazione (riga 1) + 9 righe di dati (righe 2-10)
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(5000)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(3000)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(4000)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(2000)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(6000)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(3500)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(4500)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(2500)
worksheet.getCells().get("A10").putValue("Grape")
worksheet.getCells().get("B10").putValue(2021)
worksheet.getCells().get("C10").putValue(5500)
# Aggiungi tabella pivot: intervallo sorgente A1:C10, cella di destinazione E3, nome "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Assegna campi pivot: Frutta -> area Riga, Anno -> area Colonna, Importo -> area Dati
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Crea uno stile che verrà forzato su ogni cella della tabella pivot
style = workbook.createStyle()
style.setForegroundColor(Color.YELLOW)
style.setPattern(BackgroundType.SOLID)
style.getFont().setIsBold(True)
style.getFont().setColor(Color.DARK_BLUE)
style.getBorders().get(BorderType.TOP_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.TOP_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.BOTTOM_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.BOTTOM_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.LEFT_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.LEFT_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.RIGHT_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.RIGHT_BORDER).setColor(Color.BLACK)
# Applica FormatAll: forza questo singolo stile su ogni cella della tabella pivot,
# sovrascrivendo qualsiasi PivotTableStyleType / PivotTableStyleName precedentemente impostato
pivotTable.formatAll(style)
# Salva la cartella di lavoro nel formato .xlsx moderno
workbook.save("output.xlsx")
jpype.shutdownJVM()

Quale API di stile devo usare?

La scelta dell’API di stile dipende dal formato di file con cui stai salvando. Usa la tabella seguente come riferimento rapido.

Formato del file di destinazione	API da usare	Note
`.xls` (legacy)	`pivotTable.setAutoFormatType(int)`	Valori da `com.aspose.cells.pivot.PivotTableAutoFormatType` (ad es. `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Ignorato quando si salva nei formati moderni.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile predefinito)	`pivotTable.setPivotTableStyleType(int)`	Valori da `com.aspose.cells.PivotTableStyleType` (temi chiari/scuri, incluse le aggiunte di Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile personalizzato)	`pivotTable.setPivotTableStyleName(String)` + `tableStyles.addPivotTableStyle(String)`	Da usare quando i preset predefiniti non sono sufficienti. Configura tramite `tableStyleElement.setElementStyle(Style)`.
Qualsiasi formato (sovrascrittura uniforme)	`pivotTable.formatAll(Style)`	Scorciatoia che sovrascrive ogni altra impostazione di stile nell’intera tabella pivot.
In caso di dubbio, salva come `.xlsx` e usa `setPivotTableStyleType` per i temi predefiniti oppure `setPivotTableStyleName` per i temi personalizzati.

Pythonjava: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

Mon, 01 Jan 0001 00:00:00 +0000

Aggiungere un campo alla regione di riga o colonna

Il metodo PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) sposta un campo base dai dati di origine in una delle quattro regioni della pivot. L’argomento fieldType accetta uno dei seguenti valori di PivotFieldType.

ROW — campi posizionati verticalmente a sinistra
COLUMN — campi posizionati orizzontalmente nella parte superiore
DATA — campi i cui valori vengono aggregati
PAGE — campi utilizzati come filtri del report Dopo aver aggiunto i campi, è possibile accedervi tramite i metodi PivotTable.getRowFields() e PivotTable.getColumnFields(). Ogni metodo restituisce un PivotFieldCollection. Il campo all’indice 0 di RowFields è il campo di riga più esterno e gli indici successivi rappresentano i campi nidificati al suo interno. La stessa convenzione di indicizzazione si applica a ColumnFields. L’ordine di nidificazione dei campi è importante. Aggiungendo prima Category alla regione di riga e poi Item si ottiene una pivot il cui raggruppamento esterno è Category e il cui raggruppamento interno è Item. Invertendo l’ordine si inverte la gerarchia.

Subtotali dei campi pivot

Il metodo PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) controlla quali righe di subtotale vengono visualizzate per un campo pivot. Ogni chiamata attiva o disattiva un singolo tipo di subtotale in modo indipendente. Passando shown = true viene visualizzato il subtotale, mentre con shown = false viene nascosto. Poiché ogni chiamata influisce su un solo tipo, chiamare il metodo più volte con valori diversi di subtotalType consente di creare un sottoinsieme personalizzato di subtotali. L’enum PivotFieldSubtotalType definisce i tipi di subtotale disponibili.

AUTOMATIC — Aspose.Cells sceglie la selezione predefinita (in genere SUM per i campi numerici)
NONE — elimina ogni riga di subtotale
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

I subtotali vengono visualizzati solo quando ci sono due o più campi pivot nella regione di riga (o nella regione di colonna). Un singolo campo non ha nulla di significativo da subtotalizzare, quindi le chiamate a setSubtotals non hanno alcun effetto visibile in quel caso. Questo articolo quindi posiziona due campi di riga (Category esterno, Item interno) in ogni esempio, in modo che il confine del subtotale tra ciascun gruppo Category sia visibile.

Scenario 1 — Subtotali automatici (predefiniti)

Quando non si chiama affatto setSubtotals, Aspose.Cells applica la selezione AUTOMATIC ai campi numerici. L’esempio seguente conferma esplicitamente questo comportamento chiamando setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) sul campo di riga esterno Category.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, PivotTable, PivotField, PivotFieldType, PivotFieldSubtotalType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
worksheet.getCells().get(0, 0).putValue("Category")
worksheet.getCells().get(0, 1).putValue("Item")
worksheet.getCells().get(0, 2).putValue("Year")
worksheet.getCells().get(0, 3).putValue("Amount")
worksheet.getCells().get(1, 0).putValue("Fruit")
worksheet.getCells().get(1, 1).putValue("Apple")
worksheet.getCells().get(1, 2).putValue(2020)
worksheet.getCells().get(1, 3).putValue(100)
worksheet.getCells().get(2, 0).putValue("Fruit")
worksheet.getCells().get(2, 1).putValue("Apple")
worksheet.getCells().get(2, 2).putValue(2021)
worksheet.getCells().get(2, 3).putValue(150)
worksheet.getCells().get(3, 0).putValue("Fruit")
worksheet.getCells().get(3, 1).putValue("Banana")
worksheet.getCells().get(3, 2).putValue(2020)
worksheet.getCells().get(3, 3).putValue(80)
worksheet.getCells().get(4, 0).putValue("Fruit")
worksheet.getCells().get(4, 1).putValue("Banana")
worksheet.getCells().get(4, 2).putValue(2021)
worksheet.getCells().get(4, 3).putValue(90)
worksheet.getCells().get(5, 0).putValue("Vegetable")
worksheet.getCells().get(5, 1).putValue("Carrot")
worksheet.getCells().get(5, 2).putValue(2020)
worksheet.getCells().get(5, 3).putValue(50)
worksheet.getCells().get(6, 0).putValue("Vegetable")
worksheet.getCells().get(6, 1).putValue("Carrot")
worksheet.getCells().get(6, 2).putValue(2021)
worksheet.getCells().get(6, 3).putValue(60)
worksheet.getCells().get(7, 0).putValue("Vegetable")
worksheet.getCells().get(7, 1).putValue("Daikon")
worksheet.getCells().get(7, 2).putValue(2020)
worksheet.getCells().get(7, 3).putValue(40)
worksheet.getCells().get(8, 0).putValue("Vegetable")
worksheet.getCells().get(8, 1).putValue("Daikon")
worksheet.getCells().get(8, 2).putValue(2021)
worksheet.getCells().get(8, 3).putValue(45)
pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.ROW, "Category")
pivotTable.addFieldToArea(PivotFieldType.ROW, "Item")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
categoryField = pivotTable.getRowFields().get(0)
categoryField.setSubtotals(PivotFieldSubtotalType.AUTOMATIC, True)
pivotTable.calculateData()
workbook.save("output_automatic.xlsx")
jpype.shutdownJVM()

Scenario 2 — Eliminare tutti i subtotali (None)

Chiamando setSubtotals(PivotFieldSubtotalType.NONE, true) si rimuove ogni riga di subtotale dalla pivot, lasciando solo le righe dei campi e il totale generale in fondo. Ciò è utile quando si desiderano i dati raggruppati grezzi senza righe di riepilogo.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType, PivotFieldSubtotalType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
headers = ["Category", "Item", "Year", "Amount"]
for j in range(len(headers)):
    worksheet.getCells().get(0, j).putValue(headers[j])
data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020, 80 ],
    ["Fruit",     "Banana", 2021, 90 ],
    ["Vegetable", "Carrot", 2020, 50 ],
    ["Vegetable", "Carrot", 2021, 60 ],
    ["Vegetable", "Daikon", 2020, 40 ],
    ["Vegetable", "Daikon", 2021, 45 ]
]
for i in range(len(data)):
    for j in range(len(data[0])):
        worksheet.getCells().get(i + 1, j).putValue(data[i][j])
pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.ROW, "Category")
pivotTable.addFieldToArea(PivotFieldType.ROW, "Item")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
categoryField = pivotTable.getRowFields().get(0)
categoryField.setSubtotals(PivotFieldSubtotalType.NONE, True)
pivotTable.calculateData()
workbook.save("output_none.xlsx")
jpype.shutdownJVM()

Scenario 3 — Sottoinsieme di subtotali personalizzato (Sum + Average)

Non si è limitati a un singolo tipo di subtotale. Ogni chiamata a setSubtotals opera in modo indipendente su un tipo, quindi chiamando il metodo due volte — una con SUM e una con AVERAGE — si produce un sottoinsieme personalizzato di due righe di subtotale per ciascun gruppo Category.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotTableCollection, PivotTable, PivotFieldType, PivotField, PivotFieldSubtotalType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
worksheet.getCells().get("A1").putValue("Category")
worksheet.getCells().get("B1").putValue("Item")
worksheet.getCells().get("C1").putValue("Year")
worksheet.getCells().get("D1").putValue("Amount")
worksheet.getCells().get(1, 0).putValue("Fruit")
worksheet.getCells().get(1, 1).putValue("Apple")
worksheet.getCells().get(1, 2).putValue(2020)
worksheet.getCells().get(1, 3).putValue(100)
worksheet.getCells().get(2, 0).putValue("Fruit")
worksheet.getCells().get(2, 1).putValue("Apple")
worksheet.getCells().get(2, 2).putValue(2021)
worksheet.getCells().get(2, 3).putValue(150)
worksheet.getCells().get(3, 0).putValue("Fruit")
worksheet.getCells().get(3, 1).putValue("Banana")
worksheet.getCells().get(3, 2).putValue(2020)
worksheet.getCells().get(3, 3).putValue(80)
worksheet.getCells().get(4, 0).putValue("Fruit")
worksheet.getCells().get(4, 1).putValue("Banana")
worksheet.getCells().get(4, 2).putValue(2021)
worksheet.getCells().get(4, 3).putValue(90)
worksheet.getCells().get(5, 0).putValue("Vegetable")
worksheet.getCells().get(5, 1).putValue("Carrot")
worksheet.getCells().get(5, 2).putValue(2020)
worksheet.getCells().get(5, 3).putValue(50)
worksheet.getCells().get(6, 0).putValue("Vegetable")
worksheet.getCells().get(6, 1).putValue("Carrot")
worksheet.getCells().get(6, 2).putValue(2021)
worksheet.getCells().get(6, 3).putValue(60)
worksheet.getCells().get(7, 0).putValue("Vegetable")
worksheet.getCells().get(7, 1).putValue("Daikon")
worksheet.getCells().get(7, 2).putValue(2020)
worksheet.getCells().get(7, 3).putValue(40)
worksheet.getCells().get(8, 0).putValue("Vegetable")
worksheet.getCells().get(8, 1).putValue("Daikon")
worksheet.getCells().get(8, 2).putValue(2021)
worksheet.getCells().get(8, 3).putValue(45)
pivotTables = worksheet.getPivotTables()
pivotIndex = pivotTables.add("A1:D9", "F3", "PivotTable1")
pivotTable = pivotTables.get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.Row, "Category")
pivotTable.addFieldToArea(PivotFieldType.Row, "Item")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
categoryField = pivotTable.getRowFields().get(0)
categoryField.setSubtotals(PivotFieldSubtotalType.Sum, True)
categoryField.setSubtotals(PivotFieldSubtotalType.Average, True)
pivotTable.calculateData()
workbook.save("output_custom.xlsx")
jpype.shutdownJVM()

Riepilogo

I tre scenari precedenti condividono lo stesso set di dati e la stessa struttura di tabella pivot. L’unica differenza tra essi è la chiamata a setSubtotals applicata al campo di riga esterno Category. Ricorda la regola dei due campi: un singolo campo in una regione non ha nulla da subtotalizzare, quindi posiziona sempre almeno due campi nella regione di riga o colonna quando desideri che setSubtotals abbia un effetto visibile.

Pythonjava: Campi Valore in Aspose.Cells for Python via Java

Mon, 01 Jan 0001 00:00:00 +0000

Aggiunta di un Campo all’Area Dati

L’aggiunta di un campo base all’area dati (valore) è il primo passo per definire come una tabella pivot aggrega i dati di origine. Aspose.Cells espone PivotTable.addFieldToArea(PivotFieldType, string), un overload che accetta la costante PivotFieldType.DATA e il nome della colonna di origine. Una volta che un campo viene aggiunto all’area dati, l’API lo espone attraverso la raccolta PivotTable.DataFields, nell’ordine in cui i campi sono stati aggiunti. Per impostazione predefinita, una colonna di origine numerica viene riassunta con ConsolidationFunction.SUM, mentre una colonna non numerica utilizza COUNT come valore predefinito.

import aspose.cells as ac
from aspose.cells.pivot import PivotFieldType
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"
headers = ["Category", "Item", "Year", "Amount"]
for j, h in enumerate(headers):
    worksheet.cells.get(0, j).put_value(h)
data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45],
]
for i, row in enumerate(data):
    for j, val in enumerate(row):
        worksheet.cells.get(i + 1, j).put_value(val)
pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1", True, False)
pivot_table = worksheet.pivot_tables[pivot_index]
pivot_table.add_field_to_area(PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")
pivot_table.calculate_data()
workbook.save("output_drag.xlsx")

Modifica della Funzione di Riepilogo

Ogni campo posizionato nell’area dati viene incapsulato internamente come un’istanza di PivotField, e la sua proprietà Function restituisce un valore dall’enum ConsolidationFunction. Lo stesso setter Function consente di passare tra gli aggregati disponibili, tra cui SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STDDEV, STDDEVP, VAR e VARP.

La modifica di Function influisce solo sull’aggregato, la colonna di origine non cambia.

Puoi quindi lasciare un campo dati come SUM mentre aggiungi un secondo campo dati che ha come destinazione la stessa colonna di origine ma utilizza COUNT o AVERAGE, tutto in un’unica tabella pivot.

import aspose.cells as ac
from aspose.cells.pivot import PivotFieldType, ConsolidationFunction
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"
headers = ["Category", "Item", "Year", "Amount"]
for j, h in enumerate(headers):
    worksheet.cells.get(0, j).put_value(h)
data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45],
]
for i, row in enumerate(data):
    for j, val in enumerate(row):
        worksheet.cells.get(i + 1, j).put_value(val)
pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1", True, False)
pivot_table = worksheet.pivot_tables[pivot_index]
pivot_table.add_field_to_area(PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")
pivot_table.data_fields[1].function = ConsolidationFunction.COUNT
pivot_table.calculate_data()
workbook.save("output_function.xlsx")

Visualizzazione dei Campi Valore sull’Asse Riga o Colonna

Quando una tabella pivot contiene due o più campi dati, Aspose.Cells espone un campo virtuale aggiuntivo chiamato PivotTable.ValuesField. Questo campo virtuale rappresenta l’aggregato di ogni campo dati presente nell’area dati. Puoi trascinarlo nell’area Riga o Colonna come campo pivot di base, utile per disporre più misure fianco a fianco.

PivotTable.ValuesField non funziona se non è presente alcun campo valore o se ne è presente solo uno.

Gli scenari seguenti illustrano tre esempi end-to-end che dimostrano ciascuna delle funzionalità descritte sopra sulla stessa struttura pivot.

import aspose.cells as ac
from aspose.cells.pivot import PivotFieldType, ConsolidationFunction
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"
headers = ["Category", "Item", "Year", "Amount"]
for j, h in enumerate(headers):
    worksheet.cells.get(0, j).put_value(h)
data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45],
]
for i, row in enumerate(data):
    for j, val in enumerate(row):
        worksheet.cells.get(i + 1, j).put_value(val)
pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1", True, False)
pivot_table = worksheet.pivot_tables[pivot_index]
pivot_table.add_field_to_area(PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")
pivot_table.data_fields[1].function = ConsolidationFunction.COUNT
pivot_table.add_field_to_area(PivotFieldType.COLUMN, pivot_table.values_field)
pivot_table.calculate_data()
workbook.save("output_plot.xlsx")

Pythonjava: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells supporta l’intero ciclo di vita dei campi filtro nelle tabelle pivot. È possibile aggiungere un campo filtro tramite un’API di alto livello comoda da usare oppure tramite la raccolta di livello inferiore page_fields, e si può gestire il filtro pagina in modalità selezione singola, azzerarlo per mostrare ogni elemento della pagina, oppure commutare il campo in multi-selezione così che gli utenti possano scegliere più elementi di pagina contemporaneamente tramite l’interfaccia a caselle di controllo in Excel.

Introduzione

Un campo filtro è un campo pivot che controlla quale sottoinsieme dei dati di origine viene visualizzato nel corpo della tabella pivot. Gli utenti finali lo vedono come un menu a discesa nella parte superiore di una tabella pivot renderizzata in Excel, e selezionare uno degli elementi di pagina disponibili ricostruisce il corpo della tabella pivot in modo che vengano riepilogati solo i record appartenenti a quell’elemento di pagina. Un campo pivot diventa un campo filtro quando viene registrato come PivotFieldType.PAGE anziché PivotFieldType.ROW, PivotFieldType.COLUMN o PivotFieldType.DATA. Un campo filtro può operare in due modalità. Nella modalità predefinita selezione singola è visibile un solo elemento di pagina alla volta, quindi il corpo della tabella pivot riepiloga esattamente un sottoinsieme. Nella modalità multi-selezione il campo espone un elenco di caselle di controllo e il corpo della tabella pivot riepiloga l’unione di ogni elemento di pagina selezionato. Lo stesso campo di origine può essere spostato avanti e indietro tra queste modalità attivando o disattivando una singola proprietà. Aspose.Cells for Python via Java espone due modi equivalenti per registrare un campo filtro. L’API di alto livello è PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName"), che riceve il nome della colonna di origine e aggiunge il campo in una sola chiamata. L’API di livello inferiore è PivotTable.page_fields.add(PivotField), che si utilizza quando si dispone già di un riferimento a PivotField e si desidera aggiungere la stessa istanza del campo all’area filtro. Entrambe le API finiscono per popolare la stessa raccolta page_fields, e il resto di questo articolo mostra come scegliere tra di esse e come gestire ciascuna modalità di filtraggio.

Aggiungere un campo filtro

Esistono due modi per registrare un campo pivot nell’area filtro. La chiamata di alto livello riceve il nome della colonna di origine come stringa ed è il percorso più comune. La chiamata di livello inferiore accetta un’istanza esistente di PivotField ed è comoda quando lo stesso oggetto campo deve essere riutilizzato in più aree della tabella pivot. Entrambe le chiamate collocano il campo in PivotTable.page_fields, dopodiché appare come menu a discesa della pagina nella parte superiore della tabella pivot renderizzata.

Aggiungere un campo filtro con add_field_to_area

L’esempio seguente crea un piccolo dataset Fruit / Year / Amount, posiziona una tabella pivot alla cella E3 con Fruit nell’area righe, Amount nell’area dati e Year nell’area filtro, aggiorna la tabella pivot e salva la cartella di lavoro.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType
# Crea una nuova cartella di lavoro
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
# Imposta la riga di intestazione
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Popola 9 righe di dati di esempio: Frutta, Anno, Quantità
data = [
    ["apple", 2020, 100],
    ["banana", 2021, 200],
    ["apple", 2021, 150],
    ["grape", 2020, 120],
    ["orange", 2022, 180],
    ["banana", 2020, 90],
    ["grape", 2021, 130],
    ["apple", 2022, 170],
    ["orange", 2021, 110]
]
for i in range(len(data)):
    worksheet.getCells().get(i + 1, 0).putValue(data[i][0])
    worksheet.getCells().get(i + 1, 1).putValue(data[i][1])
    worksheet.getCells().get(i + 1, 2).putValue(data[i][2])
# Aggiungi una tabella pivot ancorata alla cella E3
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Aggiungi campi alle loro aree: Frutta come Riga, Quantità come Dati, Anno come Campo Pagina
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# Aggiorna e calcola i dati della tabella pivot
pivotTable.calculateData()
# Salva la cartella di lavoro
workbook.save("pageFieldSample.xlsx")
jpype.shutdownJVM()

Aggiungere un campo filtro con page_fields.add

Quando si lavora già con un’istanza di PivotField, è possibile passarla direttamente a PivotTable.page_fields.add. La tabella pivot e il campo filtro vengono costruiti esattamente come nello scenario precedente; solo la registrazione finale nell’area filtro viene sostituita con la chiamata all’API di livello inferiore.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotTable, PivotField, PivotFieldType
# — La tabella pivot e il campo pagina sono costruiti esattamente come in
#   Scenario 1a (dati Frutto/Anno/Importo, pivot in E3, Frutto→Riga,
#   Importo→Dati). Di seguito otteniamo il PivotField Anno dalla
#   collezione BaseFields e lo passiamo a PageFields.Add — l'
#   alternativa di basso livello a AddFieldToArea. Il risultato è
#   funzionalmente identico allo Scenario 1a.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Intestazioni
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
# Dati di esempio (9 righe)
sheet.getCells().get("A2").putValue("apple");    sheet.getCells().get("B2").putValue("2020"); sheet.getCells().get("C2").putValue(100)
sheet.getCells().get("A3").putValue("apple");    sheet.getCells().get("B3").putValue("2021"); sheet.getCells().get("C3").putValue(150)
sheet.getCells().get("A4").putValue("apple");    sheet.getCells().get("B4").putValue("2022"); sheet.getCells().get("C4").putValue(200)
sheet.getCells().get("A5").putValue("grape");    sheet.getCells().get("B5").putValue("2020"); sheet.getCells().get("C5").putValue(300)
sheet.getCells().get("A6").putValue("grape");    sheet.getCells().get("B6").putValue("2021"); sheet.getCells().get("C6").putValue(400)
sheet.getCells().get("A7").putValue("grape");    sheet.getCells().get("B7").putValue("2022"); sheet.getCells().get("C7").putValue(500)
sheet.getCells().get("A8").putValue("blueberry"); sheet.getCells().get("B8").putValue("2020"); sheet.getCells().get("C8").putValue(250)
sheet.getCells().get("A9").putValue("blueberry"); sheet.getCells().get("B9").putValue("2021"); sheet.getCells().get("C9").putValue(350)
sheet.getCells().get("A10").putValue("blueberry");sheet.getCells().get("B10").putValue("2022"); sheet.getCells().get("C10").putValue(450)
# Aggiungi tabella pivot in E3 coprendo A1:C10
pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Frutto -> Riga, Importo -> Dati (Anno andrà nella Pagina sotto)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Approccio di basso livello: prendi il PivotField Anno esistente da BaseFields
# e registralo nell'area Pagina tramite PageFields.Add(PivotField).
yearField = pivotTable.getBaseFields().get("Year")
pivotTable.getPageFields().add(yearField)
# Aggiorna così che il nuovo campo pagina venga riflesso nel workbook salvato
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Filtraggio a selezione singola (mostrare un elemento di pagina)

Nel comportamento predefinito a selezione singola, il campo filtro viene reso come un singolo menu a discesa e l’intero PivotField.current_page_item seleziona quale elemento di pagina guida il corpo della tabella pivot. Assegnando un indice specifico si seleziona quell’unico elemento; assegnando il valore sentinella speciale 0x7FFD (decimale 32765) si azzera il filtro così che ogni elemento di pagina venga riepilogato contemporaneamente. La selezione singola è il valore predefinito; non è necessario abilitarla esplicitamente.

Mostrare tutti gli elementi

Impostare current_page_item sul valore magico 0x7FFD equivale ad azzerare il filtro pagina: il corpo della tabella pivot riepiloga ogni elemento di pagina come se non fosse applicato alcun filtro.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Crea una nuova cartella di lavoro
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Popola i dati Frutto/Anno/Importo
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
data = [
    ["Apple", 2022, 100],
    ["Apple", 2023, 150],
    ["Banana", 2022, 80],
    ["Banana", 2023, 120],
    ["Cherry", 2022, 200],
    ["Cherry", 2023, 250]
]
for r in range(len(data)):
    for c in range(len(data[r])):
        sheet.getCells().get(r + 1, c).putValue(data[r][c])
# Crea tabella pivot in E3
pivotTables = sheet.getPivotTables()
index = pivotTables.add("=A1:C7", "E3", "PivotTable1")
pivotTable = pivotTables.get(index)
# Configura i campi pivot: Frutto→Riga, Importo→Dati, Anno→Pagina
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
pivotTable.addFieldToArea(PivotFieldType.PAGE, "Year")
pivotTable.calculateData()
# Cancella il filtro pagina così ogni elemento nel campo pagina è visibile.
# 0x7FFD (decimale 32765) è il valore sentinella speciale che significa "tutti gli elementi" —
# equivalente a selezionare "(Tutti)" nel menu a discesa del campo pagina di Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD)
workbook.save("output.xlsx")
jpype.shutdownJVM()

Mostrare un elemento specifico

Impostare current_page_item su un indice reale seleziona solo quell’elemento di pagina. L’indice è la posizione dell’elemento nell’elenco ordinato degli elementi del campo filtro, quindi ad esempio 1 seleziona il secondo elemento dopo l’ordinamento.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Create workbook
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
cells = sheet.getCells()
# Add sample data (Fruit/Year/Amount)
cells.get("A1").putValue("Fruit")
cells.get("B1").putValue("Year")
cells.get("C1").putValue("Amount")
cells.get("A2").putValue("Apple")
cells.get("B2").putValue("2020")
cells.get("C2").putValue("100")
cells.get("A3").putValue("Apple")
cells.get("B3").putValue("2021")
cells.get("C3").putValue("150")
cells.get("A4").putValue("Banana")
cells.get("B4").putValue("2020")
cells.get("C4").putValue("200")
cells.get("A5").putValue("Banana")
cells.get("B5").putValue("2021")
cells.get("C5").putValue("250")
# Add pivot table at E3
pivotTables = sheet.getPivotTables()
pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1")
pivotTable = pivotTables.get(pivotIndex)
# Add fields: Fruit→Row, Amount→Data, Year→Page
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# Page-field-specific operations
pivotTable.getPageFields().get(0).setCurrentPageItem(1) # 1 = second item in sorted order (e.g. "2021")
# Refresh and calculate pivot table
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Filtraggio multi-selezione

Il filtraggio multi-selezione trasforma il menu a discesa della pagina in un elenco di caselle di controllo e consente all’utente finale di selezionare più elementi di pagina contemporaneamente. Aspose.Cells espone due proprietà che lavorano insieme. PivotField.is_multiple_item_selection_allowed deve essere impostato su True prima che l’interfaccia multi-selezione abbia effetto. Dopo averla abilitata, PivotItem.is_hidden controlla quali elementi appaiono nell’elenco delle caselle di controllo, così è possibile mostrare ogni elemento o autorizzare solo elementi specifici. Il codice seguente abilita la multi-selezione sullo stesso campo filtro Year costruito nello Scenario 1a, e quindi mostra due pattern: la Parte A rivela ogni elemento di pagina lasciando is_hidden impostato su False per ogni voce, mentre la Parte B autorizza solo i valori di origine scelti e nasconde tutto il resto tramite un blocco switch (pivot_items[i].get_string_value()).

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
import os
import re
# — La tabella pivot e il campo pagina sono costruiti esattamente come in
#   Scenario 1a (dati Frutto/Anno/Importo, pivot in E3, Frutto→Riga,
#   Importo→Dati, Anno→Pagina tramite AddFieldToArea).
#   Di seguito applichiamo il filtro multi-selezione sul campo pagina.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
cells = sheet.getCells()
# Dati di esempio: Frutto | Anno | Importo
cells.get(0, 0).putValue("Fruit")
cells.get(0, 1).putValue("Year")
cells.get(0, 2).putValue("Amount")
data = [
    ["apple",  "2019", "100"],
    ["apple",  "2020", "150"],
    ["apple",  "2021", "200"],
    ["banana", "2019", "110"],
    ["banana", "2020", "160"],
    ["banana", "2021", "210"],
    ["grape",  "2019", "120"],
    ["grape",  "2020", "170"],
    ["grape",  "2021", "220"]
]
for i in range(len(data)):
    cells.get(i + 1, 0).putValue(data[i][0])
    cells.get(i + 1, 1).putValue(int(data[i][1]))
    cells.get(i + 1, 2).putValue(int(data[i][2]))
pivotSheet = workbook.getWorksheets().add("Pivot")
pivots = pivotSheet.getPivotTables()
pivotIndex = pivots.add("E3", "A1:C10", "PivotTable1")
pivotTable = pivots.get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# — Abilita la multi-selezione sul campo pagina
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(True)
# Parte A — seleziona TUTTI gli elementi (rendi visibile ogni elemento)
pivotItems = pivotTable.getPageFields().get(0).getPivotItems()
for i in range(pivotItems.getCount()):
    pivotItems.get(i).setHidden(False)
# Parte B — seleziona solo elementi specifici per valore di origine
for i in range(pivotItems.getCount()):
    value = pivotItems.get(i).getStringValue()
    if value == "2020" or value == "grape" or value == "blueberry":
        pivotItems.get(i).setHidden(False)
    else:
        pivotItems.get(i).setHidden(True)
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Nota: Quando si utilizza il filtraggio multi-selezione tramite PivotItem.is_hidden, almeno un PivotItem deve rimanere visibile (is_hidden == False). Se ogni elemento è nascosto, Excel si arresta in modo anomalo all’apertura del file oppure rende una tabella pivot vuota. Verificare sempre che la whitelist di multi-selezione includa almeno un elemento dei dati di origine.

Quale API e quale modalità devo usare?

La tabella seguente riassume quando utilizzare ciascuna API e modalità così da poter scegliere la combinazione corretta senza leggere ogni scenario nel dettaglio.

Scenario / Caso d’uso	API consigliata	Proprietà utilizzata	Note
Aggiungere un campo filtro tramite il nome della colonna di origine (caso più comune)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName")`	n/d	Alto livello, una sola riga. Usare questa opzione a meno che non serva un riferimento a `PivotField`.
Aggiungere un campo filtro quando si ha già un oggetto `PivotField`	`PivotTable.page_fields.add(PivotField)`	n/d	Usare quando l’oggetto campo è stato ottenuto altrove o deve essere riutilizzato.
Filtrare un singolo elemento di pagina (modalità predefinita)	`PivotField.current_page_item`	impostare su un indice specifico	Ad esempio, `1` mostra il secondo elemento nell’elenco ordinato.
Mostrare tutti gli elementi / azzerare il filtro pagina	`PivotField.current_page_item`	impostare su `0x7FFD`	Il valore magico `0x7FFD` (decimale 32765) è la sentinella per “tutti gli elementi”.
Abilitare l’interfaccia multi-selezione in Excel	`PivotField.is_multiple_item_selection_allowed`	impostare su `True`	Richiesto prima che qualsiasi chiamata a `is_hidden` abbia effetto.
Nascondere / mostrare singoli elementi in un elenco multi-selezione	`PivotItem.is_hidden`	impostare per ciascun elemento	Almeno un elemento deve rimanere visibile (`is_hidden == False`).

Ricordare sempre il vincolo di visibilità quando si configura il filtraggio multi-selezione. Se ogni PivotItem in un campo filtro multi-selezione è nascosto, Excel si arresta in modo anomalo all’apertura oppure rende una tabella pivot vuota. Costruire la whitelist sui dati di origine in modo che almeno un elemento rimanga visibile e le cartelle di lavoro salvate si apriranno in modo affidabile su ogni macchina.

Documentation – Tabelle Pivot

Pythonjava: Crea una tabella pivot

Crea una tabella pivot

Pythonjava: Formattare le celle della tabella pivot

Pythonjava: Aggiornare Tabelle Pivot e Cache Pivot in Aspose.Cells for Python via Java

Introduzione

Avvio rapido

Importazioni richieste

Aggiornare tutte le Tabelle Pivot nella cartella di lavoro

Aggiornare tutte le Tabelle Pivot su un singolo foglio di lavoro

Aggiornare una singola Tabella Pivot

Dati di origine modificati — Usa PivotCache.refresh()

Cambiata solo la vista/layout — Usa calculateData()

Migrazione dall’obsoleto PivotTable.refreshData()

Quale API di aggiornamento devo usare?

Insidie comuni

Pythonjava: Applica stili alle tabelle pivot in Aspose.Cells for Python via Java

Introduzione

Applica un formato automatico predefinito legacy XLS

Applica uno stile di tabella pivot predefinito denominato moderno

Definisci e applica uno stile personalizzato di tabella pivot

Applica uno stile a ogni cella della tabella pivot con FormatAll

Quale API di stile devo usare?

Pythonjava: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

Aggiungere un campo alla regione di riga o colonna

Subtotali dei campi pivot

Scenario 1 — Subtotali automatici (predefiniti)

Scenario 2 — Eliminare tutti i subtotali (None)

Scenario 3 — Sottoinsieme di subtotali personalizzato (Sum + Average)

Riepilogo

Pythonjava: Campi Valore in Aspose.Cells for Python via Java

Aggiunta di un Campo all’Area Dati

Modifica della Funzione di Riepilogo

Visualizzazione dei Campi Valore sull’Asse Riga o Colonna

Pythonjava: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

Introduzione

Aggiungere un campo filtro

Aggiungere un campo filtro con add_field_to_area

Aggiungere un campo filtro con page_fields.add

Filtraggio a selezione singola (mostrare un elemento di pagina)

Mostrare tutti gli elementi

Mostrare un elemento specifico

Filtraggio multi-selezione

Quale API e quale modalità devo usare?

Dati di origine modificati — Usa `PivotCache.refresh()`

Cambiata solo la vista/layout — Usa `calculateData()`

Migrazione dall’obsoleto `PivotTable.refreshData()`