Documentation – Insérer un tableau croisé dynamique

Pythonnet: Formatage du tableau croisé dynamique

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

Apparence du tableau croisé dynamique

Comment créer un tableau croisé dynamique explique comment créer un tableau croisé dynamique simple. Cet article décrit comment personnaliser l’apparence d’un tableau croisé dynamique en définissant diverses propriétés :

Options de formatage du tableau croisé dynamique
Options de formatage des champs de tableau croisé dynamique
Options de formatage des champs de données

Comment définir les options de formatage du tableau croisé dynamique

La classe PivotTable contrôle le tableau croisé dynamique global et peut être formatée de plusieurs manières.

Comment définir le type de mise en forme automatique

Microsoft Excel propose différents formats de rapport prédéfinis. Aspose.Cells for Python via .NET prend également en charge ces options de mise en forme. Pour y accéder :

Définissez PivotTable.is_auto_format sur true.
Attribuer une option de mise en forme de l’énumération PivotTableAutoFormatType.

Comment définir les options de mise en forme

L’exemple de code ci-dessous montre comment formater le tableau croisé dynamique pour afficher les totaux généraux pour les lignes et les colonnes, et comment définir l’ordre des champs du rapport. Il montre également comment définir une chaîne personnalisée pour les valeurs nulles.

Aspect et sensation du formatage manuel

Pour formater manuellement l’aspect du rapport de table de données, au lieu d’utiliser des formats de rapport prédéfinis, utilisez les méthodes PivotTable.format_all(style) et PivotTable.format(row, column, style). Créez un objet de style pour le format souhaité, par exemple :

Comment définir les options de format de champ de table de données

La classe PivotField représente un champ dans une table de données et peut être formatée de plusieurs manières. L’exemple de code ci-dessous montre comment :

Accéder aux champs de lignes.
Définir les sous-totaux.
Définir l’autotri.
Définir l’auto-affichage.

Comment définir le format des champs de lignes/colonnes/page

Comment définir le format des champs de données

L’exemple de code ci-dessous montre comment définir les formats d’affichage et de nombres pour les champs de données.

Comment effacer les champs de table de données

La classe PivotFieldCollection possède une méthode nommée clear() qui vous permet d’effacer les champs de table de données. Utilisez-la lorsque vous voulez effacer tous les champs de table de données dans les zones, par exemple, les pages, les colonnes, les lignes ou les données. L’exemple de code ci-dessous montre comment effacer tous les champs de table de données dans une zone de données.

Pythonnet: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

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

Un tableau croisé dynamique est un résumé interactif des enregistrements. Par exemple, vous pouvez avoir des centaines d’entrées de facture dans une liste dans une feuille de calcul. Un tableau croisé dynamique peut totaliser les factures par client, produit ou date. Avec Microsoft Excel, il est possible de réarranger rapidement les informations dans le tableau croisé dynamique en faisant glisser les boutons vers une nouvelle position.

Un graphique croisé dynamique est une représentation graphique interactive des données dans un tableau croisé dynamique. Les graphiques croisés dynamiques ont été introduits dans Excel 2000. L’utilisation d’un graphique croisé dynamique rend encore plus facile la compréhension des données puisque le tableau croisé dynamique crée automatiquement des sous-totaux et des totaux.

Aspose.Cells pour Python via .NET prend en charge les tableaux croisés dynamiques et les graphiques croisés dynamiques.

Ajouter des tableaux croisés dynamiques et des graphiques à l’aide de la bibliothèque Excel Aspose.Cells pour Python

Aspose.Cells pour Python via .NET fournit un ensemble spécial de classes utilisées pour créer des tableaux croisés dynamiques. Ces classes sont utilisées pour créer et définir des objets PivotTable, qui agissent comme éléments de base des objets PivotTable :

PivotField, un champ dans un rapport de tableau croisé dynamique.
PivotFields, une collection de tous les objets PivotField dans un tableau croisé dynamique.
PivotTable, un rapport de tableau croisé dynamique sur une feuille de calcul.
PivotTables, une collection de tous les objets PivotTable sur la feuille de calcul.

Préparez-vous à utiliser Aspose.Cells pour Python via .NET

Installez Aspose.Cells for Python via .NET depuis pypi, utilisez la commande suivante : $ pip install aspose-cells-python.
Vous pouvez également suivre les instructions étape par étape sur la façon d’installer “Aspose.Cells for Python via .NET” dans votre environnement de développement.

Comment ajouter une table pivotante à l’aide de la bibliothèque Excel Aspose.Cells for Python

Pour créer une table pivotante à l’aide de Aspose.Cells for Python via .NET :

Ajoutez des données à des cellules de feuille de calcul en utilisant la méthode put_value d’un objet Cell. Vous pouvez également utiliser un fichier de modèle déjà rempli de données. Les données seront utilisées comme source de données de la table pivotante.
Ajoutez une table pivotante à la feuille de calcul en appelant la méthode add de la collection PivotTables (encapsulée dans l’objet Feuille de calcul).
Accédez au nouvel objet PivotTable depuis la collection PivotTables en passant son index. # Utilisez l’un des objets table pivotante encapsulés dans l’objet PivotTable pour gérer la table.

Des exemples de code sont donnés ci-dessous.

Comment ajouter un graphique pivotant à l’aide de la bibliothèque Excel Aspose.Cells for Python

Pour créer un graphique pivotant à l’aide de Aspose.Cells for Python via .NET :

Ajoutez un graphique.
Définissez la PivotSource du graphique pour qu’elle fasse référence à une table pivotante existante dans la feuille de calcul.
Définissez d’autres attributs.

Pythonnet: Tableau croisé dynamique et données sources

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

Données source du tableau croisé dynamique

Il arrive parfois que vous souhaitiez créer des rapports Microsoft Excel avec des tableaux croisés dynamiques prenant des données de différentes sources de données (telles qu’une base de données) qui ne sont pas connues au moment de la conception. Cet article propose une approche pour modifier dynamiquement la source de données d’un tableau croisé dynamique.

Modification des données source d’un tableau croisé dynamique

Création d’un nouveau modèle de concepteur.
1. Créez un nouveau fichier de modèle de concepteur comme sur la capture d’écran ci-dessous.
2. Ensuite, définissez une plage nommée, DataSource, qui fait référence à cette plage de cellules.
  
  Création d’un modèle de concepteur et définition d’une plage nommée, DataSource

Création d’un tableau croisé dynamique basé sur cette plage nommée.
1. Dans Microsoft Excel, choisissez Données, puis Tableau croisé dynamique et Rapport de tableau croisé dynamique.
2. Créez un tableau croisé dynamique basé sur la plage nommée créée à l’étape précédente.
  
  Création d’un tableau croisé dynamique basé sur la plage nommée, DataSource

Faites glisser le champ correspondant pour le placer dans les colonnes et les lignes du tableau croisé dynamique, puis créez le tableau croisé dynamique résultant comme sur la capture d’écran ci-dessous.

Création d’un tableau croisé dynamique basé sur un champ correspondant

Cliquez avec le bouton droit sur le tableau croisé dynamique et sélectionnez Options de tableau.
1. Cochez Actualiser à l’ouverture dans les paramètres Options de données.
  
  Configuration des options de tableau croisé dynamique

Maintenant, vous pouvez enregistrer ce fichier en tant que fichier de modèle de concepteur.

Remplir de nouvelles données et changer les données source d’un tableau croisé dynamique.
1. Une fois que le modèle de concepteur est créé, utilisez le code suivant pour changer les données source du tableau croisé dynamique.

L’exécution du code d’exemple ci-dessous modifie les données source du tableau croisé dynamique.

Pythonnet: Ajouter un champ calculé dans le tableau croisé dynamique

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

Scénarios d’utilisation possibles

Lorsque vous créez un tableau croisé dynamique basé sur des données connues, vous constatez que les données qui s’y trouvent ne correspondent pas à ce que vous souhaitez. Les données que vous souhaitez sont la combinaison de ces données d’origine. Par exemple, vous devez ajouter, soustraire, multiplier et diviser les données d’origine avant de les vouloir. À ce moment-là, vous devez construire un champ calculé et définir la formule correspondante pour le calcul. Ensuite, effectuez des statistiques et d’autres opérations sur le champ calculé.

Comment ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Insérer un champ calculé dans un tableau croisé dynamique dans Excel, suivez ces étapes :

Sélectionnez le tableau croisé dynamique auquel vous souhaitez ajouter un champ calculé.
Accédez à l’onglet Analyse du tableau croisé dynamique dans le ruban.
Cliquez sur “Champs, éléments et ensembles” puis sélectionnez “Champ calculé” dans le menu déroulant.
Dans le champ “Nom”, entrez un nom pour le champ calculé.
Dans le champ “Formule”, entrez la formule du calcul que vous souhaitez effectuer en utilisant les noms de champ appropriés du tableau croisé dynamique et les opérateurs mathématiques.
Cliquez sur “OK” pour créer le champ calculé.
Le nouveau champ calculé apparaîtra dans la liste des champs du tableau croisé dynamique sous la section “Valeurs”.
Faites glisser le champ calculé dans la section Valeurs du tableau croisé dynamique pour afficher les valeurs calculées.

