Documentation – Tableaux croisés dynamiques

Pythonjava: Créer un tableau croisé dynamique

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

Créer un tableau croisé dynamique

Aspose.Cells for Python via Java offre la possibilité de créer des tableaux croisés dynamiques. Pour créer un tableau croisé dynamique avec Aspose.Cells, suivez les étapes ci-dessous :

Ajoutez des données aux cellules de la feuille de calcul en utilisant la propriété setValue de l’objet Cell. Ces données seront utilisées comme source de données pour le tableau croisé dynamique.
Ajoutez un tableau croisé dynamique à la feuille de calcul en appelant la méthode add de la collection PivotTableCollection, encapsulée dans l’objet Worksheet.
Accédez à l’objet PivotTable dans la PivotTableCollection en utilisant l’index du PivotTable.
Utilisez l’un des objets de tableau croisé dynamique (expliqués ci-dessus) encapsulés dans la PivotTableCollection pour gérer le tableau croisé dynamique.

Le code suivant montre comment créer un tableau croisé dynamique avec l’API Aspose.Cells.

Pythonjava: Formatter les cellules du tableau croisé dynamique

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

Parfois, vous souhaitez formater les cellules de tableau croisé dynamique. Par exemple, vous souhaitez appliquer une couleur de fond aux cellules de tableau croisé dynamique. Aspose.Cells propose deux méthodes PivotTable.formatAll() et PivotTable.format(), que vous pouvez utiliser à cet effet.

PivotTable.formatAll() applique le style à l’ensemble du tableau croisé dynamique tandis que PivotTable.format() applique le style à une seule cellule du tableau croisé dynamique.

Le code d’exemple suivant formate l’ensemble du tableau croisé dynamique avec une couleur bleu clair, puis formate la deuxième ligne du tableau en jaune.

Le tableau croisé dynamique d’entrée, avant l’exécution du code

Le tableau croisé dynamique de sortie, après l’exécution du code

Pythonjava: Actualiser les Tableaux Croisés Dynamiques et les caches de tableaux croisés dynamiques dans Aspose.Cells for Python via Java

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

Aspose.Cells fournit une API d’actualisation en couches qui vous permet de recharger les données de tableau croisé dynamique à quatre niveaux différents — du classeur entier jusqu’à un seul tableau croisé dynamique. À partir d'Aspose.Cells for Python via Java v26.7, la méthode héritée PivotTable.refreshData() est marquée comme obsolète et doit être remplacée par les API plus efficaces, conscientes du cache, décrites dans cet article.

Introduction

L’actualisation d’un tableau croisé dynamique n’est que rarement une opération ponctuelle. En arrière-plan, Aspose.Cells maintient une chaîne de données en couches qui relie vos données sources d’origine aux valeurs rendues que vous voyez dans la feuille de calcul. Comprendre cette chaîne est la clé pour choisir la bonne API d’actualisation dans chaque situation. La chaîne de données à quatre niveaux est :

Source de données — les plages de feuilles de calcul d’origine, la requête de base de données, ou la plage de consolidation où vivent les valeurs brutes.
PivotCache — l’instantané en mémoire des données sources. Chaque tableau croisé dynamique est construit au-dessus d’un PivotCache ; c’est là que toutes les données sont rassemblées et agrégées.
PivotTable — l’objet de vue qui définit les champs de ligne, colonne, valeur et filtre. Un PivotTable lit uniquement à partir de son PivotCache, jamais directement à partir de la source de données.
Cells — la collection Cells de la feuille de calcul dans laquelle le PivotTable rend ses valeurs calculées et ses styles.

PivotCache.getSourceType() (énumération PivotTableSourceType) indique d’où proviennent les données du cache. À partir de la v26.7, PivotCache.refresh() ne prend en charge que les types de source SHEET et CONSOLIDATION — c’est-à-dire les données qui vivent dans des plages de feuilles de calcul. Les sources externes (bases de données, connexions externes, etc.) ne sont pas encore actualisables via l’API du cache.

En raison de cette chaîne, il existe deux chemins d’actualisation fondamentaux dans Aspose.Cells :

PivotTable.calculateData() — recalcule l’affichage d’un PivotTable à partir des données déjà mises en cache, sans aller-retour vers la source de données. Tous les scénarios de cet article utilisent des données sources de cellules de feuille de calcul, donc le type de source est SHEET et les opérations d’actualisation se comportent comme décrit.

Démarrage rapide

Si vous avez seulement besoin du code le plus court possible qui actualise chaque tableau croisé dynamique dans le classeur, un seul appel suffit :

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Créer un nouveau classeur
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Écrire la ligne d'en-tête dans les cellules A1:C1
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Écrire les lignes de données dans les cellules A2:C9 (8 lignes de données de fruits sur 2020 et 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)
# Ajouter un tableau croisé dynamique : plage source "A1:C9", cellule de destination "E3", nom "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Affecter les champs du tableau croisé dynamique : Fruit aux Lignes, Année aux Colonnes, Montant aux Données
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modifier plusieurs valeurs de Montant dans les données source pour simuler des changements
worksheet.getCells().get("C2").putValue(55)
worksheet.getCells().get("C5").putValue(85)
worksheet.getCells().get("C9").putValue(125)
# Actualiser tous les tableaux croisés dynamiques / caches de tableaux croisés dynamiques dans le classeur
workbook.refreshAll()
# Enregistrer le classeur
workbook.save("output.xlsx")
jpype.shutdownJVM()

