Documentation – Infoga pivot tabell

Pythonnet: Formatera Pivot tabell

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

Pivottabellens utseende

Hur man skapar en pivottabell förklarar hur man skapar en enkel pivottabell. Den här artikeln beskriver hur man anpassar en pivottabells utseende genom att ställa in olika egenskaper:

Pivottabellformatalternativ
Alternativ för pivottabellfältformat
Alternativ för datafältformat

Hur man ställer in pivottabellsformatalternativ

Klassen PivotTable kontrollerar den övergripande pivottabellen och kan formateras på olika sätt.

Hur man ställer in automatiskt format typ

Microsoft Excel erbjuder olika förinställda rapportformat. Aspose.Cells för Python via .NET stöder också dessa formateringsalternativ. För att komma åt dem:

Ställ in PivotTable.is_auto_format till true.
Tilldela ett formateringsalternativ från uppräkningen PivotTableAutoFormatType.

Hur man ställer in formateringsalternativ

Kodprovet nedan visar hur man formaterar pivottabellen för att visa totaler för rader och kolumner, och hur man ställer in rapportens fältsortering. Det visar också hur man ställer in en anpassad sträng för nollvärden.

Manuell formatering av utseende

För att manuellt formatera hur pivottabelrapporten ser ut, istället för att använda förinställda rapportformat, använd PivotTable.format_all(style)- och PivotTable.format(row, column, style)-metoderna. Skapa en stilobjekt för önskad formatering, till exempel:

Hur man ställer in pivottabellsfältformatalternativ

Klassen PivotField representerar ett fält i en pivottabell och kan formateras på olika sätt. Kodprovet nedan visar hur man:

Tillgång till radfält.
Inställning av delsummer.
Inställning av autosortering.
Inställning av autoshow.

Hur man ställer in rad/kolumn/sida fältformat

Hur man ställer in datafältformat

Kodprovet nedan visar hur man ställer in visningsformat och nummerformat för datafält.

Hur man rensar pivottabellsfält

Klassen PivotFieldCollection har en metod som heter clear() som låter dig rensa pivottabellsfält. Använd den när du vill rensa alla pivottabellfält i områdena, till exempel sida, kolumn, rad eller data. Kodprovet nedan visar hur man rensar alla pivottabellfält i ett dataområde.

Pythonnet: Skapa pivottabeller och pivotdiagram

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

En pivottabell är en interaktiv sammanfattning av poster. Till exempel kan du ha hundratals faktura-poster i en lista i ett kalkylblad. En pivottabell kan summera fakturorna efter kund, produkt eller datum. Med Microsoft Excel är det möjligt att snabbt omorganisera informationen i pivottabellen genom att dra knappar till en ny position.

Ett pivotdiagram är en interaktiv grafisk representation av data i en pivottabell. Pivotdiagram introducerades i Excel 2000. Att använda ett pivotdiagram gör det ännu enklare att förstå data eftersom pivottabellen skapar delsummer och totaler automatiskt.

Aspose.Cells för Python via .NET stöder pivottabeller och pivottabell-diagram.

Lägg till pivottabeller och diagram med Aspose.Cells för Python Excel-bibliotek

Aspose.Cells för Python via .NET tillhandahåller en speciell uppsättning klasser som används för att skapa pivottabeller. Dessa klasser används för att skapa och ställa in PivotTable-objekt, vilket fungerar som grundläggande byggstenar för ett PivotTable-objekt:

PivotField, ett fält i en pivottabellrapport.
PivotFields, en samling av alla PivotField-objekt i en pivottabell.
PivotTable, en pivottabellrapport på ett kalkylblad.
PivotTables, en samling av alla PivotTable-objekt på kalkylbladet.

Förbered att använda Aspose.Cells för Python via .NET

Installera Aspose.Cells for Python via .NET från pypi, använd kommandot: $ pip install aspose-cells-python.
Du kan också följa steg-för-steg-instruktionerna om hur du installerar “Aspose.Cells för Python via .NET” till din utvecklingsmiljö.

Hur du lägger till en pivottabell med hjälp av Aspose.Cells för Python Excel-bibliotek

För att skapa en pivottabell med Aspose.Cells för Python via .NET:

Lägg till lite data i ett kalkylbladsceller med hjälp av en Cell-objekts put_value-metod. Du använder också en mallfil som redan är ifylld med data. Datan kommer att användas som pivottabellens datakälla.
Lägg till en pivot tabell till arbetsbladet genom att anropa PivotTables -samlingens add-metod (inkapslad i Worksheet-objektet).
Hämta det nya PivotTable-objektet från PivotTables-samlingen genom att ange dess index. # Använd något av de pivottabellobjekt som är inkapslade i PivotTable-objektet för att hantera tabellen.

Kodexempel ges nedan.

Hur man lägger till ett pivottabell-diagram med hjälp av Aspsoe.Cells för Python Excel-bibliotek

För att skapa ett pivotdiagram med Aspose.Cells för Python via .NET:

Lägg till en graf.
Ange grafens PivotSource så att den hänvisar till en befintlig pivot tabell i kalkylarket.
Ange andra attribut.

Pythonnet: Pivot tabell och källdata

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

Pivot-tabellens källdata

Det finns tillfällen då du vill skapa Microsoft Excel-rapporter med pivottabeller som hämtar data från olika datakällor (t.ex. en databas) som inte är kända vid design-tid. Denna artikel ger en metod för att dynamiskt ändra en pivot-tabells datakälla.

Ändra en pivot-tabells källdata

Skapa en ny designer-mall.
1. Skapa en ny designer-mallfil enligt skärmbilden nedan.
2. Definiera sedan ett namngivet område, Datakälla, som hänvisar till detta cellområde.
  
  Skapa en designer-mall & definiera ett namngivet område, Datakälla

Skapa en pivot-tabell baserad på detta namngivna område.
1. I Microsoft Excel, välj Data, sedan Pivottabell och PivotDiagramrapport.
2. Skapa en pivottabell baserad på det namngivna området som skapats i det första steget.
  
  Skapa en pivottabell baserad på det namngivna området, DataSource

Dra det motsvarande fältet till pivottabellraden och kolumnen, skapa sedan den resulterande pivottabellen enligt skärmdumpen nedan.

Skapa en pivottabell baserad på ett motsvarande fält

Högerklicka på pivottabellen och välj Tabelloptioner.
1. Markera Uppdatera vid öppning i inställningarna för Dataalternativ.
  
  Inställning av pivottabellalternativ

Nu kan du spara den här filen som din designer-mallfil.

Försörjning av ny data och ändring av källdata för en pivottabell.
1. När den designer-mall är skapad, använd följande kod för att ändra källan till pivottabellen.

Genom att köra den här exempelkoden nedan ändras källan till pivottabellen.

Pythonnet: Lägg till beräknat fält i pivottabell

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

Möjliga användningsscenario

När du skapar en pivottabell baserad på kända data finner du att datan i den inte är det du vill ha. Den data du vill ha är kombinationen av denna ursprungliga data. Till exempel behöver du lägga till, subtrahera, multiplicera och dividera den ursprungliga datan innan du vill ha datan. Vid den här tiden behöver du bygga ett beräknat fält och ställa in motsvarande formel för beräkning. Utför sedan vissa statistik och andra operationer på det beräknade fältet.

Hur man lägger till beräknat fält i pivot-tabell i Excel

Så här lägger du till ett beräknat fält i en pivot-tabell i Excel, följ dessa steg:

