Documentation – Pivot Tabellen

Pythonjava: Ein Pivot Table erstellen

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

Ein Pivot-Table erstellen

Aspose.Cells für Python via Java bietet die Möglichkeit, Pivot-Tabellen zu erstellen. Um eine Pivot-Tabelle mit Aspose.Cells zu erstellen, befolgen Sie bitte die folgenden Schritte:

Fügen Sie einige Daten zu den Arbeitsblattzellen hinzu, indem Sie die setValue-Eigenschaft des Cell-Objekts verwenden. Diese Daten dienen als Datenquelle für die Pivot-Tabelle.
Fügen Sie dem Arbeitsblatt eine Pivot-Tabelle hinzu, indem Sie die PivotTableCollection-Methode add aufrufen, die im Worksheet-Objekt gekapselt ist.
Greifen Sie auf das PivotTable-Objekt aus der PivotTableCollectionzu, indem Sie den Index des PivotTable-Objekts übergeben.
Verwenden Sie eines der oben erklärten Pivot-Tabellen-Objekte, die im PivotTableCollectionObjekt gekapselt sind, um die Pivot-Tabelle zu verwalten.

Der folgende Code-Ausschnitt zeigt das Erstellen einer Pivot-Tabelle mit der Aspose.Cells-API.

Pythonjava: Formatieren von Pivottabellenzellen

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

Manchmal möchten Sie Pivot-Tabelle Zellen formatieren. Zum Beispiel möchten Sie eine Hintergrundfarbe auf Pivot-Tabelle Zellen anwenden. Aspose.Cells bietet zwei Methoden PivotTable.formatAll() und PivotTable.format(), die Sie zu diesem Zweck verwenden können.

PivotTable.formatAll() wendet den Stil auf die gesamte Pivot-Tabelle an, während PivotTable.format() den Stil auf eine einzelne Zelle der Pivot-Tabelle anwendet.

Der folgende Beispielcode formatiert die gesamte Pivot-Tabelle mit einer hellblauen Farbe und formatiert dann die zweite Tabellenzeile gelb.

Der Eingabe-Pivot-Table, bevor der Code ausgeführt wird

Der Ausgabe-Pivot-Table, nach Ausführung des Codes

Pythonjava: Anwenden von Stilen auf Pivot-Tabellen in Aspose.Cells for Python via Java

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

Aspose.Cells unterstützt sowohl die Anwendung von Legacy-Pivot-Autoformaten (für .xls-Dateien vorgesehen) als auch modernen benannten oder benutzerdefinierten Pivot-Tabellenstilen (für .xlsx-, .xlsm- und .xlsb-Dateien vorgesehen). Welche API Sie aufrufen sollten, hängt vom Dateiformat ab, in dem die Arbeitsmappe gespeichert wird, nicht vom Format, aus dem sie geladen wurde.

Einführung

Aspose.Cells stellt zwei parallele Stil-APIs für Pivot-Tabellen bereit. Die Entscheidung zwischen ihnen wird durch das Dateiformat bestimmt, in dem Sie die Arbeitsmappe speichern, nicht durch das Format, aus dem Sie sie lesen. Eine aus einer .xls-Datei geladene Arbeitsmappe kann als .xlsx neu gespeichert werden; in diesem Fall kommt die moderne Stil-API zum Einsatz, nicht die Legacy-API.

pivotTable.setPivotTableStyleType(int) wählt einen der integrierten benannten Stile aus (helle und dunkle Designs, einschließlich der in Excel 2017 hinzugefügten Stile). Diese Voreinstellungen sind schreibgeschützt.
pivotTable.setPivotTableStyleName(String) wählt einen benutzerdefinierten Stil aus, den Sie selbst über workbook.getWorksheets().getTableStyles().addPivotTableStyle(String) definieren. Benutzerdefinierte Stile sind erforderlich, wenn Sie Farben, Rahmen oder Schriftarten über das hinaus ändern möchten, was die Voreinstellungen bieten. Zusätzlich ist pivotTable.formatAll(Style) ein Kurzbefehl, der ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet und alles überschreibt, was über eine der oben genannten Stilnamen-APIs festgelegt wurde. Dies ist nützlich, wenn ein einheitliches Erscheinungsbild unabhängig vom zugrunde liegenden Design erforderlich ist.

Legacy-XLS-Voreinstellungs-Autoformat anwenden

Die Methode setAutoFormatType für eine Pivot-Tabelle akzeptiert einen Wert aus der Aufzählung com.aspose.cells.pivot.PivotTableAutoFormatType. Die verfügbaren Werte sind REPORT_1 bis REPORT_10, CLASSIC und TABLE_1 bis TABLE_10. Das folgende Beispiel lädt eine neue Arbeitsmappe, füllt die Fruit/Year/Amount-Beispieldaten, fügt eine Pivot-Tabelle hinzu, wendet PivotTableAutoFormatType.REPORT_5 an und speichert das Ergebnis als .xls.

Warum keine Spaltenfelder? Autoformate der Report-Serie (Report1 bis Report10, Table1 bis Table10) wurden im klassischen Excel für eindimensionale Pivot-Tabellen ausschließlich mit Zeilenfeldern und Werten entworfen — sie verfügen über keine integrierte Formatierung für Spaltenfeldüberschriften. Wenn Ihre Pivot-Tabelle Spaltenfelder benötigt, verwenden Sie stattdessen die modernen PivotTableStyleType-Voreinstellungen aus Szenario 2, die für das zweidimensionale Layout des modernen Excel konzipiert sind.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType, PivotTableAutoFormatType
# Szenario 1: Ein Legacy-XLS-Voreinstellungs-Autoformat anwenden
# Verwendete API: PivotTable.AutoFormatType
# Zieldateiformat: .xls (Legacy)
# Für vollständige Beispiele und Datendateien besuchen Sie bitte https://github.com/aspose-cells/Aspose.Cells-for-.NET
# Eine neue Arbeitsmappe erstellen
workbook = Workbook()
# Das erste Arbeitsblatt abrufen
sheet = workbook.getWorksheets().get(0)
# Quelldaten mit Kopfzeile (Fruit, Year, Amount) befüllen
# und 9 Datenzeilen mit Trauben, Blaubeeren, Kiwi, Kirsche über 2020 und 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)
# Eine Pivot-Tabelle an der Zielzelle E3 hinzufügen, benannt "Pivot1", unter Verwendung des Quellbereichs A1:C10
pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Felder zuweisen: Fruit -> Zeilen, Amount -> Daten
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Das Legacy-XLS-Voreinstellungs-Autoformat "Report5" anwenden
# Hinweis: Diese Eigenschaft ist nur beim Speichern als .xls von Bedeutung.
# Beim Speichern als .xlsx/.xlsm/.xlsb ignoriert Excel AutoFormatType
# und verwendet das, was PivotTableStyleType / PivotTableStyleName angibt.
pivotTable.setAutoFormatType(PivotTableAutoFormatType.Report5)
# Die Arbeitsmappe im Legacy-.xls-Format speichern
workbook.save("output.xls")
jpype.shutdownJVM()

