Documentation – Tablas dinámicas

Pythonjava: Crear una tabla dinámica

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

Crear una tabla dinámica

Aspose.Cells for Python via Java proporciona la función para crear tablas dinámicas. Para crear una tabla dinámica usando Aspose.Cells, sigue los siguientes pasos:

Agrega algunos datos a las celdas de la hoja de trabajo utilizando la propiedad setValue del objeto Cell. Estos datos se utilizarán como fuente de datos para la tabla dinámica.
Agrega una tabla dinámica a la hoja de trabajo llamando al método add de PivotTableCollection, encapsulado en el objeto Worksheet.
Accede al objeto PivotTable desde PivotTableCollection pasando el índice de PivotTable.
Utiliza cualquiera de los objetos de tabla dinámica (explicados arriba) encapsulados en PivotTableCollection para gestionar la tabla dinámica.

El siguiente fragmento de código demuestra cómo crear una tabla dinámica con la API de Aspose.Cells.

Pythonjava: Formato de celdas de tabla dinámica

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

A veces desearás dar formato a las celdas de una tabla dinámica. Por ejemplo, aplicar un color de fondo a las celdas de una tabla dinámica. Aspose.Cells proporciona dos métodos PivotTable.formatAll() y PivotTable.format(), que puedes utilizar para este propósito.

PivotTable.formatAll() aplica el estilo a toda la tabla dinámica, mientras que PivotTable.format() aplica el estilo a una única celda de la tabla dinámica.

El siguiente código de ejemplo da formato a toda la tabla dinámica con un color azul claro y luego formatea la segunda fila de la tabla con color amarillo.

La tabla dinámica de entrada, antes de ejecutar el código

La tabla dinámica de salida, después de ejecutar el código

Pythonjava: Actualizar tablas dinámicas y cachés de tablas dinámicas en Aspose.Cells for Python via Java

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

Aspose.Cells ofrece una API de actualización en capas que permite recargar los datos de las tablas dinámicas en cuatro niveles diferentes, desde todo el libro hasta una sola tabla dinámica. A partir de Aspose.Cells for Python via Java v26.7, el método heredado PivotTable.refreshData() está marcado como obsoleto y debe reemplazarse por las API más eficientes y conscientes de la caché que se describen en este artículo.

Introducción

Actualizar una tabla dinámica rara vez es una operación única. Entre bastidores, Aspose.Cells mantiene una cadena de datos en capas que conecta los datos de origen originales con los valores renderizados que se ven en la hoja de cálculo. Comprender esta cadena es la clave para elegir la API de actualización adecuada para cada situación. La cadena de datos de cuatro capas es:

Origen de datos — los rangos originales de la hoja de cálculo, la consulta a la base de datos o el rango de consolidación donde residen los valores sin procesar.
PivotCache — la instantánea en memoria de los datos de origen. Cada tabla dinámica se construye sobre un PivotCache; aquí es donde se recopilan y agregan todos los datos.
PivotTable — el objeto de vista que define los campos de fila, columna, valor y filtro. Un PivotTable lee solamente de su PivotCache, nunca directamente del origen de datos.
Cells — el Cells de la hoja de cálculo en el que el PivotTable renderiza sus valores calculados y estilos.

PivotCache.getSourceType() (enum PivotTableSourceType) indica de dónde provienen los datos de la caché. A partir de la v26.7, PivotCache.refresh() admite solo los tipos de origen SHEET y CONSOLIDATION, es decir, datos que residen en rangos de hojas de cálculo. Las fuentes externas (bases de datos, conexiones externas, etc.) aún no se pueden actualizar mediante la API de caché.

Debido a esta cadena, existen dos rutas fundamentales de actualización en Aspose.Cells:

PivotTable.calculateData() — recalcula la visualización de un PivotTable a partir de los datos ya almacenados en caché, sin volver al origen de datos. Todos los escenarios de este artículo usan datos de origen de celdas de la hoja de cálculo, por lo que el tipo de origen es SHEET y las operaciones de actualización se comportan como se describe.

Inicio rápido