Tout le reste de cet article explique quand choisir une API plus restreinte à la place.

Importations requises

Tous les exemples Python de cet article reposent sur les importations suivantes car les types de tableau croisé dynamique vivent dans l’espace de noms aspose.cells.pivot :

import jpype
import aspose.cells as cells Le module jpype est utilisé pour démarrer la JVM, tandis que aspose.cells expose les types de classeur/feuille de calcul/cellule/tableau croisé dynamique utilisés tout au long de cet article.

Actualiser tous les Tableaux Croisés Dynamiques dans le classeur

Lorsque vous devez vous assurer que chaque cache de tableau croisé dynamique et chaque tableau croisé dynamique du classeur reflète les dernières données sources, l’API la plus simple et la plus complète est Workbook.refreshAll(). Un seul appel parcourt le classeur entier — actualisant chaque PivotCache à partir de sa source puis recalculant chaque PivotTable dépendant. C’est l’approche recommandée pour les actualisations générales et complètes de documents où la performance n’est pas une préoccupation. L’exemple suivant crée un classeur avec une plage source Fruits/Année/Montant, crée un tableau croisé dynamique, modifie certaines valeurs sources, puis utilise refreshAll() pour tout mettre à jour en un seul appel.

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

Actualiser tous les Tableaux Croisés Dynamiques sur une seule feuille de calcul

Parfois, vous n’avez besoin d’actualiser que les tableaux croisés dynamiques qui vivent sur une feuille de calcul spécifique — par exemple, lorsque les tableaux croisés dynamiques d’autres feuilles de calcul sont connus pour être sans rapport et ne doivent pas être touchés. Pour ce cas, Aspose.Cells fournit Worksheet.refreshPivotTables(), qui est limité à une seule instance de 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)
# Écrire la ligne d'en-tête Fruit / Année / Montant
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Écrire 8 lignes de données (lignes 2-9, correspondant à la plage source 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)
# Ajouter un tableau croisé dynamique nommé "Pivot1" placé dans la cellule de destination E3, à partir de la plage A1:C9
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Affecter les champs : Fruit à Ligne, Année à Colonne, Montant à Données
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modifier une propriété d'affichage/disposition — il s'agit d'une modification purement visuelle,
# elle ne nécessite PAS de relire les données source via PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(False)
# CalculateData() réaffiche l'affichage de CE tableau croisé dynamique (données + style) à partir des
# données déjà contenues dans le PivotCache. Comme les données source n'ont pas changé,
# aucun aller-retour vers la source n'est effectué — seules les valeurs mises en cache sont recalculées
# dans les cellules de la feuille de calcul.
pivotTable.calculateData()
# Enregistrer le classeur sur le disque
workbook.save("output.xlsx")
jpype.shutdownJVM()

Actualiser un seul Tableau Croisé Dynamique

Lorsque vous souhaitez un contrôle fin sur un seul tableau croisé dynamique, l’API basée sur le cache vous offre deux options. Le choix entre elles dépend de ce qui a réellement changé : les données sources sous-jacentes, ou simplement les paramètres de vue/disposition du tableau croisé dynamique lui-même.

Données sources modifiées — Utilisez `PivotCache.refresh()`

Si les données sources sous-jacentes ont changé, le bon point d’entrée est pivotTable.getPivotCache().refresh(). Cet appel relit les données sources dans le cache puis recalcule chaque PivotTable qui dépend de ce cache.

Seule la vue/la disposition a été modifiée — Utilisez `calculateData()`

Si les données sources n’ont pas changé mais que seuls les paramètres de vue ou de disposition du tableau croisé dynamique ont été modifiés (par exemple, un champ a été déplacé vers une zone différente, ou un paramètre d’actualisation à l’ouverture a été basculé), il n’est pas nécessaire de faire un aller-retour vers la source de données. Le cache contient déjà les bonnes données ; seul le PivotTable rendu a besoin d’être recalculé. Dans ce cas, pivotTable.calculateData() est le bon choix. L’exemple suivant modifie une propriété non source du tableau croisé dynamique, puis appelle calculateData() pour le rendre à nouveau à partir du cache existant. Un classeur contient souvent de nombreux tableaux croisés dynamiques qui reposent tous sur un cache partagé. Pour les énumérer — par exemple, avant d’effectuer une actualisation par lot, ou pour diagnostiquer l’impact d’un cache partagé — utilisez PivotCache.getPivotTables(). Cette méthode renvoie la collection de chaque PivotTable qui dépend du cache donné.

Migration depuis l’obsolète `PivotTable.refreshData()`

Avant Aspose.Cells for Python via Java v26.7, la méthode standard pour actualiser un tableau croisé dynamique consistait à appeler PivotTable.refreshData() sur chaque tableau croisé dynamique individuellement. À partir de la v26.7, cette méthode est marquée comme obsolète et doit être remplacée par les API conscientes du cache décrites ci-dessus. Il y a deux raisons pour lesquelles l’approche refreshData() par tableau est problématique dans les classeurs réels :

Elle récupère les données depuis la source à chaque appel, même lorsque la source n’a pas changé. Les remplacements recommandés sont : L’exemple suivant démontre le nouveau modèle efficace pour les classeurs contenant plusieurs tableaux croisés dynamiques partageant un seul cache.

Quelle API d’actualisation dois-je utiliser ?

Le tableau ci-dessous résume les API d’actualisation disponibles et quand choisir chacune d’elles.