Välj pivottabellen som du vill lägga till ett beräknat fält i.
Gå till fliken Pivottabell analysera på menyfliken.
Klicka på “Fält, artiklar och uppsättningar” och välj sedan “Beräknat fält” i rullgardinsmenyn.
I fältet “Namn” anger du ett namn för det beräknade fältet.
I fältet “Formel” anger du formeln för beräkningen du vill utföra med hjälp av lämpliga PivotTable-fältnamn och matematiska operatorer.
Klicka på “ok” för att skapa det beräknade fältet.
Det nya beräknade fältet kommer att visas i PivotTable Field List under avsnittet Värden.
Dra det beräknade fältet till värdesektionen i PivotTable för att visa de beräknade värdena.

Hur man lägger till ett beräknat fält i pivot-tabell med Aspose.Cells för Python Excel Library

Lägg till beräknat fält i Excel-fil med Aspose.Cells för Python via .NET. Se följande exempelkod. Efter att exempelkoden har utförts, läggs en pivot-tabell med beräknat fält till kalkylarket.

Ange originaldata och skapa en pivot-tabell.
Skapa det beräknade fältet enligt det befintliga PivotField i pivot-tabellen.
Lägg till det beräknade fältet i dataområdet.
Slutligen sparas arbetsboken i utdata XLSX-format.

Exempelkod

Pythonnet: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

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

Aspose.Cells stöder tillämpning av både äldre pivot-autoformat (avsedda för .xls-filer) och moderna namngivna eller anpassade pivottabellstilar (avsedda för .xlsx-, .xlsm- och .xlsb-filer). Vilket API du bör anropa beror på det filformat som arbetsboken sparas till, inte det format den laddades från.

Introduktion

Aspose.Cells exponerar två parallella stil-API:er för pivottabeller. Valet mellan dem styrs av det filformat du sparar arbetsboken till, inte av det format du läser från. En arbetsbok som laddats från en .xls-fil kan sparas om som .xlsx, och i det fallet gäller det moderna stil-API:et snarare än det äldre.

För äldre .xls-utdata använder du egenskapen PivotTable.auto_format_type tillsammans med enumerationen aspose.cells.pivot.PivotTableAutoFormatType. Detta API motsvarar den autoformatväljare som klassisk Excel erbjöd för pivottabeller.

För moderna .xlsx-, .xlsm- och .xlsb-utdata finns två varianter av stil-API:

PivotTable.pivot_table_style_type väljer en av de inbyggda namngivna stilarna (ljusa och mörka teman, inklusive de stilar som lades till i Excel 2017). Dessa förinställningar är skrivskyddade.
PivotTable.pivot_table_style_name väljer en anpassad stil som du själv definierar via workbook.worksheets.table_styles.add_pivot_table_style(...). Anpassade stilar krävs när du vill ändra färger, kanter eller typsnitt utöver vad förinställningarna erbjuder.

Dessutom är PivotTable.format_all(Style) en genväg som tillämpar ett enda Style-objekt på varje cell i pivoten och åsidosätter vad som än ställts in via något av stil-namns-API:erna ovan. Detta är användbart när ett enhetligt utseende krävs oavsett det underliggande temat.

Tillämpa ett äldre XLS-förinställt autoformat

PivotTable.auto_format_type accepterar ett värde från enumerationen aspose.cells.pivot.PivotTableAutoFormatType. De tillgängliga värdena är REPORT_1 till REPORT_10, CLASSIC och TABLE_1 till TABLE_10.

auto_format_type respekteras endast när arbetsboken sparas som .xls. När samma arbetsbok sparas som .xlsx, .xlsm eller .xlsb ignorerar Excel denna egenskap och faller tillbaka på inställningarna pivot_table_style_type och pivot_table_style_name.

Följande exempel laddar en ny arbetsbok, fyller i exempeldata för Fruit/Year/Amount, lägger till en pivottabell, tillämpar PivotTableAutoFormatType.REPORT_5 och sparar resultatet som .xls.

Varför inga kolumnfält? Autoformaten i Report-serien (Report1 till Report10, Table1 till Table10) designades i klassiska Excel för endimensionella pivottabeller med endast radfält och värden — de har ingen inbyggd formatering för kolumnfält-rubriker. Om din pivottabell behöver kolumnfält, använd de moderna PivotTableStyleType-förinställningarna från Scenario 2 nedan istället, som är designade för den tvådimensionella layout som moderna Excel använder.

import aspose.cells as ac

# Scenario 1: Tillämpa ett äldre XLS-förinställt autoformat
# API som används: PivotTable.AutoFormatType
# Målfilformat: .xls (äldre)
# För fullständiga exempel och datafiler, vänligen gå till https://github.com/aspose-cells/Aspose.Cells-for-.NET

# Skapa en ny arbetsbok
workbook = ac.Workbook()

# Hämta det första kalkylbladet
sheet = workbook.worksheets[0]

# Fyll källdata med rubrikrad (Fruit, Year, Amount)
# och 9 datarader som täcker grape, blueberry, kiwi, cherry över 2020 och 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)

# Lägg till en pivottabell vid destinationscell E3, med namnet "Pivot1", med källintervall A1:C10
pivot_index = sheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = sheet.pivot_tables[pivot_index]

# Tilldela fält: Fruit -> Rader, Year -> Kolumner, Amount -> Data
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Tillämpa det äldre XLS-förinställda autoformatet "Report5"
# Obs: Den här egenskapen är endast meningsfull när den sparas som .xls.
# När den sparas som .xlsx/.xlsm/.xlsb ignorerar Excel AutoFormatType
# och använder det som PivotTableStyleType / PivotTableStyleName anger.
pivot_table.auto_format_type = ac.PivotTableAutoFormatType.REPORT5

# Spara arbetsboken i äldre .xls-format
workbook.save("output.xls")

Tillämpa en modern namngiven förinställd pivottabellsstil

PivotTable.pivot_table_style_type accepterar ett värde från enumerationen aspose.cells.PivotTableStyleType. Enumerationen täcker ljusa teman PIVOT_TABLE_STYLE_LIGHT_1 till PIVOT_TABLE_STYLE_LIGHT_28 och mörka teman PIVOT_TABLE_STYLE_DARK_1 till PIVOT_TABLE_STYLE_DARK_28. Stilarna som lades till i Excel 2017 (den andra vågen av ljusa och mörka teman) nås via samma enumeration.

Detta är det rekommenderade API:et för alla moderna filformat. Till skillnad från det äldre autoformatet återges stilen som väljs här troget av Excel och överlever rundresor genom andra Office-verktyg.

Följande exempel använder samma Fruit/Year/Amount-data, skapar en identisk pivottabell, tillämpar PIVOT_TABLE_STYLE_DARK_1 och sparar arbetsboken som .xlsx.

import aspose.cells as ac

# Scenario 2: Tillämpa en modern förinställd stil från Excel 2007+ med PivotTableStyleType.
# Målfilformat: .xlsx. PivotTableStyleType-enum finns i Aspose.Cells-namnområdet
# (inte i Aspose.Cells.Pivot) — det är därför vi inte behöver någon extra using för det.
# GitHub-referens: https://github.com/aspose-cells/Aspose.Cells-for-.NET/blob/master/Examples/CSharp/PivotTables/ApplyStyleToPivotTable2.cs

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

# Huvudrad: Fruit / Year / Amount
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# 9 datarader med Fruit / Year / 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(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)

# Lägg till en pivottabell vid E3 med namnet "Pivot1", med källa från A1:C10
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Tilldela pivotfält: Fruit -> Rad-område, Year -> Kolumn-område, Amount -> Data-område
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")