Si solo necesita el código más breve posible que actualice todas las tablas dinámicas del libro, basta con una sola llamada:

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Crear un nuevo libro de trabajo
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Escribir la fila de encabezado en las celdas A1:C1
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Escribir filas de datos en las celdas A2:C9 (8 filas de datos de frutas entre 2020 y 2021)
worksheet.getCells().get("A2").putValue("grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(50)
worksheet.getCells().get("A3").putValue("blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(60)
worksheet.getCells().get("A4").putValue("kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(70)
worksheet.getCells().get("A5").putValue("cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(80)
worksheet.getCells().get("A6").putValue("grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(90)
worksheet.getCells().get("A7").putValue("blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(100)
worksheet.getCells().get("A8").putValue("kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(110)
worksheet.getCells().get("A9").putValue("cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(120)
# Agregar una tabla dinámica: rango de origen "A1:C9", celda de destino "E3", nombre "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Asignar campos dinámicos: Fruit a Filas, Year a Columnas, Amount a Datos
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modificar varios valores de Amount en los datos de origen para simular cambios
worksheet.getCells().get("C2").putValue(55)
worksheet.getCells().get("C5").putValue(85)
worksheet.getCells().get("C9").putValue(125)
# Actualizar todas las tablas dinámicas / caché de tablas dinámicas en el libro de trabajo
workbook.refreshAll()
# Guardar el libro de trabajo
workbook.save("output.xlsx")
jpype.shutdownJVM()

Todo lo demás de este artículo explica cuándo elegir una API más específica en su lugar.

Importaciones requeridas

Todos los ejemplos de Python de este artículo dependen de las siguientes importaciones porque los tipos de tablas dinámicas se encuentran en el espacio de nombres aspose.cells.pivot:

import jpype
import aspose.cells as cells El módulo jpype se usa para iniciar la JVM, mientras que aspose.cells expone los tipos de libro/hoja de cálculo/celda/tabla dinámica utilizados en todo el artículo.

Actualizar todas las tablas dinámicas del libro

Cuando necesita asegurarse de que cada caché de tabla dinámica y cada tabla dinámica del libro reflejen los datos de origen más recientes, la API más sencilla y completa es Workbook.refreshAll(). Una sola llamada recorre todo el libro, actualiza cada PivotCache desde su origen y luego recalcula cada PivotTable dependiente. Este es el enfoque recomendado para actualizaciones generales de todo el documento cuando el rendimiento no es un problema. El siguiente ejemplo crea un libro con un rango de origen Fruta/Año/Importe, crea una tabla dinámica, modifica algunos valores de origen y luego utiliza refreshAll() para actualizar todo en una sola llamada.

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

Actualizar todas las tablas dinámicas en una sola hoja de cálculo

A veces solo necesita actualizar las tablas dinámicas que se encuentran en una hoja de cálculo específica, por ejemplo, cuando se sabe que las tablas dinámicas de otras hojas no están relacionadas y no deben tocarse. Para este caso, Aspose.Cells ofrece Worksheet.refreshPivotTables(), que está limitada a una sola instancia de Worksheet.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Escribir fila de encabezado Fruta / Año / Monto
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Escribir 8 filas de datos (filas 2-9, ajustándose al rango de origen A1:C9)
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(100)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(200)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(300)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(400)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(150)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(250)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(350)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(450)
# Agregar una tabla dinámica llamada "Pivot1" ubicada en la celda destino E3, con origen en A1:C9
pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Asignar campos: Fruta a Fila, Año a Columna, Monto a Datos
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Column, "Year")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Modificar una propiedad de vista/diseño — este es un cambio solo de presentación,
# por lo que NO requiere volver a leer los datos de origen a través de PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(False)
# CalculateData() vuelve a renderizar la visualización de ESTA tabla dinámica (datos + estilo) a partir de
# los datos ya almacenados en el PivotCache. Dado que los datos de origen no cambiaron,
# no se realiza ningún viaje de ida y vuelta al origen — solo los valores en caché se recalculan
# en las celdas de la hoja de cálculo.
pivotTable.calculateData()
# Guardar el libro de trabajo en disco
workbook.save("output.xlsx")
jpype.shutdownJVM()

Actualizar una sola tabla dinámica

Cuando desea un control detallado sobre una sola tabla dinámica, la API basada en caché le ofrece dos opciones. La elección entre ellas depende de qué haya cambiado realmente: los datos de origen subyacentes, o solo la configuración de vista/diseño de la propia tabla dinámica.

Cambiaron los datos de origen — Use `PivotCache.refresh()`

Si los datos de origen subyacentes han cambiado, el punto de entrada correcto es pivotTable.getPivotCache().refresh(). Esta llamada vuelve a leer los datos de origen en la caché y luego recalcula cada PivotTable que depende de esa caché.

Solo cambió la vista/diseño — Use `calculateData()`

Si los datos de origen no han cambiado pero solo se han modificado la configuración de vista o diseño de la tabla dinámica (por ejemplo, se ha movido un campo a un área diferente o se ha activado/desactivado la configuración de actualizar al abrir), no es necesario volver al origen de datos. La caché ya contiene los datos correctos; solo es necesario recalcular el PivotTable renderizado. En este caso, pivotTable.calculateData() es la opción correcta. El siguiente ejemplo modifica una propiedad no relacionada con el origen de la tabla dinámica y luego llama a calculateData() para volver a renderizarla desde la caché existente. Un libro a menudo contiene muchas tablas dinámicas que se asientan sobre una caché compartida. Para enumerarlas, por ejemplo, antes de realizar una actualización por lotes o para diagnosticar el impacto de la caché compartida, use PivotCache.getPivotTables(). Este método devuelve la colección de cada PivotTable que depende de la caché indicada.

Migración desde el obsoleto `PivotTable.refreshData()`

Antes de Aspose.Cells for Python via Java v26.7, la forma estándar de actualizar una tabla dinámica era llamar a PivotTable.refreshData() en cada tabla dinámica individualmente. A partir de la v26.7, ese método está marcado como obsoleto y debe reemplazarse por las API conscientes de la caché descritas anteriormente. Hay dos razones por las que el enfoque refreshData() por tabla es problemático en libros del mundo real:

Recupera datos del origen cada vez que se llama, incluso cuando el origen no ha cambiado. Los reemplazos recomendados son: El siguiente ejemplo demuestra el nuevo patrón eficiente para libros con varias tablas dinámicas que comparten una sola caché.

¿Qué API de actualización debo usar?

La tabla siguiente resume las API de actualización disponibles y cuándo elegir cada una.

Objetivo	API recomendada	Notas
Actualizar todo el libro	`Workbook.refreshAll()`	Una sola llamada; cubre todas las cachés y tablas.
Actualizar solo las tablas dinámicas de una hoja	`Worksheet.refreshPivotTables()`	Limitada a una hoja de cálculo.
Cambiaron los datos de origen para una caché	`pivotTable.getPivotCache().refresh()`	Actualiza TODAS las tablas dinámicas en esa caché compartida.
Solo cambiaron los ajustes de vista/diseño	`pivotTable.calculateData()`	Evita viajes innecesarios al origen.
Listar todas las tablas dinámicas en una caché compartida	`pivotCache.getPivotTables()`	Úsela para enumerar antes de una actualización masiva.
En la práctica, prefiera las API basadas en caché sobre el obsoleto `refreshData()` por tabla. Son conscientes de las cachés compartidas, evitan lecturas redundantes del origen y le permiten elegir el alcance más pequeño que satisfaga su requisito de actualización.

Errores comunes

Olvidar actualizar antes de guardar. Una tabla dinámica solo escribe sus valores renderizados en la hoja de cálculo cuando se actualiza su cadena de datos. Si modifica celdas de origen, llame a PivotCache.Refresh() (o Workbook.RefreshAll()) antes de Workbook.save(), de lo contrario, el archivo guardado seguirá conteniendo los valores agregados antiguos.
Llamar al obsoleto RefreshData() por tabla. En la v26.7, PivotTable.RefreshData() está marcado como obsoleto y recupera el origen en cada llamada. Con varias tablas dinámicas que comparten una caché, esto significa N lecturas redundantes del origen. Reemplácelo con una sola llamada a PivotCache.Refresh() seguida de CalculateData() por tabla.
Actualizar cuando solo cambió el diseño. Si solo cambió la vista de una tabla dinámica (orden de columnas, ConsolidationFunction, etc.) sin tocar los datos de origen, PivotCache.Refresh() es innecesario y lento. Llame a pivotTable.CalculateData() para volver a renderizar desde la caché existente.
Origen externo no compatible con PivotCache.Refresh(). Si el origen de la tabla dinámica proviene de una conexión externa (base de datos, cubo OLAP, etc.), PivotCache.Refresh() no puede actualizarla en la v26.7; actualmente solo admite los tipos de origen Sheet y Consolidation. Para orígenes externos, vuelva a abrir el libro o reconstruya la caché desde el origen.

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

Pythonjava: Aplicar estilos a tablas dinámicas en Aspose.Cells for Python via Java

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

Aspose.Cells admite la aplicación tanto de autoformatos heredados para tablas dinámicas (pensados para archivos .xls) como de estilos con nombre modernos o personalizados para tablas dinámicas (pensados para archivos .xlsx, .xlsm y .xlsb). La API que debe llamar depende del formato de archivo en el que se guarde el libro, no del formato desde el que se haya cargado.

Introducción

Aspose.Cells expone dos API de estilos paralelas para tablas dinámicas. La decisión entre ellas depende del formato de archivo en el que guarde el libro, no del formato desde el que lo lea. Un libro cargado desde un archivo .xls puede volver a guardarse como .xlsx, y en ese caso se aplica la API de estilos moderna en lugar de la heredada.

pivotTable.setPivotTableStyleType(int) selecciona uno de los estilos con nombre integrados (temas claros y oscuros, incluidos los estilos añadidos en Excel 2017). Estos preajustes son de solo lectura.
pivotTable.setPivotTableStyleName(String) selecciona un estilo personalizado que usted mismo define mediante workbook.getWorksheets().getTableStyles().addPivotTableStyle(String). Los estilos personalizados son necesarios cuando desea modificar colores, bordes o fuentes más allá de lo que ofrecen los preajustes. Además, pivotTable.formatAll(Style) es un atajo que aplica un único objeto Style a cada celda de la tabla dinámica, anulando lo que se haya establecido mediante cualquiera de las API de nombres de estilo anteriores. Esto resulta útil cuando se requiere una apariencia uniforme independientemente del tema subyacente.

Aplicar un autoformato preestablecido heredado de XLS

El método setAutoFormatType en una tabla dinámica acepta un valor de la enumeración com.aspose.cells.pivot.PivotTableAutoFormatType. Los valores disponibles son REPORT_1 a REPORT_10, CLASSIC y TABLE_1 a TABLE_10. El siguiente ejemplo carga un libro nuevo, rellena los datos de muestra Fruta/Año/Importe, agrega una tabla dinámica, aplica PivotTableAutoFormatType.REPORT_5 y guarda el resultado como .xls.

¿Por qué no hay campos de columna? Los autoformatos de la serie Report (Report1 a Report10, Table1 a Table10) se diseñaron en el Excel clásico para tablas dinámicas unidimensionales con solo campos de fila y valores, ya que no disponen de estilos integrados para los encabezados de campos de columna. Si su tabla dinámica necesita campos de columna, utilice en su lugar los preajustes modernos PivotTableStyleType del Escenario 2, que están diseñados para el diseño bidimensional que utiliza el Excel moderno.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType, PivotTableAutoFormatType
# Escenario 1: Aplicar un formato automático preestablecido XLS heredado
# API en uso: PivotTable.AutoFormatType
# Formato de archivo de destino: .xls (heredado)
# Para ejemplos completos y archivos de datos, por favor vaya a https://github.com/aspose-cells/Aspose.Cells-for-.NET
# Crear un nuevo libro de trabajo
workbook = Workbook()
# Obtener la primera hoja de trabajo
sheet = workbook.getWorksheets().get(0)
# Rellenar los datos de origen con fila de encabezado (Fruta, Año, Cantidad)
# y 9 filas de datos que cubren uva, arándano, kiwi, cereza en 2020 y 2021
sheet.getCells().get(0, 0).putValue("Fruit")
sheet.getCells().get(0, 1).putValue("Year")
sheet.getCells().get(0, 2).putValue("Amount")
sheet.getCells().get(1, 0).putValue("grape")
sheet.getCells().get(1, 1).putValue(2020)
sheet.getCells().get(1, 2).putValue(50)
sheet.getCells().get(2, 0).putValue("blueberry")
sheet.getCells().get(2, 1).putValue(2020)
sheet.getCells().get(2, 2).putValue(30)
sheet.getCells().get(3, 0).putValue("kiwi")
sheet.getCells().get(3, 1).putValue(2020)
sheet.getCells().get(3, 2).putValue(25)
sheet.getCells().get(4, 0).putValue("cherry")
sheet.getCells().get(4, 1).putValue(2020)
sheet.getCells().get(4, 2).putValue(40)
sheet.getCells().get(5, 0).putValue("grape")
sheet.getCells().get(5, 1).putValue(2021)
sheet.getCells().get(5, 2).putValue(60)
sheet.getCells().get(6, 0).putValue("blueberry")
sheet.getCells().get(6, 1).putValue(2021)
sheet.getCells().get(6, 2).putValue(35)
sheet.getCells().get(7, 0).putValue("kiwi")
sheet.getCells().get(7, 1).putValue(2021)
sheet.getCells().get(7, 2).putValue(28)
sheet.getCells().get(8, 0).putValue("cherry")
sheet.getCells().get(8, 1).putValue(2021)
sheet.getCells().get(8, 2).putValue(45)
sheet.getCells().get(9, 0).putValue("grape")
sheet.getCells().get(9, 1).putValue(2020)
sheet.getCells().get(9, 2).putValue(45)
# Agregar una tabla dinámica en la celda de destino E3, llamada "Pivot1", usando el rango de origen A1:C10
pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Asignar campos: Fruta -> Filas, Cantidad -> Datos
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Aplicar el formato automático preestablecido XLS heredado "Report5"
# Nota: Esta propiedad solo es significativa al guardar como .xls.
# Cuando se guarda como .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
# y usa lo que sea que especifique PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(PivotTableAutoFormatType.Report5)
# Guardar el libro de trabajo en formato .xls heredado
workbook.save("output.xls")
jpype.shutdownJVM()

Aplicar un estilo de tabla dinámica preestablecido con nombre moderno

Definir y aplicar un estilo personalizado de tabla dinámica

Los preajustes integrados no se pueden modificar. Siempre que necesite anular colores, bordes o fuentes, debe definir un estilo personalizado para tabla dinámica. El flujo de trabajo consta de tres pasos:

Agregue un estilo personalizado a la colección TableStyles del libro mediante workbook.getWorksheets().getTableStyles().addPivotTableStyle(String name). Esto devuelve el índice del estilo recién creado.
Configure el estilo añadiendo elementos (como WHOLE_TABLE o GRAND_TOTAL_ROW) mediante tableStyle.getTableStyleElements().add(TableStyleElementType) y, a continuación, asigne un Style a cada elemento con tableStyleElement.setElementStyle(Style).
Aplique el estilo personalizado a la tabla dinámica llamando a pivotTable.setPivotTableStyleName(String) con el nombre del estilo. No utilice aquí setPivotTableStyleType, ya que ese método selecciona preajustes integrados.

setPivotTableStyleName y setPivotTableStyleType no son intercambiables. Utilice setPivotTableStyleType para preajustes integrados y setPivotTableStyleName para estilos personalizados que haya definido mediante addPivotTableStyle. Establecer ambos es inofensivo, pero solo se representa el que coincide con el origen previsto.

Los valores disponibles de TableStyleElementType incluyen WHOLE_TABLE, FIRST_ROW, LAST_ROW, FIRST_COLUMN, LAST_COLUMN, GRAND_TOTAL_ROW, GRAND_TOTAL_COLUMN, PAGE_FIELD_LABELS y PAGE_FIELD_VALUES. El siguiente ejemplo define un estilo personalizado para tabla dinámica con un borde negro fino en WHOLE_TABLE y una fuente roja en negrita en GRAND_TOTAL_ROW, lo aplica mediante setPivotTableStyleName y guarda como .xlsx.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat
from asposecells.api import PivotFieldType, TableStyleElementType, BorderType, CellBorderType
from java.awt import Color
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Poblar datos fuente: fila de encabezado + 9 filas de datos (A1:C10)
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(100)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(200)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(300)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(400)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(500)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(600)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(700)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(800)
worksheet.getCells().get("A10").putValue("Grape")
worksheet.getCells().get("B10").putValue(2021)
worksheet.getCells().get("C10").putValue(900)
# Agregar tabla dinámica con origen en A1:C10, anclada en E3, llamada "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Paso 1: registrar un nuevo estilo personalizado de tabla dinámica y capturar su índice
styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle")
tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex)
# Paso 2: agregar un elemento WholeTable y aplicar bordes negros finos en los cuatro lados
wholeTableElementIndex = tableStyle.getTableStyleElements().add(TableStyleElementType.WHOLE_TABLE)
wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex)
wholeTableStyle = workbook.createStyle()
wholeTableStyle.getBorders().get(BorderType.TOP_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.TOP_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.BOTTOM_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.BOTTOM_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.LEFT_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.LEFT_BORDER).setColor(Color.BLACK)
wholeTableStyle.getBorders().get(BorderType.RIGHT_BORDER).setLineStyle(CellBorderType.THIN)
wholeTableStyle.getBorders().get(BorderType.RIGHT_BORDER).setColor(Color.BLACK)
wholeTableElement.setElementStyle(wholeTableStyle)
# Paso 3: agregar un elemento GrandTotalRow y aplicar fuente roja en negrita
grandTotalElementIndex = tableStyle.getTableStyleElements().add(TableStyleElementType.GRAND_TOTAL_ROW)
grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex)
grandTotalStyle = workbook.createStyle()
grandTotalStyle.getFont().setBold(True)
grandTotalStyle.getFont().setColor(Color.RED)
grandTotalElement.setElementStyle(grandTotalStyle)
# Paso 4: aplicar el estilo personalizado por nombre (NO por PivotTableStyleType, que es para presets integrados)
pivotTable.setPivotTableStyleName("CustomPivotStyle")
workbook.save("output.xlsx")
jpype.shutdownJVM()

Aplicar un único estilo a cada celda de la tabla dinámica con FormatAll

pivotTable.formatAll(Style) es un atajo que aplica un único objeto Style a cada celda de la tabla dinámica, incluyendo el área de datos, los encabezados de fila y columna y los totales. Todo lo establecido previamente mediante setPivotTableStyleType o setPivotTableStyleName queda anulado.

formatAll anula tanto setPivotTableStyleType como setPivotTableStyleName. Utilícelo solo cuando se requiera una apariencia uniforme e independiente del tema en toda la tabla dinámica.

El siguiente ejemplo crea un Style con un relleno sólido amarillo, una fuente azul oscuro en negrita y bordes negros finos en todos los lados, lo aplica con formatAll y guarda como .xlsx.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, Style
from asposecells.api import Color
from asposecells.api import PivotTable, PivotFieldType
from asposecells.api import BorderType, CellBorderType, BackgroundType
# Escenario 4: Aplicar un único Estilo a cada celda de tabla dinámica usando FormatAll
# API en uso: PivotTable.FormatAll(Style)
# Formato de destino: .xlsx
# Referencia de GitHub: ver el repositorio Aspose.Cells-for-.NET — ejemplos de estilo de tablas dinámicas
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
# Poblar datos de origen: fila de encabezado (fila 1) + 9 filas de datos (filas 2-10)
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
worksheet.getCells().get("A2").putValue("Grape")
worksheet.getCells().get("B2").putValue(2020)
worksheet.getCells().get("C2").putValue(5000)
worksheet.getCells().get("A3").putValue("Blueberry")
worksheet.getCells().get("B3").putValue(2020)
worksheet.getCells().get("C3").putValue(3000)
worksheet.getCells().get("A4").putValue("Kiwi")
worksheet.getCells().get("B4").putValue(2020)
worksheet.getCells().get("C4").putValue(4000)
worksheet.getCells().get("A5").putValue("Cherry")
worksheet.getCells().get("B5").putValue(2020)
worksheet.getCells().get("C5").putValue(2000)
worksheet.getCells().get("A6").putValue("Grape")
worksheet.getCells().get("B6").putValue(2021)
worksheet.getCells().get("C6").putValue(6000)
worksheet.getCells().get("A7").putValue("Blueberry")
worksheet.getCells().get("B7").putValue(2021)
worksheet.getCells().get("C7").putValue(3500)
worksheet.getCells().get("A8").putValue("Kiwi")
worksheet.getCells().get("B8").putValue(2021)
worksheet.getCells().get("C8").putValue(4500)
worksheet.getCells().get("A9").putValue("Cherry")
worksheet.getCells().get("B9").putValue(2021)
worksheet.getCells().get("C9").putValue(2500)
worksheet.getCells().get("A10").putValue("Grape")
worksheet.getCells().get("B10").putValue(2021)
worksheet.getCells().get("C10").putValue(5500)
# Agregar tabla dinámica: rango de origen A1:C10, celda de destino E3, nombre "Pivot1"
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Asignar campos dinámicos: Fruta -> área de Fila, Año -> área de Columna, Monto -> área de Datos
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.COLUMN, "Year")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
# Construir un Estilo que se forzará en cada celda de la tabla dinámica
style = workbook.createStyle()
style.setForegroundColor(Color.YELLOW)
style.setPattern(BackgroundType.SOLID)
style.getFont().setIsBold(True)
style.getFont().setColor(Color.DARK_BLUE)
style.getBorders().get(BorderType.TOP_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.TOP_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.BOTTOM_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.BOTTOM_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.LEFT_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.LEFT_BORDER).setColor(Color.BLACK)
style.getBorders().get(BorderType.RIGHT_BORDER).setLineStyle(CellBorderType.THIN)
style.getBorders().get(BorderType.RIGHT_BORDER).setColor(Color.BLACK)
# Aplicar FormatAll: fuerza este único estilo en cada celda de la tabla dinámica,
# sobrescribiendo cualquier PivotTableStyleType / PivotTableStyleName establecido previamente
pivotTable.formatAll(style)
# Guardar el libro en el formato moderno .xlsx
workbook.save("output.xlsx")
jpype.shutdownJVM()

¿Qué API de estilo debo utilizar?

La elección de la API de estilo depende del formato de archivo en el que esté guardando. Utilice la tabla siguiente como referencia rápida.

Formato de archivo de destino	API a utilizar	Notas
`.xls` (heredado)	`pivotTable.setAutoFormatType(int)`	Valores de `com.aspose.cells.pivot.PivotTableAutoFormatType` (p. ej., `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Se ignora al guardar en formatos modernos.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo integrado)	`pivotTable.setPivotTableStyleType(int)`	Valores de `com.aspose.cells.PivotTableStyleType` (temas claros/oscuros, incluidas las adiciones de Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo personalizado)	`pivotTable.setPivotTableStyleName(String)` + `tableStyles.addPivotTableStyle(String)`	Utilícelo cuando los preajustes integrados no sean suficientes. Configure mediante `tableStyleElement.setElementStyle(Style)`.
Cualquier formato (anulación uniforme)	`pivotTable.formatAll(Style)`	Atajo que anula cualquier otra configuración de estilo en toda la tabla dinámica.
En caso de duda, guarde como `.xlsx` y utilice `setPivotTableStyleType` para temas integrados, o `setPivotTableStyleName` para temas personalizados.

Pythonjava: Agregar campos de fila y columna a una tabla dinámica en Aspose.Cells para .NET

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

Agregar un campo a la región de fila o columna

El método PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) mueve un campo base desde los datos de origen a una de las cuatro regiones de la tabla dinámica. El argumento fieldType acepta uno de los siguientes valores de PivotFieldType.

ROW — campos colocados verticalmente a la izquierda
COLUMN — campos colocados horizontalmente en la parte superior
DATA — campos cuyos valores se agregan
PAGE — campos utilizados como filtros de informe Después de agregar los campos, puede acceder a ellos a través de los métodos PivotTable.getRowFields() y PivotTable.getColumnFields(). Cada método devuelve un PivotFieldCollection. El campo en el índice 0 de RowFields es el campo de fila más externo, y los índices siguientes representan campos anidados dentro de él. La misma convención de indexación se aplica a ColumnFields. El orden de anidamiento de los campos es importante. Agregar Category a la región de fila primero y luego Item produce una tabla dinámica cuya agrupación externa es Category y cuya agrupación interna es Item. Invertir el orden invierte la jerarquía.

Subtotales de campo de pivote

El método PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) controla qué filas de subtotal aparecen para un campo de pivote. Cada llamada activa o desactiva un único tipo de subtotal de forma independiente. Pasar shown = true muestra el subtotal, mientras que shown = false lo oculta. Como cada llamada solo afecta a un tipo, llamar al método varias veces con diferentes valores de subtotalType crea un subconjunto personalizado de subtotales. La enumeración PivotFieldSubtotalType define los tipos de subtotales disponibles.

AUTOMATIC — Aspose.Cells elige la selección predeterminada (normalmente SUM para campos numéricos)
NONE — suprime todas las filas de subtotal
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Los subtotales solo se representan cuando hay dos o más campos de pivote en la región de fila (o en la región de columna). Un solo campo no tiene nada significativo que subtotalizar entre ellos, por lo que las llamadas a setSubtotals no tienen ningún efecto visible en ese caso. Por lo tanto, este artículo coloca dos campos de fila (Category externo, Item interno) en cada ejemplo para que el límite del subtotal entre cada grupo Category sea visible.

Escenario 1 — Subtotales automáticos (predeterminados)

Cuando no se llama a setSubtotals en absoluto, Aspose.Cells aplica la selección AUTOMATIC a los campos numéricos. El siguiente ejemplo confirma explícitamente este comportamiento llamando a setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) en el campo de fila Category externo.

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

Escenario 2 — Suprimir todos los subtotales (Ninguno)

Llamar a setSubtotals(PivotFieldSubtotalType.NONE, true) elimina todas las filas de subtotal de la tabla dinámica, dejando solo las filas de campo y el total general en la parte inferior. Esto es útil cuando desea los datos agrupados sin procesar sin ninguna fila de resumen.

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

Escenario 3 — Subconjunto de subtotales personalizado (Suma + Promedio)

No está limitado a un solo tipo de subtotal. Cada llamada a setSubtotals opera de forma independiente en un tipo, por lo que llamar al método dos veces — una vez con SUM y otra con AVERAGE — produce un subconjunto personalizado de dos filas de subtotal para cada grupo Category.

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

Resumen

Los tres escenarios anteriores comparten el mismo conjunto de datos y la misma estructura de tabla dinámica. La única diferencia entre ellos es la llamada a setSubtotals aplicada al campo de fila Category externo. Recuerde la regla de los dos campos: un solo campo en una región no tiene nada que subtotalizar entre ellos, por lo que siempre debe colocar al menos dos campos en la región de fila o columna cuando desee que setSubtotals tenga un efecto visible.

Pythonjava: Campos de Valor en Aspose.Cells for Python via Java

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

Añadir un Campo a la Región de Datos

Añadir un campo base a la región de datos (valor) es el primer paso para dar forma a cómo una tabla dinámica agrega sus datos de origen. Aspose.Cells expone PivotTable.addFieldToArea(PivotFieldType, string), una sobrecarga que acepta la constante PivotFieldType.DATA y el nombre de la columna de origen. Una vez que se añade un campo a la región de datos, la API lo expone a través de la colección PivotTable.DataFields, en el orden en que se añadieron los campos. Por defecto, una columna de origen numérica se resume con ConsolidationFunction.SUM, mientras que una columna no numérica utiliza COUNT por defecto.

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

Cambiar la Función de Resumen

Cada campo colocado en la región de datos se envuelve internamente como una instancia de PivotField, y su propiedad Function devuelve un valor de la enumeración ConsolidationFunction. El mismo setter Function le permite cambiar entre los agregados disponibles, incluyendo SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STDDEV, STDDEVP, VAR y VARP.

Cambiar Function solo afecta al agregado, la columna de origen no cambia.

Por lo tanto, puede dejar un campo de datos como SUM mientras añade un segundo campo de datos que apunte a la misma columna de origen pero use COUNT o AVERAGE, todo en una sola tabla dinámica.

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

Colocar Campos de Valor en el Eje de Filas o Columnas

Cuando una tabla dinámica contiene dos o más campos de datos, Aspose.Cells expone un campo virtual adicional llamado PivotTable.ValuesField. Este campo virtual representa el agregado de cada campo de datos que reside en la región de datos. Puede arrastrarlo a la región de Filas o Columnas como un campo dinámico base, lo cual resulta útil para disponer múltiples medidas una junto a otra.

PivotTable.ValuesField no funciona si no hay ningún campo de valor o si solo hay uno.

Los escenarios a continuación recorren tres ejemplos de extremo a extremo que demuestran cada capacidad descrita anteriormente contra la misma estructura de tabla dinámica.

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

Pythonjava: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

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

Aspose.Cells admite el ciclo de vida completo de los campos de filtro en tablas dinámicas. Puede añadir un campo de filtro mediante una API de conveniencia de alto nivel o mediante la colección de nivel inferior page_fields, y puede controlar el filtro de página en modo de selección única, limpiarlo para mostrar todos los elementos de la página, o cambiar el campo a selección múltiple para que los usuarios puedan elegir varios elementos de la página a la vez a través de la interfaz de casillas de verificación en Excel.

Introducción

Un campo de filtro es un campo dinámico que controla qué subconjunto de los datos de origen muestra el cuerpo de la tabla dinámica. Los usuarios finales lo ven como un menú desplegable en la parte superior de una tabla dinámica renderizada en Excel, y al seleccionar uno de los elementos de página disponibles, el cuerpo de la tabla dinámica se reconstruye de modo que solo se resuman los registros que pertenecen a ese elemento de página. Un campo dinámico se convierte en un campo de filtro cuando se registra como PivotFieldType.PAGE en lugar de PivotFieldType.ROW, PivotFieldType.COLUMN o PivotFieldType.DATA. Un campo de filtro puede operar en dos comportamientos. En el comportamiento predeterminado de selección única, solo un elemento de página es visible a la vez, por lo que el cuerpo de la tabla dinámica resume exactamente un subconjunto. En el comportamiento de selección múltiple, el campo expone una lista de casillas de verificación, y el cuerpo de la tabla dinámica resume la unión de cada elemento de página marcado. El mismo campo de origen se puede mover de un lado a otro entre estos comportamientos alternando una sola propiedad. Aspose.Cells for Python via Java expone dos formas equivalentes de registrar un campo de filtro. La API de alto nivel es PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName"), que toma el nombre de la columna de origen y añade el campo en una sola llamada. La API de nivel inferior es PivotTable.page_fields.add(PivotField), que se utiliza cuando ya tiene una referencia PivotField y desea añadir la misma instancia de campo al área de filtro. Ambas APIs terminan rellenando la misma colección page_fields, y el resto de este artículo demuestra cómo elegir entre ellas y cómo controlar cada modo de filtrado.

Añadir un campo de filtro

Hay dos formas de registrar un campo dinámico en el área de filtro. La llamada de alto nivel toma el nombre de la columna de origen como una cadena de texto y es la ruta más común. La llamada de nivel inferior acepta una instancia existente de PivotField y es conveniente cuando el mismo objeto de campo debe reutilizarse en múltiples áreas dinámicas. Ambas llamadas colocan el campo en PivotTable.page_fields, tras lo cual aparece como el menú desplegable de página en la parte superior de la tabla dinámica renderizada.

Añadir un campo de filtro con add_field_to_area

El siguiente ejemplo construye un pequeño conjunto de datos de Fruta / Año / Cantidad, coloca una tabla dinámica en la celda E3 con Fruit en el área de filas, Amount en el área de datos, y Year en el área de filtro, actualiza la tabla dinámica y guarda el libro.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, PivotFieldType
# Crear un nuevo libro de trabajo
workbook = Workbook()
worksheet = workbook.getWorksheets().get(0)
worksheet.setName("Data")
# Configurar la fila de encabezado
worksheet.getCells().get("A1").putValue("Fruit")
worksheet.getCells().get("B1").putValue("Year")
worksheet.getCells().get("C1").putValue("Amount")
# Poblar 9 filas de datos de muestra: Fruta, Año, Cantidad
data = [
    ["apple", 2020, 100],
    ["banana", 2021, 200],
    ["apple", 2021, 150],
    ["grape", 2020, 120],
    ["orange", 2022, 180],
    ["banana", 2020, 90],
    ["grape", 2021, 130],
    ["apple", 2022, 170],
    ["orange", 2021, 110]
]
for i in range(len(data)):
    worksheet.getCells().get(i + 1, 0).putValue(data[i][0])
    worksheet.getCells().get(i + 1, 1).putValue(data[i][1])
    worksheet.getCells().get(i + 1, 2).putValue(data[i][2])
# Agregar una tabla dinámica anclada en la celda E3
pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1")
pivotTable = worksheet.getPivotTables().get(pivotIndex)
# Agregar campos a sus áreas: Fruta como Fila, Cantidad como Dato, Año como campo de Página
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# Actualizar y calcular los datos de la tabla dinámica
pivotTable.calculateData()
# Guardar el libro de trabajo
workbook.save("pageFieldSample.xlsx")
jpype.shutdownJVM()

Añadir un campo de filtro con page_fields.add

Cuando ya trabaja con una instancia de PivotField, puede pasarla directamente a PivotTable.page_fields.add. La tabla dinámica y el campo de filtro se construyen exactamente como en el escenario anterior; solo se reemplaza el registro final del área de filtro con la llamada a la API de nivel inferior.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotTable, PivotField, PivotFieldType
# — La tabla dinámica y el campo de página se construyen exactamente como en
#   el Escenario 1a (datos de Fruta/Año/Cantidad, pivote en E3, Fruta→Fila,
#   Cantidad→Datos). A continuación obtenemos el PivotField de Año de
#   la colección BaseFields y lo pasamos a PageFields.Add — la
#   alternativa de bajo nivel a AddFieldToArea. El resultado es
#   funcionalmente idéntico al Escenario 1a.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Encabezados
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
# Datos de muestra (9 filas)
sheet.getCells().get("A2").putValue("apple");    sheet.getCells().get("B2").putValue("2020"); sheet.getCells().get("C2").putValue(100)
sheet.getCells().get("A3").putValue("apple");    sheet.getCells().get("B3").putValue("2021"); sheet.getCells().get("C3").putValue(150)
sheet.getCells().get("A4").putValue("apple");    sheet.getCells().get("B4").putValue("2022"); sheet.getCells().get("C4").putValue(200)
sheet.getCells().get("A5").putValue("grape");    sheet.getCells().get("B5").putValue("2020"); sheet.getCells().get("C5").putValue(300)
sheet.getCells().get("A6").putValue("grape");    sheet.getCells().get("B6").putValue("2021"); sheet.getCells().get("C6").putValue(400)
sheet.getCells().get("A7").putValue("grape");    sheet.getCells().get("B7").putValue("2022"); sheet.getCells().get("C7").putValue(500)
sheet.getCells().get("A8").putValue("blueberry"); sheet.getCells().get("B8").putValue("2020"); sheet.getCells().get("C8").putValue(250)
sheet.getCells().get("A9").putValue("blueberry"); sheet.getCells().get("B9").putValue("2021"); sheet.getCells().get("C9").putValue(350)
sheet.getCells().get("A10").putValue("blueberry");sheet.getCells().get("B10").putValue("2022"); sheet.getCells().get("C10").putValue(450)
# Agregar tabla dinámica en E3 cubriendo A1:C10
pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1")
pivotTable = sheet.getPivotTables().get(pivotIndex)
# Fruta -> Fila, Cantidad -> Datos (Año irá a la Página abajo)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
# Enfoque de bajo nivel: tomar el PivotField de Año existente de BaseFields
# y registrarlo en el área de Página mediante PageFields.Add(PivotField).
yearField = pivotTable.getBaseFields().get("Year")
pivotTable.getPageFields().add(yearField)
# Actualizar para que el nuevo campo de página se refleje en el libro guardado
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Filtrado de selección única (mostrando un elemento de página)

En el comportamiento predeterminado de selección única, el campo de filtro se renderiza como un único menú desplegable y el entero PivotField.current_page_item selecciona qué elemento de página dirige el cuerpo de la tabla dinámica. Asignar un índice específico elige ese único elemento; asignar el centinela especial 0x7FFD (decimal 32765) limpia el filtro para que cada elemento de página se resuma a la vez. La selección única es el valor predeterminado; no necesita habilitarla explícitamente.

Mostrar todos los elementos

Establecer current_page_item al valor mágico 0x7FFD equivale a limpiar el filtro de página: el cuerpo de la tabla dinámica resume cada elemento de página como si no se aplicara ningún filtro.

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
# Crear un nuevo libro de trabajo
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
# Poblar datos de Fruta/Año/Cantidad
sheet.getCells().get("A1").putValue("Fruit")
sheet.getCells().get("B1").putValue("Year")
sheet.getCells().get("C1").putValue("Amount")
data = [
    ["Apple", 2022, 100],
    ["Apple", 2023, 150],
    ["Banana", 2022, 80],
    ["Banana", 2023, 120],
    ["Cherry", 2022, 200],
    ["Cherry", 2023, 250]
]
for r in range(len(data)):
    for c in range(len(data[r])):
        sheet.getCells().get(r + 1, c).putValue(data[r][c])
# Crear tabla dinámica en E3
pivotTables = sheet.getPivotTables()
index = pivotTables.add("=A1:C7", "E3", "PivotTable1")
pivotTable = pivotTables.get(index)
# Configurar campos dinámicos: Fruta→Fila, Cantidad→Datos, Año→Página
pivotTable.addFieldToArea(PivotFieldType.ROW, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.DATA, "Amount")
pivotTable.addFieldToArea(PivotFieldType.PAGE, "Year")
pivotTable.calculateData()
# Limpiar el filtro de página para que cada elemento del campo de página sea visible.
# 0x7FFD (decimal 32765) es el valor centinela especial que significa "todos los elementos" —
# equivalente a seleccionar "(Todos)" en el menú desplegable del campo de página de Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD)
workbook.save("output.xlsx")
jpype.shutdownJVM()

Mostrar un elemento específico

Establecer current_page_item a un índice real elige solo ese elemento de página. El índice es la posición del elemento en la lista ordenada de elementos del campo de filtro, por ejemplo, 1 selecciona el segundo elemento después de ordenar.

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

Filtrado de selección múltiple

El filtrado de selección múltiple convierte el menú desplegable de página en una lista de casillas de verificación y permite al usuario final seleccionar varios elementos de página simultáneamente. Aspose.Cells expone dos propiedades que trabajan juntas. PivotField.is_multiple_item_selection_allowed debe establecerse en True antes de que la interfaz de selección múltiple surta efecto. Una vez habilitada, PivotItem.is_hidden controla qué elementos aparecen en la lista de casillas de verificación, por lo que puede mostrar cada elemento o incluir en la lista blanca solo elementos específicos. El código siguiente habilita la selección múltiple en el mismo campo de filtro Year construido en el Escenario 1a, y luego muestra dos patrones: la Parte A revela cada elemento de página dejando is_hidden establecido en False para cada entrada, mientras que la Parte B incluye en la lista blanca solo los valores de origen que elija y oculta todo lo demás mediante un bloque switch (pivot_items[i].get_string_value()).

import jpype
import asposecells
jpype.startJVM()
from asposecells.api import Workbook
from asposecells.api import Workbook, Worksheet, Cells, Range, SaveFormat, PivotFieldType
import os
import re
# — La tabla dinámica y el campo de página se construyen exactamente como en
#   Escenario 1a (datos de Fruta/Año/Cantidad, pivote en E3, Fruta→Fila,
#   Cantidad→Datos, Año→Página mediante AddFieldToArea).
#   A continuación aplicamos el filtrado de selección múltiple en el campo de página.
workbook = Workbook()
sheet = workbook.getWorksheets().get(0)
cells = sheet.getCells()
# Datos de ejemplo: Fruta | Año | Cantidad
cells.get(0, 0).putValue("Fruit")
cells.get(0, 1).putValue("Year")
cells.get(0, 2).putValue("Amount")
data = [
    ["apple",  "2019", "100"],
    ["apple",  "2020", "150"],
    ["apple",  "2021", "200"],
    ["banana", "2019", "110"],
    ["banana", "2020", "160"],
    ["banana", "2021", "210"],
    ["grape",  "2019", "120"],
    ["grape",  "2020", "170"],
    ["grape",  "2021", "220"]
]
for i in range(len(data)):
    cells.get(i + 1, 0).putValue(data[i][0])
    cells.get(i + 1, 1).putValue(int(data[i][1]))
    cells.get(i + 1, 2).putValue(int(data[i][2]))
pivotSheet = workbook.getWorksheets().add("Pivot")
pivots = pivotSheet.getPivotTables()
pivotIndex = pivots.add("E3", "A1:C10", "PivotTable1")
pivotTable = pivots.get(pivotIndex)
pivotTable.addFieldToArea(PivotFieldType.Row, "Fruit")
pivotTable.addFieldToArea(PivotFieldType.Data, "Amount")
pivotTable.addFieldToArea(PivotFieldType.Page, "Year")
# — Habilitar selección múltiple en el campo de página
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(True)
# Parte A — seleccionar TODOS los elementos (hacer visible cada elemento)
pivotItems = pivotTable.getPageFields().get(0).getPivotItems()
for i in range(pivotItems.getCount()):
    pivotItems.get(i).setHidden(False)
# Parte B — seleccionar solo elementos específicos por valor de origen
for i in range(pivotItems.getCount()):
    value = pivotItems.get(i).getStringValue()
    if value == "2020" or value == "grape" or value == "blueberry":
        pivotItems.get(i).setHidden(False)
    else:
        pivotItems.get(i).setHidden(True)
pivotTable.calculateData()
workbook.save("output.xlsx")
jpype.shutdownJVM()

Nota: Cuando use el filtrado de selección múltiple a través de PivotItem.is_hidden, al menos un PivotItem debe permanecer visible (is_hidden == False). Si cada elemento está oculto, Excel se bloquea al abrir el archivo o renderiza una tabla dinámica en blanco. Verifique siempre que su lista blanca de selección múltiple incluya al menos un elemento de sus datos de origen.

¿Qué API y qué modo debo usar?

La tabla siguiente resume cuándo usar cada API y modo para que pueda elegir la combinación correcta sin leer cada escenario en detalle.

Escenario / Caso de uso	API recomendada	Propiedad utilizada	Notas
Añadir un campo de filtro por nombre de columna de origen (lo más común)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "fieldName")`	n/a	Alto nivel, una sola línea. Use esto a menos que necesite una referencia `PivotField`.
Añadir un campo de filtro cuando ya tiene un objeto `PivotField`	`PivotTable.page_fields.add(PivotField)`	n/a	Use cuando el objeto de campo se obtuvo en otro lugar o necesita reutilizarse.
Filtrar a un único elemento de página (modo predeterminado)	`PivotField.current_page_item`	establecido a un índice específico	Por ejemplo, `1` muestra el segundo elemento en la lista ordenada.
Mostrar todos los elementos / limpiar el filtro de página	`PivotField.current_page_item`	establecido a `0x7FFD`	El valor mágico `0x7FFD` (decimal 32765) es el centinela de “todos los elementos”.
Habilitar la interfaz de selección múltiple en Excel	`PivotField.is_multiple_item_selection_allowed`	establecido a `True`	Requerido antes de que cualquier llamada a `is_hidden` surta efecto.
Ocultar / mostrar elementos individuales en una lista de selección múltiple	`PivotItem.is_hidden`	establecido por elemento	Al menos un elemento debe permanecer visible (`is_hidden == False`).

Recuerde siempre la restricción de visibilidad al configurar el filtrado de selección múltiple. Si cada PivotItem en un campo de filtro de selección múltiple está oculto, Excel se bloquea al abrir o renderiza una tabla dinámica en blanco. Construya su lista blanca contra sus datos de origen para que al menos un elemento permanezca visible, y sus libros guardados se abrirán de forma fiable en cualquier máquina.

Documentation – Tablas dinámicas

Pythonjava: Crear una tabla dinámica

Crear una tabla dinámica

Pythonjava: Formato de celdas de tabla dinámica

Pythonjava: Actualizar tablas dinámicas y cachés de tablas dinámicas en Aspose.Cells for Python via Java

Introducción

Inicio rápido

Importaciones requeridas

Actualizar todas las tablas dinámicas del libro

Actualizar todas las tablas dinámicas en una sola hoja de cálculo

Actualizar una sola tabla dinámica

Cambiaron los datos de origen — Use PivotCache.refresh()

Solo cambió la vista/diseño — Use calculateData()

Migración desde el obsoleto PivotTable.refreshData()

¿Qué API de actualización debo usar?

Errores comunes

Pythonjava: Aplicar estilos a tablas dinámicas en Aspose.Cells for Python via Java

Introducción

Aplicar un autoformato preestablecido heredado de XLS

Aplicar un estilo de tabla dinámica preestablecido con nombre moderno

Definir y aplicar un estilo personalizado de tabla dinámica

Aplicar un único estilo a cada celda de la tabla dinámica con FormatAll

¿Qué API de estilo debo utilizar?

Pythonjava: Agregar campos de fila y columna a una tabla dinámica en Aspose.Cells para .NET

Agregar un campo a la región de fila o columna

Subtotales de campo de pivote

Escenario 1 — Subtotales automáticos (predeterminados)

Escenario 2 — Suprimir todos los subtotales (Ninguno)

Escenario 3 — Subconjunto de subtotales personalizado (Suma + Promedio)

Resumen

Pythonjava: Campos de Valor en Aspose.Cells for Python via Java

Añadir un Campo a la Región de Datos

Cambiar la Función de Resumen

Colocar Campos de Valor en el Eje de Filas o Columnas

Pythonjava: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

Introducción

Añadir un campo de filtro

Añadir un campo de filtro con add_field_to_area

Añadir un campo de filtro con page_fields.add

Filtrado de selección única (mostrando un elemento de página)

Mostrar todos los elementos

Mostrar un elemento específico

Filtrado de selección múltiple

¿Qué API y qué modo debo usar?

Cambiaron los datos de origen — Use `PivotCache.refresh()`

Solo cambió la vista/diseño — Use `calculateData()`

Migración desde el obsoleto `PivotTable.refreshData()`