Objectif	API recommandée	Notes
Actualiser tout dans le classeur	`Workbook.refreshAll()`	Un seul appel ; couvre tous les caches et tableaux.
Actualiser uniquement les tableaux croisés dynamiques d’une seule feuille	`Worksheet.refreshPivotTables()`	Limité à une feuille de calcul.
Données sources modifiées pour un cache	`pivotTable.getPivotCache().refresh()`	Actualise TOUS les tableaux croisés dynamiques sur ce cache partagé.
Seuls les paramètres de vue/disposition ont changé	`pivotTable.calculateData()`	Évite un aller-retour inutile vers la source.
Lister tous les tableaux croisés dynamiques sur un cache partagé	`pivotCache.getPivotTables()`	À utiliser pour énumérer avant une actualisation en masse.
En pratique, préférez les API basées sur le cache par rapport à l’obsolète `refreshData()` par tableau. Elles sont conscientes des caches partagés, elles évitent les récupérations de source redondantes, et elles vous permettent de choisir le plus petit niveau qui satisfait votre besoin d’actualisation.

Pièges courants

Oublier d’actualiser avant de sauvegarder. Un tableau croisé dynamique n’écrit ses valeurs rendues dans la feuille de calcul que lorsque sa chaîne de données est actualisée. Si vous modifiez des cellules sources, appelez PivotCache.Refresh() (ou Workbook.RefreshAll()) avant Workbook.save(), sinon le fichier sauvegardé contiendra toujours les anciennes valeurs agrégées.
Appeler l’obsolète RefreshData() par tableau. Dans la v26.7, PivotTable.RefreshData() est marquée comme obsolète et récupère la source pour chaque appel. Avec plusieurs tableaux croisés dynamiques partageant un cache, cela signifie N récupérations de source redondantes. Remplacez par un seul PivotCache.Refresh() suivi de CalculateData() par tableau.
Actualiser lorsque seule la disposition a changé. Si vous n’avez modifié que la vue d’un tableau croisé dynamique (ordre des colonnes, ConsolidationFunction, etc.) sans toucher aux données sources, PivotCache.Refresh() est inutile et lent. Appelez pivotTable.CalculateData() pour rendre à nouveau à partir du cache existant.
Source externe non prise en charge par PivotCache.Refresh(). Si la source du tableau croisé dynamique provient d’une connexion externe (base de données, cube OLAP, etc.), PivotCache.Refresh() ne peut pas l’actualiser dans la v26.7 — elle ne prend actuellement en charge que les types de source Sheet et Consolidation. Pour les sources externes, rouvrez le classeur ou reconstruisez le cache à partir de la source.

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

Pythonjava: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells for Python via Java

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

Aspose.Cells prend en charge l’application des autoformats hérités des tableaux croisés dynamiques (destinés aux fichiers .xls) ainsi que des styles nommés ou personnalisés modernes (destinés aux fichiers .xlsx, .xlsm et .xlsb). L’API que vous devez appeler dépend du format de fichier dans lequel le classeur est enregistré, et non du format à partir duquel il a été chargé.

Introduction

Aspose.Cells expose deux API de style parallèles pour les tableaux croisés dynamiques. Le choix entre elles dépend du format de fichier dans lequel vous enregistrez le classeur, et non du format à partir duquel vous le lisez. Un classeur chargé depuis un fichier .xls peut être réenregistré en .xlsx, et dans ce cas, c’est l’API de style moderne qui s’applique plutôt que l’API héritée.

pivotTable.setPivotTableStyleType(int) sélectionne l’un des styles nommés prédéfinis (thèmes clairs et sombres, y compris les styles ajoutés dans Excel 2017). Ces préréglages sont en lecture seule.
pivotTable.setPivotTableStyleName(String) sélectionne un style personnalisé que vous définissez vous-même via workbook.getWorksheets().getTableStyles().addPivotTableStyle(String). Les styles personnalisés sont nécessaires chaque fois que vous souhaitez modifier les couleurs, les bordures ou les polices au-delà de ce que les préréglages offrent. De plus, pivotTable.formatAll(Style) est un raccourci qui applique un même objet Style à chaque cellule du tableau croisé dynamique, en surchargeant tout ce qui est défini via l’une ou l’autre des API de nom de style ci-dessus. Cela est utile lorsqu’une apparence uniforme est requise quel que soit le thème sous-jacent.

Appliquer un autoformat prédéfini XLS hérité

La méthode setAutoFormatType sur un tableau croisé dynamique accepte une valeur de l’énumération com.aspose.cells.pivot.PivotTableAutoFormatType. Les valeurs disponibles sont REPORT_1 à REPORT_10, CLASSIC, et TABLE_1 à TABLE_10. L’exemple suivant charge un nouveau classeur, renseigne les données d’exemple Fruit/Année/Montant, ajoute un tableau croisé dynamique, applique PivotTableAutoFormatType.REPORT_5, puis enregistre le résultat en .xls.