# Tillämpa en modern förinställd pivotstil från Excel 2007+.
# PivotTableStyleType är det korrekta API:et för .xlsx / .xlsm / .xlsb-filer; AutoFormatType
# ignoreras av Excel för dessa format. PivotTableStyleDark1 tillhör det mörka temat
# familjen (PivotTableStyleDark1..PivotTableStyleDark28), och samma enum exponerar också de
# nyare Excel 2017 ljusa/mörka teman (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivot_table.pivot_table_style_type = ac.PivotTableStyleType.PivotTableStyleDark1

# Spara som modern .xlsx — det är formatet för vilket PivotTableStyleType är meningsfullt.
workbook.save("output.xlsx")

Definiera och tillämpa en anpassad pivottabellsstil

De inbyggda förinställningarna kan inte modifieras. När du behöver åsidosätta färger, kanter eller typsnitt måste du definiera en anpassad pivotstil. Arbetsflödet har tre steg:

Lägg till en anpassad stil i arbetsbokens table_styles-samling via workbook.worksheets.table_styles.add_pivot_table_style(name). Detta returnerar indexet för den nyskapade stilen.
Konfigurera stilen genom att lägga till element (såsom WHOLE_TABLE eller GRAND_TOTAL_ROW) via table_style.table_style_elements.add(TableStyleElementType), och tilldela sedan en Style till varje element via table_style_element.set_element_style(Style).
Tillämpa den anpassade stilen på pivoten genom att sätta PivotTable.pivot_table_style_name till stilens namn. Använd inte pivot_table_style_type här, eftersom den egenskapen väljer inbyggda förinställningar.

pivot_table_style_name och pivot_table_style_type är inte utbytbara. Använd pivot_table_style_type för inbyggda förinställningar, och pivot_table_style_name för anpassade stilar som du har definierat via add_pivot_table_style. Att sätta båda är ofarligt, men det är bara den som matchar den avsedda källan som återges.

De tillgängliga TableStyleElementType-värdena inkluderar WHOLE_TABLE, FIRST_ROW, LAST_ROW, FIRST_COLUMN, LAST_COLUMN, GRAND_TOTAL_ROW, GRAND_TOTAL_COLUMN, PAGE_FIELD_LABELS och PAGE_FIELD_VALUES.

Följande exempel definierar en anpassad pivotstil med en tunn svart kant på WHOLE_TABLE och ett fetstilt rött typsnitt på GRAND_TOTAL_ROW, och tillämpar den sedan via pivot_table_style_name och sparar som .xlsx.

import aspose.cells as ac
import System.Drawing

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

# Fyll i källdata: rubrikrad + 9 datarader (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)

# Lägg till pivottabell med källa från A1:C10, förankrad vid E3, med namnet "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")

# Steg 1: registrera en ny anpassad pivottabellstil och fånga dess index
style_index = workbook.worksheets.table_styles.add_pivot_table_style("CustomPivotStyle")
table_style = workbook.worksheets.table_styles[style_index]

# Steg 2: lägg till ett WholeTable-element och tillämpa tunna svarta kanter på alla fyra sidor
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)

# Steg 3: lägg till ett GrandTotalRow-element och tillämpa fet röd text
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)

# Steg 4: tillämpa den anpassade stilen efter namn (INTE efter PivotTableStyleType, vilket är för inbyggda förinställningar)
pivot_table.pivot_table_style_name = "CustomPivotStyle"

workbook.save("output.xlsx")

Tillämpa en stil på varje pivotcell med FormatAll

PivotTable.format_all(Style) är en genväg som tillämpar ett enda Style-objekt på varje cell i pivottabellen, inklusive dataområdet, rad- och kolumnrubriker samt totalsummor. Vad som tidigare ställts in via pivot_table_style_type eller pivot_table_style_name åsidosätts.

format_all åsidosätter både pivot_table_style_type och pivot_table_style_name. Använd det endast när ett enhetligt, temaoberoende utseende krävs över hela pivoten.

Följande exempel skapar en Style med en gul solid fyllning, ett fetstilt mörkblått typsnitt och tunna svarta kanter på alla sidor, och tillämpar den sedan med format_all och sparar som .xlsx.

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

# Scenario 4: Tillämpa en enda Stil på varje pivottabellcell med FormatAll
# API som används: PivotTable.FormatAll(Style)
# Målformat: .xlsx
# GitHub-referens: se Aspose.Cells-for-.NET-arkivet — exempel på pivottabellstil

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

# Fyll i källdata: rubrikrad (rad 1) + 9 datarader (raderna 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)

# Lägg till pivottabell: källområde A1:C10, målcell E3, namn "Pivot1"
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Tilldela pivotfält: Fruit -> Rad-område, Year -> Kolumn-område, Amount -> Data-område
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")

# Bygg en Stil som kommer att tvingas på varje cell i pivottabellen
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

# Tillämpa FormatAll: tvingar denna enda stil på varje cell i pivottabellen,
# och åsidosätter eventuell PivotTableStyleType / PivotTableStyleName som tidigare ställts in
pivot_table.format_all(style)

# Spara arbetsboken i det moderna .xlsx-formatet
workbook.save("output.xlsx")

Vilket stil-API bör jag använda?

Valet av stil-API beror på det filformat du sparar till. Använd tabellen nedan som en snabbreferens.

Målfilformat	API att använda	Anteckningar
`.xls` (äldre)	`PivotTable.auto_format_type`	Värden från `aspose.cells.pivot.PivotTableAutoFormatType` (t.ex. `REPORT_1`–`REPORT_10`, `CLASSIC`, `TABLE_1`–`TABLE_10`). Ignoreras vid sparande som moderna format.
`.xlsx` / `.xlsm` / `.xlsb` (modern, inbyggd stil)	`PivotTable.pivot_table_style_type`	Värden från `aspose.cells.PivotTableStyleType` (ljusa/mörka teman, inklusive tillägg från Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, anpassad stil)	`PivotTable.pivot_table_style_name` + `worksheets.table_styles.add_pivot_table_style(...)`	Använd när de inbyggda förinställningarna inte räcker. Konfigurera via `table_style_element.set_element_style(...)`.
Valfritt format (enhetlig åsidosättning)	`PivotTable.format_all(Style)`	Genväg som åsidosätter alla andra stilinställningar över hela pivoten.

Vid tveksamhet, spara som .xlsx och använd pivot_table_style_type för inbyggda teman, eller pivot_table_style_name för anpassade teman.

Pythonnet: Uppdatera pivottabeller i Aspose.Cells for Python via .NET

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

Aspose.Cells tillhandahåller ett skiktat uppdaterings-API som låter dig läsa in pivotdata på fyra olika omfång — från hela arbetsboken ner till en enskild pivottabell. Från och med Aspose.Cells for Python via .NET v26.7 är den äldre metoden PivotTable.refresh_data() markerad som föråldrad och bör ersättas med de mer effektiva, cache-medvetna API:er som beskrivs i denna artikel.

Introduktion

Att uppdatera en pivottabell är sällan en enskild åtgärd. Bakom kulisserna underhåller Aspose.Cells en skiktad datakedja som kopplar samman dina ursprungliga källdata med de renderade värden du ser i kalkylbladet. Att förstå denna kedja är nyckeln till att välja rätt uppdaterings-API för varje situation.

Den fyra nivåer djupa datakedjan är:

Datakälla — de ursprungliga kalkylbladsintervallen, databasfrågan eller konsolideringsintervallet där råvärdena finns.
PivotCache — ögonblicksbilden i minnet av källdatan. Varje pivottabell byggs ovanpå en PivotCache; det är här all data samlas in och aggregeras.
PivotTable — vyobjektet som definierar rad-, kolumn-, värde- och filterfält. En PivotTable läser bara från sin PivotCache, aldrig direkt från datakällan.
Cells — kalkylbladets Cells som PivotTable renderar sina beräknade värden och stilar till.

Ett särskilt viktigt koncept är delad cache. När flera pivottabeller i en arbetsbok refererar till samma källintervall delar de en PivotCache-instans. En enskild PivotCache kan refereras till av många pivottabeller, och om du uppdaterar den cachen uppdateras alla beroende PivotTables på en gång.

PivotCache.source_type (uppräkning PivotTableSourceType) anger var cache-datan kom ifrån. Från och med v26.7 stöder PivotCache.refresh() endast källtyperna Sheet och Consolidation — det vill säga data som finns i kalkylbladsintervall. Externa källor (databaser, externa anslutningar osv.) kan ännu inte uppdateras via cache-API:et.

På grund av denna kedja finns det två grundläggande uppdateringsvägar i Aspose.Cells:

PivotCache.refresh() — läser in källa → cache OCH beräknar om alla beroende PivotTables i en enda åtgärd.
PivotTable.calculate_data() — beräknar om en PivotTables visning från redan cachad data, utan någon tur-och-retur till datakällan.

Alla scenarier i denna artikel använder kalkylbladsceller som källdata, så källtypen är Sheet och uppdateringsåtgärderna fungerar enligt beskrivningen.

Nödvändiga importer

Alla Python-exempel i denna artikel inleds med följande tre importsatser eftersom pivottyperna finns i namnrymden aspose.cells.pivot:

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

Uppdatera alla pivottabeller i arbetsboken

När du behöver säkerställa att varje pivotcache och varje pivottabell i arbetsboken återspeglar den senaste källdatan är det enklaste och mest heltäckande API:et Workbook.refresh_all(). Ett enda anrop traverserar hela arbetsboken — varje PivotCache uppdateras från sin källa och sedan beräknas varje beroende PivotTable om. Detta är den rekommenderade metoden för generella, dokumentövergripande uppdateringar där prestanda inte är ett problem.

Följande exempel bygger en arbetsbok med ett källintervall för Fruit/Year/Amount, skapar en pivottabell, modifierar några källvärden och använder sedan refresh_all() för att uppdatera allt i ett enda anrop.

import aspose.cells as ac

# Skapa en ny arbetsbok
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Skriv rubrikrad i cellerna A1:C1
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Skriv datarader i cellerna A2:C9 (8 rader med fruktdata över 2020 och 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)

# Lägg till en pivottabell: källområde "A1:C9", målcell "E3", namn "Pivot1"
pivot_index = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Tilldela pivotfält: Fruit till Rader, Year till Kolumner, Amount till Data
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")

# Ändra flera Amount-värden i källdatan för att simulera förändringar
worksheet.cells["C2"].put_value(55)
worksheet.cells["C5"].put_value(85)
worksheet.cells["C9"].put_value(125)

# Uppdatera varje pivottabell / pivotcache i arbetsboken
workbook.refresh_all()

# Spara arbetsboken
workbook.save("output.xlsx")

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Ibland behöver du bara uppdatera de pivottabeller som finns på ett visst kalkylblad — till exempel när pivottabeller på andra kalkylblad är kända för att vara orelaterade och inte bör röras. För detta fall tillhandahåller Aspose.Cells Worksheet.refresh_pivot_tables(), som är begränsat till en enskild Worksheet-instans.

Detta är mer selektivt än Workbook.refresh_all(): endast pivottabellerna på det målsökta kalkylbladet uppdateras, medan pivottabeller på andra kalkylblad lämnas orörda.

Följande exempel fyller i samma Fruit/Year/Amount-källdata, lägger till en pivottabell på det första kalkylbladet, modifierar några källvärden och uppdaterar sedan endast pivottabellerna på det kalkylbladet.

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

Uppdatera en enskild pivottabell

När du vill ha finkornig kontroll över en enskild pivottabell ger det cache-baserade API:et dig två alternativ. Valet mellan dem beror på vad som faktiskt har ändrats: den underliggande källdatan, eller bara pivottabellens vy-/layoutinställningar.

Källdata har ändrats — Använd `PivotCache.refresh()`

Om den underliggande källdatan har ändrats är rätt startpunkt pivot_table.pivot_cache.refresh(). Detta anrop läser om källdatan in i cachen och beräknar sedan om varje PivotTable som är beroende av den cachen.

Eftersom pivottabeller delar en enda PivotCache-instans beräknar ett anrop till PivotCache.refresh() om alla pivottabeller som är byggda på den cachen — inte bara den du refererar till. Om två pivottabeller delar samma källintervall uppdaterar en cache-uppdatering båda.

Följande exempel skapar två pivottabeller på samma källintervall för att demonstrera detta delade cache-beteende, modifierar några källvärden och uppdaterar sedan genom en cache-referens.

import aspose.cells as ac

# Skapa en ny arbetsbok och kom åt det första kalkylbladet
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]

# Skriv rubrikrad: Frukt / År / Belopp
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Skriv ungefär 9 datarader (druva / blåbär / kiwi / körsbär över 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)

# Lägg till den första pivottabellen "Pivot1" förankrad vid cell E3, källintervall A1:C9
pivotIndex1 = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivotTable1 = worksheet.pivot_tables[pivotIndex1]

# Tilldela fält för 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")

# Lägg till en ANDRA pivottabell "Pivot2" förankrad vid E15 med SAMMA källintervall A1:C9
# Både Pivot1 och Pivot2 delar en enda PivotCache eftersom källintervallet är identiskt.
pivotIndex2 = worksheet.pivot_tables.add("A1:C9", "E15", "Pivot2")
pivotTable2 = worksheet.pivot_tables[pivotIndex2]

# Tilldela samma fält för 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")

# Ändra flera belopps cellvärden i källdatan för att simulera en dataändring
worksheet.cells["C2"].put_value(150)
worksheet.cells["C4"].put_value(350)
worksheet.cells["C7"].put_value(650)

# Uppdatera den delade PivotCache.
# Eftersom Pivot1 och Pivot2 delar samma PivotCache, uppdaterar detta enda anrop
# BÅDA pivottabellerna (data + stil) från den uppdaterade källan.
pivotTable1.pivot_cache.refresh()

# Spara arbetsboken
workbook.save("output.xlsx")

Endast vy/layout har ändrats — Använd `calculate_data()`

Om källdatan inte har ändrats men endast pivottabellens vy- eller layoutinställningar har modifierats (till exempel har ett fält flyttats till ett annat område, eller en uppdaterings-vid-öppning-inställning har växlats), finns det ingen anledning att göra en tur-och-retur tillbaka till datakällan. Cachen innehåller redan rätt data; det är bara den renderade PivotTable som behöver beräknas om. I detta fall är pivot_table.calculate_data() rätt val.

Detta undviker det onödiga källhämtningen och är avsevärt snabbare när många pivottabeller delar samma cache.

Följande exempel modifierar en icke-källrelaterad egenskap hos pivottabellen och anropar sedan calculate_data() för att rendera om den från den befintliga cachen.

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

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

# Skriv rubrikraden Fruit / Year / Amount
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Skriv 8 datarader (raderna 2-9, som passar källintervallet 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)