Modernen benannten Pivot-Tabellen-Voreinstellungsstil anwenden

Benutzerdefinierten Pivot-Tabellenstil definieren und anwenden

Die integrierten Voreinstellungen können nicht geändert werden. Wenn Sie Farben, Rahmen oder Schriftarten überschreiben müssen, müssen Sie einen benutzerdefinierten Pivot-Stil definieren. Der Arbeitsablauf umfasst drei Schritte:

Fügen Sie der TableStyles-Auflistung der Arbeitsmappe über workbook.getWorksheets().getTableStyles().addPivotTableStyle(String name) einen benutzerdefinierten Stil hinzu. Diese Methode gibt den Index des neu erstellten Stils zurück.
Konfigurieren Sie den Stil, indem Sie Elemente (wie WHOLE_TABLE oder GRAND_TOTAL_ROW) über tableStyle.getTableStyleElements().add(TableStyleElementType) hinzufügen, und weisen Sie dann jedem Element über tableStyleElement.setElementStyle(Style) einen Style zu.
Wenden Sie den benutzerdefinierten Stil auf die Pivot-Tabelle an, indem Sie pivotTable.setPivotTableStyleName(String) mit dem Namen des Stils aufrufen. Verwenden Sie hier nicht setPivotTableStyleType, da diese Methode integrierte Voreinstellungen auswählt.

setPivotTableStyleName und setPivotTableStyleType sind nicht austauschbar. Verwenden Sie setPivotTableStyleType für integrierte Voreinstellungen und setPivotTableStyleName für benutzerdefinierte Stile, die Sie über addPivotTableStyle definiert haben. Das Festlegen beider Werte ist harmlos, aber nur der Wert, der der beabsichtigten Quelle entspricht, wird gerendert.

Die verfügbaren TableStyleElementType-Werte umfassen WHOLE_TABLE, FIRST_ROW, LAST_ROW, FIRST_COLUMN, LAST_COLUMN, GRAND_TOTAL_ROW, GRAND_TOTAL_COLUMN, PAGE_FIELD_LABELS und PAGE_FIELD_VALUES. Das folgende Beispiel definiert einen benutzerdefinierten Pivot-Stil mit einem dünnen schwarzen Rahmen für WHOLE_TABLE und einer fetten roten Schriftart für GRAND_TOTAL_ROW, wendet ihn dann über setPivotTableStyleName an und speichert als .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)
# Quellendaten befüllen: Kopfzeile + 9 Datenzeilen (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)
# Pivot-Tabelle hinzufügen, die aus A1:C10 stammt, bei E3 verankert ist und den Namen "Pivot1" trägt
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")
# Schritt 1: Einen neuen benutzerdefinierten Pivot-Tabellenstil registrieren und seinen Index erfassen
styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle")
tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex)
# Schritt 2: Ein WholeTable-Element hinzufügen und dünne schwarze Rahmen auf allen vier Seiten anwenden
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)
# Schritt 3: Ein GrandTotalRow-Element hinzufügen und eine fette rote Schriftart anwenden
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)
# Schritt 4: Den benutzerdefinierten Stil über den Namen anwenden (NICHT über PivotTableStyleType, der für integrierte Voreinstellungen gedacht ist)
pivotTable.setPivotTableStyleName("CustomPivotStyle")
workbook.save("output.xlsx")
jpype.shutdownJVM()

Mit FormatAll einen Stil auf jede Pivot-Zelle anwenden

pivotTable.formatAll(Style) ist ein Kurzbefehl, der ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet, einschließlich des Datenbereichs, der Zeilen- und Spaltenüberschriften sowie der Summen. Alles, was zuvor über setPivotTableStyleType oder setPivotTableStyleName festgelegt wurde, wird überschrieben.

formatAll überschreibt sowohl setPivotTableStyleType als auch setPivotTableStyleName. Verwenden Sie es nur, wenn ein einheitliches, designunabhängiges Erscheinungsbild über die gesamte Pivot-Tabelle hinweg erforderlich ist.

Das folgende Beispiel erstellt einen Style mit einer gelben Vollfüllung, einer fetten dunkelblauen Schriftart und dünnen schwarzen Rahmen auf allen Seiten, wendet ihn dann mit formatAll an und speichert als .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
# Szenario 4: Einen einzelnen Stil auf jede Pivot-Tabellen-Zelle mit FormatAll anwenden
# Verwendete API: PivotTable.FormatAll(Style)
# Zielformat: .xlsx
# GitHub-Referenz: siehe Aspose.Cells-for-.NET-Repository — Beispiele zur Pivot-Tabellen-Stilgestaltung
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Quelldaten einfügen: Kopfzeile (Zeile 1) + 9 Datenzeilen (Zeilen 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)
# Pivot-Tabelle hinzufügen: Quellbereich A1:C10, Zielzelle E3, Name "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Pivot-Felder zuweisen: Fruit -> Zeilenbereich, Year -> Spaltenbereich, Amount -> Datenbereich
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Einen Stil erstellen, der auf jede Zelle der Pivot-Tabelle angewendet wird
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)
# FormatAll anwenden: erzwingt diesen einzelnen Stil auf jede Zelle der Pivot-Tabelle,
# und überschreibt jeden zuvor gesetzten PivotTableStyleType / PivotTableStyleName
pivotTable.formatAll(style)
# Arbeitsmappe im modernen .xlsx-Format speichern
workbook.save("output.xlsx")
jpype.shutdownJVM()