Pourquoi pas de champs de colonnes ? Les autoformats de la série Report (Report1 à Report10, Table1 à Table10) ont été conçus dans Excel classique pour des tableaux croisés dynamiques unidimensionnels comportant uniquement des champs de lignes et des valeurs — ils ne disposent pas de mise en forme intégrée pour les en-têtes de champs de colonnes. Si votre tableau croisé dynamique nécessite des champs de colonnes, utilisez plutôt les préréglages modernes PivotTableStyleType du Scénario 2, qui sont conçus pour la disposition bidimensionnelle utilisée par Excel moderne.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType, PivotTableAutoFormatType
# Scénario 1 : Appliquer un autoformat prédéfini XLS hérité
# API utilisée : PivotTable.AutoFormatType
# Format de fichier cible : .xls (hérité)
# Pour des exemples complets et des fichiers de données, veuillez aller à https://github.com/aspose-cells/Aspose.Cells-for-.NET
# Créer un nouveau classeur
workbook = Workbook()
# Obtenir la première feuille de calcul
sheet = workbook.getWorksheets().get(0)
# Remplir les données source avec une ligne d'en-tête (Fruit, Year, Amount)
# et 9 lignes de données couvrant grape, blueberry, kiwi, cherry à travers 2020 et 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)
# Ajouter un tableau croisé dynamique à la cellule de destination E3, nommé "Pivot1", en utilisant la plage source A1:C10
pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Assigner les champs : Fruit -> Lignes, Amount -> Données
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Appliquer l'autoformat prédéfini XLS hérité "Report5"
# Note : Cette propriété n'a de sens que lors de l'enregistrement en .xls.
# Lorsqu'enregistré en .xlsx/.xlsm/.xlsb, Excel ignore AutoFormatType
# et utilise ce que PivotTableStyleType / PivotTableStyleName spécifie.
pivotTable.setAutoFormatType(PivotTableAutoFormatType.Report5)
# Enregistrer le classeur au format .xls hérité
workbook.save("output.xls")
jpype.shutdownJVM()

Appliquer un style de tableau croisé dynamique nommé moderne prédéfini

Définir et appliquer un style personnalisé de tableau croisé dynamique

Les préréglages intégrés ne peuvent pas être modifiés. Chaque fois que vous devez remplacer les couleurs, les bordures ou les polices, vous devez définir un style personnalisé de tableau croisé dynamique. Le flux de travail comporte trois étapes :

Ajoutez un style personnalisé à la collection TableStyles du classeur via workbook.getWorksheets().getTableStyles().addPivotTableStyle(String name). Cela renvoie l’index du style nouvellement créé.
Configurez le style en ajoutant des éléments (tels que WHOLE_TABLE ou GRAND_TOTAL_ROW) via tableStyle.getTableStyleElements().add(TableStyleElementType), puis attribuez un Style à chaque élément via tableStyleElement.setElementStyle(Style).
Appliquez le style personnalisé au tableau croisé dynamique en appelant pivotTable.setPivotTableStyleName(String) avec le nom du style. N’utilisez pas setPivotTableStyleType ici, car cette méthode sélectionne des préréglages intégrés.

setPivotTableStyleName et setPivotTableStyleType ne sont pas interchangeables. Utilisez setPivotTableStyleType pour les préréglages intégrés, et setPivotTableStyleName pour les styles personnalisés que vous avez définis via addPivotTableStyle. Définir les deux est sans incidence, mais seule l’API correspondant à la source prévue est rendue.

Les valeurs disponibles de TableStyleElementType incluent WHOLE_TABLE, FIRST_ROW, LAST_ROW, FIRST_COLUMN, LAST_COLUMN, GRAND_TOTAL_ROW, GRAND_TOTAL_COLUMN, PAGE_FIELD_LABELS et PAGE_FIELD_VALUES. L’exemple suivant définit un style personnalisé de tableau croisé dynamique avec une fine bordure noire sur WHOLE_TABLE et une police rouge en gras sur GRAND_TOTAL_ROW, puis l’applique via setPivotTableStyleName et enregistre en .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)
# Remplir les données sources : ligne d'en-tête + 9 lignes de données (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)
# Ajouter un tableau croisé dynamique à partir de A1:C10, ancré à E3, nommé "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")
# Étape 1 : enregistrer un nouveau style de tableau croisé dynamique personnalisé et capturer son index
styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle")
tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex)
# Étape 2 : ajouter un élément WholeTable et appliquer des bordures fines noires sur les quatre côtés
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)
# Étape 3 : ajouter un élément GrandTotalRow et appliquer une police rouge en gras
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)
# Étape 4 : appliquer le style personnalisé par nom (PAS par PivotTableStyleType, qui est pour les préréglages intégrés)
pivotTable.setPivotTableStyleName("CustomPivotStyle")
workbook.save("output.xlsx")
jpype.shutdownJVM()

Appliquer un seul style à chaque cellule du tableau croisé dynamique avec FormatAll

pivotTable.formatAll(Style) est un raccourci qui applique un même objet Style à chaque cellule du tableau croisé dynamique, y compris la zone de données, les en-têtes de lignes et de colonnes, ainsi que les totaux. Tout ce qui avait été défini précédemment via setPivotTableStyleType ou setPivotTableStyleName est écrasé.

formatAll écrase à la fois setPivotTableStyleType et setPivotTableStyleName. Utilisez-le uniquement lorsqu’une apparence uniforme et indépendante du thème est requise sur l’ensemble du tableau croisé dynamique.