# Lägg till en pivottabell med namnet "Pivot1" placerad i destinationscell E3, med källa från A1:C9
pivot_index = worksheet.pivot_tables.add("A1:C9", "E3", "Pivot1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Tilldela fält: Fruit till Rad, Year till Kolumn, Amount till Data
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")

# Ändra en egenskap för vy/layout — detta är en presentation-förändring,
# så den kräver INTE att källdata läses igen via PivotCache.Refresh().
pivot_table.refresh_data_on_opening_file = False

# CalculateData() renderar om DEN HÄR pivottabellens visning (data + stil) från
# datan som redan finns i PivotCache. Eftersom källdatan inte ändrades,
# görs ingen tur och retur till källan — endast de cachade värdena beräknas om
# till arbetsbladets celler.
pivot_table.calculate_data()

# Spara arbetsboken till disk
workbook.save("output.xlsx")

Hämta alla pivottabeller som delar samma PivotCache

En arbetsbok innehåller ofta många pivottabeller som alla ligger ovanpå en delad cache. För att räkna upp dem — till exempel innan du utför en batchuppdatering, eller för att diagnostisera delad cache-påverkan — använd PivotCache.get_pivot_tables(). Denna metod returnerar samlingen av varje PivotTable som är beroende av den givna cachen.

Detta är också det mest direkta sättet att bekräfta att två pivottabeller verkligen delar samma PivotCache-instans: du kan jämföra cache-referenser, eller helt enkelt iterera samlingen som returneras av get_pivot_tables() och observera vilka pivottabeller som förekommer i den.

Följande exempel skapar två pivottabeller på samma källintervall, verifierar att de delar samma cache-instans och räknar sedan upp cachens pivottabeller.

Migrera från den föråldrade `PivotTable.refresh_data()`

Före Aspose.Cells for Python via .NET v26.7 var standardmetoden för att uppdatera en pivottabell att anropa PivotTable.refresh_data() på varje pivottabell individuellt. Från och med v26.7 är den metoden markerad som föråldrad och bör ersättas med de cache-medvetna API:er som beskrivs ovan.

Det finns två skäl till att den tabellvisa refresh_data()-metoden är problematisk i verkliga arbetsböcker:

Den hämtar data från källan varje gång den anropas, även när källan inte har ändrats.
Varje anrop uppdaterar hela den delade cachen. När många pivottabeller delar en cache, gör upprepade anrop till refresh_data() per pivottabell att samma cache hämtas om och om igen, vilket är mycket långsamt.

De rekommenderade ersättningarna är:

Uppdatera ALLA pivottabeller i arbetsboken → använd workbook.refresh_all();
Uppdatera NÅGRA av dem → använd pivot_table.pivot_cache.refresh(); för en cache. Eftersom cachen delas, uppdaterar detta enda anrop varje pivottabell som är byggd ovanpå den cachen. Andra pivottabeller som sitter på en redan uppdaterad cache kan tryggt hoppas över.
Endast pivotvyn/layouten har ändrats → använd pivot_table.calculate_data(); för att rendera om från den befintliga cachen utan någon källtur-och-retur.

Följande exempel demonstrerar det nya effektiva mönstret för arbetsböcker med flera pivottabeller som delar en enda cache.

import aspose.cells as ac

# Skapa en ny arbetsbok och öppna det första kalkylbladet
workbook = ac.Workbook()
sheet = workbook.worksheets[0]

# --- Bygg källdatan: Frukt / År / Belopp (rubrik + 9 rader) ---
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)

# --- Lägg till den första pivottabellen (Pivot1) vid målcell 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")

# --- Lägg till den ANDRA pivottabellen (Pivot2) på SAMMA källintervall ---
# Både Pivot1 och Pivot2 delar EN underliggande PivotCache.
# Detta är exakt scenariot där det äldre per-tabell RefreshData()-tillvägagångssättet
# blir ineffektivt: att uppdatera en tabell hämtar om hela
# delade cachen, så att uppdatera N tabeller gör samma dyra hämtning N gånger.
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")

# --- Ändra flera beloppsvärden i källdatan ---
sheet.cells["C2"].put_value(5000)   # Grape  2020
sheet.cells["C5"].put_value(7500)   # Cherry 2020
sheet.cells["C9"].put_value(9500)   # Cherry 2021

# --- FÖRÅLDRAD mönster (före 26.7) — PivotTable.RefreshData() ---
# pivot_table1.refresh_data();  # hämtar om från källan, uppdaterar hela cachen
# pivot_table2.refresh_data();  # hämtar om IGEN — cachen är redan färsk!
# Varje anrop bygger om den delade cachen, så N tabeller = N redundanta hämtningar.

# --- NYTT v26.7+ mönster: uppdatera cachen EN GÅNG, rendera sedan om efter behov ---
# Ett anrop till PivotCache.Refresh() hämtar de ändrade värdena till den delade
# cachen OCH beräknar om visningen av VARJE pivottabell som refererar till den.
# Eftersom Pivot1 och Pivot2 delar en PivotCache, uppdaterar detta enda anrop
# båda tabellerna — ingen andra källomgång krävs.
pivot_table1.pivot_cache.refresh()

# CalculateData() renderar bara om en pivottabells vy (data + stil)
# från data som redan finns i cachen — den rör INTE källan.
# Vi anropar det på Pivot2 här enbart för att demonstrera API:et: efter att cachen
# har uppdaterats en gång, kan vilken som helst beroende tabell renderas om utan att
# gå tillbaka till källan. Använd CalculateData() ensamt när bara
# pivottabellens vy/layoutinställningar har ändrats och cachen är aktuell.
pivot_table2.calculate_data()

workbook.save("output.xlsx")

Vilket uppdaterings-API bör jag använda?

Tabellen nedan sammanfattar de tillgängliga uppdaterings-API:erna och när du bör välja var och en.

Mål	Rekommenderat API	Anteckningar
Uppdatera allt i arbetsboken	`Workbook.refresh_all()`	Ett anrop; täcker alla cachar och tabeller.
Uppdatera endast pivottabeller på ett enskilt blad	`Worksheet.refresh_pivot_tables()`	Begränsat till ett kalkylblad.
Källdata har ändrats för en cache	`pivot_table.pivot_cache.refresh()`	Uppdaterar ALLA pivottabeller på den delade cachen.
Endast vy-/layoutinställningar har ändrats	`pivot_table.calculate_data()`	Hoppar över onödig källtur-och-retur.
Lista alla pivottabeller på en delad cache	`pivot_cache.get_pivot_tables()`	Använd för att räkna upp före bulkuppdatering.

I praktiken bör du föredra de cache-baserade API:erna framför den föråldrade tabellvisa refresh_data(). De är medvetna om delade cachar, de undviker redundanta källhämtningar, och de låter dig välja det minsta omfång som uppfyller ditt uppdateringskrav.

Pythonnet: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i rad- eller kolumnområdet

Metoden PivotTable.add_field_to_area(PivotFieldType field_type, string field_name) flyttar ett basfält från källdata till ett av de fyra pivotområdena. Argumentet field_type accepterar ett av följande PivotFieldType-värden.

ROW — fält placerade vertikalt till vänster
COLUMN — fält placerade horisontellt överst
DATA — fält vars värden aggregeras
PAGE — fält som används som rapportfilter

När fälten har lagts till kan du komma åt dem via egenskaperna PivotTable.row_fields och PivotTable.column_fields. Varje egenskap returnerar en PivotFieldCollection. Fältet vid index 0 i row_fields är det yttersta radfältet, och efterföljande index representerar fält som är nästlade inuti det. Samma indexeringskonvention gäller för column_fields.