Welche Stil-API sollte ich verwenden?

Die Wahl der Stil-API hängt vom Dateiformat ab, in dem Sie speichern. Verwenden Sie die folgende Tabelle als Kurzreferenz.

Zieldateiformat	Zu verwendende API	Hinweise
`.xls` (Legacy)	`pivotTable.setAutoFormatType(int)`	Werte aus `com.aspose.cells.pivot.PivotTableAutoFormatType` (z. B. `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Wird beim Speichern in modernen Formaten ignoriert.
`.xlsx` / `.xlsm` / `.xlsb` (modern, integrierter Stil)	`pivotTable.setPivotTableStyleType(int)`	Werte aus `com.aspose.cells.PivotTableStyleType` (helle/dunkle Designs, einschließlich Ergänzungen aus Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, benutzerdefinierter Stil)	`pivotTable.setPivotTableStyleName(String)` + `tableStyles.addPivotTableStyle(String)`	Zu verwenden, wenn die integrierten Voreinstellungen nicht ausreichen. Konfiguration über `tableStyleElement.setElementStyle(Style)`.
Beliebiges Format (einheitliche Überschreibung)	`pivotTable.formatAll(Style)`	Kurzbefehl, der jede andere Stileinstellung in der gesamten Pivot-Tabelle überschreibt.
Im Zweifelsfall speichern Sie als `.xlsx` und verwenden Sie `setPivotTableStyleType` für integrierte Designs oder `setPivotTableStyleName` für benutzerdefinierte Designs.

Pythonjava: Pivot-Tabellen und Pivot-Caches in Aspose.Cells for Python via Java aktualisieren

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

Aspose.Cells stellt eine mehrschichtige Aktualisierungs-API bereit, mit der Sie Pivot-Daten in vier verschiedenen Geltungsbereichen neu laden können — von der gesamten Arbeitsmappe bis hin zu einer einzelnen Pivot-Tabelle. Ab Aspose.Cells for Python via Java v26.7 ist die Legacy-Methode PivotTable.refreshData() als veraltet markiert und sollte durch die effizienteren, cache-bewussten APIs ersetzt werden, die in diesem Artikel beschrieben werden.

Einführung

Das Aktualisieren einer Pivot-Tabelle ist selten ein einzelner Vorgang. Hinter den Kulissen verwaltet Aspose.Cells eine mehrschichtige Datenkette, die Ihre ursprünglichen Quelldaten mit den gerenderten Werten verbindet, die Sie im Arbeitsblatt sehen. Das Verständnis dieser Kette ist der Schlüssel zur Auswahl der richtigen Aktualisierungs-API für jede Situation. Die vierschichtige Datenkette ist:

Datenquelle — die ursprünglichen Arbeitsblattbereiche, Datenbankabfragen oder Konsolidierungsbereiche, in denen die Rohwerte leben.
PivotCache — der In-Memory-Snapshot der Quelldaten. Jede Pivot-Tabelle wird auf einem PivotCache aufgebaut; hier werden alle Daten gesammelt und aggregiert.
PivotTable — das Ansichtsobjekt, das Zeilen-, Spalten-, Wert- und Filterfelder definiert. Eine PivotTable liest nur aus ihrem PivotCache, niemals direkt aus der Datenquelle.
Cells — die Cells des Arbeitsblatts, in die die PivotTable ihre berechneten Werte und Stile rendert.

PivotCache.getSourceType() (Enum PivotTableSourceType) gibt an, woher die Cache-Daten stammen. Ab v26.7 unterstützt PivotCache.refresh() nur die Quelltypen SHEET und CONSOLIDATION — also Daten, die in Arbeitsblattbereichen leben. Externe Quellen (Datenbanken, externe Verbindungen usw.) sind derzeit nicht über die Cache-API aktualisierbar.

Aufgrund dieser Kette gibt es in Aspose.Cells zwei grundlegende Aktualisierungspfade:

PivotTable.calculateData() — berechnet die Anzeige einer PivotTable aus den bereits zwischengespeicherten Daten neu, ohne Rückkehr zur Datenquelle. Alle Szenarien in diesem Artikel verwenden Arbeitsblattzellen als Quelldaten, sodass der Quelltyp SHEET ist und die Aktualisierungsvorgänge wie beschrieben funktionieren.

Schnellstart

Wenn Sie nur den kürzestmöglichen Code benötigen, der jede Pivot-Tabelle in der Arbeitsmappe aktualisiert, reicht ein einziger Aufruf:

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Eine neue Arbeitsmappe erstellen
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Kopfzeile in die Zellen A1:C1 schreiben
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Datenzeilen in die Zellen A2:C9 schreiben (8 Zeilen mit Fruchtdaten für 2020 und 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)
# Eine Pivot-Tabelle hinzufügen: Quellbereich "A1:C9", Zielzelle "E3", Name "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Pivot-Felder zuweisen: Frucht zu Zeilen, Jahr zu Spalten, Betrag zu Daten
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Mehrere Betragswerte in den Quelldaten ändern, um Änderungen zu simulieren
worksheet.getCells().get("C2").putValue(55)
worksheet.getCells().get("C5").putValue(85)
worksheet.getCells().get("C9").putValue(125)
# Alle Pivot-Tabellen / Pivot-Caches in der Arbeitsmappe aktualisieren
workbook.refreshAll()
# Die Arbeitsmappe speichern
workbook.save("output.xlsx")
jpype.shutdownJVM()

Der gesamte Rest dieses Artikels erklärt, wann stattdessen eine eingegrenztere API zu wählen ist.

Erforderliche Importe

Alle Python-Beispiele in diesem Artikel basieren auf den folgenden Importen, da die Pivot-Typen im Namespace aspose.cells.pivot leben:

import jpype
import aspose.cells as cells Das Modul jpype wird zum Starten der JVM verwendet, während aspose.cells die workbook/worksheet/cell/pivot-Typen bereitstellt, die durchgängig verwendet werden.

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Wenn Sie sicherstellen müssen, dass jeder Pivot-Cache und jede Pivot-Tabelle in der Arbeitsmappe die aktuellsten Quelldaten widerspiegelt, ist die einfachste und umfassendste API Workbook.refreshAll(). Ein einziger Aufruf durchläuft die gesamte Arbeitsmappe — aktualisiert jeden PivotCache aus seiner Quelle und berechnet dann jede abhängige PivotTable neu. Dies ist der empfohlene Ansatz für allgemeine, vollständige Dokumentaktualisierungen, bei denen die Leistung keine Rolle spielt. Das folgende Beispiel erstellt eine Arbeitsmappe mit einem Fruit/Year/Amount-Quellbereich, erstellt eine Pivot-Tabelle, ändert einige Quellwerte und verwendet dann refreshAll(), um alles in einem einzigen Aufruf auf den neuesten Stand zu bringen.

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()

Alle Pivot-Tabellen auf einem einzelnen Arbeitsblatt aktualisieren

Manchmal müssen Sie nur die Pivot-Tabellen aktualisieren, die sich auf einem bestimmten Arbeitsblatt befinden — z. B. wenn bekannt ist, dass Pivot-Tabellen auf anderen Arbeitsblättern irrelevant sind und nicht angefasst werden sollten. Für diesen Fall stellt Aspose.Cells Worksheet.refreshPivotTables() bereit, das auf eine einzelne Worksheet-Instanz beschränkt ist.

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)
# Kopfzeile mit Fruit / Year / Amount schreiben
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# 8 Datenzeilen schreiben (Zeilen 2-9, passend zum Quellbereich 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)
# Eine Pivot-Tabelle namens "Pivot1" hinzufügen, platziert an der Zielzelle E3, mit Quelle aus A1:C9
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Felder zuweisen: Fruit als Zeile, Year als Spalte, Amount als Daten
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Eine Ansichts-/Layout-Eigenschaft ändern — dies ist eine reine Darstellungsänderung,
# erfordert also KEIN erneutes Einlesen der Quelldaten über PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(False)
# CalculateData() rendert die Anzeige DIESER Pivot-Tabelle (Daten + Stil) neu aus den
# Daten, die bereits im PivotCache gehalten werden. Da sich die Quelldaten nicht geändert haben,
# wird kein Roundtrip zur Quelle durchgeführt — nur die zwischengespeicherten Werte werden neu
# in die Arbeitsblatt-Zellen berechnet.
pivotTable.calculateData()
# Die Arbeitsmappe auf der Festplatte speichern
workbook.save("output.xlsx")
jpype.shutdownJVM()

Eine einzelne Pivot-Tabelle aktualisieren

Wenn Sie eine fein abgestimmte Kontrolle über eine einzelne Pivot-Tabelle wünschen, bietet die cache-basierte API zwei Optionen. Die Wahl zwischen ihnen hängt davon ab, was sich tatsächlich geändert hat: die zugrunde liegenden Quelldaten oder nur die Ansichts-/Layouteinstellungen der Pivot-Tabelle selbst.

Quelldaten geändert — Verwenden Sie `PivotCache.refresh()`

Wenn sich die zugrunde liegenden Quelldaten geändert haben, ist der richtige Einstiegspunkt pivotTable.getPivotCache().refresh(). Dieser Aufruf liest die Quelldaten erneut in den Cache und berechnet dann jede PivotTable neu, die von diesem Cache abhängt.

Nur Ansicht/Layout geändert — Verwenden Sie `calculateData()`

Wenn sich die Quelldaten nicht geändert haben, sondern nur die Ansichts- oder Layouteinstellungen der Pivot-Tabelle geändert wurden (z. B. ein Feld in einen anderen Bereich verschoben wurde oder eine Aktualisierung-beim-Öffnen-Einstellung umgeschaltet wurde), ist es nicht erforderlich, zur Datenquelle zurückzukehren. Der Cache enthält bereits die richtigen Daten; nur die gerenderte PivotTable muss neu berechnet werden. In diesem Fall ist pivotTable.calculateData() die richtige Wahl. Das folgende Beispiel ändert eine Nicht-Quell-Eigenschaft der Pivot-Tabelle und ruft dann calculateData() auf, um sie aus dem vorhandenen Cache neu zu rendern. Eine Arbeitsmappe enthält oft viele Pivot-Tabellen, die alle auf einem gemeinsamen Cache sitzen. Um sie aufzulisten — z. B. vor einer Stapelaktualisierung oder zur Diagnose der Auswirkungen gemeinsamer Caches — verwenden Sie PivotCache.getPivotTables(). Diese Methode gibt die Sammlung jeder PivotTable zurück, die vom angegebenen Cache abhängt.

Migration von der veralteten Methode `PivotTable.refreshData()`

Vor Aspose.Cells for Python via Java v26.7 bestand die Standardmethode zum Aktualisieren einer Pivot-Tabelle darin, PivotTable.refreshData() auf jeder Pivot-Tabelle einzeln aufzurufen. Ab v26.7 ist diese Methode als veraltet markiert und sollte durch die oben beschriebenen cache-bewussten APIs ersetzt werden. Es gibt zwei Gründe, warum der refreshData()-Ansatz pro Tabelle in realen Arbeitsmappen problematisch ist:

Er ruft die Daten jedes Mal aus der Quelle erneut ab, wenn er aufgerufen wird, selbst wenn sich die Quelle nicht geändert hat. Die empfohlenen Ersetzungen sind: Das folgende Beispiel demonstriert das neue effiziente Muster für Arbeitsmappen mit mehreren Pivot-Tabellen, die sich einen einzelnen Cache teilen.

Welche Aktualisierungs-API sollte ich verwenden?

Die folgende Tabelle fasst die verfügbaren Aktualisierungs-APIs zusammen und gibt an, wann welche zu wählen ist.

Ziel	Empfohlene API	Hinweise
Alles in der Arbeitsmappe aktualisieren	`Workbook.refreshAll()`	Ein Aufruf; deckt alle Caches und Tabellen ab.
Nur Pivot-Tabellen auf einem einzelnen Blatt aktualisieren	`Worksheet.refreshPivotTables()`	Beschränkt auf ein Arbeitsblatt.
Quelldaten für einen Cache geändert	`pivotTable.getPivotCache().refresh()`	Aktualisiert ALLE Pivot-Tabellen auf diesem gemeinsamen Cache.
Nur Ansichts-/Layouteinstellungen geändert	`pivotTable.calculateData()`	Überspringt unnötige Quellrückkehr.
Alle Pivot-Tabellen auf einem gemeinsamen Cache auflisten	`pivotCache.getPivotTables()`	Zur Auflistung vor der Massenaktualisierung verwenden.
In der Praxis sind die cache-basierten APIs dem veralteten `refreshData()` pro Tabelle vorzuziehen. Sie kennen gemeinsame Caches, vermeiden redundante Quellabrufe und ermöglichen die Auswahl des kleinsten Geltungsbereichs, der Ihre Aktualisierungsanforderung erfüllt.

Häufige Fallstricke

Vergessen der Aktualisierung vor dem Speichern. Eine Pivot-Tabelle schreibt ihre gerenderten Werte erst dann in das Arbeitsblatt, wenn ihre Datenkette aktualisiert wird. Wenn Sie Quellzellen ändern, rufen Sie PivotCache.Refresh() (oder Workbook.RefreshAll()) vor Workbook.save() auf, da die gespeicherte Datei sonst weiterhin die alten aggregierten Werte enthält.
Aufrufen des veralteten RefreshData() pro Tabelle. In v26.7 ist PivotTable.RefreshData() als veraltet markiert und ruft die Quelle bei jedem Aufruf erneut ab. Bei mehreren Pivot-Tabellen, die sich einen Cache teilen, bedeutet dies N redundante Quellabrufe. Ersetzen Sie dies durch ein einzelnes PivotCache.Refresh(), gefolgt von CalculateData() pro Tabelle.
Aktualisieren, wenn nur das Layout geändert wurde. Wenn Sie nur die Ansicht einer Pivot-Tabelle geändert haben (Spaltenreihenfolge, ConsolidationFunction usw.), ohne die Quelldaten zu berühren, ist PivotCache.Refresh() unnötig und langsam. Rufen Sie pivotTable.CalculateData() auf, um aus dem vorhandenen Cache neu zu rendern.
Externe Quelle wird von PivotCache.Refresh() nicht unterstützt. Wenn die Quelle der Pivot-Tabelle aus einer externen Verbindung stammt (Datenbank, OLAP-Würfel usw.), kann PivotCache.Refresh() sie in v26.7 nicht aktualisieren — es werden derzeit nur die Quelltypen Sheet und Consolidation unterstützt. Für externe Quellen öffnen Sie die Arbeitsmappe erneut oder erstellen Sie den Cache aus der Quelle neu.

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

Pythonjava: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

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

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

Die Methode PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) verschiebt ein Basisfeld aus den Quelldaten in einen der vier Pivot-Bereiche. Das Argument fieldType akzeptiert einen der folgenden PivotFieldType-Werte.

ROW — Felder, die vertikal auf der linken Seite platziert werden
COLUMN — Felder, die horizontal oben platziert werden
DATA — Felder, deren Werte aggregiert werden
PAGE — Felder, die als Berichtsfilter verwendet werden Nachdem Felder hinzugefügt wurden, können Sie über die Methoden PivotTable.getRowFields() und PivotTable.getColumnFields() darauf zugreifen. Jede Methode gibt eine PivotFieldCollection zurück. Das Feld an Index 0 von RowFields ist das äußerste Zeilenfeld, und die nachfolgenden Indizes stellen Felder dar, die darin verschachtelt sind. Die gleiche Indizierungskonvention gilt für ColumnFields. Die Verschachtelungsreihenfolge der Felder ist wichtig. Wenn Sie zuerst Category zum Zeilenbereich und dann Item hinzufügen, entsteht eine PivotTable, deren äußere Gruppierung Category und deren innere Gruppierung Item ist. Eine Umkehrung der Reihenfolge kehrt die Hierarchie um.

Zwischensummen für Pivot-Felder

Die Methode PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) steuert, welche Zwischensummenzeilen für ein Pivot-Feld angezeigt werden. Jeder Aufruf schaltet einen einzelnen Zwischensummentyp unabhängig um. Die Übergabe von shown = true zeigt die Zwischensumme an, während shown = false sie ausblendet. Da jeder Aufruf nur einen Typ betrifft, können Sie durch mehrere Aufrufe der Methode mit unterschiedlichen subtotalType-Werten eine benutzerdefinierte Teilmenge von Zwischensummen erstellen. Die Enumeration PivotFieldSubtotalType definiert die verfügbaren Zwischensummentypen.

AUTOMATIC — Aspose.Cells wählt die Standardauswahl (in der Regel SUM für numerische Felder)
NONE — alle Zwischensummenzeilen unterdrücken
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Zwischensummen werden nur angezeigt, wenn zwei oder mehr Pivot-Felder im Zeilenbereich (oder im Spaltenbereich) vorhanden sind. Ein einzelnes Feld hat keine sinnvolle Zwischensumme dazwischen, daher haben setSubtotals-Aufrufe in diesem Fall keine sichtbare Wirkung. Dieser Artikel platziert daher in jedem Beispiel zwei Zeilenfelder (Category außen, Item innen), damit die Zwischensummengrenze zwischen jeder Category-Gruppe sichtbar ist.

Szenario 1 — Automatische (Standard-) Zwischensummen

Wenn Sie setSubtotals gar nicht aufrufen, wendet Aspose.Cells die Auswahl AUTOMATIC auf numerische Felder an. Das folgende Beispiel bestätigt dieses Verhalten explizit, indem es setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) auf dem äußeren Zeilenfeld Category aufruft.

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()

Szenario 2 — Alle Zwischensummen unterdrücken (Keine)

Der Aufruf von setSubtotals(PivotFieldSubtotalType.NONE, true) entfernt jede Zwischensummenzeile aus der PivotTable und lässt nur die Feldzeilen und die Gesamtsumme am Ende übrig. Dies ist nützlich, wenn Sie die rohen gruppierten Daten ohne Zusammenfassungszeilen wünschen.

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()

Szenario 3 — Benutzerdefinierte Zwischensummenteilmenge (Summe + Durchschnitt)

Sie sind nicht auf einen einzelnen Zwischensummentyp beschränkt. Jeder setSubtotals-Aufruf wirkt unabhängig auf einen Typ. Wenn Sie die Methode zweimal aufrufen — einmal mit SUM und einmal mit AVERAGE — erhalten Sie eine benutzerdefinierte Teilmenge von zwei Zwischensummenzeilen für jede Category-Gruppe.

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()

Zusammenfassung

Die drei oben genannten Szenarien verwenden denselben Datensatz und dieselbe PivotTable-Struktur. Der einzige Unterschied zwischen ihnen ist der setSubtotals-Aufruf, der auf das äußere Zeilenfeld Category angewendet wird. Beachten Sie die Zwei-Felder-Regel: Ein einzelnes Feld in einem Bereich hat keine Zwischensumme dazwischen. Platzieren Sie daher immer mindestens zwei Felder im Zeilen- oder Spaltenbereich, wenn Sie möchten, dass setSubtotals eine sichtbare Wirkung hat.

Pythonjava: Wertefelder in Aspose.Cells for Python via Java

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

Hinzufügen eines Felds zum Datenbereich

Das Hinzufügen eines Basisfelds zum Daten- (Werte-) Bereich ist der erste Schritt, um zu steuern, wie eine PivotTable Ihre Quelldaten aggregiert. Aspose.Cells stellt PivotTable.addFieldToArea(PivotFieldType, string) bereit, eine Überladung, die die Konstante PivotFieldType.DATA und den Namen der Quellspalte akzeptiert. Sobald ein Feld zum Datenbereich hinzugefügt wurde, wird es über die PivotTable.DataFields-Auflistung in der Reihenfolge bereitgestellt, in der die Felder hinzugefügt wurden. Standardmäßig wird eine numerische Quellspalte mit ConsolidationFunction.SUM zusammengefasst, während eine nicht numerische Spalte standardmäßig COUNT verwendet.

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")

Ändern der Zusammenfassungsfunktion

Jedes im Datenbereich platzierte Feld wird intern als PivotField-Instanz gekapselt, und seine Function-Eigenschaft gibt einen Wert aus der ConsolidationFunction-Enumeration zurück. Mit demselben Function-Setter können Sie zwischen den verfügbaren Aggregaten wechseln, einschließlich SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STDDEV, STDDEVP, VAR und VARP.

Das Ändern von Function wirkt sich nur auf das Aggregat aus, die Quellspalte ändert sich nicht.

Sie können daher ein Datenfeld als SUM belassen, während Sie ein zweites Datenfeld hinzufügen, das auf dieselbe Quellspalte abzielt, aber COUNT oder AVERAGE verwendet, alles in einer einzigen PivotTable.

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")

Wertefelder auf die Zeilen- oder Spaltenachse setzen

Wenn eine PivotTable zwei oder mehr Datenfelder enthält, stellt Aspose.Cells ein zusätzliches virtuelles Feld namens PivotTable.ValuesField bereit. Dieses virtuelle Feld repräsentiert das Aggregat jedes Datenfelds, das sich im Datenbereich befindet. Sie können es als Basis-Pivot-Feld in den Zeilen- oder Spaltenbereich ziehen, was nützlich ist, um mehrere Kennzahlen nebeneinander anzuordnen.

PivotTable.ValuesField funktioniert nicht, wenn kein oder nur ein Wertefeld vorhanden ist.

Die folgenden Szenarien führen durch drei durchgängige Beispiele, die jede der oben beschriebenen Funktionen anhand derselben Pivot-Struktur demonstrieren.

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: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

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

Aspose.Cells unterstützt den gesamten Lebenszyklus von Filterfeldern in PivotTables. Sie können ein Filterfeld über eine komfortable High-Level-API oder über die Low-Level-Sammlung page_fields hinzufügen, und Sie können den Filter im Einzel-Auswahl-Modus steuern, ihn zurücksetzen, um alle Seitenelemente anzuzeigen, oder das Feld auf Mehrfach-Auswahl umschalten, sodass Benutzer über die Kontrollkästchen-Benutzeroberfläche in Excel mehrere Seitenelemente gleichzeitig auswählen können.

Einführung

Ein Filterfeld ist ein Pivot-Feld, das steuert, welche Teilmenge der Quelldaten der Pivot-Bereich anzeigt. Endbenutzer sehen es als Dropdown am oberen Rand einer gerenderten Pivot-Tabelle in Excel, und die Auswahl eines der verfügbaren Seitenelemente baut den Pivot-Bereich neu auf, sodass nur die zu diesem Seitenelement gehörenden Datensätze zusammengefasst werden. Ein Pivot-Feld wird zu einem Filterfeld, wenn es als PivotFieldType.PAGE registriert wird, anstatt als PivotFieldType.ROW, PivotFieldType.COLUMN oder PivotFieldType.DATA. Ein Filterfeld kann in zwei Verhaltensweisen arbeiten. Im Standardverhalten Einzelauswahl ist jeweils nur ein Seitenelement sichtbar, sodass der Pivot-Bereich genau eine Teilmenge zusammenfasst. Im Verhalten Mehrfachauswahl zeigt das Feld eine Kontrollkästchenliste, und der Pivot-Bereich fasst die Vereinigungsmenge aller markierten Seitenelemente zusammen. Dasselbe Quellfeld kann zwischen diesen Verhaltensweisen hin und her verschoben werden, indem eine einzelne Eigenschaft umgeschaltet wird. Aspose.Cells for Python via Java stellt zwei gleichwertige Möglichkeiten bereit, um ein Filterfeld zu registrieren. Die High-Level-API ist PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName"), die den Namen der Quellspalte übernimmt und das Feld in einem einzigen Aufruf hinzufügt. Die Low-Level-API ist PivotTable.page_fields.add(PivotField), die verwendet wird, wenn Sie bereits eine PivotField-Referenz besitzen und dieselbe Feldinstanz dem Filterbereich hinzufügen möchten. Beide APIs füllen am Ende dieselbe page_fields-Sammlung, und der Rest dieses Artikels zeigt, wie Sie zwischen ihnen wählen und wie Sie jeden Filtermodus steuern.

Hinzufügen eines Filterfelds

Es gibt zwei Möglichkeiten, ein Pivot-Feld im Filterbereich zu registrieren. Der High-Level-Aufruf übernimmt den Namen der Quellspalte als Zeichenkette und ist der häufigste Weg. Der Low-Level-Aufruf akzeptiert eine vorhandene PivotField-Instanz und ist praktisch, wenn dieselbe Feldinstanz in mehreren Pivot-Bereichen wiederverwendet werden muss. Beide Aufrufe platzieren das Feld in PivotTable.page_fields, woraufhin es als Dropdown für die Seite am oberen Rand der gerenderten Pivot-Tabelle erscheint.

Hinzufügen eines Filterfelds mit add_field_to_area

Das folgende Beispiel erstellt einen kleinen Datensatz mit Frucht / Jahr / Betrag, platziert eine PivotTable an Zelle E3 mit Fruit im Zeilenbereich, Amount im Datenbereich und Year im Filterbereich, aktualisiert die PivotTable und speichert die Arbeitsmappe.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType
# Erstellen einer neuen Arbeitsmappe
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
# Kopfzeile einrichten
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# 9 Zeilen Beispieldaten einfügen: Frucht, Jahr, Betrag
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])
# Pivot-Tabelle hinzufügen, verankert an Zelle E3
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Felder ihren Bereichen hinzufügen: Frucht als Zeile, Betrag als Daten, Jahr als Seitenfeld
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# Pivot-Tabellen-Daten aktualisieren und berechnen
pivotTable.calculateData()
# Arbeitsmappe speichern
workbook.save("pageFieldSample.xlsx")
jpype.shutdownJVM()

Hinzufügen eines Filterfelds mit page_fields.add

Wenn Sie bereits mit einer PivotField-Instanz arbeiten, können Sie diese direkt an PivotTable.page_fields.add übergeben. Die PivotTable und das Filterfeld werden genau wie im vorherigen Szenario erstellt; nur die endgültige Registrierung im Filterbereich wird durch den Low-Level-API-Aufruf ersetzt.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotTable, PivotField, PivotFieldType
# — Die Pivot-Tabelle und das Seitenfeld werden genau wie in
#   Szenario 1a (Obst/Jahr/Betrag-Daten, Pivot bei E3, Obst→Zeile,
#   Betrag→Daten) erstellt. Unten rufen wir das Jahr-PivotField aus der
#   BaseFields-Sammlung ab und übergeben es an PageFields.Add — die
#   Low-Level-Alternative zu AddFieldToArea. Das Ergebnis ist
#   funktional identisch mit Szenario 1a.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Kopfzeilen
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
# Beispieldaten (9 Zeilen)
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)
# Pivot-Tabelle bei E3 hinzufügen, die A1:C10 abdeckt
pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Obst -> Zeile, Betrag -> Daten (Jahr wird unten zur Seite hinzugefügt)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Low-Level-Ansatz: das vorhandene Jahr-PivotField aus BaseFields holen
# und im Seitenbereich über PageFields.Add(PivotField) registrieren.
yearField = pivotTable.getBaseFields().get("Year")
pivotTable.getPageFields().add(yearField)
# Aktualisieren, damit das neue Seitenfeld in der gespeicherten Arbeitsmappe widergespiegelt wird
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Einzel-Auswahl-Filterung (Anzeigen eines Seitenelements)

Im Standardverhalten der Einzelauswahl wird das Filterfeld als einzelnes Dropdown dargestellt, und der ganzzahlige Wert PivotField.current_page_item wählt aus, welches Seitenelement den Pivot-Bereich steuert. Durch Zuweisen eines bestimmten Index wird dieses eine Element ausgewählt; durch Zuweisen des speziellen Sentinelwerts 0x7FFD (Dezimal 32765) wird der Filter zurückgesetzt, sodass alle Seitenelemente gleichzeitig zusammengefasst werden. Die Einzelauswahl ist die Standardeinstellung; Sie müssen sie nicht explizit aktivieren.

Anzeigen aller Elemente

Das Setzen von current_page_item auf den magischen Wert 0x7FFD entspricht dem Zurücksetzen des Filters: Der Pivot-Bereich fasst alle Seitenelemente zusammen, als ob kein Filter angewendet wäre.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Erstellen Sie eine neue Arbeitsmappe
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Daten für Fruit/Year/Amount einfügen
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])
# Pivot-Tabelle bei E3 erstellen
pivotTables = sheet.getPivotTables()
index = pivotTables.add("=A1:C7", "E3", "PivotTable1")
pivotTable = pivotTables.get(index)
# Pivot-Felder konfigurieren: Fruit→Zeile, Amount→Daten, Year→Seite
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
pivotTable.addFieldToArea(PivotFieldType.PAGE, "Year")
pivotTable.calculateData()
# Den Seitenfilter löschen, damit jeder Eintrag im Seitenfeld sichtbar ist.
# 0x7FFD (dezimal 32765) ist der spezielle Sentinel-Wert, der „alle Einträge" bedeutet —
# entspricht der Auswahl von „(Alle)" im Dropdown-Menü des Seitenfelds in Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD)
workbook.save("output.xlsx")
jpype.shutdownJVM()

Anzeigen eines bestimmten Elements

Das Setzen von current_page_item auf einen realen Index wählt genau dieses eine Seitenelement aus. Der Index ist die Position des Elements in der sortierten Elementliste des Filterfelds, sodass beispielsweise 1 das zweite Element nach dem Sortieren auswählt.

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()

Mehrfach-Auswahl-Filterung

Die Mehrfach-Auswahl-Filterung verwandelt das Seiten-Dropdown in eine Kontrollkästchenliste und ermöglicht es dem Endbenutzer, mehrere Seitenelemente gleichzeitig auszuwählen. Aspose.Cells stellt zwei Eigenschaften bereit, die zusammenarbeiten. PivotField.is_multiple_item_selection_allowed muss auf True gesetzt werden, bevor die Mehrfachauswahl-Benutzeroberfläche überhaupt wirksam wird. Nach der Aktivierung steuert PivotItem.is_hidden, welche Elemente in der Kontrollkästchenliste erscheinen, sodass Sie entweder alle Elemente anzeigen oder nur bestimmte Elemente in eine Whitelist aufnehmen können. Der folgende Code aktiviert die Mehrfachauswahl für dasselbe Year-Filterfeld, das in Szenario 1a erstellt wurde, und zeigt dann zwei Muster: Teil A deckt alle Seitenelemente auf, indem is_hidden für jeden Eintrag auf False belassen wird, während Teil B nur die von Ihnen gewählten Quellwerte in eine Whitelist aufnimmt und alles andere durch einen switch (pivot_items[i].get_string_value())-Block ausblendet.

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
# — Die Pivot-Tabelle und das Seitenfeld werden genau wie in
#   Szenario 1a (Frucht/Jahr/Betrag-Daten, Pivot bei E3, Frucht→Zeile,
#   Betrag→Daten, Jahr→Seite über AddFieldToArea) erstellt.
#   Unten wenden wir die Mehrfachauswahl-Filterung auf das Seitenfeld an.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
cells = sheet.getCells()
# Beispieldaten: Frucht | Jahr | Betrag
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")
# — Mehrfachauswahl auf dem Seitenfeld aktivieren
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(True)
# Teil A — ALLE Elemente auswählen (jedes Element sichtbar machen)
pivotItems = pivotTable.getPageFields().get(0).getPivotItems()
for i in range(pivotItems.getCount()):
    pivotItems.get(i).setHidden(False)
# Teil B — nur bestimmte Elemente nach Quellwert auswählen
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()

Hinweis: Bei Verwendung der Mehrfach-Auswahl-Filterung über PivotItem.is_hidden muss mindestens ein PivotItem sichtbar bleiben (is_hidden == False). Wenn jedes Element ausgeblendet ist, stürzt Excel beim Öffnen der Datei entweder ab oder rendert eine leere PivotTable. Überprüfen Sie immer, dass Ihre Mehrfachauswahl-Whitelist mindestens ein Element aus Ihren Quelldaten enthält.

Welche API und welcher Modus sollten verwendet werden?

Die folgende Tabelle fasst zusammen, wann jede API und jeder Modus verwendet werden sollte, damit Sie die richtige Kombination wählen können, ohne jedes Szenario im Detail lesen zu müssen.

Szenario / Anwendungsfall	Empfohlene API	Verwendete Eigenschaft	Hinweise
Hinzufügen eines Filterfelds über den Namen der Quellspalte (am häufigsten)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName")`	n/a	High-Level, einzeilig. Verwenden Sie dies, es sei denn, Sie benötigen eine `PivotField`-Referenz.
Hinzufügen eines Filterfelds, wenn Sie bereits ein `PivotField`-Objekt besitzen	`PivotTable.page_fields.add(PivotField)`	n/a	Verwenden Sie dies, wenn das Feldobjekt anderswo bezogen wurde oder wiederverwendet werden muss.
Filtern auf ein einzelnes Seitenelement (Standardmodus)	`PivotField.current_page_item`	auf einen bestimmten Index setzen	Beispielsweise zeigt `1` das zweite Element in der sortierten Liste an.
Alle Elemente anzeigen / Filter zurücksetzen	`PivotField.current_page_item`	auf `0x7FFD` setzen	Der magische Wert `0x7FFD` (Dezimal 32765) ist der Sentinelwert für „alle Elemente".
Mehrfachauswahl-Benutzeroberfläche in Excel aktivieren	`PivotField.is_multiple_item_selection_allowed`	auf `True` setzen	Erforderlich, bevor `is_hidden`-Aufrufe wirksam werden.
Einzelne Elemente in einer Mehrfachauswahlliste ein-/ausblenden	`PivotItem.is_hidden`	pro Element setzen	Mindestens ein Element muss sichtbar bleiben (`is_hidden == False`).

Denken Sie immer an die Sichtbarkeitseinschränkung, wenn Sie die Mehrfach-Auswahl-Filterung konfigurieren. Wenn jedes PivotItem in einem Mehrfachauswahl-Filterfeld ausgeblendet ist, stürzt Excel beim Öffnen ab oder rendert eine leere PivotTable. Erstellen Sie Ihre Whitelist anhand Ihrer Quelldaten, sodass mindestens ein Element sichtbar bleibt, und Ihre gespeicherten Arbeitsmappen werden auf jedem Rechner zuverlässig geöffnet.

Documentation – Pivot Tabellen

Pythonjava: Ein Pivot Table erstellen

Ein Pivot-Table erstellen

Pythonjava: Formatieren von Pivottabellenzellen

Pythonjava: Anwenden von Stilen auf Pivot-Tabellen in Aspose.Cells for Python via Java

Einführung

Legacy-XLS-Voreinstellungs-Autoformat anwenden

Modernen benannten Pivot-Tabellen-Voreinstellungsstil anwenden

Benutzerdefinierten Pivot-Tabellenstil definieren und anwenden

Mit FormatAll einen Stil auf jede Pivot-Zelle anwenden

Welche Stil-API sollte ich verwenden?

Pythonjava: Pivot-Tabellen und Pivot-Caches in Aspose.Cells for Python via Java aktualisieren

Einführung

Schnellstart

Erforderliche Importe

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Alle Pivot-Tabellen auf einem einzelnen Arbeitsblatt aktualisieren

Eine einzelne Pivot-Tabelle aktualisieren

Quelldaten geändert — Verwenden Sie PivotCache.refresh()

Nur Ansicht/Layout geändert — Verwenden Sie calculateData()

Migration von der veralteten Methode PivotTable.refreshData()

Welche Aktualisierungs-API sollte ich verwenden?

Häufige Fallstricke

Pythonjava: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

Zwischensummen für Pivot-Felder

Szenario 1 — Automatische (Standard-) Zwischensummen

Szenario 2 — Alle Zwischensummen unterdrücken (Keine)

Szenario 3 — Benutzerdefinierte Zwischensummenteilmenge (Summe + Durchschnitt)

Zusammenfassung

Pythonjava: Wertefelder in Aspose.Cells for Python via Java

Hinzufügen eines Felds zum Datenbereich

Ändern der Zusammenfassungsfunktion

Wertefelder auf die Zeilen- oder Spaltenachse setzen

Pythonjava: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Einführung

Hinzufügen eines Filterfelds

Hinzufügen eines Filterfelds mit add_field_to_area

Hinzufügen eines Filterfelds mit page_fields.add

Einzel-Auswahl-Filterung (Anzeigen eines Seitenelements)

Anzeigen aller Elemente

Anzeigen eines bestimmten Elements

Mehrfach-Auswahl-Filterung

Welche API und welcher Modus sollten verwendet werden?

Quelldaten geändert — Verwenden Sie `PivotCache.refresh()`

Nur Ansicht/Layout geändert — Verwenden Sie `calculateData()`

Migration von der veralteten Methode `PivotTable.refreshData()`