L’exemple suivant crée un Style avec un remplissage uni jaune, une police bleu foncé en gras et de fines bordures noires sur tous les côtés, puis l’applique avec formatAll et enregistre en .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
# Scénario 4 : Appliquer un seul Style à chaque cellule d'un tableau croisé dynamique en utilisant FormatAll
# API utilisée : PivotTable.FormatAll(Style)
# Format cible : .xlsx
# Référence GitHub : voir le dépôt Aspose.Cells-for-.NET — exemples de mise en forme de tableaux croisés dynamiques
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Remplir les données source : ligne d'en-tête (ligne 1) + 9 lignes de données (lignes 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)
# Ajouter un tableau croisé dynamique : plage source A1:C10, cellule de destination E3, nom "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Affecter les champs du tableau croisé dynamique : Fruit -> zone Ligne, Year -> zone Colonne, Amount -> zone Données
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Construire un Style qui sera forcé sur chaque cellule du tableau croisé dynamique
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)
# Appliquer FormatAll : force ce style unique sur chaque cellule du tableau croisé dynamique,
# écrasant tout PivotTableStyleType / PivotTableStyleName précédemment défini
pivotTable.formatAll(style)
# Enregistrer le classeur au format moderne .xlsx
workbook.save("output.xlsx")
jpype.shutdownJVM()

Quelle API de style dois-je utiliser ?

Le choix de l’API de style dépend du format de fichier dans lequel vous enregistrez. Utilisez le tableau ci-dessous comme référence rapide.