Ordningen på fältnästningen är viktig. Att lägga till Category i radområdet först och sedan Item skapar en pivot vars yttre gruppering är Category och vars inre gruppering är Item. Om ordningen vänds så vänds också hierarkin.

Delsummor för pivotfält

Metoden PivotField.set_subtotals(PivotFieldSubtotalType subtotal_type, bool shown) styr vilka delsummarader som visas för ett pivotfält. Varje anrop växlar en enskild delsummatyp oberoende av de andra. Att skicka shown = True visar delsummaraden, medan shown = False döljer den. Eftersom varje anrop endast påverkar en typ kan du bygga en anpassad delmängd av delsummor genom att anropa metoden flera gånger med olika subtotal_type-värden.

Uppräkningen PivotFieldSubtotalType definierar de tillgängliga typerna av delsummor.

AUTOMATIC — Aspose.Cells väljer standardvalet (vanligtvis SUM för numeriska fält)
NONE — undertrycker alla delsummarader
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STDDEV
STDDEVP
VAR
VARP

Delsummor visas endast när det finns två eller flera pivotfält i radområdet (eller i kolumnområdet). Ett enskilt fält saknar meningsfull grund för delsummor, så anrop till set_subtotals har ingen synlig effekt i det fallet. Denna artikel placerar därför två radfält (Category ytterst, Item innerst) i varje exempel så att delsummogränsen mellan varje Category-grupp blir synlig.

Scenario 1 — Automatiska (standard) delsummor

När du inte anropar set_subtotals alls tillämpar Aspose.Cells valet AUTOMATIC på numeriska fält. Följande exempel bekräftar uttryckligen detta beteende genom att anropa set_subtotals(PivotFieldSubtotalType.AUTOMATIC, True) på det yttre Category-radfältet.

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

Scenario 2 — Undertrycka alla delsummor (None)

Att anropa set_subtotals(PivotFieldSubtotalType.NONE, True) tar bort alla delsummarader från pivottabellen och lämnar endast fältraderna och totalsumman längst ner. Detta är användbart när du vill ha den råa grupperade datan utan några sammanfattningsrader.

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

Scenario 3 — Anpassad delmängd av delsummor (Sum + Average)

Du är inte begränsad till en enskild delsummatyp. Varje anrop till set_subtotals verkar oberoende på en typ, så att anropa metoden två gånger — en gång med SUM och en gång med AVERAGE — skapar en anpassad delmängd av två delsummarader för varje Category-grupp.

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

Sammanfattning

De tre scenarierna ovan delar samma dataset och pivottabellstruktur. Den enda skillnaden mellan dem är anropet till set_subtotals som tillämpas på det yttre Category-radfältet. Kom ihåg regeln om två fält: ett enskilt fält i ett område saknar meningsfull grund för delsummor, så placera alltid minst två fält i rad- eller kolumnområdet när du vill att set_subtotals ska ha en synlig effekt.

Pythonnet: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i dataregionen

Att lägga till ett basfält i data- (värde-)regionen är det första steget för att forma hur en pivottabell aggregerar dina källdata. Aspose.Cells exponerar PivotTable.add_field_to_area(PivotFieldType, str), en överlagring som accepterar konstanten PivotFieldType.DATA och källkolumnens namn. När ett fält har lagts till i dataregionen exponerar API:et det via samlingen PivotTable.data_fields, i den ordning som fälten lades till. Som standard sammanfattas en numerisk källkolumn med ConsolidationFunction.SUM, medan en icke-numerisk kolumn som standard blir Count.

from aspose.cells.pivot import PivotFieldType

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

# Rubriker i 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")

# Datarader A2:D9 med nästlade slingor som förgrenar sig på 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)

# Lägg till pivottabell vid F3 med namnet PivotTable1
pivot_index = worksheet.pivot_tables.add("A1:D9", "F3", "PivotTable1", True, False)
pivot_table = worksheet.pivot_tables[pivot_index]

# Pivotlayout: Kategori och Objekt på Rad, År på Kolumn, Belopp som datafält
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")

Ändra summeringsfunktionen

Varje fält som placeras i dataregionen omsluts internt som en PivotField-instans, och dess egenskap function returnerar ett värde från enum ConsolidationFunction. Samma function-setter låter dig växla mellan de tillgängliga aggregaten, inklusive Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var och Varp.

Att ändra function påverkar bara aggregatet, källkolumnen ändras inte.

Du kan därför låta ett datafält vara kvar som Sum medan du lägger till ett andra datafält som riktar sig mot samma källkolumn men använder Count eller Average, allt i en enda pivot.

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

Placera värdefält på rad- eller kolumnaxeln

När en pivottabell innehåller två eller fler datafält exponerar Aspose.Cells ett ytterligare virtuellt fält kallat PivotTable.values_field. Detta virtuella fält representerar aggregatet av varje datafält som finns i dataregionen. Du kan dra det till rad- eller kolumnregionen som ett baspivotfält, vilket är användbart för att lägga ut flera mått sida vid sida.

PivotTable.values_field fungerar inte om det inte finns något eller bara ett värdefält.

Scenarierna nedan går igenom tre kompletta exempel som demonstrerar varje funktionalitet som beskrivs ovan mot samma pivotstruktur.

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

# Plotta värdefälten på kolumnaxeln.
pivot_table.add_field_to_area(ac.PivotFieldType.COLUMN, pivot_table.values_field)

pivot_table.calculate_data()

workbook.save("output_plot.xlsx")

Pythonnet: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

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

Aspose.Cells stöder hela livscykeln för filterfält i pivottabeller. Du kan lägga till ett filterfält via ett bekvämt API på hög nivå eller via den lägre nivåns page_fields-samling, och du kan styra sidfiltret i enkelvalsläge, rensa det för att visa varje sidobjekt, eller växla fältet till flerval så att användare kan välja flera sidobjekt samtidigt via kryssrutegränssnittet i Excel.

Introduktion

Ett filterfält är ett pivotfält som styr vilken delmängd av källdatan som pivotkroppen visar. Slutanvändare ser det som en rullgardinsmeny överst i en renderad pivot i Excel, och val av ett av de tillgängliga sidobjekten bygger om pivotkroppen så att endast posterna som tillhör det sidobjektet sammanfattas. Ett pivotfält blir ett filterfält när det registreras som PivotFieldType.PAGE snarare än PivotFieldType.ROW, PivotFieldType.COLUMN eller PivotFieldType.DATA.

Ett filterfält kan fungera i två beteenden. I standardbeteendet enkelval är endast ett sidobjekt synligt åt gången, så pivotkroppen sammanfattar exakt en delmängd. I beteendet flerval exponerar fältet en kryssrutelista, och pivotkroppen sammanfattar unionen av varje ikryssat sidobjekt. Samma källfält kan flyttas fram och tillbaka mellan dessa beteenden genom att växla en enskild egenskap.

Aspose.Cells for Python via .NET exponerar två likvärdiga sätt att registrera ett filterfält. API:et på hög nivå är PivotTable.add_field_to_area(PivotFieldType.PAGE, "field_name"), som tar källkolonnens namn och lägger till fältet i ett enda anrop. API:et på lägre nivå är PivotTable.page_fields.add(PivotField), som används när du redan har en PivotField-referens och vill lägga till samma fältinstans i filterområdet. Båda API:erna slutar med att fylla samma page_fields-samling, och resten av denna artikel visar hur du väljer mellan dem och hur du styr varje filtreringsläge.

Lägga till ett filterfält