Comment ajouter un champ calculé dans un tableau croisé dynamique en utilisant la bibliothèque Excel Aspose.Cells pour Python

Ajoutez un champ calculé au fichier Excel en utilisant Aspose.Cells pour Python via .NET. Veuillez consulter le code d’exemple suivant. Après avoir exécuté le code d’exemple, un tableau croisé dynamique avec un champ calculé est ajouté à la feuille de calcul.

Définissez les données d’origine et créez un tableau croisé dynamique.
Créez le champ calculé en fonction du PivotField existant dans le tableau croisé dynamique.
Ajoutez le champ calculé à la zone de données.
Enfin, enregistrez le classeur au format XLSX de sortie.

Code d’exemple

Pythonnet: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

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

Aspose.Cells prend en charge l’application des autoformats hérités pour les tableaux croisés dynamiques (destinés aux fichiers .xls) ainsi que des styles nommés modernes ou personnalisés pour les tableaux croisés dynamiques (destinés aux fichiers .xlsx, .xlsm et .xlsb). L’API à 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é à partir d’un fichier .xls peut être réenregistré au format .xlsx, et dans ce cas l’API de style moderne s’applique plutôt que celle héritée.

Pour la sortie au format .xls hérité, utilisez la propriété PivotTable.auto_format_type conjointement avec l’énumération aspose.cells.pivot.PivotTableAutoFormatType. Cette API correspond au sélecteur d’autoformat que la version classique d’Excel proposait pour les tableaux croisés dynamiques.

Pour les sorties modernes .xlsx, .xlsm et .xlsb, deux variantes d’API de style sont disponibles :

PivotTable.pivot_table_style_type sélectionne l’un des styles nommés intégrés (thèmes clairs et sombres, y compris les styles ajoutés dans Excel 2017). Ces préréglages sont en lecture seule.
PivotTable.pivot_table_style_name sélectionne un style personnalisé que vous définissez vous-même via workbook.worksheets.table_styles.add_pivot_table_style(...). Les styles personnalisés sont nécessaires lorsque vous souhaitez modifier les couleurs, les bordures ou les polices au-delà de ce que les préréglages offrent.

De plus, PivotTable.format_all(Style) est un raccourci qui applique un seul objet Style à chaque cellule du tableau croisé dynamique, écrasant tout ce qui a été défini via l’une des API de nom de style ci-dessus. Cela est utile lorsqu’une apparence uniforme est requise indépendamment du thème sous-jacent.

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

PivotTable.auto_format_type accepte une valeur de l’énumération aspose.cells.pivot.PivotTableAutoFormatType. Les valeurs disponibles sont REPORT_1 à REPORT_10, CLASSIC, et TABLE_1 à TABLE_10.

auto_format_type n’est pris en compte que lorsque le classeur est enregistré au format .xls. Lorsque le même classeur est enregistré au format .xlsx, .xlsm ou .xlsb, Excel ignore cette propriété et se rabat sur les paramètres pivot_table_style_type et pivot_table_style_name.

L’exemple suivant charge un nouveau classeur, remplit les données d’exemple Fruit/Année/Montant, ajoute un tableau croisé dynamique, applique PivotTableAutoFormatType.REPORT_5 et enregistre le résultat au format .xls.

Pourquoi pas de champs de colonne ? Les autoformats de la série Report (Report1 à Report10, Table1 à Table10) ont été conçus dans Excel classique pour des tableaux croisés dynamiques à une dimension avec uniquement des champs de ligne et des valeurs — ils n’ont pas de style intégré pour les en-têtes de champs de colonne. Si votre tableau croisé dynamique nécessite des champs de colonne, utilisez plutôt les préréglages modernes PivotTableStyleType du Scénario 2 ci-dessous, qui sont conçus pour la disposition bidimensionnelle qu’utilise Excel moderne.

import aspose.cells as ac

# Scénario 1 : Appliquer un autoformat prédéfini XLS existant
# API utilisée : PivotTable.AutoFormatType
# Format de fichier cible : .xls (ancien)
# Pour des exemples complets et des fichiers de données, veuillez consulter https://github.com/aspose-cells/Aspose.Cells-for-.NET

# Créer un nouveau classeur
workbook = ac.Workbook()

# Obtenir la première feuille de calcul
sheet = workbook.worksheets[0]

# Remplir les données source avec une ligne d'en-tête (Fruit, Year, Amount)
# et 9 lignes de données couvrant raisin, myrtille, kiwi, cerise sur 2020 et 2021
sheet.cells[0, 0].put_value("Fruit")
sheet.cells[0, 1].put_value("Year")
sheet.cells[0, 2].put_value("Amount")

sheet.cells[1, 0].put_value("grape")
sheet.cells[1, 1].put_value(2020)
sheet.cells[1, 2].put_value(50)

sheet.cells[2, 0].put_value("blueberry")
sheet.cells[2, 1].put_value(2020)
sheet.cells[2, 2].put_value(30)

sheet.cells[3, 0].put_value("kiwi")
sheet.cells[3, 1].put_value(2020)
sheet.cells[3, 2].put_value(25)

sheet.cells[4, 0].put_value("cherry")
sheet.cells[4, 1].put_value(2020)
sheet.cells[4, 2].put_value(40)

sheet.cells[5, 0].put_value("grape")
sheet.cells[5, 1].put_value(2021)
sheet.cells[5, 2].put_value(60)

sheet.cells[6, 0].put_value("blueberry")
sheet.cells[6, 1].put_value(2021)
sheet.cells[6, 2].put_value(35)

sheet.cells[7, 0].put_value("kiwi")
sheet.cells[7, 1].put_value(2021)
sheet.cells[7, 2].put_value(28)

sheet.cells[8, 0].put_value("cherry")
sheet.cells[8, 1].put_value(2021)
sheet.cells[8, 2].put_value(45)

sheet.cells[9, 0].put_value("grape")
sheet.cells[9, 1].put_value(2020)
sheet.cells[9, 2].put_value(45)

# Ajouter un tableau croisé dynamique à la cellule de destination E3, nommé "Pivot1", en utilisant la plage source A1:C10
pivot_index = sheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = sheet.pivot_tables[pivot_index]

# Affecter les champs : Fruit -> Lignes, Year -> Colonnes, Amount -> Données
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Appliquer l'autoformat prédéfini XLS existant "Report5"
# Remarque : Cette propriété n'a de sens que lors de l'enregistrement au format .xls.
# Lors de l'enregistrement au format .xlsx/.xlsm/.xlsb, Excel ignore AutoFormatType
# et utilise ce que spécifient PivotTableStyleType / PivotTableStyleName.
pivot_table.auto_format_type = ac.PivotTableAutoFormatType.REPORT5

# Enregistrer le classeur au format .xls existant
workbook.save("output.xls")

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

PivotTable.pivot_table_style_type accepte une valeur de l’énumération aspose.cells.PivotTableStyleType. L’énumération couvre les thèmes clairs PIVOT_TABLE_STYLE_LIGHT_1 à PIVOT_TABLE_STYLE_LIGHT_28 et les thèmes sombres PIVOT_TABLE_STYLE_DARK_1 à PIVOT_TABLE_STYLE_DARK_28. Les styles ajoutés dans Excel 2017 (la deuxième vague de thèmes clairs et sombres) sont accessibles via la même énumération.

Il s’agit de l’API recommandée pour tout format de fichier moderne. Contrairement à l’autoformat hérité, le style sélectionné ici est rendu fidèlement par Excel et survit aux aller-retours avec d’autres outils Office.

L’exemple suivant utilise les mêmes données Fruit/Année/Montant, crée un tableau croisé dynamique identique, applique PIVOT_TABLE_STYLE_DARK_1 et enregistre le classeur au format .xlsx.

import aspose.cells as ac