Format de fichier cible	API à utiliser	Remarques
`.xls` (hérité)	`pivotTable.setAutoFormatType(int)`	Valeurs de `com.aspose.cells.pivot.PivotTableAutoFormatType` (par exemple `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Ignoré lors de l’enregistrement dans un format moderne.
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style intégré)	`pivotTable.setPivotTableStyleType(int)`	Valeurs de `com.aspose.cells.PivotTableStyleType` (thèmes clairs/sombres, y compris les ajouts d’Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style personnalisé)	`pivotTable.setPivotTableStyleName(String)` + `tableStyles.addPivotTableStyle(String)`	À utiliser lorsque les préréglages intégrés ne suffisent pas. Configurer via `tableStyleElement.setElementStyle(Style)`.
N’importe quel format (écrasement uniforme)	`pivotTable.formatAll(Style)`	Raccourci qui écrase tout autre paramètre de style sur l’ensemble du tableau croisé dynamique.
En cas de doute, enregistrez en `.xlsx` et utilisez `setPivotTableStyleType` pour les thèmes intégrés, ou `setPivotTableStyleName` pour les thèmes personnalisés.

Pythonjava: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Ajout d’un champ à la zone de ligne ou de colonne

La méthode PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) déplace un champ de base depuis les données source vers l’une des quatre zones du tableau croisé dynamique. L’argument fieldType accepte l’une des valeurs suivantes de PivotFieldType.

ROW — champs placés verticalement à gauche
COLUMN — champs placés horizontalement en haut
DATA — champs dont les valeurs sont agrégées
PAGE — champs utilisés comme filtres de rapport Une fois les champs ajoutés, vous pouvez y accéder via les méthodes PivotTable.getRowFields() et PivotTable.getColumnFields(). Chaque méthode renvoie une PivotFieldCollection. Le champ à l’index 0 de RowFields est le champ de ligne le plus externe, et les index suivants représentent les champs imbriqués à l’intérieur. La même convention d’indexation s’applique à ColumnFields. L’ordre d’imbrication des champs est important. Ajouter Category à la zone de ligne en premier, puis Item, produit un tableau croisé dynamique dont le regroupement externe est Category et le regroupement interne est Item. Inverser l’ordre inverse la hiérarchie.

Sous-totaux des champs croisés

La méthode PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) contrôle les lignes de sous-total qui s’affichent pour un champ croisé. Chaque appel active ou désactive indépendamment un seul type de sous-total. Passer shown = true affiche le sous-total, tandis que shown = false le masque. Comme chaque appel n’affecte qu’un seul type, appeler la méthode plusieurs fois avec différentes valeurs de subtotalType permet de construire un sous-ensemble personnalisé de sous-totaux. L’énumération PivotFieldSubtotalType définit les types de sous-totaux disponibles.

AUTOMATIC — Aspose.Cells choisit la sélection par défaut (généralement SUM pour les champs numériques)
NONE — supprime toutes les lignes de sous-total
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Les sous-totaux ne s’affichent que lorsqu’il y a au moins deux champs croisés dans la zone de ligne (ou dans la zone de colonne). Un champ unique n’a rien de significatif à sous-totaliser entre les groupes, donc les appels à setSubtotals n’ont aucun effet visible dans ce cas. Cet article place donc deux champs de ligne (Category externe, Item interne) dans chaque exemple afin que la limite de sous-total entre chaque groupe Category soit visible.

Scénario 1 — Sous-totaux automatiques (par défaut)

Lorsque vous n’appelez pas du tout setSubtotals, Aspose.Cells applique la sélection AUTOMATIC aux champs numériques. L’exemple suivant confirme explicitement ce comportement en appelant setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) sur le champ de ligne externe 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()

Scénario 2 — Suppression de tous les sous-totaux (None)

Appeler setSubtotals(PivotFieldSubtotalType.NONE, true) supprime toutes les lignes de sous-total du tableau croisé dynamique, ne laissant que les lignes de champ et le total général en bas. Ceci est utile lorsque vous souhaitez obtenir les données groupées brutes sans aucune ligne de résumé.

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

Scénario 3 — Sous-ensemble de sous-totaux personnalisé (Somme + Moyenne)

Vous n’êtes pas limité à un seul type de sous-total. Chaque appel à setSubtotals opère indépendamment sur un seul type, donc appeler la méthode deux fois — une fois avec SUM et une fois avec AVERAGE — produit un sous-ensemble personnalisé de deux lignes de sous-total pour chaque groupe 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()

Récapitulatif

Les trois scénarios ci-dessus partagent le même jeu de données et la même structure de tableau croisé dynamique. La seule différence entre eux est l’appel à setSubtotals appliqué au champ de ligne externe Category. Rappelez-vous la règle des deux champs : un champ unique dans une zone n’a rien à sous-totaliser entre les groupes, donc placez toujours au moins deux champs dans la zone de ligne ou de colonne lorsque vous souhaitez que setSubtotals ait un effet visible.

Pythonjava: Champs de valeurs dans Aspose.Cells for Python via Java

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

Ajouter un champ à la zone des données

L’ajout d’un champ de base à la zone des données (valeurs) est la première étape pour façonner la manière dont un tableau croisé dynamique agrège vos données sources. Aspose.Cells expose PivotTable.addFieldToArea(PivotFieldType, string), une surcharge qui accepte la constante PivotFieldType.DATA et le nom de la colonne source. Une fois qu’un champ est ajouté à la zone des données, l’API l’expose via la collection PivotTable.DataFields, dans l’ordre dans lequel les champs ont été ajoutés. Par défaut, une colonne source numérique est synthétisée avec ConsolidationFunction.SUM, tandis qu’une colonne non numérique est définie par défaut sur COUNT.

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

Modifier la fonction de synthèse

Chaque champ placé dans la zone des données est encapsulé en interne en tant qu’instance de PivotField, et sa propriété Function renvoie une valeur de l’énumération ConsolidationFunction. Le même setter Function vous permet de basculer entre les agrégats disponibles, notamment SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STDDEV, STDDEVP, VAR et VARP.

La modification de Function n’affecte que l’agrégat, la colonne source ne change pas.

Vous pouvez donc laisser un champ de données en tant que SUM tout en ajoutant un second champ de données qui cible la même colonne source mais utilise COUNT ou AVERAGE, le tout dans un seul tableau croisé dynamique.

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

Placer les champs de valeurs sur l’axe Ligne ou Colonne

Lorsqu’un tableau croisé dynamique contient deux champs de données ou plus, Aspose.Cells expose un champ virtuel supplémentaire appelé PivotTable.ValuesField. Ce champ virtuel représente l’agrégat de chaque champ de données présent dans la zone des données. Vous pouvez le faire glisser dans la zone Ligne ou Colonne en tant que champ de base du tableau croisé dynamique, ce qui est utile pour disposer plusieurs mesures côte à côte.

PivotTable.ValuesField ne fonctionne pas s’il n’y a aucun champ de valeur ou seulement un.

Les scénarios ci-dessous présentent trois exemples de bout en bout qui démontrent chaque capacité décrite ci-dessus sur la même structure de tableau croisé dynamique.

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: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Aspose.Cells prend en charge le cycle de vie complet des champs de filtre dans les tableaux croisés dynamiques. Vous pouvez ajouter un champ de filtre via une API de haut niveau pratique ou via la collection de bas niveau page_fields, et vous pouvez piloter le filtre en mode sélection unique, le réinitialiser pour afficher chaque élément de page, ou basculer le champ vers la sélection multiple afin que les utilisateurs puissent choisir plusieurs éléments de page à la fois via l’interface à cases à cocher dans Excel.

Introduction

Un champ de filtre est un champ de tableau croisé dynamique qui contrôle quel sous-ensemble des données sources le corps du tableau croisé dynamique affiche. Les utilisateurs finaux le voient comme une liste déroulante en haut d’un tableau croisé dynamique rendu dans Excel, et la sélection de l’un des éléments de page disponibles reconstruit le corps du tableau croisé dynamique de sorte que seuls les enregistrements appartenant à cet élément de page sont résumés. Un champ de tableau croisé dynamique devient un champ de filtre lorsqu’il est enregistré en tant que PivotFieldType.PAGE plutôt que PivotFieldType.ROW, PivotFieldType.COLUMN ou PivotFieldType.DATA. Un champ de filtre peut fonctionner selon deux comportements. Dans le comportement par défaut de sélection unique, un seul élément de page est visible à la fois, de sorte que le corps du tableau croisé dynamique résume exactement un sous-ensemble. Dans le comportement de sélection multiple, le champ expose une liste de cases à cocher, et le corps du tableau croisé dynamique résume l’union de chaque élément de page coché. Le même champ source peut être basculé d’avant en arrière entre ces comportements en activant une seule propriété. Aspose.Cells for Python via Java expose deux manières équivalentes d’enregistrer un champ de filtre. L’API de haut niveau est PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName"), qui prend le nom de la colonne source et ajoute le champ en un seul appel. L’API de bas niveau est PivotTable.page_fields.add(PivotField), qui est utilisée lorsque vous détenez déjà une référence PivotField et souhaitez ajouter la même instance de champ à la zone de filtre. Les deux API finissent par alimenter la même collection page_fields, et le reste de cet article montre comment choisir entre elles et comment piloter chaque mode de filtrage.

Ajout d’un champ de filtre

Il existe deux manières d’enregistrer un champ de tableau croisé dynamique dans la zone de filtre. L’appel de haut niveau prend le nom de la colonne source sous forme de chaîne de caractères et constitue le chemin le plus courant. L’appel de bas niveau accepte une instance PivotField existante et est pratique lorsque le même objet de champ doit être réutilisé dans plusieurs zones de tableau croisé dynamique. Les deux appels placent le champ dans PivotTable.page_fields, après quoi il apparaît comme la liste déroulante de page en haut du tableau croisé dynamique rendu.

Ajout d’un champ de filtre avec add_field_to_area

L’exemple suivant construit un petit jeu de données Fruit / Année / Montant, place un tableau croisé dynamique à la cellule E3 avec Fruit sur la zone de lignes, Amount sur la zone de données et Year sur la zone de filtre, actualise le tableau croisé dynamique et enregistre le classeur.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType
# Créer un nouveau classeur
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
# Configurer la ligne d'en-tête
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Remplir 9 lignes de données d'exemple : Fruit, Année, Montant
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])
# Ajouter un tableau croisé dynamique ancré à la cellule E3
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Ajouter des champs à leurs zones : Fruit comme Ligne, Montant comme Données, Année comme Page
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# Actualiser et calculer les données du tableau croisé dynamique
pivotTable.calculateData()
# Enregistrer le classeur
workbook.save("pageFieldSample.xlsx")
jpype.shutdownJVM()

Ajout d’un champ de filtre avec page_fields.add

Lorsque vous travaillez déjà avec une instance PivotField, vous pouvez la passer directement à PivotTable.page_fields.add. Le tableau croisé dynamique et le champ de filtre sont construits exactement comme dans le scénario précédent ; seul l’enregistrement final dans la zone de filtre est remplacé par l’appel d’API de bas niveau.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotTable, PivotField, PivotFieldType
# — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
#   Scénario 1a (données Fruit/Année/Montant, tableau croisé à E3, Fruit→Ligne,
#   Montant→Données). Ci-dessous, nous obtenons le PivotField Année de la
#   collection BaseFields et le passons à PageFields.Add — l'
#   alternative de bas niveau à AddFieldToArea. Le résultat est
#   fonctionnellement identique au Scénario 1a.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# En-têtes
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
# Données d'exemple (9 lignes)
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)
# Ajouter un tableau croisé dynamique à E3 couvrant A1:C10
pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Fruit -> Ligne, Montant -> Données (Année ira à Page ci-dessous)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Approche de bas niveau : récupérer le PivotField Année existant depuis BaseFields
# et l'enregistrer dans la zone Page via PageFields.Add(PivotField).
yearField = pivotTable.getBaseFields().get("Year")
pivotTable.getPageFields().add(yearField)
# Actualiser pour que le nouveau champ de page soit reflété dans le classeur enregistré
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Filtrage à sélection unique (affichage d’un élément de page)

Dans le comportement par défaut de sélection unique, le champ de filtre est rendu sous forme de liste déroulante unique et l’entier PivotField.current_page_item sélectionne quel élément de page pilote le corps du tableau croisé dynamique. L’assignation d’un index spécifique sélectionne cet élément unique ; l’assignation de la valeur sentinelle spéciale 0x7FFD (32765 en décimal) réinitialise le filtre de sorte que chaque élément de page soit résumé simultanément. La sélection unique est le mode par défaut ; vous n’avez pas besoin de l’activer explicitement.

Affichage de tous les éléments

Définir current_page_item sur la valeur magique 0x7FFD équivaut à effacer le filtre : le corps du tableau croisé dynamique résume chaque élément de page comme si aucun filtre n’était appliqué.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Créer un nouveau classeur
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Remplir les données Fruit/Année/Montant
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])
# Créer un tableau croisé dynamique à E3
pivotTables = sheet.getPivotTables()
index = pivotTables.add("=A1:C7", "E3", "PivotTable1")
pivotTable = pivotTables.get(index)
# Configurer les champs du tableau croisé dynamique : Fruit→Ligne, Amount→Données, Year→Page
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
pivotTable.addFieldToArea(PivotFieldType.PAGE, "Year")
pivotTable.calculateData()
# Effacer le filtre de page afin que chaque élément du champ de page soit visible.
# 0x7FFD (décimal 32765) est la valeur sentinelle spéciale qui signifie "tous les éléments" —
# équivalent à sélectionner "(Tous)" dans le menu déroulant du champ de page d'Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD)
workbook.save("output.xlsx")
jpype.shutdownJVM()

Affichage d’un élément spécifique

Définir current_page_item sur un index réel sélectionne uniquement cet élément de page. L’index est la position de l’élément dans la liste triée des éléments du champ de filtre, donc par exemple 1 sélectionne le deuxième élément après le tri.

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

Filtrage à sélection multiple

Le filtrage à sélection multiple transforme la liste déroulante de page en une liste de cases à cocher et permet à l’utilisateur final de sélectionner simultanément plusieurs éléments de page. Aspose.Cells expose deux propriétés qui fonctionnent ensemble. PivotField.is_multiple_item_selection_allowed doit être défini sur True avant que l’interface de sélection multiple ne prenne effet. Une fois activée, PivotItem.is_hidden contrôle quels éléments apparaissent dans la liste de cases à cocher, de sorte que vous pouvez soit afficher tous les éléments, soit autoriser uniquement certains éléments spécifiques. Le code ci-dessous active la sélection multiple sur le même champ de filtre Year construit dans le scénario 1a, puis montre deux modèles : la partie A révèle chaque élément de page en laissant is_hidden défini sur False pour chaque entrée, tandis que la partie B n’autorise que les valeurs sources que vous choisissez et masque tout le reste via un bloc 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
# — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
#   Scénario 1a (données Fruit/Année/Montant, pivot à E3, Fruit→Ligne,
#   Montant→Données, Année→Page via AddFieldToArea).
#   Ci-dessous, nous appliquons un filtrage multi-sélection sur le champ de page.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
cells = sheet.getCells()
# Données d'exemple : Fruit | Année | Montant
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")
# — Activer la multi-sélection sur le champ de page
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(True)
# Partie A — sélectionner TOUS les éléments (rendre chaque élément visible)
pivotItems = pivotTable.getPageFields().get(0).getPivotItems()
for i in range(pivotItems.getCount()):
    pivotItems.get(i).setHidden(False)
# Partie B — sélectionner uniquement des éléments spécifiques par valeur source
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()

Remarque : Lorsque vous utilisez le filtrage à sélection multiple via PivotItem.is_hidden, au moins un PivotItem doit rester visible (is_hidden == False). Si tous les éléments sont masqués, Excel plante à l’ouverture du fichier ou rend un tableau croisé dynamique vide. Vérifiez toujours que votre liste autorisée de sélection multiple inclut au moins un élément de vos données sources.

Quelle API et quel mode dois-je utiliser ?

Le tableau ci-dessous résume quand utiliser chaque API et chaque mode afin que vous puissiez choisir la bonne combinaison sans lire chaque scénario en détail.

Scénario / Cas d’utilisation	API recommandée	Propriété utilisée	Notes
Ajouter un champ de filtre par nom de colonne source (le plus courant)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName")`	n/a	Haut niveau, une seule ligne. Utilisez ceci sauf si vous avez besoin d’une référence `PivotField`.
Ajouter un champ de filtre lorsque vous avez déjà un objet `PivotField`	`PivotTable.page_fields.add(PivotField)`	n/a	À utiliser lorsque l’objet de champ a été obtenu ailleurs ou doit être réutilisé.
Filtrer sur un seul élément de page (mode par défaut)	`PivotField.current_page_item`	définir sur un index spécifique	Par exemple, `1` affiche le deuxième élément dans la liste triée.
Afficher tous les éléments / effacer le filtre	`PivotField.current_page_item`	définir sur `0x7FFD`	La valeur magique `0x7FFD` (32765 en décimal) est la sentinelle pour « tous les éléments ».
Activer l’interface de sélection multiple dans Excel	`PivotField.is_multiple_item_selection_allowed`	définir sur `True`	Requis avant que tout appel à `is_hidden` ne prenne effet.
Masquer / afficher des éléments individuels dans une liste à sélection multiple	`PivotItem.is_hidden`	définir par élément	Au moins un élément doit rester visible (`is_hidden == False`).

N’oubliez jamais la contrainte de visibilité lors de la configuration du filtrage à sélection multiple. Si chaque PivotItem dans un champ de filtre à sélection multiple est masqué, Excel plante à l’ouverture ou rend un tableau croisé dynamique vide. Construisez votre liste autorisée à partir de vos données sources afin qu’au moins un élément reste visible, et vos classeurs enregistrés s’ouvriront de manière fiable sur chaque machine.

Documentation – Tableaux croisés dynamiques

Pythonjava: Créer un tableau croisé dynamique

Créer un tableau croisé dynamique

Pythonjava: Formatter les cellules du tableau croisé dynamique

Pythonjava: Actualiser les Tableaux Croisés Dynamiques et les caches de tableaux croisés dynamiques dans Aspose.Cells for Python via Java

Introduction

Démarrage rapide

Importations requises

Actualiser tous les Tableaux Croisés Dynamiques dans le classeur

Actualiser tous les Tableaux Croisés Dynamiques sur une seule feuille de calcul

Actualiser un seul Tableau Croisé Dynamique

Données sources modifiées — Utilisez PivotCache.refresh()

Seule la vue/la disposition a été modifiée — Utilisez calculateData()

Migration depuis l’obsolète PivotTable.refreshData()

Quelle API d’actualisation dois-je utiliser ?

Pièges courants

Pythonjava: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells for Python via Java

Introduction

Appliquer un autoformat prédéfini XLS hérité

Appliquer un style de tableau croisé dynamique nommé moderne prédéfini

Définir et appliquer un style personnalisé de tableau croisé dynamique

Appliquer un seul style à chaque cellule du tableau croisé dynamique avec FormatAll

Quelle API de style dois-je utiliser ?

Pythonjava: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

Ajout d’un champ à la zone de ligne ou de colonne

Sous-totaux des champs croisés

Scénario 1 — Sous-totaux automatiques (par défaut)

Scénario 2 — Suppression de tous les sous-totaux (None)

Scénario 3 — Sous-ensemble de sous-totaux personnalisé (Somme + Moyenne)

Récapitulatif

Pythonjava: Champs de valeurs dans Aspose.Cells for Python via Java

Ajouter un champ à la zone des données

Modifier la fonction de synthèse

Placer les champs de valeurs sur l’axe Ligne ou Colonne

Pythonjava: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

Introduction

Ajout d’un champ de filtre

Ajout d’un champ de filtre avec add_field_to_area

Ajout d’un champ de filtre avec page_fields.add

Filtrage à sélection unique (affichage d’un élément de page)

Affichage de tous les éléments

Affichage d’un élément spécifique

Filtrage à sélection multiple

Quelle API et quel mode dois-je utiliser ?

Données sources modifiées — Utilisez `PivotCache.refresh()`

Seule la vue/la disposition a été modifiée — Utilisez `calculateData()`

Migration depuis l’obsolète `PivotTable.refreshData()`