Det finns två sätt att registrera ett pivotfält i filterområdet. Anropet på hög nivå tar källkolonnens namn som en sträng och är den vanligaste vägen. Anropet på lägre nivå accepterar en befintlig PivotField-instans och är bekvämt när samma fältobjekt måste återanvändas över flera pivotområden. Båda anropen placerar fältet i PivotTable.page_fields, varefter det visas som sidans rullgardinsmeny överst i den renderade pivoten.

Lägga till ett filterfält med add_field_to_area

Följande exempel bygger ett litet Fruit / Year / Amount-dataset, placerar en pivottabell vid cell E3 med Fruit i radområdet, Amount i dataområdet och Year i filterområdet, uppdaterar pivoten och sparar arbetsboken.

import aspose.cells as ac

# Skapa en ny arbetsbok
workbook = ac.Workbook()
worksheet = workbook.worksheets[0]
worksheet.name = "Data"

# Ställ in rubrikraden
worksheet.cells["A1"].put_value("Fruit")
worksheet.cells["B1"].put_value("Year")
worksheet.cells["C1"].put_value("Amount")

# Fyll i 9 rader med exempeldata: 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])

# Lägg till en pivottabell förankrad vid cell E3
pivot_index = worksheet.pivot_tables.add("A1:C10", "E3", "PivotTable1")
pivot_table = worksheet.pivot_tables[pivot_index]

# Lägg till fält i deras områden: Fruit som Rad, Amount som Data, Year som Sidfält
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")

# Uppdatera och beräkna pivottabellens data
pivot_table.calculate_data()

# Spara arbetsboken
workbook.save("pageFieldSample.xlsx")

Lägga till ett filterfält med page_fields.add

När du redan arbetar med en PivotField-instans kan du skicka den direkt till PivotTable.page_fields.add. Pivottabellen och filterfältet konstrueras exakt som i föregående scenario; endast den slutliga registreringen i filterområdet ersätts med API-anropet på lägre nivå.

import aspose.cells as ac

# — Pivottabellen och sidfältet konstrueras exakt som i
#   Scenario 1a (Fruit/Year/Amount-data, pivot vid E3, Fruit→Rad,
#   Amount→Data). Nedan hämtar vi Year-PivotField från
#   BaseFields-samlingen och skickar det till PageFields.Add — det
#   lågnivåalternativet till AddFieldToArea. Resultatet är
#   funktionellt identiskt med Scenario 1a.

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

# Rubriker
sheet.cells["A1"].put_value("Fruit")
sheet.cells["B1"].put_value("Year")
sheet.cells["C1"].put_value("Amount")

# Exempeldata (9 rader)
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)

# Lägg till pivottabell vid E3 som täcker A1:C10
pivot_index = sheet.pivot_tables.add("E3", "A1:C10", "PivotTable1")
pivot_table = sheet.pivot_tables[pivot_index]

# Fruit -> Rad, Amount -> Data (Year kommer att gå till Sida nedan)
pivot_table.add_field_to_area(ac.PivotFieldType.ROW, "Fruit")
pivot_table.add_field_to_area(ac.PivotFieldType.DATA, "Amount")

# Lågnivåmetod: hämta den befintliga Year-PivotField från BaseFields
# och registrera den i Sid-området via PageFields.Add(PivotField).
year_field = pivot_table.base_fields["Year"]
pivot_table.page_fields.add(year_field)

# Uppdatera så att det nya sidfältet återspeglas i den sparade arbetsboken
pivot_table.calculate_data()

workbook.save("output.xlsx")

Enkelvalsfiltrering (visa ett sidobjekt)

I standardbeteendet enkelval renderas filterfältet som en enda rullgardinsmeny och heltalsvärdet PivotField.current_page_item väljer vilket sidobjekt som styr pivotkroppen. Att tilldela ett specifikt index väljer det ena objektet; att tilldela det speciella sentinelvärdet 0x7FFD (decimalt 32765) rensar filtret så att varje sidobjekt sammanfattas på en gång. Enkelval är standard; du behöver inte aktivera det explicit.

Visa alla objekt

Att sätta current_page_item till det magiska värdet 0x7FFD är likvärdigt med att rensa sidfiltret: pivotkroppen sammanfattar varje sidobjekt som om inget filter tillämpades.

import aspose.cells as ac

# Skapa en ny arbetsbok
workbook = ac.Workbook()
sheet = workbook.worksheets[0]

# Fylla i Fruit/Year/Amount-data
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])

# Skapa pivottabell vid E3
pivot_tables = sheet.pivot_tables
index = pivot_tables.add("=A1:C7", "E3", "PivotTable1")
pivot_table = pivot_tables[index]

# Konfigurera pivotfält: Fruit→Rad, Amount→Data, Year→Sida
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()

# Rensa sidfiltret så att alla objekt i sidfältet visas.
# 0x7FFD (decimal 32765) är det speciella sentinelvärdet som betyder "alla objekt" —
# motsvarande att välja "(Alla)" i Excels sidfält-rullgardin.
pivot_table.page_fields[0].current_page_item = 0x7FFD

workbook.save("output.xlsx")

Visa ett specifikt objekt

Att sätta current_page_item till ett verkligt index väljer bara det ena sidobjektet. Indexet är positionen för objektet i filterfältets sorterade objektlista, så till exempel 1 väljer det andra objektet efter sortering.

import aspose.cells as ac

# Skapa arbetsbok
workbook = ac.Workbook()
sheet = workbook.worksheets[0]
cells = sheet.cells

# Lägg till exempeldata (Frukt/År/Belopp)
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")

# Lägg till pivottabell vid E3
pivot_tables = sheet.pivot_tables
pivot_index = pivot_tables.add("A1:C5", "E3", "PivotTable1")
pivot_table = pivot_tables[pivot_index]

# Lägg till fält: Frukt→Rad, Belopp→Data, År→Sida
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")

# Sidfältsspecifika operationer
pivot_table.page_fields[0].current_page_item = 1  # 1 = andra objektet i sorterad ordning (t.ex. "2021")

# Uppdatera och beräkna pivottabell
pivot_table.calculate_data()

workbook.save("output.xlsx")

Flervalsfiltrering

Flervalsfiltrering förvandlar sidans rullgardinsmeny till en kryssrutelista och låter slutanvändaren välja flera sidobjekt samtidigt. Aspose.Cells exponerar två egenskaper som fungerar tillsammans. PivotField.is_multiple_item_selection_allowed måste sättas till True innan flervalsgränssnittet överhuvudtaget aktiveras. När det är aktiverat styr PivotItem.is_hidden vilka objekt som visas i kryssrutelistan, så du kan antingen visa varje objekt eller vitlista endast specifika objekt.

Koden nedan aktiverar flerval på samma Year-filterfält som byggdes i Scenario 1a, och visar sedan två mönster: Del A visar varje sidobjekt genom att lämna is_hidden satt till False för varje post, medan Del B vitlistar endast de källvärden du väljer och döljer allt annat genom ett if / elif-block som testar pivot_items[i].get_string_value().

import aspose.cells as ac

# — Pivottabellen och sidfältet konstrueras exakt som i
#   Scenario 1a (Fruit/Year/Amount-data, pivot vid E3, Fruit→Rad,
#   Amount→Data, Year→Sida via AddFieldToArea).
#   Nedan tillämpar vi flervalsfiltrering på sidfältet.

workbook = ac.Workbook()
sheet = workbook.worksheets[0]
cells = sheet.cells

# Exempeldata: Fruit | Year | Amount
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")

# — Aktivera flerval på sidfältet
pivot_table.page_fields[0].is_multiple_item_selection_allowed = True