# Scénario 2 : Appliquer un style prédéfini nommé moderne d'Excel 2007+ en utilisant PivotTableStyleType.
# Format de fichier cible : .xlsx. L'énumération PivotTableStyleType se trouve dans l'espace de noms Aspose.Cells
# (pas dans Aspose.Cells.Pivot) — c'est pourquoi nous n'avons pas besoin d'un using supplémentaire pour cela.
# Référence GitHub : https://github.com/aspose-cells/Aspose.Cells-for-.NET/blob/master/Examples/CSharp/PivotTables/ApplyStyleToPivotTable2.cs

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Ligne d'en-tête : Fruit / Année / Montant
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# 9 lignes de données de Fruit / Année / Montant
worksheet.cells["A2"].put_value("Grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(100)

worksheet.cells["A3"].put_value("Blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(150)

worksheet.cells["A4"].put_value("Kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(200)

worksheet.cells["A5"].put_value("Cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(180)

worksheet.cells["A6"].put_value("Grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(120)

worksheet.cells["A7"].put_value("Blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(170)

worksheet.cells["A8"].put_value("Kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(210)

worksheet.cells["A9"].put_value("Cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(190)

worksheet.cells["A10"].put_value("Grape")
worksheet.cells["B10"].put_value(2021)
worksheet.cells["C10"].put_value(130)

# Ajouter un tableau croisé dynamique en E3 nommé "Pivot1", provenant de A1:C10
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Assigner les champs du tableau croisé dynamique : Fruit -> Zone de ligne, Année -> Zone de colonne, Montant -> Zone de données
pivot_table.add_field_to_area(ac.PivotFieldType.Row, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.Column, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.Data, "Amount")

# Appliquer un style de tableau croisé dynamique prédéfini nommé moderne d'Excel 2007+.
# PivotTableStyleType est l'API correcte pour les fichiers .xlsx / .xlsm / .xlsb ; AutoFormatType
# est ignoré par Excel pour ces formats. PivotTableStyleDark1 appartient à la famille
# des thèmes sombres (PivotTableStyleDark1..PivotTableStyleDark28), et la même énumération expose également les
# thèmes plus récents d'Excel 2017 clairs/sombres (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivot_table.pivot_table_style_type = ac.PivotTableStyleType.PivotTableStyleDark1

# Enregistrer en tant que .xlsx moderne — c'est le format pour lequel PivotTableStyleType est significatif.
workbook.save("output.xlsx")

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

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 de tableau croisé dynamique personnalisé. Le flux de travail comporte trois étapes :

Ajoutez un style personnalisé à la collection table_styles du classeur via workbook.worksheets.table_styles.add_pivot_table_style(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 table_style.table_style_elements.add(TableStyleElementType), puis affectez un Style à chaque élément via table_style_element.set_element_style(Style).
Appliquez le style personnalisé au tableau croisé dynamique en définissant PivotTable.pivot_table_style_name sur le nom du style. N’utilisez pas pivot_table_style_type ici, car cette propriété sélectionne les préréglages intégrés.

pivot_table_style_name et pivot_table_style_type ne sont pas interchangeables. Utilisez pivot_table_style_type pour les préréglages intégrés, et pivot_table_style_name pour les styles personnalisés que vous avez définis via add_pivot_table_style. Définir les deux est sans danger, mais seul celui correspondant à la source prévue est rendu.

Les valeurs TableStyleElementType disponibles 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 de tableau croisé dynamique personnalisé avec une bordure noire fine sur WHOLE_TABLE et une police rouge en gras sur GRAND_TOTAL_ROW, puis l’applique via pivot_table_style_name et enregistre au format .xlsx.

import aspose.cells as ac
import System.Drawing

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Remplir les données sources : ligne d'en-tête + 9 lignes de données (A1:C10)
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

worksheet.cells["A2"].put_value("Grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(100)

worksheet.cells["A3"].put_value("Blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(200)

worksheet.cells["A4"].put_value("Kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(300)

worksheet.cells["A5"].put_value("Cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(400)

worksheet.cells["A6"].put_value("Grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(500)

worksheet.cells["A7"].put_value("Blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(600)

worksheet.cells["A8"].put_value("Kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(700)

worksheet.cells["A9"].put_value("Cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(800)

worksheet.cells["A10"].put_value("Grape")
worksheet.cells["B10"].put_value(2021)
worksheet.cells["C10"].put_value(900)

# Ajouter un tableau croisé dynamique à partir de A1:C10, ancré à E3, nommé "Pivot1"
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Étape 1 : enregistrer un nouveau style de tableau croisé dynamique personnalisé et capturer son index
style_index = workbook.worksheets.table_styles.add_pivot_table_style("CustomPivotStyle")
table_style = workbook.worksheets.table_styles[style_index]

# Étape 2 : ajouter un élément WholeTable et appliquer des bordures noires fines sur les quatre côtés
whole_table_element_index = table_style.table_style_elements.add(ac.TableStyleElementType.WHOLE_TABLE)
whole_table_element = table_style.table_style_elements[whole_table_element_index]
whole_table_style = workbook.create_style()
whole_table_style.borders[ac.BorderType.TOP_BORDER].line_style = ac.CellBorderType.THIN
whole_table_style.borders[ac.BorderType.TOP_BORDER].color = System.Drawing.Color.Black
whole_table_style.borders[ac.BorderType.BOTTOM_BORDER].line_style = ac.CellBorderType.THIN
whole_table_style.borders[ac.BorderType.BOTTOM_BORDER].color = System.Drawing.Color.Black
whole_table_style.borders[ac.BorderType.LEFT_BORDER].line_style = ac.CellBorderType.THIN
whole_table_style.borders[ac.BorderType.LEFT_BORDER].color = System.Drawing.Color.Black
whole_table_style.borders[ac.BorderType.RIGHT_BORDER].line_style = ac.CellBorderType.THIN
whole_table_style.borders[ac.BorderType.RIGHT_BORDER].color = System.Drawing.Color.Black
whole_table_element.set_element_style(whole_table_style)

# Étape 3 : ajouter un élément GrandTotalRow et appliquer une police rouge en gras
grand_total_element_index = table_style.table_style_elements.add(ac.TableStyleElementType.GRAND_TOTAL_ROW)
grand_total_element = table_style.table_style_elements[grand_total_element_index]
grand_total_style = workbook.create_style()
grand_total_style.font.is_bold = True
grand_total_style.font.color = System.Drawing.Color.Red
grand_total_element.set_element_style(grand_total_style)

# Étape 4 : appliquer le style personnalisé par nom (PAS par PivotTableStyleType, qui est pour les préréglages intégrés)
pivot_table.pivot_table_style_name = "CustomPivotStyle"

workbook.save("output.xlsx")

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

PivotTable.format_all(Style) est un raccourci qui applique un seul 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 a été précédemment défini via pivot_table_style_type ou pivot_table_style_name est écrasé.

format_all écrase à la fois pivot_table_style_type et pivot_table_style_name. Utilisez-le uniquement lorsqu’une apparence uniforme, 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 des bordures noires fines sur tous les côtés, puis l’applique avec format_all et enregistre au format .xlsx.

from System.Drawing import Color
import aspose.cells as ac
from aspose.cells.pivot import PivotFieldType
from aspose.cells import BackgroundType, CellBorderType, BorderType

# Scénario 4 : Appliquer un seul Style à chaque cellule de 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 tableau croisé dynamique

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Remplir les données sources : ligne d'en-tête (ligne 1) + 9 lignes de données (lignes 2-10)
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

worksheet.cells["A2"].put_value("Grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(5000)

worksheet.cells["A3"].put_value("Blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(3000)

worksheet.cells["A4"].put_value("Kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(4000)

worksheet.cells["A5"].put_value("Cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(2000)

worksheet.cells["A6"].put_value("Grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(6000)

worksheet.cells["A7"].put_value("Blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(3500)

worksheet.cells["A8"].put_value("Kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(4500)

worksheet.cells["A9"].put_value("Cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(2500)

worksheet.cells["A10"].put_value("Grape")
worksheet.cells["B10"].put_value(2021)
worksheet.cells["C10"].put_value(5500)

# Ajouter un tableau croisé dynamique : plage source A1:C10, cellule de destination E3, nom "Pivot1"
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Assigner les champs du tableau croisé dynamique : Fruit -> zone Lignes, Year -> zone Colonnes, Amount -> zone Données
pivot_table.add_field_to_area(PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(PivotFieldType.DATA, "Amount")

# Construire un Style qui sera appliqué de force sur chaque cellule du tableau croisé dynamique
style = workbook.create_style()
style.foreground_color = Color.Yellow
style.pattern = BackgroundType.SOLID
style.font.is_bold = True
style.font.color = Color.DarkBlue
style.borders[BorderType.TOP_BORDER].line_style = CellBorderType.THIN
style.borders[BorderType.TOP_BORDER].color = Color.Black
style.borders[BorderType.BOTTOM_BORDER].line_style = CellBorderType.THIN
style.borders[BorderType.BOTTOM_BORDER].color = Color.Black
style.borders[BorderType.LEFT_BORDER].line_style = CellBorderType.THIN
style.borders[BorderType.LEFT_BORDER].color = Color.Black
style.borders[BorderType.RIGHT_BORDER].line_style = CellBorderType.THIN
style.borders[BorderType.RIGHT_BORDER].color = Color.Black

# Appliquer FormatAll : force ce style unique sur chaque cellule du tableau croisé dynamique,
# écrasant tout PivotTableStyleType / PivotTableStyleName précédemment défini
pivot_table.format_all(style)

# Enregistrer le classeur au format moderne .xlsx
workbook.save("output.xlsx")

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	Notes
`.xls` (hérité)	`PivotTable.auto_format_type`	Valeurs de `aspose.cells.pivot.PivotTableAutoFormatType` (par ex. `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Ignoré lors de l’enregistrement dans des formats modernes.
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style intégré)	`PivotTable.pivot_table_style_type`	Valeurs de `aspose.cells.PivotTableStyleType` (thèmes clairs/sombres, y compris les ajouts d’Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style personnalisé)	`PivotTable.pivot_table_style_name` + `worksheets.table_styles.add_pivot_table_style(...)`	À utiliser lorsque les préréglages intégrés ne suffisent pas. Configurez via `table_style_element.set_element_style(...)`.
Tout format (substitution uniforme)	`PivotTable.format_all(Style)`	Raccourci qui écrase tous les autres paramètres de style sur l’ensemble du tableau croisé dynamique.

En cas de doute, enregistrez au format .xlsx et utilisez pivot_table_style_type pour les thèmes intégrés, ou pivot_table_style_name pour les thèmes personnalisés.

Pythonnet: Refreshing Pivot Tables in Aspose.Cells for Python via .NET

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 tableaux croisés dynamiques à quatre portées différentes — du classeur entier jusqu’à un seul tableau croisé dynamique. À partir de Aspose.Cells for Python via .NET v26.7, la méthode héritée PivotTable.refresh_data() est marquée comme obsolète et doit être remplacée par les API plus efficaces, prenant en charge le cache, décrites dans cet article.

Introduction

L’actualisation d’un tableau croisé dynamique est rarement une opération unique. En arrière-plan, Aspose.Cells maintient une chaîne de données en couches qui connecte 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 pour toute 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ù résident 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, de colonne, de valeur et de filtre. Un PivotTable lit uniquement depuis son PivotCache, jamais directement depuis la source de données.
Cellules — les Cells de la feuille de calcul dans lesquelles le PivotTable rend ses valeurs calculées et ses styles.

Un concept particulièrement important est le cache partagé. Lorsque plusieurs tableaux croisés dynamiques dans un classeur font référence à la même plage source, ils partagent une seule instance de PivotCache. Un seul PivotCache peut être référencé par de nombreux tableaux croisés dynamiques, et l’actualisation de ce cache actualise chaque PivotTable dépendant en une seule fois.

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

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

PivotCache.refresh() — recharge la source vers le cache ET recalcule tous les PivotTable dépendants en une seule opération.
PivotTable.calculate_data() — 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, le type de source est donc Sheet et les opérations d’actualisation se comportent comme décrit.

Imports requis

Tous les exemples Python de cet article commencent par les trois instructions d’importation suivantes, car les types de tableaux croisés dynamiques se trouvent dans l’espace de noms aspose.cells.pivot :

import sys
import aspose.cells
import aspose.cells.pivot

Actualiser tous les tableaux croisés dynamiques du 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.refresh_all(). Un seul appel parcourt tout le classeur — actualisant chaque PivotCache depuis sa source, puis recalculant chaque PivotTable dépendant. C’est l’approche recommandée pour les actualisations générales de documents complets où la performance n’est pas un souci.

L’exemple suivant crée un classeur avec une plage source Fruit/Year/Amount, crée un tableau croisé dynamique, modifie certaines valeurs sources, puis utilise refresh_all() pour tout mettre à jour en un seul appel.

import aspose.cells as ac

# Créer un nouveau classeur
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Écrire la ligne d'en-tête dans les cellules A1:C1
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Écrire les lignes de données dans les cellules A2:C9 (8 lignes de données sur les fruits pour 2020 et 2021)
worksheet.cells["A2"].put_value("grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(50)

worksheet.cells["A3"].put_value("blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(60)

worksheet.cells["A4"].put_value("kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(70)

worksheet.cells["A5"].put_value("cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(80)

worksheet.cells["A6"].put_value("grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(90)

worksheet.cells["A7"].put_value("blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(100)

worksheet.cells["A8"].put_value("kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(110)

worksheet.cells["A9"].put_value("cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(120)

# Ajouter un tableau croisé dynamique : plage source "A1:C9", cellule de destination "E3", nom "Pivot1"
pivot_index = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Affecter les champs du tableau croisé dynamique : Fruit aux Lignes, Année aux Colonnes, Montant aux Données
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Modifier plusieurs valeurs de Montant dans les données source pour simuler des changements
worksheet.cells["C2"].put_value(55)
worksheet.cells["C5"].put_value(85)
worksheet.cells["C9"].put_value(125)

# Actualiser tous les tableaux croisés dynamiques / caches de tableau croisé dynamique dans le classeur
workbook.refresh_all()

# Enregistrer le classeur
workbook.save("output.xlsx")

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Parfois, vous avez uniquement besoin d’actualiser les tableaux croisés dynamiques qui se trouvent sur une feuille de calcul spécifique — par exemple, lorsque les tableaux croisés dynamiques sur d’autres feuilles de calcul ne sont pas liés et ne doivent pas être touchés. Dans ce cas, Aspose.Cells fournit Worksheet.refresh_pivot_tables(), qui est limité à une seule instance de Worksheet.

C’est plus sélectif que Workbook.refresh_all() : seuls les tableaux croisés dynamiques de la feuille de calcul ciblée sont actualisés, laissant intacts les tableaux croisés dynamiques des autres feuilles de calcul.

L’exemple suivant remplit les mêmes données sources Fruit/Year/Amount, ajoute un tableau croisé dynamique sur la première feuille de calcul, modifie certaines valeurs sources, puis actualise uniquement les tableaux croisés dynamiques de cette feuille de calcul.

import aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

worksheet.cells["A2"].put_value("grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(100)

worksheet.cells["A3"].put_value("blueberry")
worksheet.cells["B3"].put_value(2021)
worksheet.cells["C3"].put_value(150)

worksheet.cells["A4"].put_value("kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(200)

worksheet.cells["A5"].put_value("cherry")
worksheet.cells["B5"].put_value(2021)
worksheet.cells["C5"].put_value(120)

worksheet.cells["A6"].put_value("grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(180)

worksheet.cells["A7"].put_value("blueberry")
worksheet.cells["B7"].put_value(2020)
worksheet.cells["C7"].put_value(130)

worksheet.cells["A8"].put_value("kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(220)

worksheet.cells["A9"].put_value("cherry")
worksheet.cells["B9"].put_value(2020)
worksheet.cells["C9"].put_value(140)

pivot_index = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

worksheet.cells["C2"].put_value(300)
worksheet.cells["C5"].put_value(250)
worksheet.cells["C9"].put_value(400)

worksheet.refresh_pivot_tables()

workbook.save("output.xlsx")

Actualiser un seul tableau croisé dynamique

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

Les données sources ont changé — Utilisez `PivotCache.refresh()`

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

Parce que les tableaux croisés dynamiques partagent une seule instance de PivotCache, l’appel de PivotCache.refresh() recalcule tous les tableaux croisés dynamiques construits sur ce même cache — pas seulement celui que vous référencez. Si deux tableaux croisés dynamiques partagent la même plage source, l’actualisation d’un seul cache les actualise tous les deux.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source pour démontrer ce comportement de cache partagé, modifie certaines valeurs sources, puis actualise via une seule référence de cache.

import aspose.cells as ac

# Créer un nouveau classeur et accéder à la première feuille de calcul
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Écrire la ligne d'en-tête : Fruit / Année / Montant
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Écrire environ 9 lignes de données (raisin / myrtille / kiwi / cerise sur 2020-2021)
worksheet.cells["A2"].put_value("Grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(100)

worksheet.cells["A3"].put_value("Blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(200)

worksheet.cells["A4"].put_value("Kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(300)

worksheet.cells["A5"].put_value("Cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(400)

worksheet.cells["A6"].put_value("Grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(500)

worksheet.cells["A7"].put_value("Blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(600)

worksheet.cells["A8"].put_value("Kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(700)

worksheet.cells["A9"].put_value("Cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(800)

# Ajouter le premier tableau croisé dynamique "Pivot1" ancré à la cellule E3, plage source A1:C9
pivotIndex1 = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivotTable1 = worksheet.pivot_tables[pivotIndex1]

# Assigner les champs pour Pivot1
pivotTable1.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivotTable1.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivotTable1.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Ajouter un SECOND tableau croisé dynamique "Pivot2" ancré à E15 en utilisant la MÊME plage source A1:C9
# Pivot1 et Pivot2 partagent un seul PivotCache car la plage source est identique.
pivotIndex2 = worksheet.pivot_tables.add("A1:C9", "E15", "Pivot2")
pivotTable2 = worksheet.pivot_tables[pivotIndex2]

# Assigner les mêmes champs pour Pivot2
pivotTable2.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivotTable2.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivotTable2.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Modifier plusieurs valeurs de cellules Montant dans les données source pour simuler un changement de données
worksheet.cells["C2"].put_value(150)
worksheet.cells["C4"].put_value(350)
worksheet.cells["C7"].put_value(650)

# Rafraîchir le PivotCache partagé.
# Parce que Pivot1 et Pivot2 partagent le même PivotCache, cet unique appel
# rafraîchit LES DEUX tableaux croisés dynamiques (données + style) à partir de la source mise à jour.
pivotTable1.pivot_cache.refresh()

# Enregistrer le classeur
workbook.save("output.xlsx")

Seuls l’affichage/la mise en page ont changé — Utilisez `calculate_data()`

Si les données sources n’ont pas changé mais que seuls les paramètres d’affichage ou de mise en page du tableau croisé dynamique ont été modifiés (par exemple, un champ a été déplacé vers une autre zone, ou un paramètre d’actualisation à l’ouverture a été basculé), il n’est pas nécessaire de retourner à la source de données. Le cache contient déjà les bonnes données ; seul le PivotTable rendu nécessite un recalcul. Dans ce cas, pivot_table.calculate_data() est le bon choix.

Cela évite la récupération de source inutile et est nettement plus rapide lorsque de nombreux tableaux croisés dynamiques partagent le même cache.

L’exemple suivant modifie une propriété non source du tableau croisé dynamique, puis appelle calculate_data() pour le restituer à partir du cache existant.

import aspose.cells as ac
import aspose.cells.pivot as acp

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Écrire la ligne d'en-tête Fruit / Année / Montant
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Écrire 8 lignes de données (lignes 2-9, correspondant à la plage source A1:C9)
worksheet.cells["A2"].put_value("Grape")
worksheet.cells["B2"].put_value(2020)
worksheet.cells["C2"].put_value(100)

worksheet.cells["A3"].put_value("Blueberry")
worksheet.cells["B3"].put_value(2020)
worksheet.cells["C3"].put_value(200)

worksheet.cells["A4"].put_value("Kiwi")
worksheet.cells["B4"].put_value(2020)
worksheet.cells["C4"].put_value(300)

worksheet.cells["A5"].put_value("Cherry")
worksheet.cells["B5"].put_value(2020)
worksheet.cells["C5"].put_value(400)

worksheet.cells["A6"].put_value("Grape")
worksheet.cells["B6"].put_value(2021)
worksheet.cells["C6"].put_value(150)

worksheet.cells["A7"].put_value("Blueberry")
worksheet.cells["B7"].put_value(2021)
worksheet.cells["C7"].put_value(250)

worksheet.cells["A8"].put_value("Kiwi")
worksheet.cells["B8"].put_value(2021)
worksheet.cells["C8"].put_value(350)

worksheet.cells["A9"].put_value("Cherry")
worksheet.cells["B9"].put_value(2021)
worksheet.cells["C9"].put_value(450)

# Ajouter un tableau croisé dynamique nommé "Pivot1" placé à la cellule de destination E3, avec comme source A1:C9
pivot_index = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Affecter les champs : Fruit à Ligne, Année à Colonne, Montant à Données
pivot_table.add_field_to_area(acp.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(acp.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(acp.PivotFieldType.DATA, "Amount")

# Modifier une propriété d'affichage/de mise en page — il s'agit d'une modification de présentation uniquement,
# elle ne nécessite PAS de relire les données source via PivotCache.Refresh().
pivot_table.refresh_data_on_opening_file = False

# CalculateData() restitue l'affichage de CE tableau croisé dynamique (données + style) à partir des
# données déjà conservées 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.
pivot_table.calculate_data()

# Enregistrer le classeur sur le disque
workbook.save("output.xlsx")

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

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 du cache partagé — utilisez PivotCache.get_pivot_tables(). Cette méthode renvoie la collection de chaque PivotTable qui dépend du cache donné.

C’est également le moyen le plus direct de confirmer que deux tableaux croisés dynamiques partagent bien la même instance de PivotCache : vous pouvez comparer les références de cache, ou simplement itérer la collection renvoyée par get_pivot_tables() et observer quels tableaux croisés dynamiques y apparaissent.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source, vérifie qu’ils partagent la même instance de cache, puis énumère les tableaux croisés dynamiques du cache.

Migration depuis la méthode obsolète `PivotTable.refresh_data()`

Avant Aspose.Cells for Python via .NET v26.7, la façon standard d’actualiser un tableau croisé dynamique était d’appeler PivotTable.refresh_data() sur chaque tableau croisé dynamique individuellement. À partir de v26.7, cette méthode est marquée comme obsolète et doit être remplacée par les API basées sur le cache décrites ci-dessus.

Il y a deux raisons pour lesquelles l’approche refresh_data() par table est problématique dans les classeurs du monde réel :

Elle récupère à nouveau les données depuis la source à chaque appel, même lorsque la source n’a pas changé.
Chaque appel actualise l’ensemble du cache partagé. Lorsque de nombreux tableaux croisés dynamiques partagent un cache, l’appel répété de refresh_data() par tableau croisé dynamique provoque la récupération répétée du même cache encore et encore, ce qui est très lent.

Les remplacements recommandés sont :

Actualiser TOUS les tableaux croisés dynamiques du classeur → utilisez workbook.refresh_all();
Actualiser CERTAINS d’entre eux → utilisez pivot_table.pivot_cache.refresh(); pour un cache. Parce que le cache est partagé, cet appel unique met à jour chaque tableau croisé dynamique construit au-dessus de ce cache. Les autres tableaux croisés dynamiques qui reposent sur un cache déjà actualisé peuvent être ignorés en toute sécurité.
Seuls l’affichage/la mise en page du tableau croisé ont changé → utilisez pivot_table.calculate_data(); pour restituer à partir du cache existant sans aucun aller-retour vers la source.

L’exemple suivant illustre le nouveau modèle efficace pour les classeurs comportant plusieurs tableaux croisés dynamiques partageant un seul cache.

import aspose.cells as ac

# Créer un nouveau classeur et accéder à la première feuille de calcul
workbook = ac.Workbook()
sheet = workbook.worksheets[0]

# --- Construire les données source : Fruit / Année / Montant (en-tête + 9 lignes) ---
sheet.cells["A1"].put_value("Fruit")
sheet.cells["B1"].put_value("Year")
sheet.cells["C1"].put_value("Amount")

sheet.cells["A2"].put_value("Grape")      ; sheet.cells["B2"].put_value(2020); sheet.cells["C2"].put_value(1000)
sheet.cells["A3"].put_value("Blueberry")  ; sheet.cells["B3"].put_value(2020); sheet.cells["C3"].put_value(2000)
sheet.cells["A4"].put_value("Kiwi")       ; sheet.cells["B4"].put_value(2020); sheet.cells["C4"].put_value(1500)
sheet.cells["A5"].put_value("Cherry")     ; sheet.cells["B5"].put_value(2020); sheet.cells["C5"].put_value(2500)
sheet.cells["A6"].put_value("Grape")      ; sheet.cells["B6"].put_value(2021); sheet.cells["C6"].put_value(3000)
sheet.cells["A7"].put_value("Blueberry")  ; sheet.cells["B7"].put_value(2021); sheet.cells["C7"].put_value(1800)
sheet.cells["A8"].put_value("Kiwi")       ; sheet.cells["B8"].put_value(2021); sheet.cells["C8"].put_value(2200)
sheet.cells["A9"].put_value("Cherry")     ; sheet.cells["B9"].put_value(2021); sheet.cells["C9"].put_value(2700)

# --- Ajouter le premier tableau croisé dynamique (Pivot1) à la cellule de destination E3 ---
idx1 = sheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table1 = sheet.pivot_tables[idx1]
pivot_table1.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table1.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table1.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# --- Ajouter le SECOND tableau croisé dynamique (Pivot2) sur la MÊME plage source ---
# Pivot1 et Pivot2 partagent UN SEUL PivotCache sous-jacent.
# C'est exactement le scénario où l'approche héritée par table RefreshData()
# devient inefficace : rafraîchir une table ré-extrait l'intégralité du cache
# partagé, donc rafraîchir N tables effectue la même extraction coûteuse N fois.
idx2 = sheet.pivot_tables.add("A1:C9", "E15", "Pivot2")
pivot_table2 = sheet.pivot_tables[idx2]
pivot_table2.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table2.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table2.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# --- Modifier plusieurs valeurs de Montant dans les données source ---
sheet.cells["C2"].put_value(5000)   # Grape  2020
sheet.cells["C5"].put_value(7500)   # Cherry 2020
sheet.cells["C9"].put_value(9500)   # Cherry 2021

# --- Modèle OBSOLÈTE (avant la 26.7) — PivotTable.RefreshData() ---
# pivot_table1.refresh_data();  # ré-extrait depuis la source, rafraîchit tout le cache
# pivot_table2.refresh_data();  # ré-extrait À NOUVEAU — le cache est déjà à jour !
# Chaque appel reconstruit le cache partagé, donc N tables = N extractions redondantes.

# --- NOUVEAU modèle v26.7+ : rafraîchir le cache UNE SEULE FOIS, puis ré-afficher au besoin ---
# Un seul appel à PivotCache.Refresh() récupère les valeurs modifiées dans le cache
# partagé ET recalcule l'affichage de CHAQUE tableau croisé dynamique qui le référence.
# Comme Pivot1 et Pivot2 partagent un seul PivotCache, cet appel unique met à jour
# les deux tables — aucun second aller-retour vers la source n'est nécessaire.
pivot_table1.pivot_cache.refresh()

# CalculateData() ne ré-affiche que la vue d'un tableau croisé dynamique (données + style)
# à partir des données déjà détenues dans le cache — il ne touche PAS à la source.
# Nous l'appelons sur Pivot2 ici uniquement pour démontrer l'API : après le rafraîchissement
# du cache une seule fois, toute table dépendante peut être ré-affichée sans
# revenir à la source. Utilisez CalculateData() seul lorsque seuls les paramètres
# d'affichage/mise en page du tableau croisé ont changé et que le cache est à jour.
pivot_table2.calculate_data()

workbook.save("output.xlsx")

Quelle API d’actualisation dois-je utiliser ?

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

Objectif	API recommandée	Remarques
Actualiser tout dans le classeur	`Workbook.refresh_all()`	Un seul appel ; couvre tous les caches et tous les tableaux.
Actualiser uniquement les tableaux croisés dynamiques d’une seule feuille	`Worksheet.refresh_pivot_tables()`	Limité à une feuille de calcul.
Données sources modifiées pour un cache	`pivot_table.pivot_cache.refresh()`	Actualise TOUS les tableaux croisés dynamiques sur ce cache partagé.
Seuls les paramètres d’affichage/de mise en page ont changé	`pivot_table.calculate_data()`	Évite les allers-retours inutiles vers la source.
Lister tous les tableaux croisés dynamiques sur un cache partagé	`pivot_cache.get_pivot_tables()`	À utiliser pour énumérer avant une actualisation en masse.

En pratique, préférez les API basées sur le cache à la méthode obsolète refresh_data() par table. Elles sont conscientes des caches partagés, évitent les récupérations redondantes depuis la source et vous permettent de choisir le plus petit périmètre qui satisfait votre besoin d’actualisation.

Pythonnet: 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.add_field_to_area(PivotFieldType field_type, string field_name) déplace un champ de base depuis les données sources vers l’une des quatre zones du tableau croisé dynamique. L’argument field_type accepte l’une des valeurs PivotFieldType suivantes.

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 propriétés PivotTable.row_fields et PivotTable.column_fields. Chaque propriété renvoie une PivotFieldCollection. Le champ à l’index 0 de row_fields est le champ de ligne le plus externe, et les indices suivants représentent les champs imbriqués à l’intérieur. La même convention d’indexation s’applique à column_fields.

L’ordre d’imbrication des champs est important. Ajouter Category à la zone de ligne en premier, puis Item, produit un tableau croisé 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.set_subtotals(PivotFieldSubtotalType subtotal_type, bool shown) contrôle quelles lignes de sous-totaux apparaissent pour un champ croisé. Chaque appel active ou désactive un seul type de sous-total indépendamment. 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 subtotal_type 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 — supprimer toutes les lignes de sous-total
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STDDEV
STDDEVP
VAR
VARP

Les sous-totaux ne s’affichent que lorsqu’il y a deux champs croisés ou plus dans la zone de ligne (ou dans la zone de colonne). Un seul champ n’a rien de significatif à sous-totaliser entre les groupes, donc les appels à set_subtotals n’ont aucun effet visible dans ce cas. Par conséquent, cet article place 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 set_subtotals, Aspose.Cells applique la sélection AUTOMATIC aux champs numériques. L’exemple suivant confirme explicitement ce comportement en appelant set_subtotals(PivotFieldSubtotalType.AUTOMATIC, True) sur le champ de ligne externe Category.

import aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

worksheet.cells[0, 0].put_value("Category")
worksheet.cells[0, 1].put_value("Item")
worksheet.cells[0, 2].put_value("Year")
worksheet.cells[0, 3].put_value("Amount")

worksheet.cells[1, 0].put_value("Fruit")
worksheet.cells[1, 1].put_value("Apple")
worksheet.cells[1, 2].put_value(2020)
worksheet.cells[1, 3].put_value(100)

worksheet.cells[2, 0].put_value("Fruit")
worksheet.cells[2, 1].put_value("Apple")
worksheet.cells[2, 2].put_value(2021)
worksheet.cells[2, 3].put_value(150)

worksheet.cells[3, 0].put_value("Fruit")
worksheet.cells[3, 1].put_value("Banana")
worksheet.cells[3, 2].put_value(2020)
worksheet.cells[3, 3].put_value(80)

worksheet.cells[4, 0].put_value("Fruit")
worksheet.cells[4, 1].put_value("Banana")
worksheet.cells[4, 2].put_value(2021)
worksheet.cells[4, 3].put_value(90)

worksheet.cells[5, 0].put_value("Vegetable")
worksheet.cells[5, 1].put_value("Carrot")
worksheet.cells[5, 2].put_value(2020)
worksheet.cells[5, 3].put_value(50)

worksheet.cells[6, 0].put_value("Vegetable")
worksheet.cells[6, 1].put_value("Carrot")
worksheet.cells[6, 2].put_value(2021)
worksheet.cells[6, 3].put_value(60)

worksheet.cells[7, 0].put_value("Vegetable")
worksheet.cells[7, 1].put_value("Daikon")
worksheet.cells[7, 2].put_value(2020)
worksheet.cells[7, 3].put_value(40)

worksheet.cells[8, 0].put_value("Vegetable")
worksheet.cells[8, 1].put_value("Daikon")
worksheet.cells[8, 2].put_value(2021)
worksheet.cells[8, 3].put_value(45)

pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1")
pivot_table = worksheet.pivot_tables[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

category_field = pivot_table.row_fields[0]
category_field.set_subtotals(ac.PivotFieldSubtotalType.AUTOMATIC, True)

pivot_table.calculate_data()

workbook.save("output_automatic.xlsx")

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

Appeler set_subtotals(PivotFieldSubtotalType.NONE, True) supprime chaque ligne de sous-total du tableau croisé, ne laissant que les lignes de champ et le total général en bas. Cela est utile lorsque vous souhaitez les données regroupées brutes sans aucune ligne de synthèse.

import aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

headers = ["Category", "Item", "Year", "Amount"]
for j in range(len(headers)):
    worksheet.cells[0, j].put_value(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[i])):
        worksheet.cells[i + 1, j].put_value(data[i][j])

pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1")
pivot_table = worksheet.pivot_tables[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

category_field = pivot_table.row_fields[0]
for st in [ac.PivotFieldSubtotalType.SUM, ac.PivotFieldSubtotalType.COUNT, ac.PivotFieldSubtotalType.AVERAGE, ac.PivotFieldSubtotalType.MAX, ac.PivotFieldSubtotalType.MIN, ac.PivotFieldSubtotalType.PRODUCT]:
    category_field.set_subtotals(st, True)
pivot_table.calculate_data()

workbook.save("output_none.xlsx")

Scénario 3 — Sous-ensemble personnalisé de sous-totaux (Sum + Average)

Vous n’êtes pas limité à un seul type de sous-total. Chaque appel à set_subtotals 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 aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

worksheet.cells["A1"].put_value("Category")
worksheet.cells["B1"].put_value("Item")
worksheet.cells["C1"].put_value("Year")
worksheet.cells["D1"].put_value("Amount")

worksheet.cells[1, 0].put_value("Fruit")
worksheet.cells[1, 1].put_value("Apple")
worksheet.cells[1, 2].put_value(2020)
worksheet.cells[1, 3].put_value(100)

worksheet.cells[2, 0].put_value("Fruit")
worksheet.cells[2, 1].put_value("Apple")
worksheet.cells[2, 2].put_value(2021)
worksheet.cells[2, 3].put_value(150)

worksheet.cells[3, 0].put_value("Fruit")
worksheet.cells[3, 1].put_value("Banana")
worksheet.cells[3, 2].put_value(2020)
worksheet.cells[3, 3].put_value(80)

worksheet.cells[4, 0].put_value("Fruit")
worksheet.cells[4, 1].put_value("Banana")
worksheet.cells[4, 2].put_value(2021)
worksheet.cells[4, 3].put_value(90)

worksheet.cells[5, 0].put_value("Vegetable")
worksheet.cells[5, 1].put_value("Carrot")
worksheet.cells[5, 2].put_value(2020)
worksheet.cells[5, 3].put_value(50)

worksheet.cells[6, 0].put_value("Vegetable")
worksheet.cells[6, 1].put_value("Carrot")
worksheet.cells[6, 2].put_value(2021)
worksheet.cells[6, 3].put_value(60)

worksheet.cells[7, 0].put_value("Vegetable")
worksheet.cells[7, 1].put_value("Daikon")
worksheet.cells[7, 2].put_value(2020)
worksheet.cells[7, 3].put_value(40)

worksheet.cells[8, 0].put_value("Vegetable")
worksheet.cells[8, 1].put_value("Daikon")
worksheet.cells[8, 2].put_value(2021)
worksheet.cells[8, 3].put_value(45)

pivot_tables = worksheet.pivot_tables
pivot_index = pivot_tables.add("A1:D9", "F3", "PivotTable1")
pivot_table = pivot_tables[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

category_field = pivot_table.row_fields[0]
category_field.set_subtotals(ac.PivotFieldSubtotalType.SUM, True)
category_field.set_subtotals(ac.PivotFieldSubtotalType.AVERAGE, True)

pivot_table.calculate_data()

workbook.save("output_custom.xlsx")

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 à set_subtotals appliqué au champ de ligne externe Category. Rappelez-vous la règle des deux champs : un seul champ dans une zone n’a rien à sous-totaliser, donc placez toujours au moins deux champs dans la zone de ligne ou de colonne lorsque vous souhaitez que set_subtotals ait un effet visible.

Pythonnet: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Ajout d’un champ à la zone de données

L’ajout d’un champ de base à la zone de données (valeur) 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.add_field_to_area(PivotFieldType, str), une surcharge qui accepte la constante PivotFieldType.DATA et le nom de la colonne source. Une fois qu’un champ est ajouté à la zone de données, l’API l’expose via la collection PivotTable.data_fields, dans l’ordre dans lequel les champs ont été ajoutés. Par défaut, une colonne source numérique est résumée avec ConsolidationFunction.SUM, tandis qu’une colonne non numérique utilise Count par défaut.

from aspose.cells.pivot import PivotFieldType

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

# En-têtes dans A1:D1
worksheet.cells[0, 0].put_value("Category")
worksheet.cells[0, 1].put_value("Item")
worksheet.cells[0, 2].put_value("Year")
worksheet.cells[0, 3].put_value("Amount")

# Lignes de données A2:D9 utilisant des boucles imbriquées avec branchement sur j
for i in range(1, 9):
    for j in range(4):
        if j == 0:
            worksheet.cells[i, j].put_value("Fruit" if i <= 4 else "Vegetable")
        elif j == 1:
            if i == 1 or i == 2:
                worksheet.cells[i, j].put_value("Apple")
            elif i == 3 or i == 4:
                worksheet.cells[i, j].put_value("Banana")
            elif i == 5 or i == 6:
                worksheet.cells[i, j].put_value("Carrot")
            else:
                worksheet.cells[i, j].put_value("Daikon")
        elif j == 2:
            worksheet.cells[i, j].put_value(2020 + ((i - 1) % 2))
        elif j == 3:
            if i == 1:
                worksheet.cells[i, j].put_value(100)
            elif i == 2:
                worksheet.cells[i, j].put_value(150)
            elif i == 3:
                worksheet.cells[i, j].put_value(80)
            elif i == 4:
                worksheet.cells[i, j].put_value(90)
            elif i == 5:
                worksheet.cells[i, j].put_value(50)
            elif i == 6:
                worksheet.cells[i, j].put_value(60)
            elif i == 7:
                worksheet.cells[i, j].put_value(40)
            else:
                worksheet.cells[i, j].put_value(45)

# Ajouter un tableau croisé dynamique à F3 avec le nom PivotTable1
pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1", True, False)
pivot_table = worksheet.pivot_tables[pivot_index]

# Disposition du tableau croisé : Category et Item en Ligne, Year en Colonne, Amount comme champ de données
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")

Modification de la fonction de synthèse

Chaque champ placé dans la zone de données est encapsulé en interne sous forme d’instance 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 affecte uniquement l’agrégat, la colonne source ne change pas.

Vous pouvez donc laisser un champ de données en Sum tout en ajoutant un second champ de données ciblant la même colonne source mais utilisant Count ou Average, le tout dans un seul tableau croisé dynamique.

import aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

headers = ["Category", "Item", "Year", "Amount"]
for j in range(len(headers)):
    worksheet.cells[0, j].put_value(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[i])):
        worksheet.cells[i + 1, j].put_value(data[i][j])

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(ac.PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")

pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

count_field = pivot_table.data_fields[1]
count_field.function = ac.ConsolidationFunction.COUNT

pivot_table.calculate_data()

workbook.save("output_function.xlsx")

Tracer les champs de valeur sur l’axe Ligne ou Colonne

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

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

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

import aspose.cells as ac

workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

headers = ["Category", "Item", "Year", "Amount"]
for j in range(len(headers)):
    worksheet.cells[0, j].put_value(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[i])):
        worksheet.cells[i + 1, j].put_value(data[i][j])

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(ac.PivotFieldType.ROW, "Category")
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Item")
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, "Year")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")
pivot_table.data_fields[1].function = ac.ConsolidationFunction.COUNT

# Tracer les champs de valeurs sur l'axe des colonnes.
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, pivot_table.values_field)

pivot_table.calculate_data()

workbook.save("output_plot.xlsx")

Pythonnet: 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 page_fields de bas niveau, et vous pouvez piloter le filtre en mode sélection unique, l’effacer pour afficher chaque élément de page, ou basculer le champ en 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 croisé dynamique qui contrôle quel sous-ensemble des données source 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 sélectionner 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 synthétisés. Un champ 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 en sélection unique, un seul élément de page est visible à la fois, de sorte que le corps du tableau croisé dynamique synthétise exactement un sous-ensemble. Dans le comportement en sélection multiple, le champ expose une liste de cases à cocher, et le corps du tableau croisé dynamique synthétise l’union de chaque élément de page coché. Le même champ source peut être déplacé d’avant en arrière entre ces comportements en activant ou désactivant une seule propriété.

Aspose.Cells for Python via .NET expose deux façons équivalentes d’enregistrer un champ de filtre. L’API de haut niveau est PivotTable.add_field_to_area(PivotFieldType.PAGE, "field_name"), 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 remplir 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 croisé dynamique dans la zone de filtre. L’appel de haut niveau prend le nom de la colonne source sous forme de chaîne 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 champ doit être réutilisé dans plusieurs zones du 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 dans la zone de ligne, Amount dans la zone de données et Year dans la zone de filtre, actualise le tableau croisé dynamique et enregistre le classeur.

import aspose.cells as ac

# Créer un nouveau classeur
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

# Configurer la ligne d'en-tête
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Remplir 9 lignes de données d'exemple : Fruit, Year, Amount
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.cells[i + 1, 0].put_value(data[i][0])
    worksheet.cells[i + 1, 1].put_value(data[i][1])
    worksheet.cells[i + 1, 2].put_value(data[i][2])

# Ajouter un tableau croisé dynamique ancré à la cellule E3
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "PivotTable1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Ajouter des champs à leurs zones : Fruit comme Ligne, Amount comme Données, Year comme champ de Page
pivot_table.add_field_to_area(ac.PivotFieldType.Row, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.Data, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.Page, "Year")

# Actualiser et calculer les données du tableau croisé dynamique
pivot_table.calculate_data()

# Enregistrer le classeur
workbook.save("pageFieldSample.xlsx")

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 aspose.cells as ac

# — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
#   le scénario 1a (données Fruit/Année/Montant, pivot à E3, Fruit→Ligne,
#   Montant→Données). Ci-dessous, nous obtenons le PivotField Année à partir
#   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 = ac.Workbook()
sheet = workbook.worksheets[0]

# En-têtes
sheet.cells["A1"].put_value("Fruit")
sheet.cells["B1"].put_value("Year")
sheet.cells["C1"].put_value("Amount")

# Données d'exemple (9 lignes)
sheet.cells["A2"].put_value("apple");    sheet.cells["B2"].put_value("2020"); sheet.cells["C2"].put_value(100)
sheet.cells["A3"].put_value("apple");    sheet.cells["B3"].put_value("2021"); sheet.cells["C3"].put_value(150)
sheet.cells["A4"].put_value("apple");    sheet.cells["B4"].put_value("2022"); sheet.cells["C4"].put_value(200)
sheet.cells["A5"].put_value("grape");    sheet.cells["B5"].put_value("2020"); sheet.cells["C5"].put_value(300)
sheet.cells["A6"].put_value("grape");    sheet.cells["B6"].put_value("2021"); sheet.cells["C6"].put_value(400)
sheet.cells["A7"].put_value("grape");    sheet.cells["B7"].put_value("2022"); sheet.cells["C7"].put_value(500)
sheet.cells["A8"].put_value("blueberry"); sheet.cells["B8"].put_value("2020"); sheet.cells["C8"].put_value(250)
sheet.cells["A9"].put_value("blueberry"); sheet.cells["B9"].put_value("2021"); sheet.cells["C9"].put_value(350)
sheet.cells["A10"].put_value("blueberry");sheet.cells["B10"].put_value("2022"); sheet.cells["C10"].put_value(450)

# Ajoute le tableau croisé dynamique à E3 couvrant A1:C10
pivot_index = sheet.pivot_tables.add("E3", "A1:C10", "PivotTable1")
pivot_table = sheet.pivot_tables[pivot_index]

# Fruit -> Ligne, Montant -> Données (Année ira dans Page ci-dessous)
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Approche de bas niveau : récupère le PivotField Année existant depuis BaseFields
# et l'enregistre dans la zone Page via PageFields.Add(PivotField).
year_field = pivot_table.base_fields["Year"]
pivot_table.page_fields.add(year_field)

# Actualise pour que le nouveau champ de page soit reflété dans le classeur enregistré
pivot_table.calculate_data()

workbook.save("output.xlsx")

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

Dans le comportement par défaut en sélection unique, le champ de filtre s’affiche sous forme de liste déroulante unique et l’entier PivotField.current_page_item sélectionne l’élément de page qui pilote le corps du tableau croisé dynamique. L’affectation d’un index spécifique sélectionne cet élément unique ; l’affectation de la sentinelle spéciale 0x7FFD (32765 en décimal) efface le filtre afin que chaque élément de page soit synthétisé en une seule fois. 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 synthétise chaque élément de page comme si aucun filtre n’était appliqué.

import aspose.cells as ac

# Créer un nouveau classeur
workbook = ac.Workbook()
sheet = workbook.worksheets[0]

# Remplir les données Fruit/Année/Montant
sheet.cells["A1"].put_value("Fruit")
sheet.cells["B1"].put_value("Year")
sheet.cells["C1"].put_value("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.cells[r + 1, c].put_value(data[r][c])

# Créer un tableau croisé dynamique à E3
pivot_tables = sheet.pivot_tables
index = pivot_tables.add("=A1:C7", "E3", "PivotTable1")
pivot_table = pivot_tables[index]

# Configurer les champs du tableau croisé dynamique : Fruit→Ligne, Montant→Données, Année→Page
pivot_table.add_field_to_area(ac.PivotFieldType.Row, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.Data, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.Page, "Year")

pivot_table.calculate_data()

# Effacer le filtre de page pour 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.
pivot_table.page_fields[0].current_page_item = 0x7FFD

workbook.save("output.xlsx")

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 aspose.cells as ac

# Créer un classeur
workbook = ac.Workbook()
sheet = workbook.worksheets[0]
cells = sheet.cells

# Ajouter des données d'exemple (Fruit/Année/Montant)
cells["A1"].put_value("Fruit")
cells["B1"].put_value("Year")
cells["C1"].put_value("Amount")

cells["A2"].put_value("Apple")
cells["B2"].put_value("2020")
cells["C2"].put_value("100")

cells["A3"].put_value("Apple")
cells["B3"].put_value("2021")
cells["C3"].put_value("150")

cells["A4"].put_value("Banana")
cells["B4"].put_value("2020")
cells["C4"].put_value("200")

cells["A5"].put_value("Banana")
cells["B5"].put_value("2021")
cells["C5"].put_value("250")

# Ajouter un tableau croisé dynamique à E3
pivot_tables = sheet.pivot_tables
pivot_index = pivot_tables.add("A1:C5", "E3", "PivotTable1")
pivot_table = pivot_tables[pivot_index]

# Ajouter des champs : Fruit→Ligne, Montant→Données, Année→Page
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.PAGE, "Year")

# Opérations spécifiques au champ de page
pivot_table.page_fields[0].current_page_item = 1  # 1 = deuxième élément dans l'ordre trié (par ex. "2021")

# Actualiser et calculer le tableau croisé dynamique
pivot_table.calculate_data()

workbook.save("output.xlsx")

Filtrage en sélection multiple

Le filtrage en sélection multiple transforme la liste déroulante de page en une liste de cases à cocher et permet à l’utilisateur final de sélectionner plusieurs éléments de page simultanément. 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, ce qui vous permet soit d’afficher chaque élément, soit de n’autoriser que des é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 schémas : 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 source que vous choisissez et masque tout le reste via un bloc if / elif qui teste pivot_items[i].get_string_value().

import aspose.cells as ac

# — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
#   Scénario 1a (données Fruit/Année/Montant, pivot en 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 = ac.Workbook()
sheet = workbook.worksheets[0]
cells = sheet.cells

# Données d'exemple : Fruit | Année | Montant
cells[0, 0].put_value("Fruit")
cells[0, 1].put_value("Year")
cells[0, 2].put_value("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[i + 1, 0].put_value(data[i][0])
    cells[i + 1, 1].put_value(int(data[i][1]))
    cells[i + 1, 2].put_value(int(data[i][2]))

pivot_sheet = workbook.worksheets.add("Pivot")
pivots = pivot_sheet.pivot_tables
pivot_index = pivots.add("E3", "A1:C10", "PivotTable1")
pivot_table = pivots[pivot_index]

pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")
pivot_table.add_field_to_area(ac.PivotFieldType.PAGE, "Year")

# — Activer la multi-sélection sur le champ de page
pivot_table.page_fields[0].is_multiple_item_selection_allowed = True

# Partie A — sélectionner TOUS les éléments (rendre chaque élément visible)
pivot_items = pivot_table.page_fields[0].pivot_items
for i in range(pivot_items.count):
    pivot_items[i].is_hidden = False

# Partie B — sélectionner uniquement des éléments spécifiques par valeur source
for i in range(pivot_items.count):
    value = pivot_items[i].get_string_value()
    if value == "2020" or value == "grape" or value == "blueberry":
        pivot_items[i].is_hidden = False
    else:
        pivot_items[i].is_hidden = True

pivot_table.calculate_data()

workbook.save("output.xlsx")

Remarque : Lors de l’utilisation du filtrage en sélection multiple via PivotItem.is_hidden, au moins un PivotItem doit rester visible (is_hidden == False). Si chaque élément est masqué, Excel plante à l’ouverture du fichier ou affiche un tableau croisé dynamique vide. Vérifiez toujours que votre liste d’autorisation en sélection multiple inclut au moins un élément de vos données source.

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 avoir à 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 (cas le plus courant)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "field_name")`	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	Utilisez lorsque l’objet 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 les appels à `is_hidden` ne prennent 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 en sélection multiple. Si chaque PivotItem d’un champ de filtre à sélection multiple est masqué, Excel plante à l’ouverture ou affiche un tableau croisé dynamique vide. Construisez votre liste d’autorisation à partir de vos données source afin qu’au moins un élément reste visible, et vos classeurs enregistrés s’ouvriront de manière fiable sur toutes les machines.

Pythonnet: Supprimer le tableau croisé dynamique d une feuille de calcul

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

Aspose.Cells pour Python via .NET fournit une fonctionnalité pour supprimer ou récupérer un tableau croisé dynamique d’une feuille de calcul. Vous pouvez supprimer le tableau croisé dynamique en utilisant un objet tableau croisé dynamique ou une position de tableau croisé dynamique. Veuillez utiliser la méthode Worksheet.pivot_tables.remove(pivot_table) pour supprimer le tableau croisé dynamique en utilisant l’objet tableau croisé dynamique et la méthode Worksheet.pivot_tables.remove_at(index, keep_data) pour supprimer l’objet tableau croisé dynamique en utilisant sa position dans la collection de tableaux croisés dynamiques.

Comment supprimer un tableau croisé dynamique d’une feuille de calcul en utilisant la bibliothèque Aspose.Cells pour Python Excel

Le code d’exemple suivant supprime deux tableaux croisés dynamiques de la feuille de calcul. D’abord, il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.pivot_tables.remove(pivot_table) et ensuite il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.pivot_tables.remove_at(index, keep_data)

Pythonnet: Enregistrer un tableau croisé dynamique dans un fichier ODS

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

Comment enregistrer un tableau croisé dynamique dans un fichier ODS

Aspose.Cells for Python via .NET offre la possibilité d’enregistrer un tableau croisé dynamique dans des fichiers ODS. Pour cela, vous convertissez simplement un classeur avec un tableau croisé dynamique existant ou créez un nouveau tableau croisé dynamique et enregistrez le fichier au format ODS. Assurez-vous d’appeler PivotTable.calculate_data avant l’enregistrement pour garantir que le tableau croisé dynamique est rendu dans le fichier ODS de sortie. Le code suivant illustre l’enregistrement d’un tableau croisé dynamique dans un fichier ODS.

Code d’exemple

Le fichier de sortie généré par le code ci-dessus est joint à titre de référence.

Fichier ODS de sortie

Documentation – Insérer un tableau croisé dynamique

Pythonnet: Formatage du tableau croisé dynamique

Apparence du tableau croisé dynamique

Comment définir les options de formatage du tableau croisé dynamique

Comment définir le type de mise en forme automatique

Comment définir les options de mise en forme

Aspect et sensation du formatage manuel

Comment définir les options de format de champ de table de données

Comment définir le format des champs de lignes/colonnes/page

Comment définir le format des champs de données

Comment effacer les champs de table de données

Pythonnet: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

Ajouter des tableaux croisés dynamiques et des graphiques à l’aide de la bibliothèque Excel Aspose.Cells pour Python

Préparez-vous à utiliser Aspose.Cells pour Python via .NET

Comment ajouter une table pivotante à l’aide de la bibliothèque Excel Aspose.Cells for Python

Comment ajouter un graphique pivotant à l’aide de la bibliothèque Excel Aspose.Cells for Python

Pythonnet: Tableau croisé dynamique et données sources

Données source du tableau croisé dynamique

Modification des données source d’un tableau croisé dynamique

Pythonnet: Ajouter un champ calculé dans le tableau croisé dynamique

Scénarios d’utilisation possibles

Comment ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Comment ajouter un champ calculé dans un tableau croisé dynamique en utilisant la bibliothèque Excel Aspose.Cells pour Python

Code d’exemple

Pythonnet: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

Introduction

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

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

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

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

Quelle API de style dois-je utiliser ?

Pythonnet: Refreshing Pivot Tables in Aspose.Cells for Python via .NET

Introduction

Imports requis

Actualiser tous les tableaux croisés dynamiques du classeur

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Actualiser un seul tableau croisé dynamique

Les données sources ont changé — Utilisez PivotCache.refresh()

Seuls l’affichage/la mise en page ont changé — Utilisez calculate_data()

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

Migration depuis la méthode obsolète PivotTable.refresh_data()

Quelle API d’actualisation dois-je utiliser ?

Pythonnet: 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 personnalisé de sous-totaux (Sum + Average)

Récapitulatif

Pythonnet: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

Ajout d’un champ à la zone de données

Modification de la fonction de synthèse

Tracer les champs de valeur sur l’axe Ligne ou Colonne

Pythonnet: 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 en sélection unique (affichage d’un seul élément de page)

Affichage de tous les éléments

Affichage d’un élément spécifique

Filtrage en sélection multiple

Quelle API et quel mode dois-je utiliser ?

Pythonnet: Supprimer le tableau croisé dynamique d une feuille de calcul

Comment supprimer un tableau croisé dynamique d’une feuille de calcul en utilisant la bibliothèque Aspose.Cells pour Python Excel

Pythonnet: Enregistrer un tableau croisé dynamique dans un fichier ODS

Comment enregistrer un tableau croisé dynamique dans un fichier ODS

Code d’exemple

Les données sources ont changé — Utilisez `PivotCache.refresh()`

Seuls l’affichage/la mise en page ont changé — Utilisez `calculate_data()`

Migration depuis la méthode obsolète `PivotTable.refresh_data()`