# Del A — välj ALLA objekt (gör alla objekt synliga)
pivot_items = pivot_table.page_fields[0].pivot_items
for i in range(pivot_items.count):
    pivot_items[i].is_hidden = False

# Del B — välj endast specifika objekt efter källvärde
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")

Obs: När du använder flervalsfiltrering via PivotItem.is_hidden måste minst en PivotItem förbli synlig (is_hidden == False). Om varje objekt är dolt kraschar antingen Excel när filen öppnas eller renderas en tom pivot. Verifiera alltid att din flervalsvitlista innehåller minst ett objekt från din källdata.

Vilket API och vilket läge ska jag använda?

Tabellen nedan sammanfattar när du ska använda varje API och läge så att du kan välja rätt kombination utan att läsa varje scenario i detalj.

Scenario / Användningsfall	Rekommenderat API	Egenskap som används	Anteckningar
Lägg till ett filterfält efter källkolonnens namn (vanligast)	`PivotTable.add_field_to_area(PivotFieldType.PAGE, "field_name")`	n/a	Hög nivå, en rad. Använd detta om du inte behöver en `PivotField`-referens.
Lägg till ett filterfält när du redan har ett `PivotField`-objekt	`PivotTable.page_fields.add(PivotField)`	n/a	Använd när fältobjektet erhölls någon annanstans eller behöver återanvändas.
Filtrera till ett enskilt sidobjekt (standardläge)	`PivotField.current_page_item`	sätt till ett specifikt index	Till exempel visar `1` det andra objektet i den sorterade listan.
Visa alla objekt / rensa sidfiltret	`PivotField.current_page_item`	sätt till `0x7FFD`	Det magiska värdet `0x7FFD` (decimalt 32765) är sentinelvärdet för “alla objekt”.
Aktivera flervalsgränssnitt i Excel	`PivotField.is_multiple_item_selection_allowed`	sätt till `True`	Krävs innan några `is_hidden`-anrop får effekt.
Dölj / visa enskilda objekt i en flervalslista	`PivotItem.is_hidden`	sätt per objekt	Minst ett objekt måste förbli synligt (`is_hidden == False`).

Kom alltid ihåg synlighetsbegränsningen när du konfigurerar flervalsfiltrering. Om varje PivotItem i ett flervalsfilterfält är dolt kraschar Excel vid öppning eller renderar en tom pivot. Bygg din vitlista mot din källdata så att minst ett objekt förblir synligt, och dina sparade arbetsböcker öppnas tillförlitligt på varje maskin.

Pythonnet: Ta bort pivottabell från ett arbetsblad

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

Aspose.Cells för Python via .NET ger en funktion för att ta bort eller ta bort pivot-tabell från en arbetsbok. Du kan ta bort pivot-tabellen med hjälp av pivot-tabellobjekt eller pivot-tabellposition. Använd Worksheet.pivot_tables.remove(pivot_table)-metoden för att ta bort pivot-tabellen med pivot-tabellobjekt och Worksheet.pivot_tables.remove_at(index, keep_data)-metoden för att ta bort pivot-tabellobjekt med sin position inuti pivot-tabellkollektionen.

Hur man tar bort pivot-tabell från kalkylblad med hjälp av Aspose.Cells för Python Excel Library

Följande kodexempel tar bort två pivottabeller från arbetsbladet. Först tar det bort pivottabellen med hjälp av Worksheet.pivot_tables.remove(pivot_table) -metoden och sedan tar det bort pivottabellen med hjälp av Worksheet.pivot_tables.remove_at(index, keep_data) -metoden

Pythonnet: Spara pivottabell i ODS fil

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

Hur man sparar pivottabell i ODS-fil

Aspose.Cells för Python via .NET ger möjlighet att spara pivottabell i ODS-filer. För detta konverterar du bara en arbetsbok med befintlig pivottabell eller skapar en ny pivottabell och sparar filen i ODS-format. Se till att anropa PivotTable.calculate_data innan du sparar för att säkerställa att pivottabellen visas i den resulterande ODS-filen. Följande kodsnutt demonstrerar att spara pivottabell i ODS-fil.

Exempelkod

Utdatafilen som genererats av ovanstående kod är bifogad för din referens.

Utgångs-ODS-fil

Documentation – Infoga pivot tabell

Pythonnet: Formatera Pivot tabell

Pivottabellens utseende

Hur man ställer in pivottabellsformatalternativ

Hur man ställer in automatiskt format typ

Hur man ställer in formateringsalternativ

Manuell formatering av utseende

Hur man ställer in pivottabellsfältformatalternativ

Hur man ställer in rad/kolumn/sida fältformat

Hur man ställer in datafältformat

Hur man rensar pivottabellsfält

Pythonnet: Skapa pivottabeller och pivotdiagram

Lägg till pivottabeller och diagram med Aspose.Cells för Python Excel-bibliotek

Förbered att använda Aspose.Cells för Python via .NET

Hur du lägger till en pivottabell med hjälp av Aspose.Cells för Python Excel-bibliotek

Hur man lägger till ett pivottabell-diagram med hjälp av Aspsoe.Cells för Python Excel-bibliotek

Pythonnet: Pivot tabell och källdata

Pivot-tabellens källdata

Ändra en pivot-tabells källdata

Pythonnet: Lägg till beräknat fält i pivottabell

Möjliga användningsscenario

Hur man lägger till beräknat fält i pivot-tabell i Excel

Hur man lägger till ett beräknat fält i pivot-tabell med Aspose.Cells för Python Excel Library

Exempelkod

Pythonnet: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

Introduktion

Tillämpa ett äldre XLS-förinställt autoformat

Tillämpa en modern namngiven förinställd pivottabellsstil

Definiera och tillämpa en anpassad pivottabellsstil

Tillämpa en stil på varje pivotcell med FormatAll

Vilket stil-API bör jag använda?

Pythonnet: Uppdatera pivottabeller i Aspose.Cells for Python via .NET

Introduktion

Nödvändiga importer

Uppdatera alla pivottabeller i arbetsboken

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Uppdatera en enskild pivottabell

Källdata har ändrats — Använd PivotCache.refresh()

Endast vy/layout har ändrats — Använd calculate_data()

Hämta alla pivottabeller som delar samma PivotCache

Migrera från den föråldrade PivotTable.refresh_data()

Vilket uppdaterings-API bör jag använda?

Pythonnet: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i rad- eller kolumnområdet

Delsummor för pivotfält

Scenario 1 — Automatiska (standard) delsummor

Scenario 2 — Undertrycka alla delsummor (None)

Scenario 3 — Anpassad delmängd av delsummor (Sum + Average)

Sammanfattning

Pythonnet: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i dataregionen

Ändra summeringsfunktionen

Placera värdefält på rad- eller kolumnaxeln

Pythonnet: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

Introduktion

Lägga till ett filterfält

Lägga till ett filterfält med add_field_to_area

Lägga till ett filterfält med page_fields.add

Enkelvalsfiltrering (visa ett sidobjekt)

Visa alla objekt

Visa ett specifikt objekt

Flervalsfiltrering

Vilket API och vilket läge ska jag använda?

Pythonnet: Ta bort pivottabell från ett arbetsblad

Hur man tar bort pivot-tabell från kalkylblad med hjälp av Aspose.Cells för Python Excel Library

Pythonnet: Spara pivottabell i ODS fil

Hur man sparar pivottabell i ODS-fil

Exempelkod

Källdata har ändrats — Använd `PivotCache.refresh()`

Endast vy/layout har ändrats — Använd `calculate_data()`

Migrera från den föråldrade `PivotTable.refresh_data()`