DEV Community: Allen Yang

Creating Funnel Charts in PowerPoint Using Python

Allen Yang — Thu, 04 Jun 2026 10:35:37 +0000

Funnel charts are a common data visualization tool, particularly useful for displaying sales processes, user conversion paths, or any data that decreases progressively through stages. In business analysis and marketing reports, funnel charts can intuitively present conversion rates from the initial stage to the final stage.

This article will introduce how to create professional funnel charts in PowerPoint presentations using Python and the Spire.Presentation for Python library. By automating chart generation, you can easily integrate dynamic data into your presentations and improve the efficiency of report creation.

Environment Setup

Before you begin, you need to install the Spire.Presentation for Python library. You can install it using pip:

pip install Spire.Presentation

After installation, you can import and use this library in your Python scripts to manipulate PowerPoint documents.

Creating a Basic Funnel Chart

The process of creating a funnel chart involves several key steps: initializing the presentation, adding the chart, setting up data, configuring styles, and finally saving the file. Below is a complete example showing how to create a basic funnel chart.

from spire.presentation.common import *
from spire.presentation import *

# Create a PPT document object
ppt = Presentation()

# Add a funnel chart to the first slide
# Parameters: ChartType.Funnel specifies the chart type
# RectangleF.FromLTRB(50, 50, 600, 450) defines the chart position and size
chart = ppt.Slides[0].Shapes.AppendChartInit(ChartType.Funnel, RectangleF.FromLTRB(50, 50, 600, 450), False)

# Set series name
chart.ChartData[0, 1].Text = "Series 1"

# Set category labels
categories = ["Website Visits", "Downloads", "Uploads", "Price Inquiry", "Quote Sent", "Closed Deals"]
i = 0
while i < len(categories):
    chart.ChartData[i + 1, 0].Text = categories[i]
    i += 1

# Fill data values
values = [50000, 47000, 30000, 15000, 9000, 5600]
i = 0
while i < len(values):
    chart.ChartData[i + 1, 1].NumberValue = values[i]
    i += 1

# Set series label range
chart.Series.SeriesLabel = chart.ChartData[0, 1, 0, 1]

# Set category label range
chart.Categories.CategoryLabels = chart.ChartData[1, 0, len(categories), 0]

# Assign data values to the series
chart.Series[0].Values = chart.ChartData[1, 1, len(values), 1]

# Set chart title
chart.ChartTitle.TextProperties.Text = "Sales Funnel Analysis"

# Save the document
ppt.SaveToFile("FunnelChart.pptx", FileFormat.Pptx2013)
ppt.Dispose()

Code Explanation

The core logic of the above code is as follows:

Initialize the Presentation: Use Presentation() to create a new PowerPoint document object
Add the Chart: Use the AppendChartInit method to add a funnel chart to the first slide, specifying its position and dimensions
Set Up Data Structure:
- Leave the first row and first column empty
- Set the series name in the first row, second column
- Set category labels (such as "Website Visits", "Downloads", etc.) in subsequent rows of the first column
- Set corresponding values in subsequent rows of the second column
Bind Data: Associate the data with the chart series through the SeriesLabel, CategoryLabels, and Values properties
Set the Title: Use the ChartTitle.TextProperties.Text property to set the chart title
Save the File: Call the SaveToFile method to save the document in PPTX format

Customizing Funnel Chart Styles

After creating a basic funnel chart, you may want to further customize it to enhance visual appeal and professionalism. Spire.Presentation provides rich APIs to adjust various chart properties.

Adjusting Colors and Formatting

You can enhance chart readability by modifying the fill colors of the series:

# Get the first series
series = chart.Series[0]

# Set series fill color
series.Fill.FillType = FillFormatType.Solid
series.Fill.SolidColor.KnownColor = KnownColors.SteelBlue

# Enable data label display
series.DataLabels.LabelValueVisible = True
series.DataLabels.Position = DataLabelPositionType.Center

Tips for Adjusting Chart Position and Size

In practical applications, you may need to adjust the chart position based on the slide layout. The four parameters of the RectangleF.FromLTRB method represent:

Left: Left boundary position (50)
Top: Top boundary position (50)
Right: Right boundary position (600)
Bottom: Bottom boundary position (450)

By adjusting these values, you can precisely control the chart's position and size on the slide. It is recommended to maintain appropriate margins to ensure the chart does not appear too close to the slide edges.

Adding Data Label Formatting

To make the data clearer, you can format the display of data labels:

# Set number format for data labels
series.DataLabels.NumberFormat = "#,##0"

# Set data label font
series.DataLabels.TextProperties.FontHeight = 12
series.DataLabels.TextProperties.LatinFont = TextFont("Arial")

Practical Application Scenarios

Funnel charts have wide applications in multiple business scenarios:

Sales Process Analysis: Track various stages from potential customers to final deals, identifying stages with lower conversion rates.

Marketing Campaign Evaluation: Analyze conversion situations across stages such as ad placement, user clicks, registrations, and purchases.

User Behavior Research: Track user operation paths in applications or websites to optimize user experience.

Recruitment Process Management: Monitor each stage from resume submission to final hiring to improve recruitment efficiency.

By using Python to automatically generate these charts, you can:

Regularly retrieve the latest data from databases or APIs
Automatically generate presentations containing the most recent data
Batch create multiple funnel charts with different dimensions
Reduce the time cost of manually creating charts

Important Considerations

When creating funnel charts with Spire.Presentation, keep the following points in mind:

Data Order: Funnel chart data should be arranged in descending order to correctly display the funnel shape
Number of Categories: It is recommended to keep the number of categories between 5-8; too many categories will make the chart difficult to read
Value Differences: There should be reasonable decreasing relationships between adjacent stages, avoiding excessive jumps
Color Selection: Use colors with moderate contrast to ensure data labels are clearly readable

Summary

This article introduced how to create funnel charts in PowerPoint using Python and the Spire.Presentation for Python library. With simple code, you can quickly generate professional data visualization charts and integrate them into automated reporting workflows.

Funnel charts are an ideal choice for displaying staged data and conversion rates, particularly suitable for scenarios such as sales, marketing, and user analysis. After mastering this skill, you can further explore other chart types, such as bar charts, pie charts, line charts, and more, to meet different data visualization needs.

For more advanced features, you can refer to the official Spire.Presentation documentation to learn about adding animation effects, exporting to images, merging multiple charts, and other operations.

Manage Word Footnotes with Python: Add, Extract, and Edit

Allen Yang — Thu, 04 Jun 2026 10:04:28 +0000

In academic papers, technical reports, and legal documents, footnotes and endnotes are essential tools for providing supplementary information, citing sources, or explaining terminology. Manually adding and managing these annotations is not only time-consuming but also prone to errors when dealing with large volumes of documents. Automating this process with Python can significantly improve both efficiency and accuracy in document processing.

This article demonstrates how to programmatically add footnotes and endnotes to Word documents, customize their formatting, and remove unnecessary annotations using Python. We will use the Spire.Doc for Python library to accomplish these tasks, which provides a comprehensive API for Word document manipulation.

Environment Setup

First, you need to install the Spire.Doc for Python library. This can be easily done using pip:

pip install Spire.Doc

Once installed, you can import and use the relevant modules in your Python scripts.

Adding Footnotes to Word Documents

Footnotes typically appear at the bottom of pages and are used to provide supplementary explanations or citations for content on the current page. The following example demonstrates how to insert footnotes at specific locations in a Word document.

Basic Footnote Insertion

The code below shows how to load an existing document, find specific text, and insert a footnote at that location:

from spire.doc import *
from spire.doc.common import *

# Create a Document object and load the document
document = Document()
document.LoadFromFile("Sample.docx")

# Find the text to which the footnote will be added
selection = document.FindString("Spire.Doc", False, True)
textRange = selection.GetAsOneRange()
paragraph = textRange.OwnerParagraph

# Get the position of the text within the paragraph
index = paragraph.ChildObjects.IndexOf(textRange)

# Create a footnote object
footnote = paragraph.AppendFootnote(FootnoteType.Footnote)
paragraph.ChildObjects.Insert(index + 1, footnote)

# Set the footnote text and its formatting
textRange = footnote.TextBody.AddParagraph().AppendText("Footnote example.")
textRange.CharacterFormat.FontName = "Arial Black"
textRange.CharacterFormat.FontSize = 10
textRange.CharacterFormat.TextColor = Color.get_DarkGray()

# Set the format of the footnote marker
footnote.MarkerCharacterFormat.FontName = "Calibri"
footnote.MarkerCharacterFormat.FontSize = 12
footnote.MarkerCharacterFormat.Bold = True
footnote.MarkerCharacterFormat.TextColor = Color.get_DarkGreen()

# Save the document
document.SaveToFile("AddFootnote.docx", FileFormat.Docx2010)
document.Close()

In this code, we first use the FindString method to locate the target text, then retrieve the paragraph containing that text. A footnote object is created using the AppendFootnote method and inserted immediately after the target text. Both the footnote text content and marker style can be configured independently, including properties such as font, size, and color.

Adding Endnotes

Endnotes are similar to footnotes but typically appear at the end of the document or section, making them suitable for references or lengthy explanations. The code structure for adding endnotes is similar:

from spire.doc import *
from spire.doc.common import *

# Create a document and load the file
doc = Document()
doc.LoadFromFile("Sample.docx")

# Get the first section and specified paragraph
section = doc.Sections[0]
paragraph = section.Paragraphs[1]

# Add an endnote
endnote = paragraph.AppendFootnote(FootnoteType.Endnote)

# Add endnote text
text = endnote.TextBody.AddParagraph().AppendText("Reference: Wikipedia")

# Set text formatting
text.CharacterFormat.FontName = "Impact"
text.CharacterFormat.FontSize = 14
text.CharacterFormat.TextColor = Color.get_DarkOrange()

# Set endnote marker format
endnote.MarkerCharacterFormat.FontName = "Calibri"
endnote.MarkerCharacterFormat.FontSize = 25
endnote.MarkerCharacterFormat.TextColor = Color.get_DarkBlue()

# Save the document
doc.SaveToFile("AddEndnote.docx", FileFormat.Docx)
doc.Close()

The key difference lies in using FootnoteType.Endnote instead of FootnoteType.Footnote. Other operational steps remain essentially the same, allowing independent formatting of both the text and marker.

Customizing Global Settings for Footnotes and Endnotes

In addition to configuring each annotation individually, you can apply global configurations to footnotes and endnotes across an entire section or document. This includes numbering formats, restart rules, and position settings.

from spire.doc import *
from spire.doc.common import *

# Load the document
doc = Document()
doc.LoadFromFile("Sample.docx")

# Get the first section
section = doc.Sections[0]

# Set the footnote numbering format to uppercase letters
section.FootnoteOptions.NumberFormat = FootnoteNumberFormat.UpperCaseLetter

# Set numbering to restart on each page
section.FootnoteOptions.RestartRule = FootnoteRestartRule.RestartPage

# Set footnote position to the end of the section
section.FootnoteOptions.Position = FootnotePosition.PrintAsEndOfSection

# Save the document
doc.SaveToFile("CustomizeFootnote.docx", FileFormat.Docx)
doc.Close()

These global settings allow you to standardize the display of footnotes throughout the entire document. The NumberFormat property supports various numbering formats, including Arabic numerals, Roman numerals, and letters. The RestartRule controls whether numbering continues sequentially or restarts by page or section. The Position property determines whether footnotes appear at the bottom of the page or at the end of the section.

Removing Footnotes from Word Documents

In certain scenarios, you may need to remove existing footnotes or endnotes from a document. The following example demonstrates how to iterate through all paragraphs in a document, locate footnote objects, and delete them.

from spire.doc import *
from spire.doc.common import *

# Load the document
document = Document()
document.LoadFromFile("Sample.docx")

# Iterate through all paragraphs in the first section
section = document.Sections[0]
for y in range(section.Paragraphs.Count):
    paragraph = section.Paragraphs.get_Item(y)
    index = -1
    i = 0
    count = paragraph.ChildObjects.Count

    # Search for footnote objects within the paragraph
    while i < count:
        object = paragraph.ChildObjects[i]
        if isinstance(object, Footnote):
            index = i
            break
        i += 1

    # If a footnote is found, remove it
    if index > -1:
        paragraph.ChildObjects.RemoveAt(index)

# Save the document
document.SaveToFile("RemoveFootnote.docx", FileFormat.Docx)
document.Close()

This code searches for Footnote type objects by iterating through all child objects of each paragraph. Once found, it records the index position and removes the footnote from the paragraph using the RemoveAt method. This approach allows precise deletion of specific footnotes without affecting other document content.

Practical Application Recommendations

In real-world applications, footnote and endnote management can be extended based on specific requirements:

Batch Processing: Iterate through multiple documents to automatically add footnotes for specific keywords, suitable for glossary or standardized document processing
Dynamic Content: Generate footnote content dynamically based on external data sources (such as databases or configuration files) to enable automatic document content updates
Format Standardization: Establish unified footnote format templates for enterprises or institutions to ensure all documents follow consistent visual standards
Citation Management: Combine with bibliographic databases to automatically generate and update reference endnotes in academic documents

Additionally, footnote operations can be integrated with other document processing features, such as:

Automatically adding footnotes during mail merge processes
Preserving or adjusting footnote formats during document conversion
Identifying footnote changes during document comparison

Summary

This article has introduced methods for adding and managing footnotes and endnotes in Word documents using Python. With the Spire.Doc for Python library, we can easily:

Insert footnotes and endnotes at specified locations in documents
Customize the formatting of footnote text and markers
Configure global footnote settings, including numbering formats and positions
Remove unwanted footnotes from documents

These capabilities provide powerful support for automated document processing, particularly valuable in professional scenarios involving frequent handling of documents with extensive annotations. By integrating these operations into larger document processing workflows, you can further enhance work efficiency and ensure consistent document quality.

Create SmartArt Graphics in PowerPoint with Python

Allen Yang — Fri, 29 May 2026 08:37:39 +0000

In modern business presentations, SmartArt graphics serve as a powerful visualization tool that presents complex information, processes, and hierarchical structures in an intuitive manner. Whether it's organizational charts, flowcharts, or cycle diagrams, SmartArt helps audiences quickly grasp key information. This article demonstrates how to create and customize SmartArt graphics in PowerPoint presentations using Python, enabling automated generation of professional presentation documents.

Environment Setup

First, install the Spire.Presentation for Python library:

pip install Spire.Presentation

This library provides a comprehensive PowerPoint API that supports creating, editing, and saving PPT files, including full control over SmartArt graphics.

Basic Steps for Creating SmartArt Graphics

Initialize Presentation and Add SmartArt

The first step in creating SmartArt is to initialize a PowerPoint document object and then add a SmartArt shape to a slide. The position and size of the SmartArt are specified through coordinate parameters:

from spire.presentation import *
from spire.presentation.common import *

# Create a presentation object
presentation = Presentation()

# Get the first slide
slide = presentation.Slides[0]

# Add SmartArt graphic (position x=200, y=60, width=300, height=300)
# Using gear layout type
smartArt = slide.Shapes.AppendSmartArt(
    200, 60, 300, 300, SmartArtLayoutType.Gear)

The AppendSmartArt method accepts five parameters: x-coordinate, y-coordinate, width, height, and layout type. Spire.Presentation supports various built-in layout types, including:

BasicCycle - Basic cycle diagram
Process - Process flowchart
Hierarchy - Hierarchical structure diagram
Relationship - Relationship diagram
Matrix - Matrix diagram
Gear - Gear diagram

Choosing the appropriate layout type is crucial for effectively conveying information.

Set SmartArt Style and Color

After creating the SmartArt, you can enhance its visual appeal by setting styles and colors:

# Set SmartArt style to subtle effect
smartArt.Style = SmartArtStyleType.SubtleEffect

# Set color theme to gradient loop accent 3
smartArt.ColorStyle = SmartArtColorType.GradientLoopAccent3

Styles control the visual effects of shapes (such as shadows, reflections, glows, etc.), while color themes define the overall color scheme of the SmartArt. Available styles include:

SimpleFill - Simple fill
SubtleEffect - Subtle effect
ModerateEffect - Moderate effect
IntenseEffect - Intense effect

Color themes offer dozens of preset color schemes that can be selected based on the overall design style of your presentation.

Managing SmartArt Nodes

Clear Default Nodes

Newly created SmartArt typically contains default nodes. In practical applications, we usually need to clear these default nodes and then add custom content:

# Collect all nodes to be removed
nodes_to_remove = []
for node in smartArt.Nodes:
    nodes_to_remove.append(node)

# Remove all default nodes
for node in nodes_to_remove:
    smartArt.Nodes.RemoveNode(node)

This two-step deletion method is necessary because directly deleting nodes while iterating through the collection would cause iterator errors. Adding nodes to a temporary list first and then deleting them one by one ensures operation stability.

Add Custom Nodes and Set Text

After clearing the default nodes, you can add custom nodes and set their text content:

# Add the first node
node1 = smartArt.Nodes.AddNode()
node1.TextFrame.Text = "Data Collection"

# Add the second node
node2 = smartArt.Nodes.AddNode()
node2.TextFrame.Text = "Data Processing"

# Set text style
node2.TextFrame.TextRange.Fill.FillType = FillFormatType.Solid
node2.TextFrame.TextRange.Fill.SolidColor.KnownColor = KnownColors.Black

Each node contains a TextFrame object for managing the node's text content. Through the TextRange property, you can further control text formatting, including font, color, size, and more.

Modify Text of Existing Nodes

In addition to adding new nodes, you can also modify the text content of existing nodes:

# Load an existing presentation with SmartArt
presentation.LoadFromFile("existing_presentation.pptx")

# Iterate through all shapes on the slide
for shape in presentation.Slides[0].Shapes:
    if isinstance(shape, ISmartArt):
        # Get the second root node (index starts from 0)
        target_node = shape.Nodes[1]
        # Modify node text
        target_node.TextFrame.Text = "Updated Content"

This approach is particularly useful for batch updating SmartArt content in presentations, such as dynamically generating reports based on data sources.

Advanced Customization Techniques

Adjust SmartArt Color Themes

You can dynamically adjust SmartArt color themes based on different scenario requirements:

# Load presentation
presentation.LoadFromFile("template.pptx")

# Iterate through all SmartArt graphics
for shape in presentation.Slides[0].Shapes:
    if isinstance(shape, ISmartArt):
        # Check current color type
        if shape.ColorStyle == SmartArtColorType.ColoredFillAccent1:
            # Change to colorful accent colors theme
            shape.ColorStyle = SmartArtColorType.ColorfulAccentColors

This conditional approach allows intelligent adjustments based on existing styles, avoiding overwriting settings that users have already customized.

Add Nodes by Position

For certain layout types, you can specify the position of new nodes:

# Add child node at a specific position
parent_node = smartArt.Nodes[0]
new_node = parent_node.ChildNodes.AddNodeByPosition(PositionType.After)
new_node.TextFrame.Text = "Sub-process"

This method is very useful when creating hierarchical structures or flowcharts, allowing precise control over node hierarchy relationships and arrangement order.

Set Node Outline Styles

To enhance visual effects, you can set outline styles for SmartArt nodes:

# Set SmartArt node outlines
for node in smartArt.Nodes:
    node.Shape.Line.FillType = FillFormatType.Solid
    node.Shape.Line.SolidFillColor.Color = Color.get_Blue()
    node.Shape.Line.Width = 2.0

Outline settings make SmartArt more clearly visible against different backgrounds, especially improving readability during projected presentations.

Practical Application Example

The following complete example demonstrates how to create a business process SmartArt graphic:

from spire.presentation import *
from spire.presentation.common import *

def create_process_smartart():
    # Create presentation
    presentation = Presentation()
    slide = presentation.Slides[0]

    # Add process-type SmartArt
    smartArt = slide.Shapes.AppendSmartArt(
        100, 100, 500, 200, SmartArtLayoutType.BasicProcess)

    # Set style
    smartArt.Style = SmartArtStyleType.ModerateEffect
    smartArt.ColorStyle = SmartArtColorType.ColorfulAccentColors

    # Clear default nodes
    nodes_to_remove = list(smartArt.Nodes)
    for node in nodes_to_remove:
        smartArt.Nodes.RemoveNode(node)

    # Add business process nodes
    steps = ["Requirements Analysis", "System Design", "Development", "Testing", "Deployment"]
    for step in steps:
        node = smartArt.Nodes.AddNode()
        node.TextFrame.Text = step
        node.TextFrame.TextRange.FontHeight = 14

    # Save file
    presentation.SaveToFile("business_process.pptx", FileFormat.Pptx2010)
    presentation.Dispose()

create_process_smartart()

Result preview:

This example creates a five-step business process diagram, with each step clearly labeled and appropriately sized fonts. By modifying the steps list, you can easily generate flowcharts with different quantities and content.

Practical Tips Summary

When working with SmartArt, keep the following points in mind:

Layout Selection: Choose the appropriate layout based on information type. Flowcharts suit linear processes, hierarchies suit organizational relationships, and cycle diagrams suit periodic processes.
Node Quantity Control: Avoid too many nodes in a single SmartArt. Typically, 5-7 nodes work best; excessive nodes reduce readability.
Color Consistency: Maintain consistency between SmartArt colors and the overall presentation style. Avoid using overly bright or conflicting color combinations.
Text Conciseness: Node text should be brief and concise, avoiding long sentences. If content is extensive, consider using notes or separate explanatory slides.
Automated Batch Generation: Combined with data sources (such as Excel or databases), you can automatically generate multiple SmartArt graphics, significantly improving report production efficiency.

Conclusion

Through Python and Spire.Presentation, we can efficiently create and customize SmartArt graphics to achieve automated generation of presentation documents. This approach is particularly suitable for scenarios requiring regular report generation, flowchart updates, or batch creation of training materials. Mastering the programming control techniques of SmartArt will significantly enhance office automation levels and work efficiency.

With deeper understanding of the API, you can further explore more complex customization features, such as node animations, intelligent layout adjustments, and integration with external data sources, injecting more dynamic and interactive elements into your presentation documents.

Create Radar Charts in Excel with Python

Allen Yang — Fri, 29 May 2026 06:56:16 +0000

Radar charts are a multidimensional data visualization tool, particularly suitable for comparing multiple variables across different dimensions. They are highly practical in scenarios such as performance evaluation, capability analysis, and product comparison. This article will demonstrate how to create radar charts and filled radar charts in Excel using Python, along with customizing chart settings.

Why Use Radar Charts

Radar charts offer the following advantages:

Multidimensional Comparison: Display data across multiple dimensions in a single chart
Intuitive Performance Analysis: Clearly show the distribution of strengths and weaknesses for each metric
Pattern Recognition: Quickly identify data patterns and anomalies through visual shapes
Ideal for Evaluation Scenarios: Such as employee performance reviews, product feature comparisons, and skill matrix analysis

Typical application scenarios include:

Multi-dimensional employee performance evaluation (communication skills, technical abilities, leadership, etc.)
Product feature comparison (price, performance, usability, reliability, etc.)
Market analysis (sales performance across different regions)
Capability model visualization (skill proficiency levels)

Environment Setup

First, install the Spire.XLS for Python library:

pip install Spire.XLS

Spire.XLS provides a comprehensive API for Excel file operations, supporting creation, reading, modification, and conversion of Excel documents without requiring Microsoft Excel installation.

Creating a Basic Radar Chart

We will create a radar chart displaying product sales data across different regions. The sample data includes sales figures for three products (bikes, cars, trucks) in two cities (Paris and New York).

Step 1: Prepare Data and Create Worksheet

First, create an Excel workbook and add sample data:

from spire.xls import *
from spire.xls.common import *

def CreateChartData(sheet):
    # Set product titles
    sheet.Range["A1"].Value = "Product"
    sheet.Range["A2"].Value = "Bikes"
    sheet.Range["A3"].Value = "Cars"
    sheet.Range["A4"].Value = "Trucks"
    sheet.Range["A5"].Value = "Buses"

    # Set Paris sales data
    sheet.Range["B1"].Value = "Paris"
    sheet.Range["B2"].NumberValue = 4000
    sheet.Range["B3"].NumberValue = 23000
    sheet.Range["B4"].NumberValue = 4000
    sheet.Range["B5"].NumberValue = 30000

    # Set New York sales data
    sheet.Range["C1"].Value = "New York"
    sheet.Range["C2"].NumberValue = 30000
    sheet.Range["C3"].NumberValue = 7600
    sheet.Range["C4"].NumberValue = 18000
    sheet.Range["C5"].NumberValue = 8000

    # Set bold font for header row
    sheet.Range["A1:C1"].Style.Font.IsBold = True

    # Set background colors for different rows
    sheet.Range["A2:C2"].Style.KnownColor = ExcelColors.LightYellow
    sheet.Range["A3:C3"].Style.KnownColor = ExcelColors.LightGreen1
    sheet.Range["A4:C4"].Style.KnownColor = ExcelColors.LightOrange
    sheet.Range["A5:C5"].Style.KnownColor = ExcelColors.LightTurquoise

    # Set border styles
    style = sheet.Range["A1:C5"].Style
    borders = style.Borders

    # Set top border
    topborder = borders[BordersLineType.EdgeTop]
    topborder.Color = Color.FromRgb(0, 0, 128)
    borders[BordersLineType.EdgeTop].LineStyle = LineStyleType.Thin

    # Set bottom border
    borders[BordersLineType.EdgeBottom].Color = Color.FromRgb(0, 0, 128)
    sheet.Range["A1:C5"].Style.Borders[BordersLineType.EdgeBottom].LineStyle = LineStyleType.Thin

    # Set left border
    sheet.Range["A1:C5"].Style.Borders[BordersLineType.EdgeLeft].Color = Color.FromRgb(0, 0, 128)
    sheet.Range["A1:C5"].Style.Borders[BordersLineType.EdgeLeft].LineStyle = LineStyleType.Thin

    # Set right border
    sheet.Range["A1:C5"].Style.Borders[BordersLineType.EdgeRight].Color = Color.FromRgb(0, 0, 128)
    sheet.Range["A1:C5"].Style.Borders[BordersLineType.EdgeRight].LineStyle = LineStyleType.Thin

    # Set number format to currency
    sheet.Range["B2:C5"].Style.NumberFormat = "\"$\"#,##0"

# Create workbook
workbook = Workbook()
workbook.CreateEmptySheets(1)
sheet = workbook.Worksheets[0]
sheet.Name = "Chart data"
sheet.GridLinesVisible = False

# Write chart data
CreateChartData(sheet)

This code accomplishes the following tasks:

Creates a table containing product and regional sales data
Applies bold formatting to the header row
Applies different background colors to different data rows to improve readability
Adds dark blue borders to make the table more visually appealing
Formats numerical values in US dollar currency format

Step 2: Add Radar Chart and Configure Properties

Next, add a radar chart to the worksheet and set its properties:

# Add a new chart to the worksheet
chart = sheet.Charts.Add()

# Set chart position
chart.LeftColumn = 1
chart.TopRow = 6
chart.RightColumn = 11
chart.BottomRow = 29

# Set chart data range
chart.DataRange = sheet.Range["A1:C5"]
chart.SeriesDataFromRange = False

# Set chart type to radar chart
chart.ChartType = ExcelChartType.Radar

# Set chart title
chart.ChartTitle = "Sale market by region"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Hide plot area background
chart.PlotArea.Fill.Visible = False

# Set legend position
chart.Legend.Position = LegendPositionType.Corner

# Save document
workbook.SaveToFile("CreateRadarChart.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

Result preview:

Key API explanations:

sheet.Charts.Add(): Adds a new chart object to the worksheet
chart.DataRange: Specifies the data range used by the chart, using the A1:C5 range here
chart.SeriesDataFromRange = False: Indicates that data series are organized by columns rather than rows
ExcelChartType.Radar: Sets the chart type to radar chart (line type)
chart.ChartTitle: Sets the chart title text
chart.PlotArea.Fill.Visible = False: Hides the plot area background for a cleaner chart appearance
LegendPositionType.Corner: Places the legend in the corner position

The generated radar chart displays sales data for each product in both regions using lines, facilitating comparative analysis.

Creating Filled Radar Charts

In addition to standard radar charts, you can also create filled radar charts. This type fills the area between data points with color, creating a more striking visual effect.

# Create workbook
workbook = Workbook()
workbook.CreateEmptySheets(1)
sheet = workbook.Worksheets[0]
sheet.Name = "Chart data"
sheet.GridLinesVisible = False

# Write chart data
CreateChartData(sheet)

# Add a new chart to the worksheet
chart = sheet.Charts.Add()

# Set chart position
chart.LeftColumn = 1
chart.TopRow = 6
chart.RightColumn = 11
chart.BottomRow = 29

# Set chart data range
chart.DataRange = sheet.Range["A1:C5"]
chart.SeriesDataFromRange = False

# Set chart type to filled radar chart
chart.ChartType = ExcelChartType.RadarFilled

# Set chart title
chart.ChartTitle = "Sale market by region"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Hide plot area background
chart.PlotArea.Fill.Visible = False

# Set legend position
chart.Legend.Position = LegendPositionType.Corner

# Save document
workbook.SaveToFile("CreateRadarChart_Fill.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

Result preview:

The main differences between filled radar charts and standard radar charts are:

ExcelChartType.RadarFilled: Uses the filled type, where areas between data points are filled with color
More suitable for emphasizing data ranges and area comparisons
Visually more prominent, ideal for presentations and reports

Customizing Radar Chart Styles

After creating a basic radar chart, you can further customize various chart elements to meet specific presentation requirements.

Adjusting Data Series Colors

You can set different colors for different data series to improve chart distinguishability:

# Get the first data series and set color
series = chart.Series[0]
series.Format.LineProperties.Color = Color.FromRgb(255, 0, 0)  # Red
series.Format.LineProperties.Width = 2.5

# Get the second data series and set color
series2 = chart.Series[1]
series2.Format.LineProperties.Color = Color.FromRgb(0, 0, 255)  # Blue
series2.Format.LineProperties.Width = 2.5

Customizing Axes

You can adjust radar chart axis properties, including scales and label formatting:

# Get the value axis
valueAxis = chart.PrimaryValueAxis

# Set axis title
valueAxis.Title = "Sales Amount"
valueAxis.TitleArea.IsBold = True
valueAxis.TitleArea.Size = 10

# Set axis number format
valueAxis.NumberFormat = "$#,##0"

# Set major gridline style
valueAxis.MajorGridLines.LineProperties.Color = Color.FromRgb(200, 200, 200)
valueAxis.MajorGridLines.LineProperties.DashStyle = LineDashStyleType.Dash

Adding Data Labels

Adding labels to data points can display specific values more clearly:

# Add data labels for each series
for series in chart.Series:
    seriePoints = series.DataPoints
    for point in seriePoints:
        point.DataLabels.HasValue = True
        point.DataLabels.Position = DataLabelPositionType.Above

Adjusting Chart Size and Position

You can adjust the chart's position and size on the worksheet as needed:

# Set the column and row range occupied by the chart
chart.LeftColumn = 1      # Starting column
chart.TopRow = 6          # Starting row
chart.RightColumn = 11    # Ending column
chart.BottomRow = 29      # Ending row

# Or use pixel-level precise control
chart.Top = 100           # Top position (pixels)
chart.Left = 50           # Left position (pixels)
chart.Width = 500         # Width (pixels)
chart.Height = 400        # Height (pixels)

Practical Application Recommendations

When using radar charts in actual projects, consider the following best practices:

Data Preparation

Ensure all dimensions use the same unit of measurement or are normalized
Keep the number of data dimensions manageable, preferably within 5-8 dimensions
Provide clear label descriptions for each dimension

Visual Optimization

Use contrasting colors to distinguish different data series
Appropriately adjust line width and transparency to avoid difficulty in identification when overlapping
Pay attention to data label positioning to avoid occlusion

Interaction Enhancement

In web applications, combine with JavaScript libraries to implement interactive radar charts
Add hover tooltips to display detailed values
Support dynamic toggling to show/hide specific data series

Applicable Scenarios

Performance evaluation systems: Display employee performance across multiple assessment dimensions
Product comparison tools: Compare various metrics of different products
Skill matrices: Visualize team members' skill distributions
Competitive analysis: Compare enterprise metrics against competitors

Summary

This article demonstrated how to create and customize radar charts in Excel using Python. With the Spire.XLS library, we can:

Easily create standard radar charts and filled radar charts
Customize chart properties such as colors, positions, and titles
Adjust the styling of axes, legends, and data labels
Apply radar charts to various data analysis and visualization scenarios

Radar charts are a powerful tool for multidimensional data analysis, especially suitable for scenarios requiring simultaneous comparison of multiple variables. Combined with Python's automation capabilities, you can batch generate radar chart reports, significantly improving data analysis efficiency.

By flexibly utilizing these APIs, you can create professional and aesthetically pleasing radar charts tailored to your specific needs, providing strong support for data analysis and decision-making.

Generating and Customizing Excel Scatter Charts with Python

Allen Yang — Thu, 28 May 2026 09:21:19 +0000

Scatter charts are a commonly used chart type in data analysis for displaying relationships and correlations between two variables. In statistical analysis, scientific research, and business decision-making, scatter charts help us quickly identify data patterns, trends, and outliers.

Python provides convenient ways to automatically generate Excel scatter charts, which is particularly suitable for scenarios requiring batch data processing or dynamic visualization report generation. By creating charts programmatically, we can integrate data analysis and visualization into automated workflows, improving work efficiency.

This article introduces how to create scatter charts in Excel using Python and demonstrates customization operations such as adding trendlines, setting axis labels, and formatting data labels.

Environment Setup

First, install the Spire.XLS for Python library:

pip install Spire.XLS

This library provides a complete Excel file operation API, supporting creation, reading, and modification of Excel documents, including generation and customization of various chart types.

Creating a Basic Scatter Chart

The basic process of creating a scatter chart includes preparing data, creating a chart object, setting the data source, and adjusting the chart position. The following code demonstrates how to create a scatter chart showing the relationship between salary and car prices:

from spire.xls import *
from spire.xls.common import *

# Create workbook
workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Scatter Chart"

# Prepare sample data
sheet.Range["A1"].Value = "Y(Salary)"
sheet.Range["A2"].Value = "42763"
sheet.Range["A3"].Value = "195387"
sheet.Range["A4"].Value = "35672"
sheet.Range["A5"].Value = "217637"
sheet.Range["A6"].Value = "74734"
sheet.Range["A7"].Value = "130550"
sheet.Range["A8"].Value = "42976"
sheet.Range["A9"].Value = "15132"
sheet.Range["A10"].Value = "54936"

sheet.Range["B1"].Value = "X(Car Price)"
sheet.Range["B2"].Value = "19455"
sheet.Range["B3"].Value = "93965"
sheet.Range["B4"].Value = "20858"
sheet.Range["B5"].Value = "107164"
sheet.Range["B6"].Value = "34036"
sheet.Range["B7"].Value = "87806"
sheet.Range["B8"].Value = "17927"
sheet.Range["B9"].Value = "61518"
sheet.Range["B10"].Value = "29479"

# Set data format
sheet.Range["A1:B1"].ColumnWidth = 12
sheet.Range["A1:B1"].RowHeight = 15
sheet.Range["A1:B1"].Style.Color = Color.get_DarkGray()
sheet.Range["A1:B1"].Style.Font.Color = Color.get_White()
sheet.Range["A1:B1"].Style.VerticalAlignment = VerticalAlignType.Center
sheet.Range["A1:B1"].Style.HorizontalAlignment = HorizontalAlignType.Center
sheet.Range["A2:B10"].Style.NumberFormat = "\"$\"#,##0"

# Create scatter chart
chart = sheet.Charts.Add(ExcelChartType.ScatterMarkers)
chart.DataRange = sheet.Range["B2:B10"]
chart.SeriesDataFromRange = False

# Set chart position
chart.LeftColumn = 1
chart.TopRow = 11
chart.RightColumn = 10
chart.BottomRow = 28

# Set chart title
chart.ChartTitle = "Salary vs Car Price Analysis"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Configure data series
chart.Series[0].CategoryLabels = sheet.Range["A2:A10"]
chart.Series[0].Values = sheet.Range["B2:B10"]

# Save file
workbook.SaveToFile("ScatterChart.xlsx", FileFormat.Version2010)
workbook.Dispose()

The core steps of this code include:

Create workbook and worksheet: Use Workbook() to create a new Excel document and get the first worksheet through Worksheets[0]
Fill data: Write X-axis and Y-axis data to specified cell ranges
Create chart object: Add a scatter chart through Charts.Add(ExcelChartType.ScatterMarkers), where ScatterMarkers indicates a scatter chart type using marker points
Bind data source: Set DataRange to specify the chart's data range, and set SeriesDataFromRange to False to manually configure data series
Configure chart properties: Set title, position, and category labels and values for data series

Adding Trendlines

Trendlines are an important supplement to scatter charts, helping to observe overall data trends and change patterns. Spire.XLS supports multiple trendline types, including linear, exponential, logarithmic, and moving average.

The following code demonstrates how to add an exponential trendline to an existing scatter chart:

from spire.xls import *
from spire.xls.common import *

# Load Excel file containing scatter chart
workbook = Workbook()
workbook.LoadFromFile("ScatterChart.xlsx")
sheet = workbook.Worksheets[0]

# Get chart and add trendline
chart = sheet.Charts[0]

# Add exponential trendline
trendline = chart.Series[0].TrendLines.Add(TrendLineType.Exponential)

# Save file
workbook.SaveToFile("ScatterChartWithTrendline.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

The TrendLineType enumeration provides multiple trendline options:

Linear: Linear trendline, suitable for scenarios where data changes in a straight line
Exponential: Exponential trendline, suitable for situations where data grows or decays exponentially
Logarithmic: Logarithmic trendline, suitable for scenarios where data changes rapidly and then stabilizes
Moving_Average: Moving average trendline, used to smooth data fluctuations

Choosing the appropriate trendline type depends on actual data characteristics and analysis purposes.

Setting Axis Labels

Clear axis labels are crucial for chart readability. By setting titles for primary and secondary axes, readers can quickly understand what the chart expresses.

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
workbook.LoadFromFile("ScatterChart.xlsx")
sheet = workbook.Worksheets[0]
chart = sheet.Charts[0]

# Set axis titles
chart.PrimaryValueAxis.Title = "Salary (Yuan)"
chart.PrimaryCategoryAxis.Title = "Car Price (Yuan)"

# Set axis title font styles
chart.PrimaryValueAxis.TitleArea.IsBold = True
chart.PrimaryValueAxis.TitleArea.Size = 10
chart.PrimaryCategoryAxis.TitleArea.IsBold = True
chart.PrimaryCategoryAxis.TitleArea.Size = 10

workbook.SaveToFile("ScatterChartWithAxisLabels.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

PrimaryValueAxis corresponds to the Y-axis (value axis), and PrimaryCategoryAxis corresponds to the X-axis (category axis). The TitleArea property allows further customization of title font, size, color, and other styles.

Customizing Data Labels

Data labels can directly display data point values on the chart, improving information density and readability. The following code demonstrates how to add and format data labels for a line chart:

from spire.xls import *
from spire.xls.common import *

workbook = Workbook()
workbook.CreateEmptySheets(1)
sheet = workbook.Worksheets[0]
sheet.Name = "Demo"

# Prepare data
sheet.Range["A1"].Value = "Month"
sheet.Range["A2"].Value = "Jan"
sheet.Range["A3"].Value = "Feb"
sheet.Range["A4"].Value = "Mar"
sheet.Range["A5"].Value = "Apr"
sheet.Range["A6"].Value = "May"
sheet.Range["A7"].Value = "Jun"

sheet.Range["B1"].Value = "Sales"
sheet.Range["B2"].NumberValue = 25
sheet.Range["B3"].NumberValue = 18
sheet.Range["B4"].NumberValue = 8
sheet.Range["B5"].NumberValue = 13
sheet.Range["B6"].NumberValue = 22
sheet.Range["B7"].NumberValue = 28

# Create line chart with markers
chart = sheet.Charts.Add(ExcelChartType.LineMarkers)
chart.DataRange = sheet.Range["B1:B7"]
chart.SeriesDataFromRange = False

# Set chart position
chart.TopRow = 5
chart.BottomRow = 26
chart.LeftColumn = 2
chart.RightColumn = 11

# Set chart title
chart.ChartTitle = "Sales Data Trend"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Configure data series
cs1 = chart.Series[0]
cs1.CategoryLabels = sheet.Range["A2:A7"]

# Set data labels
cs1.DataPoints.DefaultDataPoint.DataLabels.HasValue = True
cs1.DataPoints.DefaultDataPoint.DataLabels.HasLegendKey = False
cs1.DataPoints.DefaultDataPoint.DataLabels.HasPercentage = False
cs1.DataPoints.DefaultDataPoint.DataLabels.HasSeriesName = True
cs1.DataPoints.DefaultDataPoint.DataLabels.HasCategoryName = True
cs1.DataPoints.DefaultDataPoint.DataLabels.Delimiter = ". "
cs1.DataPoints.DefaultDataPoint.DataLabels.Size = 9
cs1.DataPoints.DefaultDataPoint.DataLabels.Color = Color.get_Red()
cs1.DataPoints.DefaultDataPoint.DataLabels.FontName = "Calibri"
cs1.DataPoints.DefaultDataPoint.DataLabels.Position = DataLabelPositionType.Center

workbook.SaveToFile("ChartWithDataLabels.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

Data label configuration options include:

HasValue: Display data point values
HasSeriesName: Display series name
HasCategoryName: Display category name
HasPercentage: Display percentage (applicable to pie charts, etc.)
Delimiter: Set delimiter between multiple label elements
Position: Set label position relative to data point

Comprehensive Application Example

In practical applications, we usually need to combine the above functions to create informative and visually appealing scatter charts. The following is a complete example:

from spire.xls import *
from spire.xls.common import *

# Create workbook
workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Data Analysis"

# Prepare data
data = [
    ("Product A", 100, 200),
    ("Product B", 150, 180),
    ("Product C", 200, 250),
    ("Product D", 120, 160),
    ("Product E", 180, 220),
    ("Product F", 90, 140),
    ("Product G", 250, 300),
    ("Product H", 160, 190),
]

sheet.Range["A1"].Value = "Product Name"
sheet.Range["B1"].Value = "Advertising Investment (10K Yuan)"
sheet.Range["C1"].Value = "Sales Revenue (10K Yuan)"

for i, (name, ads, sales) in enumerate(data, start=2):
    sheet.Range[f"A{i}"].Value = name
    sheet.Range[f"B{i}"].NumberValue = ads
    sheet.Range[f"C{i}"].NumberValue = sales

# Create scatter chart
chart = sheet.Charts.Add(ExcelChartType.ScatterMarkers)
chart.DataRange = sheet.Range["B2:C9"]
chart.SeriesDataFromRange = False

# Set chart position and size
chart.LeftColumn = 1
chart.TopRow = 12
chart.RightColumn = 11
chart.BottomRow = 30

# Set chart title
chart.ChartTitle = "Analysis of Advertising Investment vs Sales Revenue"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 14
chart.ChartTitleArea.FontName = "Microsoft YaHei"

# Configure data series
chart.Series[0].CategoryLabels = sheet.Range["A2:A9"]
chart.Series[0].Values = sheet.Range["C2:C9"]

# Add trendline
chart.Series[0].TrendLines.Add(TrendLineType.Linear)

# Set axis titles
chart.PrimaryValueAxis.Title = "Sales Revenue (10K Yuan)"
chart.PrimaryCategoryAxis.Title = "Advertising Investment (10K Yuan)"

# Set axis title styles
chart.PrimaryValueAxis.TitleArea.IsBold = True
chart.PrimaryValueAxis.TitleArea.Size = 11
chart.PrimaryCategoryAxis.TitleArea.IsBold = True
chart.PrimaryCategoryAxis.TitleArea.Size = 11

# Save file
workbook.SaveToFile("ComprehensiveScatterChart.xlsx", ExcelVersion.Version2013)
workbook.Dispose()

This comprehensive example demonstrates how to:

Batch write data from data structures to Excel cells
Create a scatter chart with complete configuration
Add linear trendline to show data trends
Set axis labels in mixed Chinese and English
Adjust chart size and position for optimal visual effect

Practical Tips

When creating scatter charts, the following tips can improve chart quality:

Data Preprocessing: Ensure data cleanliness, handle missing values and outliers to avoid misleading results in charts.

Chart Type Selection: Choose appropriate scatter chart variants based on data characteristics:

ScatterMarkers: Display only data point markers
ScatterSmoothedLines: Display smooth curves connecting data points
ScatterLines: Display straight lines connecting data points

Color Scheme: Use contrasting colors to distinguish different data series and maintain visual consistency.

Legend Position: When there are multiple data series, place legends appropriately to avoid obscuring data points.

Export Optimization: Choose appropriate file format and resolution based on purpose; higher resolution is recommended for printing purposes.

Summary

This article introduced the complete process of creating and customizing scatter charts in Excel using Python, including core functions such as basic chart creation, trendline addition, axis label setting, and data label formatting.

By mastering these techniques, developers can integrate data visualization into automated data processing workflows, improving data analysis efficiency. Scatter charts combined with trendlines are particularly suitable for exploring correlations between variables and have wide applications in fields such as statistical analysis, market research, and scientific experiments.

Further expansion directions include:

Creating multi-series scatter charts to compare different datasets
Applying conditional formatting to highlight specific data points
Combining with other chart types to create dashboards
Implementing interactive chart generation tools

These skills will help developers build more powerful data analysis and report generation systems.

Embedding and Managing OLE Objects in PowerPoint Using Python

Allen Yang — Fri, 22 May 2026 10:04:30 +0000

In modern office automation scenarios, it is often necessary to embed objects from external applications into PowerPoint presentations, such as Excel spreadsheets, Word documents, or ZIP archives. OLE (Object Linking and Embedding) technology allows these objects to be directly embedded into slides while maintaining their original editing capabilities. Automating OLE object handling with Python enables batch creation of presentations containing complex data objects, meeting the needs of enterprise reporting, data analysis, and document integration.

This article demonstrates how to embed, manage, and manipulate OLE objects in PowerPoint using Python, including embedding Excel files and ZIP archives, as well as extracting and modifying existing OLE objects.

Environment Setup

First, install the required library:

pip install Spire.Presentation

Core Implementation

Embedding Excel Files as OLE Objects

Embedding an Excel file in PowerPoint allows it to remain editable within the presentation. Double-clicking the embedded Excel object launches the Excel application for editing.

from spire.presentation.common import *
from spire.presentation import *

inputFile = "./Data/EmbedExcelAsOLE.xlsx"
outputFile = "EmbedExcelAsOLE.pptx"

# Create a PowerPoint document
ppt = Presentation()

# Load an image file as the preview image for the OLE object
stream = Stream("Data/EmbedExcelAsOLE.png")
oleImage = ppt.Images.AppendStream(stream)
stream.Close()

# Define the position and size of the OLE object
rec = RectangleF.FromLTRB(80, 60, oleImage.Width+80, oleImage.Height+60)

# Insert the OLE object based on Excel data
oleStream = Stream(inputFile)
oleObject = ppt.Slides[0].Shapes.AppendOleObject("excel", oleStream, rec)
oleObject.SubstituteImagePictureFillFormat.Picture.EmbedImage = oleImage
oleObject.ProgId = "Excel.Sheet.12"
oleStream.Close()

# Save the document
ppt.SaveToFile(outputFile, FileFormat.Pptx2010)
ppt.Dispose()

Code explanation:

First, load the Excel file and preview image
Define the rectangular area for the OLE object on the slide
Use the AppendOleObject method to add the Excel file as an OLE object to the slide
Set the preview image and ProgID (which identifies the application type) for the OLE object

ProgID is a key parameter that identifies the application used to open the object:

Excel.Sheet.8 or Excel.Sheet.12 - Excel 97-2003 workbook or Excel 2007+ workbook
Word.Document.8 or Word.Document.12 - Word 97-2003 document or Word 2007+ document
PowerPoint.Show.8 or PowerPoint.Show.12 - PowerPoint 97-2003 presentation or PowerPoint 2007+ presentation

Embedding Other Types of OLE Objects

In addition to Excel files, you can also embed ZIP archives or other types of files:

from spire.presentation.common import *
from spire.presentation import *

inputFile = "./Data/EmbedZipIntoPPT.pptx"
inputFile_z = "./Data/test.zip"
inputFile_i = "./Data/icon.png"
outputFile = "EmbedZipIntoPPT.pptx"

# Create a PowerPoint document
ppt = Presentation()
ppt.LoadFromFile(inputFile)

# Load the ZIP file stream
stream = Stream(inputFile_z)

# Define the position and size of the OLE object
rec = RectangleF.FromLTRB(80, 60, 180, 160)

# Insert the ZIP object into the presentation
ole = ppt.Slides[0].Shapes.AppendOleObject(inputFile_z, stream, rec)
ole.ProgId = "Package"  # Package ProgID is used for ZIP and other compressed files

# Load and set the icon image
image = Stream(inputFile_i)
oleImage = ppt.Images.AppendStream(image)
ole.SubstituteImagePictureFillFormat.Picture.EmbedImage = oleImage

# Save the document
ppt.SaveToFile(outputFile, FileFormat.Pptx2010)
ppt.Dispose()

Extracting OLE Object Data

You can extract embedded OLE object data from PowerPoint presentations:

from spire.presentation.common import *
from spire.presentation import *

inputFile = "./Data/ExtractOLEObject.pptx"
outputFile_xls = "ExtractOLEObject.xls"
outputFile_xlsx = "ExtractOLEObject.xlsx"
outputFile_doc = "ExtractOLEObject.doc"
outputFile_docx = "ExtractOLEObject.docx"

# Create a PowerPoint document
presentation = Presentation()

# Load the document from disk
presentation.LoadFromFile(inputFile)

# Iterate through slides and shapes
for slide in presentation.Slides:
    for shape in slide.Shapes:
        if isinstance(shape, IOleObject):
            # Find the OLE object
            oleObject = shape if isinstance(shape, IOleObject) else None

            # Get its data and write to file
            stream = oleObject.Data
            if oleObject.ProgId == "Excel.Sheet.8":
                stream.Save(outputFile_xls)
            elif oleObject.ProgId == "Excel.Sheet.12":
                stream.Save(outputFile_xlsx)
            elif oleObject.ProgId == "Word.Document.8":
                stream.Save(outputFile_doc)
            elif oleObject.ProgId == "Word.Document.12":
                stream.Save(outputFile_docx)

            stream.Dispose()

presentation.Dispose()

Modifying OLE Object Content

You can modify the content of existing OLE objects in PowerPoint:

from spire.presentation.common import *
from spire.presentation import *

inputFile = "./Data/ModifyOLEData.pptx"
outputFile = "ModifyOLEData.pptx"

# Create a PowerPoint document
presentation = Presentation()

# Load the document from disk
presentation.LoadFromFile(inputFile)

# Iterate through slides and shapes
for slide in presentation.Slides:
    for shape in slide.Shapes:
        if isinstance(shape, IOleObject):
            # Find the OLE object
            oleObject = shape if isinstance(shape, IOleObject) else None

            # Get its data
            stream = oleObject.Data
            stream2 = Stream()
            if oleObject.ProgId == "PowerPoint.Show.12":
                # Load the PowerPoint stream
                ppt = Presentation()
                ppt.LoadFromStream(stream, FileFormat.Auto)

                # Append an image to the slide
                ppt.Slides[0].Shapes.AppendEmbedImageByPath(
                    ShapeType.Rectangle, "Data/Logo.png", RectangleF.FromLTRB(50, 50, 150, 150))

                # Save to a new stream
                ppt.SaveToFile(stream2, FileFormat.Pptx2013)
                stream2.Position = 0

                # Modify the data
                oleObject.Data = stream2

# Save the document
presentation.SaveToFile(outputFile, FileFormat.Pptx2013)
presentation.Dispose()

Practical Tips

Choose appropriate preview images: Set meaningful preview images for OLE objects to make presentations more intuitive.
Set ProgID correctly: Ensure the OLE object's ProgID matches its actual content type; otherwise, it may not open properly.
Resource management: Always remember to call the Dispose() method to release resources after completing operations.
Error handling: In production environments, appropriate exception handling mechanisms should be added.

Summary

This article demonstrated how to embed and manage OLE objects in PowerPoint using Python, including embedding different types of files, extracting OLE object data, and modifying existing OLE object content. Through these techniques, powerful automation tools can be built to handle complex presentations containing multiple types of data. These methods are particularly useful for business scenarios that require integrating multiple documents into a single presentation, such as creating enterprise reports with real-time data.

Performing Mail Merge in Word Documents Using Python

Allen Yang — Fri, 22 May 2026 09:57:58 +0000

Mail merge is a powerful document automation technology widely used for batch generating personalized documents. By combining template documents with data sources, mail merge enables the automatic generation of large volumes of documents with uniform formatting but varying content, such as invoices, certificates, contracts, and labels.

In the Python environment, Spire.Doc for Python provides comprehensive mail merge APIs that support basic merging, nested merging, conditional field processing, and other advanced features. This article demonstrates how to perform mail merge operations in Word documents using Python.

Environment Setup

First, install Spire.Doc for Python:

pip install Spire.Doc

Basic Mail Merge

Basic mail merge is the most common scenario, where merge fields in a template are replaced with actual data to generate documents.

from spire.doc import *
from spire.doc.common import *

# Create a document object and load the template
document = Document()
document.LoadFromFile("MailMergeTemplate.docx")

# Define field names and corresponding values
fieldNames = ["Contact Name", "Fax", "Date"]
fieldValues = ["John Smith", "+1 (69) 123456", "2024-01-15"]

# Execute mail merge
document.MailMerge.Execute(fieldNames, fieldValues)

# Save the merged document
document.SaveToFile("MergedDocument.docx", FileFormat.Docx)
document.Close()

The code above first loads a template document containing merge fields, then defines arrays of field names and their corresponding values, and finally calls the Execute method to complete the merge. Merge fields in templates typically appear in the format «FieldName», which are replaced with actual data after execution.

Identifying Merge Field Names

When working with unknown templates, you may need to retrieve all merge field names from the document first to prepare the corresponding data.

from spire.doc import *

# Load the template document
document = Document()
document.LoadFromFile("Template.docx")

# Get all merge field names
mergeFieldNames = document.MailMerge.GetMergeFieldNames()

# Output field names
for fieldName in mergeFieldNames:
    print(fieldName)

document.Close()

The GetMergeFieldNames method returns a list of all merge field names in the document. If the template uses grouping functionality, you can also use GetMergeGroupNames to retrieve group names, or GetMergeFieldNames("GroupName") to get field names within a specific group.

Nested Mail Merge

Nested mail merge is suitable for data structures with master-detail relationships, such as scenarios where one customer corresponds to multiple orders. Through nested merging, hierarchical data can be presented in a single document.

from spire.doc import *

# Load a template containing nested regions
document = Document()
document.LoadFromFile("NestedMailMergeTemplate.doc")

# Define nested region mapping relationships
# Keys are main table names, values are child table names and their join conditions
nestedRelations = {
    "Customer": "",
    "Order": "Customer_Id = %Customer.Customer_Id%"
}

# Load XML data source and execute nested merge
dataFile = "Orders.xml"
document.MailMerge.ExecuteWidthNestedRegion(dataFile, nestedRelations)

# Save the result
document.SaveToFile("NestedMergedDocument.docx", FileFormat.Docx)
document.Close()

Nested merging requires corresponding region markers to be defined in the template, and the data source is typically XML or a database. Join conditions define the relationship between master and detail tables, ensuring correct data matching.

Hiding Empty Regions

In some cases, templates may contain optional merge fields or regions. If these fields have no corresponding data, you can configure the mail merge engine to automatically hide paragraphs or entire regions containing empty values.

from spire.doc import *
from spire.doc.common import *

# Load the template
document = Document()
document.LoadFromFile("TemplateWithOptionalFields.doc")

# Configure to hide empty paragraphs and empty regions
document.MailMerge.HideEmptyParagraphs = True
document.MailMerge.HideEmptyGroup = True

# Execute merge
fieldNames = ["Contact Name", "Fax"]
fieldValues = ["John Smith", "+1 (69) 123456"]
document.MailMerge.Execute(fieldNames, fieldValues)

# Save the result
document.SaveToFile("CleanedDocument.docx", FileFormat.Docx)
document.Close()

By setting the HideEmptyParagraphs and HideEmptyGroup properties to True, the mail merge engine automatically removes paragraphs containing empty merge fields and entire empty data groups, resulting in cleaner generated documents.

Practical Tips

Handling Date and Time Formats

Date fields in mail merge may require specific formatting. You can convert dates to strings before merging, or use date formatting switches in the template.

from spire.doc.common import DateTime

# Format the current date
formattedDate = DateTime.get_Now().ToString("yyyy-MM-dd")
fieldValues = [formattedDate]

Conditional Field Processing

Some templates may contain conditional display logic. Spire.Doc supports handling such scenarios through the ExecuteConditionalField method, which determines whether to display specific content based on data values.

Batch Processing

For scenarios requiring the generation of large volumes of documents, you can loop through the data source, execute mail merge once for each record, and save as separate files. This approach is suitable for batch generating personalized certificates, invitation letters, and similar documents.

Summary

Mail merge is a core technology in document automation. With Spire.Doc for Python, developers can easily implement basic merging, nested merging, field identification, and empty region processing. Mastering these techniques enables the construction of efficient document generation systems that significantly enhance office automation capabilities.

In practical applications, it is recommended to select appropriate merging strategies based on specific business requirements and pay attention to template design standards to ensure the accuracy and aesthetics of merge results.

Managing PowerPoint Headers and Footers with Python

Allen Yang — Thu, 21 May 2026 10:05:05 +0000

Headers and footers are essential document elements in professional PowerPoint presentations, displaying key information such as company names, presentation topics, date and time, and slide numbers. These elements not only enhance the professionalism of the document but also help the audience quickly locate and understand the presentation content. This article introduces how to programmatically add and manage headers and footers in PowerPoint presentations using Python.

Why Programmatically Manage Headers and Footers

In practical scenarios, manually setting headers and footers for each slide is inefficient, especially in the following situations:

Batch processing multiple presentations: Uniformly adding company identifiers and page numbers to a series of documents
Dynamic content updates: Automatically updating date and time based on presentation dates or meeting information
Template standardization: Ensuring all presentations follow unified formatting standards
Notes page management: Adding specialized header and footer information for speaker notes

By programmatically managing headers and footers with Python, automated processing for the above scenarios can be achieved, significantly improving work efficiency.

Environment Setup

Before starting, it is necessary to install a Python library that supports PowerPoint operations. Spire.Presentation for Python provides a complete API for header and footer operations.

pip install Spire.Presentation

After installation, the relevant modules can be imported in Python scripts to set up and manage headers and footers.

Basic Header and Footer Settings

PowerPoint's header and footer functionality is primarily controlled through properties of the Presentation object. Footer text can be set, footer visibility controlled, and slide numbers and date/time displayed.

from spire.presentation.common import *
from spire.presentation import *

outputFile = "HeaderAndFooter.pptx"

# Create a presentation object
presentation = Presentation()

# Add a blank slide
slide = presentation.Slides.Append()

# Add footer text
presentation.SetFooterText("Demo of Spire.Presentation")

# Set footer visible
presentation.FooterVisible = True

# Set slide number visible
presentation.SlideNumberVisible = True

# Set date and time visible
presentation.DateTimeVisible = True

# Save the document
presentation.SaveToFile(outputFile, FileFormat.Pptx2010)
presentation.Dispose()

Preview of the resulting document:

In this example, four key properties control the display of headers and footers:

SetFooterText(): Sets the text content displayed in the footer
FooterVisible: Controls whether the footer is displayed
SlideNumberVisible: Controls whether slide numbers are displayed
DateTimeVisible: Controls whether date and time are displayed

The combination of these properties allows for flexible configuration of the presentation's header and footer styles.

Managing Notes Master Headers and Footers

In addition to headers and footers for regular slides, PowerPoint also supports setting specialized headers and footers for notes pages. This is particularly useful when printing speaker notes, allowing independent identification information to be added to notes pages.

from spire.presentation.common import *
from spire.presentation import *

outputFile = "ManageNoteMasterHeaderFooter.pptx"

# Create a presentation object
presentation = Presentation()

# Add a blank slide
slide = presentation.Slides.Append()

# Get the notes master
noteMasterSlide = presentation.NotesMaster

if noteMasterSlide is not None:
    # Iterate through all shapes in the notes master
    for shape in noteMasterSlide.Shapes:
        if shape.Placeholder is not None:
            # Check if it is a header placeholder
            if shape.Placeholder.Type is PlaceholderType.Header:
                autoShape = shape if isinstance(shape, IAutoShape) else None
                if autoShape is not None:
                    autoShape.TextFrame.Text = "change the header by Spire"

            # Check if it is a footer placeholder
            if shape.Placeholder.Type is PlaceholderType.Footer:
                autoShape = shape if isinstance(shape, IAutoShape) else None
                if autoShape is not None:
                    autoShape.TextFrame.Text = "change the footer by Spire"

# Save the document
presentation.SaveToFile(outputFile, FileFormat.Pptx2013)
presentation.Dispose()

This example demonstrates how to manipulate headers and footers of the notes master:

Obtain the notes master object through the NotesMaster property
Iterate through all shapes in the master
Check the Placeholder type of the shape to identify header and footer placeholders
After converting the shape to IAutoShape type, modify its TextFrame.Text property

This method allows precise control over the header and footer content of notes pages, independent of the headers and footers of regular slides.

Practical Tips

Conditional Display of Headers and Footers

Headers and footers can be conditionally enabled or disabled based on specific presentation requirements:

# Display only footer and slide number, not date
presentation.SetFooterText("Company Name - 2024")
presentation.FooterVisible = True
presentation.SlideNumberVisible = True
presentation.DateTimeVisible = False

Dynamically Updating Date

If the current date needs to be displayed, it can be set dynamically at runtime:

from datetime import datetime

# Get current date and format it
current_date = datetime.now().strftime("%Y-%m-%d")
presentation.SetFooterText(f"Presentation Date: {current_date}")
presentation.FooterVisible = True

Batch Processing Multiple Files

When uniformly setting headers and footers for multiple presentations, loop processing can be used:

import os

file_list = ["presentation1.pptx", "presentation2.pptx", "presentation3.pptx"]

for filename in file_list:
    presentation = Presentation()
    presentation.LoadFromFile(filename)

    presentation.SetFooterText("Confidential - Internal Use Only")
    presentation.FooterVisible = True
    presentation.SlideNumberVisible = True

    output_name = f"updated_{filename}"
    presentation.SaveToFile(output_name, FileFormat.Pptx2010)
    presentation.Dispose()

Summary

This article introduced methods for managing headers and footers in PowerPoint presentations using Python, including:

Basic header and footer settings: Adding footer text, controlling visibility
Notes master header and footer management: Setting independent headers and footers for speaker notes
Practical tips: Conditional display, dynamic date updates, batch processing

Through these techniques, automated management of presentation headers and footers can be achieved, improving document processing efficiency. The API provided by Spire.Presentation for Python makes these operations simple and intuitive, suitable for integration into various automated workflows.

Insert and Control Audio in PowerPoint Using Python

Allen Yang — Fri, 15 May 2026 10:22:53 +0000

Audio elements significantly enhance audience engagement and information delivery in modern presentations. Whether it is background music, voice narration, or sound effects, appropriate use of audio can make PowerPoint presentations more vivid and professional. By automating audio insertion and control with Python, developers can batch-create presentations containing audio or add audio content to existing presentations.

This article demonstrates how to insert audio files into PowerPoint presentations, control audio playback behavior, and manage audio properties using Spire.Presentation for Python. These techniques are applicable to scenarios requiring dynamic generation of multimedia presentations, such as educational training materials, product demonstrations, and interactive reports.

Environment Setup

First, install the Spire.Presentation for Python library:

pip install Spire.Presentation

This library provides a complete PowerPoint document manipulation API that supports insertion and control of audio and video media.

Inserting Audio into PowerPoint Slides

Basic Audio Insertion

The basic workflow for adding audio to a PowerPoint slide includes loading or creating a presentation, specifying the audio position, inserting the audio file, and saving the document. The following code demonstrates how to insert an audio file into a slide:

from spire.presentation.common import *
from spire.presentation import *

# Create a PowerPoint document
presentation = Presentation()

# Load an existing document from disk
inputFile = "./Data/InsertAudio.pptx"
presentation.LoadFromFile(inputFile)

# Add a title text box
rec_title = RectangleF.FromLTRB(50, 240, 160+50, 50+240)
shape_title = presentation.Slides[0].Shapes.AppendShape(
    ShapeType.Rectangle, rec_title)
shape_title.ShapeStyle.LineColor.Color = Color.get_Transparent()
shape_title.Fill.FillType = FillFormatType.none

# Set title text formatting
para_title = TextParagraph()
para_title.Text = "Audio:"
para_title.Alignment = TextAlignmentType.Center
para_title.TextRanges[0].LatinFont = TextFont("Myriad Pro Light")
para_title.TextRanges[0].FontHeight = 32
para_title.TextRanges[0].IsBold = TriState.TTrue
para_title.TextRanges[0].Fill.FillType = FillFormatType.Solid
para_title.TextRanges[0].Fill.SolidColor.Color = Color.FromArgb(255, 68, 68, 68)
shape_title.TextFrame.Paragraphs.Append(para_title)

# Insert audio file at specified position
audioRect = RectangleF.FromLTRB(220, 240, 80+220, 80+240)
presentation.Slides[0].Shapes.AppendAudioMedia("./Data/Music.wav", audioRect)

# Save the document
outputFile = "InsertAudio.pptx"
presentation.SaveToFile(outputFile, FileFormat.Pptx2010)
presentation.Dispose()

Result preview:

In the above code, the AppendAudioMedia method is the key API, which accepts the audio file path and a rectangular region as parameters. The rectangular region defines the position and size of the audio icon on the slide. Common audio formats such as WAV and MP3 are supported.

Positioning and Layout Control

The positioning of audio icons is crucial for the visual effect of presentations. The RectangleF.FromLTRB method allows precise control over the left, top, right, and bottom boundary coordinates of audio icons. It is recommended to place audio icons in non-core content areas of slides to avoid obscuring important information.

Controlling Audio Playback Behavior

Setting Auto-Play Mode

By default, audio in PowerPoint requires manual clicking to play. By setting the playback mode, audio can be configured to play automatically when the slide is displayed:

from spire.presentation.common import *
from spire.presentation import *

# Load PowerPoint document
presentation = Presentation()
presentation.LoadFromFile("./Data/Template_Ppt_8.pptx")

# Iterate through all slides to find audio objects
for slide in presentation.Slides:
    for shape in slide.Shapes:
        if isinstance(shape, IAudio):
            # Set audio to auto-play mode
            (shape if isinstance(shape, IAudio) else None).PlayMode = VideoPlayMode.Auto

# Save the document
presentation.SaveToFile("SetAutoPlayAudio.pptx", FileFormat.Pptx2013)
presentation.Dispose()

The VideoPlayMode.Auto enumeration value causes audio to start playing automatically when the slide enters. This is very useful for background music or automatic voice narration. Other available playback modes include manual play and sequential play.

Hiding Audio Icons During Presentation

In certain scenarios, it may be desirable to hide audio icons during slide shows to maintain a clean interface:

from spire.presentation.common import *
from spire.presentation import *

# Load PowerPoint document containing audio
presentation = Presentation()
presentation.LoadFromFile("./Data/audio.pptx")

# Get the first slide
slide = presentation.Slides[0]

# Hide audio icon during presentation
for shape in slide.Shapes:
    if isinstance(shape, IAudio):
        shape.HideAtShowing = True

# Save the document
presentation.SaveToFile("HideAudioDuringShow.pptx", FileFormat.Pptx2013)

By setting the HideAtShowing property to True, the audio icon remains visible in edit mode but automatically hides during slide show. This is practical in scenarios where audio is needed but player controls should not be displayed.

Extracting Audio from Slides

Sometimes it is necessary to extract audio files from existing presentations for separate processing or archiving:

from spire.presentation.common import *
from spire.presentation import *

# Load PowerPoint document
presentation = Presentation()
presentation.LoadFromFile("./Data/AudioPresentation.pptx")

# Iterate through slides to find and extract audio
slide_index = 0
for slide in presentation.Slides:
    for shape in slide.Shapes:
        if isinstance(shape, IAudio):
            # Extract audio data and save as file
            audio_data = shape.EmbeddedData
            output_path = f"Extracted_Audio_Slide{slide_index}.wav"
            with open(output_path, 'wb') as f:
                f.write(audio_data)
            print(f"Audio extracted to: {output_path}")
    slide_index += 1

presentation.Dispose()

The EmbeddedData property returns the binary data of the audio, which can be written to the file system. This method supports batch extraction of audio resources from multiple slides.

Advanced Techniques

Audio Position Optimization

When inserting audio, the overall layout of the slide should be considered. The following strategies can optimize audio positioning:

Place audio icons in corner or edge areas
Ensure audio icons do not overlap with text or other important elements
Adjust audio icon visibility based on slide background color

Multi-Audio Management

For presentations containing multiple audio files, all audio objects can be managed uniformly by iterating through the shape collection and checking types:

# Batch set playback mode for all audio
for slide in presentation.Slides:
    audio_count = 0
    for shape in slide.Shapes:
        if isinstance(shape, IAudio):
            shape.PlayMode = VideoPlayMode.Auto
            audio_count += 1
    print(f"Slide {slide.Index} contains {audio_count} audio objects")

Audio File Format Considerations

Spire.Presentation supports various audio formats including WAV, MP3, WMA, and others. When selecting audio files, consider the following:

File size: Larger audio files increase presentation volume
Compatibility: Ensure the target system supports the selected audio format
Audio quality: Choose appropriate bit rate and sampling rate based on usage scenario

Summary

This article introduced the complete workflow for inserting and controlling audio in PowerPoint presentations using Python. Through Spire.Presentation for Python, developers can easily implement audio insertion, playback mode control, icon hiding, and audio extraction functionalities. These techniques provide powerful automation capabilities for creating interactive multimedia presentations.

In practical applications, richer and more professional presentation content can be created by combining text, images, and other media elements. Audio control features are particularly suitable for producing educational courseware, product demonstrations, and corporate training materials. By appropriately utilizing these APIs, the professionalism and appeal of presentations can be significantly enhanced.

Create and Customize Pie and Doughnut Charts in PowerPoint with Python

Allen Yang — Fri, 15 May 2026 10:03:36 +0000

In data visualization scenarios, pie charts and donut charts are ideal choices for displaying proportional relationships and market share. By automating chart generation with Python, data can be efficiently transformed into intuitive visual presentations, suitable for sales reports, market analysis, and management presentations.

This article demonstrates how to create and customize pie charts and donut charts in PowerPoint presentations using Spire.Presentation for Python, covering core functionalities such as data binding, color customization, and label configuration.

Environment Setup

First, install the Spire.Presentation library:

pip install Spire.Presentation

This library provides a comprehensive PowerPoint manipulation API that supports creating various chart types with fine-grained customization options.

Creating Pie Charts

Pie charts are suitable for displaying the proportion of each part relative to the whole. The following example demonstrates how to create a pie chart showing quarterly sales figures.

Basic Implementation Steps

The core process for creating a pie chart includes: initializing the presentation document, adding a chart object, binding data sources, configuring chart properties, and finally saving the file.

from spire.presentation.common import *
from spire.presentation import *

# Create presentation document
presentation = Presentation()

# Add a pie chart to the first slide, setting position and size
rect = RectangleF.FromLTRB(40, 100, 590, 420)
chart = presentation.Slides[0].Shapes.AppendChartInit(ChartType.Pie, rect, False)

# Set chart title
chart.ChartTitle.TextProperties.Text = "Quarterly Sales"
chart.ChartTitle.TextProperties.IsCentered = True
chart.ChartTitle.Height = 30
chart.HasTitle = True

# Define data
quarters = ["Q1", "Q2", "Q3", "Q4"]
sales = [210, 320, 180, 500]

# Write data to chart data table
chart.ChartData[0, 0].Text = "Quarter"
chart.ChartData[0, 1].Text = "Sales"

for i in range(len(quarters)):
    chart.ChartData[i + 1, 0].Text = quarters[i]
    chart.ChartData[i + 1, 1].NumberValue = sales[i]

# Bind data series
chart.Series.SeriesLabel = chart.ChartData["B1", "B1"]
chart.Categories.CategoryLabels = chart.ChartData["A2", "A5"]
chart.Series[0].Values = chart.ChartData["B2", "B5"]

# Set different colors for each data point
for i in range(len(chart.Series[0].Values)):
    cdp = ChartDataPoint(chart.Series[0])
    cdp.Index = i
    chart.Series[0].DataPoints.Add(cdp)

chart.Series[0].DataPoints[0].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[0].Fill.SolidColor.Color = Color.get_RosyBrown()
chart.Series[0].DataPoints[1].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[1].Fill.SolidColor.Color = Color.get_LightBlue()
chart.Series[0].DataPoints[2].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[2].Fill.SolidColor.Color = Color.get_LightPink()
chart.Series[0].DataPoints[3].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[3].Fill.SolidColor.Color = Color.get_MediumPurple()

# Display value and percentage labels
chart.Series[0].DataLabels.LabelValueVisible = True
chart.Series[0].DataLabels.PercentValueVisible = True

# Save file
presentation.SaveToFile("PieChartExample.pptx", FileFormat.Pptx2013)
presentation.Dispose()

Result Preview:

Code Analysis

The AppendChartInit method is used to add a chart at a specified position, where the first parameter specifies the chart type and the second parameter defines the rectangular area.

Data is bound through the ChartData two-dimensional array, where [row, column] indices correspond to cell positions. SeriesLabel specifies the source of series names, CategoryLabels sets the category label range, and Values binds the actual numerical data.

Each data point is individually configured through ChartDataPoint objects, allowing precise control over colors and styles. The DataLabels property controls label display content, and displaying both values and percentages provides more complete information.

Creating Donut Charts

Donut charts are a variant of pie charts with a hollow center forming a ring structure. They offer a more modern visual appearance and are suitable for displaying comparative data such as market share.

Implementation Method

The creation process for donut charts is similar to pie charts, with the main differences being the chart type and additional ring size settings.

from spire.presentation.common import *
from spire.presentation import *

# Create presentation document
presentation = Presentation()
rect = RectangleF.FromLTRB(80, 100, 630, 420)

# Add donut chart
chart = presentation.Slides[0].Shapes.AppendChartInit(ChartType.Doughnut, rect, False)

# Set title
chart.ChartTitle.TextProperties.Text = "Market Share by Country"
chart.ChartTitle.TextProperties.IsCentered = True
chart.ChartTitle.Height = 30

# Define data
countries = ["Cuba", "Mexico", "France", "Germany"]
sales = [1800, 3000, 5100, 6200]

# Write data
chart.ChartData[0, 0].Text = "Country"
chart.ChartData[0, 1].Text = "Sales"

for i in range(len(countries)):
    chart.ChartData[i + 1, 0].Text = countries[i]
    chart.ChartData[i + 1, 1].NumberValue = sales[i]

# Bind data series
chart.Series.SeriesLabel = chart.ChartData["B1", "B1"]
chart.Categories.CategoryLabels = chart.ChartData["A2", "A5"]
chart.Series[0].Values = chart.ChartData["B2", "B5"]

# Add data points and set colors
for i in range(len(chart.Series[0].Values)):
    cdp = ChartDataPoint(chart.Series[0])
    cdp.Index = i
    chart.Series[0].DataPoints.Add(cdp)

chart.Series[0].DataPoints[0].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[0].Fill.SolidColor.Color = Color.get_LightBlue()
chart.Series[0].DataPoints[1].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[1].Fill.SolidColor.Color = Color.get_MediumPurple()
chart.Series[0].DataPoints[2].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[2].Fill.SolidColor.Color = Color.get_DarkGray()
chart.Series[0].DataPoints[3].Fill.FillType = FillFormatType.Solid
chart.Series[0].DataPoints[3].Fill.SolidColor.Color = Color.get_DarkOrange()

# Display labels
chart.Series[0].DataLabels.LabelValueVisible = True
chart.Series[0].DataLabels.PercentValueVisible = True

# Set donut hole size (between 0-90)
chart.Series[0].DoughnutHoleSize = 60

# Save file
presentation.SaveToFile("DonutChartExample.pptx", FileFormat.Pptx2013)
presentation.Dispose()

Result Preview:

Key Features

The DoughnutHoleSize property controls the size of the hollow center area in the donut chart, with values ranging from 0 to 90. Larger values result in a larger center hole and thinner ring. The default value is typically between 50-60, achieving a balance between aesthetics and readability.

The data binding method for donut charts is identical to pie charts, allowing reuse of the same data processing logic.

Advanced Customization Techniques

Dynamic Color Assignment

In practical applications, colors may need to be dynamically assigned based on data volume. A predefined color list can be used with cyclic application:

# Predefined color list
colors = [
    Color.get_LightBlue(),
    Color.get_MediumPurple(),
    Color.get_LightPink(),
    Color.get_RosyBrown(),
    Color.get_DarkOrange(),
    Color.get_DarkGray()
]

# Cyclically apply colors
for i in range(len(chart.Series[0].Values)):
    cdp = ChartDataPoint(chart.Series[0])
    cdp.Index = i
    chart.Series[0].DataPoints.Add(cdp)
    chart.Series[0].DataPoints[i].Fill.FillType = FillFormatType.Solid
    chart.Series[0].DataPoints[i].Fill.SolidColor.Color = colors[i % len(colors)]

This approach is suitable for scenarios with uncertain numbers of data points, ensuring each data point has an appropriate color.

Label Position Adjustment

Data label positions can be further customized through the DataLabels property:

# Set label display position
chart.Series[0].DataLabels.Position = LabelPositionType.OutsideEnd

# Display only percentages
chart.Series[0].DataLabels.LabelValueVisible = False
chart.Series[0].DataLabels.PercentValueVisible = True

# Customize label format
chart.Series[0].DataLabels.NumberFormat = "0.0%"

The LabelPositionType enumeration provides multiple position options, such as OutsideEnd, InsideEnd, Center, etc. The most suitable position can be selected based on chart layout.

Chart Background Configuration

To enhance visual appeal, backgrounds can be added to slides:

# Set background image
image_file = "background.png"
bg_rect = RectangleF.FromLTRB(0, 0, presentation.SlideSize.Size.Width, 
                               presentation.SlideSize.Size.Height)
presentation.Slides[0].Shapes.AppendEmbedImageByPath(
    ShapeType.Rectangle, image_file, bg_rect)
presentation.Slides[0].Shapes[0].Line.FillFormat.SolidFillColor.Color = Color.get_FloralWhite()

Background images should coordinate with chart colors to avoid interfering with data readability.

Practical Recommendations

Choose Appropriate Chart Types: Pie charts are suitable for displaying proportional relationships among 5-7 categories; too many categories reduce readability. Donut charts offer a more modern visual appearance, and the center area can be used to place total numbers or explanatory text.

Color Coordination Principles: Use contrasting colors to distinguish different data points, avoiding overly similar tones. Consider accessibility for color-blind users and validate color schemes using online tools.

Label Clarity: Displaying both values and percentages provides complete information, but if space is limited, show only percentages and note the total in the legend.

Data Sorting: Arrange data in descending order, displaying from the largest share clockwise, which aligns with reading habits and facilitates quick identification of major contributors.

Summary

Through Spire.Presentation for Python, pie charts and donut charts can be flexibly created and customized in PowerPoint. Core APIs include AppendChartInit for adding charts, ChartData for data binding, DataPoints for color customization, and DataLabels for label control.

These techniques can be applied to various business scenarios such as sales analysis, market research, and budget allocation, helping transform complex data into intuitive visual presentations. Combined with dynamic data sources, automated report generation can be achieved, significantly improving work efficiency.

Creating and Customizing Line Charts in Excel Using Python

Allen Yang — Mon, 11 May 2026 08:43:56 +0000

Line charts are one of the most commonly used chart types for data visualization, particularly suitable for displaying trends in data over time. In data analysis, financial reporting, and market research, line charts can clearly present data fluctuation patterns and growth trends. This article introduces how to create line charts in Excel workbooks using Python and perform various customizations.

Environment Setup

First, install the Spire.XLS for Python library:

pip install Spire.XLS

This library provides a complete Excel file operation API, supporting creation, reading, and modification of Excel documents, including chart generation functionality.

Creating a Basic Line Chart

The basic process for creating a line chart includes: preparing data, adding a chart object, setting the data range, and configuring chart properties.

from spire.xls import *
from spire.xls.common import *

# Create workbook and worksheet
workbook = Workbook()
sheet = workbook.Worksheets[0]
sheet.Name = "Line Chart"

# Prepare sample data
sheet.Range["A1"].Value = "Country"
sheet.Range["A2"].Value = "Cuba"
sheet.Range["A3"].Value = "Mexico"
sheet.Range["A4"].Value = "France"
sheet.Range["A5"].Value = "Germany"

sheet.Range["B1"].Value = "Jun"
sheet.Range["B2"].NumberValue = 3300
sheet.Range["B3"].NumberValue = 2300
sheet.Range["B4"].NumberValue = 4500
sheet.Range["B5"].NumberValue = 6700

sheet.Range["C1"].Value = "Jul"
sheet.Range["C2"].NumberValue = 7500
sheet.Range["C3"].NumberValue = 2900
sheet.Range["C4"].NumberValue = 2300
sheet.Range["C5"].NumberValue = 4200

sheet.Range["D1"].Value = "Aug"
sheet.Range["D2"].NumberValue = 7400
sheet.Range["D3"].NumberValue = 6900
sheet.Range["D4"].NumberValue = 7800
sheet.Range["D5"].NumberValue = 4200

sheet.Range["E1"].Value = "Sep"
sheet.Range["E2"].NumberValue = 8000
sheet.Range["E3"].NumberValue = 7200
sheet.Range["E4"].NumberValue = 8500
sheet.Range["E5"].NumberValue = 5600

# Set header row style
sheet.Range["A1:E1"].Style.Color = Color.get_DarkGray()
sheet.Range["A1:E1"].Style.Font.Color = Color.get_White()
sheet.Range["A1:E1"].Style.HorizontalAlignment = HorizontalAlignType.Center

# Add line chart
chart = sheet.Charts.Add()
chart.ChartType = ExcelChartType.Line

# Set chart data range
chart.DataRange = sheet.Range["A1:E5"]

# Set chart position
chart.LeftColumn = 1
chart.TopRow = 6
chart.RightColumn = 11
chart.BottomRow = 29

# Set chart title
chart.ChartTitle = "Sales Market by Country"
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Configure axes
chart.PrimaryCategoryAxis.Title = "Month"
chart.PrimaryCategoryAxis.Font.IsBold = True
chart.PrimaryValueAxis.Title = "Sales (in Dollars)"
chart.PrimaryValueAxis.HasMajorGridLines = False

# Display data labels
for cs in chart.Series:
    cs.Format.Options.IsVaryColor = True
    cs.DataPoints.DefaultDataPoint.DataLabels.HasValue = True

# Save file
workbook.SaveToFile("Line.xlsx", ExcelVersion.Version2010)
workbook.Dispose()

Result document preview:

The code above first populates the worksheet with sales data for four countries over six months, then creates a chart object using the Charts.Add() method. The ChartType property is set to ExcelChartType.Line to specify a line chart. The data range is bound to the cell range A1:E5 through the DataRange property.

Adding Data Markers

In certain scenarios, markers need to be added to each data point on the line chart to more clearly identify specific value positions. This effect can be achieved by setting the MarkerStyle property.

# ...

# Change line chart to line chart with markers
chart.ChartType = ExcelChartType.LineMarkers

# ...

# Display data labels
for cs in chart.Series:
    cs.Format.Options.IsVaryColor = True
    cs.DataPoints.DefaultDataPoint.DataLabels.HasValue = True

# Add circular markers to each data series
for cs1 in chart.Series:
    cs = ChartSerie(cs1)
    cs.Format.Options.IsVaryColor = True
    cs.DataPoints.DefaultDataPoint.DataLabels.HasValue = True
    cs.DataFormat.MarkerStyle = ChartMarkerType.Circle

chart.Legend.Position = LegendPositionType.Top
workbook.SaveToFile("Line_Circle.xlsx", ExcelVersion.Version2010)
workbook.Dispose()

Result document preview:

By setting MarkerStyle to ChartMarkerType.Circle, each data point is displayed as a circular marker. In addition to circles, other marker styles such as squares, triangles, or diamonds can also be selected.

Creating 3D Line Charts

For presentation scenarios requiring stronger visual impact, 3D line charts can be used. The 3D effect enhances the立体感 and层次感 of the chart.

# ...

# Create 3D line chart
chart.ChartType = ExcelChartType.Line3D

# ...

# Set axis title rotation angle
chart.PrimaryValueAxis.TitleArea.TextRotationAngle = 90
chart.PrimaryValueAxis.MinValue = 1000

for cs in chart.Series:
    cs.Format.Options.IsVaryColor = True
    cs.DataPoints.DefaultDataPoint.DataLabels.HasValue = True

chart.PlotArea.Fill.Visible = False
workbook.SaveToFile("Line_3D.xlsx", ExcelVersion.Version2010)
workbook.Dispose()

Result document preview:

The creation method for 3D line charts is similar to 2D charts; simply set ChartType to ExcelChartType.Line3D. Additionally, the angle of axis titles can be rotated by adjusting the TextRotationAngle property to make the chart layout more reasonable.

Customizing Chart Styles

The appearance of line charts can be customized in various ways, including colors, fonts, gridlines, and legend positions.

# Customize chart style
chart.ChartTitleArea.IsBold = True
chart.ChartTitleArea.Size = 12

# Set primary category axis
chart.PrimaryCategoryAxis.Title = "Month"
chart.PrimaryCategoryAxis.Font.IsBold = True
chart.PrimaryCategoryAxis.TitleArea.IsBold = True

# Set primary value axis
chart.PrimaryValueAxis.Title = "Sales (in Dollars)"
chart.PrimaryValueAxis.HasMajorGridLines = False
chart.PrimaryValueAxis.TitleArea.IsBold = True
chart.PrimaryValueAxis.MinValue = 1000

# Hide plot area background
chart.PlotArea.Fill.Visible = False

# Set legend position
chart.Legend.Position = LegendPositionType.Top

Result document preview:

By accessing the PrimaryCategoryAxis and PrimaryValueAxis objects, the titles, fonts, and gridlines of the horizontal and vertical axes can be configured separately. The PlotArea.Fill.Visible property controls the visibility of the plot area background; setting it to False makes the chart cleaner.

Practical Tips

In practical applications, the following tips can enhance the usability and readability of line charts:

Data Label Display: Display specific values next to each data point by setting DataLabels.HasValue = True, making it easier for readers to quickly obtain information
Multi-Series Color Differentiation: Set IsVaryColor = True to assign different colors to different data series, improving distinguishability
Gridline Control: Decide whether to display gridlines based on data density to avoid cluttering the chart
Legend Position Adjustment: Place the legend at the top or bottom to leave more space for the data area

Summary

This article introduced the complete process of creating line charts in Excel using Python, including implementation methods for basic line charts, line charts with markers, and 3D line charts. By adjusting chart types, data markers, axis properties, and style settings, professional-grade data visualization charts that meet various requirements can be generated.

Line charts are suitable for scenarios such as displaying time series data, trend analysis, and comparative analysis. After mastering these techniques, they can be applied to practical work such as financial report generation, sales data analysis, and market trend research.

Creating and Formatting Tables in PowerPoint Using Python

Allen Yang — Sat, 09 May 2026 09:40:16 +0000

Tables are essential tools for presenting structured data in business presentations. Whether displaying financial reports, project timelines, or comparative analyses, clear and well-formatted tables significantly enhance information delivery efficiency. Automating PowerPoint table generation with Python enables batch data processing, maintains formatting consistency, and substantially reduces manual operation time.

This article demonstrates how to use the Spire.Presentation for Python library to create tables in PowerPoint slides and customize table styles, borders, cell merging, and text alignment properties. This solution is suitable for scenarios requiring dynamic report generation, automated presentation creation, or batch export of data analysis results.

Environment Setup

First, install the Spire.Presentation for Python library:

pip install Spire.Presentation

This library provides a complete PowerPoint document manipulation API, supporting creation, reading, modification, and conversion of PPT/PPTX files without requiring Microsoft PowerPoint application installation.

Core Implementation

Creating Tables and Populating Data

The first step in creating a table is defining column widths and row heights, then adding it to the slide. The following example demonstrates creating a table containing country information:

from spire.presentation.common import *
from spire.presentation import *
import math

# Create PowerPoint document
presentation = Presentation()

# Define table column widths and row heights (in points)
widths = [100, 100, 150, 100, 100]
heights = [15] * 13

# Calculate table position (horizontally centered)
left = math.trunc(presentation.SlideSize.Size.Width / 2) - 275

# Add table to slide
table = presentation.Slides[0].Shapes.AppendTable(left, 90, widths, heights)

# Prepare table data
dataStr = [
    ["Name", "Capital", "Continent", "Area", "Population"],
    ["Venezuela", "Caracas", "South America", "912047", "19700000"],
    ["Bolivia", "La Paz", "South America", "1098575", "7300000"],
    ["Brazil", "Brasilia", "South America", "8511196", "150400000"],
    ["Canada", "Ottawa", "North America", "9976147", "26500000"],
    ["Chile", "Santiago", "South America", "756943", "13200000"]
]

# Populate table data
for i in range(len(dataStr)):
    for j in range(len(dataStr[i])):
        table[j, i].TextFrame.Text = dataStr[i][j]
        # Set font
        table[j, i].TextFrame.Paragraphs[0].TextRanges[0].LatinFont = TextFont("Arial Narrow")

# Save document
presentation.SaveToFile("CreateTable.pptx", FileFormat.Pptx2010)
presentation.Dispose()

Resulting document:

The above code creates a table at the specified position using the AppendTable method, which accepts four parameters: left margin, top margin, column width array, and row height array. After table creation, each cell is accessed via two-dimensional indexing [column, row], and cell content is set using the TextFrame.Text property.

Applying Preset Table Styles

Spire.Presentation provides multiple preset table styles for quick table appearance enhancement. Preset styles include different color themes and format combinations:

from spire.presentation.common import *
from spire.presentation import *

# Load existing document
ppt = Presentation()
ppt.LoadFromFile("CreateTable.pptx")

# Get table object
table = None
for shape in ppt.Slides[0].Shapes:
    if isinstance(shape, ITable):
        table = shape
        break

if table is not None:
    # Apply preset style
    table.StylePreset = TableStylePreset.MediumStyle1Accent2

    # Other commonly used preset styles:
    # TableStylePreset.LightStyle3Accent1
    # TableStylePreset.DarkStyle1Accent2
    # TableStylePreset.MediumStyle2Accent3

# Save document
ppt.SaveToFile("StyledTable.pptx", FileFormat.Pptx2010)
ppt.Dispose()

Resulting document:

The StylePreset property accepts TableStylePreset enumeration values. These preset styles have preconfigured background colors, borders, font colors, and other properties. Selecting appropriate preset styles quickly achieves professional visual effects.

Customizing Table Borders

Beyond using preset styles, table borders can be precisely controlled for color, width, and type:

from spire.presentation.common import *
from spire.presentation import *

# Create new document
presentation = Presentation()

# Define table dimensions
tableWidth = [100, 100, 100, 100, 100]
tableHeight = [20, 20]

# Iterate through all border types and set styles
for item in TableBorderType:
    # Add table to new slide
    itable = presentation.Slides.Append().Shapes.AppendTable(100, 100, tableWidth, tableHeight)

    # Add sample text
    itable.TableRows[0][0].TextFrame.Text = "Row"
    itable.TableRows[1][0].TextFrame.Text = "Column"

    # Set border: type, width (points), color
    itable.SetTableBorder(item, 1.5, Color.get_Red())

# Save document
presentation.SaveToFile("CustomBorders.pptx", FileFormat.Pptx2013)
presentation.Dispose()

The SetTableBorder method allows separate style settings for different border types (such as internal horizontal borders, internal vertical borders, outer borders, etc.). The TableBorderType enumeration includes the following commonly used values:

InsideHorizontal: Internal horizontal borders
InsideVertical: Internal vertical borders
Top: Top border
Bottom: Bottom border
Left: Left border
Right: Right border

Merging Cells

When handling complex table layouts, merging adjacent cells is often necessary to create header rows or grouping areas:

from spire.presentation.common import *
from spire.presentation import *

# Load document
presentation = Presentation()
presentation.LoadFromFile("CreateTable.pptx")

# Get table
table = None
for shape in presentation.Slides[0].Shapes:
    if isinstance(shape, ITable):
        table = shape
        break

if table is not None:
    # Vertical merge: merge rows 2 and 3 in the first column
    table.MergeCells(table[0, 1], table[0, 2], False)

    # Horizontal merge: merge columns 4 and 5 in row 5
    table.MergeCells(table[3, 4], table[4, 4], True)

# Save document
presentation.SaveToFile("MergedCells.pptx", FileFormat.Pptx2010)
presentation.Dispose()

The MergeCells method accepts three parameters: starting cell, ending cell, and merge direction flag. The third parameter set to True indicates horizontal merging, while False indicates vertical merging. Merged cells retain the content and formatting of the starting cell.

Setting Text Alignment

Text alignment in tables directly impacts readability and aesthetics. Both horizontal and vertical alignment can be set simultaneously:

from spire.presentation.common import *
from spire.presentation import *

# Load document
presentation = Presentation()
presentation.LoadFromFile("CreateTable.pptx")

# Get table
table = None
for shape in presentation.Slides[0].Shapes:
    if isinstance(shape, ITable):
        table = shape
        break

if table is not None:
    # Horizontal alignment settings
    # Left align
    table[0, 1].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Left
    # Center align
    table[0, 2].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Center
    # Right align
    table[0, 3].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Right
    # Justify
    table[0, 4].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Justify

    # Vertical alignment settings
    # Top align
    table[1, 1].TextAnchorType = TextAnchorType.Top
    # Vertically center
    table[1, 2].TextAnchorType = TextAnchorType.Center
    # Bottom align
    table[1, 3].TextAnchorType = TextAnchorType.Bottom

    # Set both horizontal and vertical alignment
    table[2, 1].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Left
    table[2, 1].TextAnchorType = TextAnchorType.Top

# Save document
presentation.SaveToFile("AlignedTable.pptx", FileFormat.Pptx2010)
presentation.Dispose()

Horizontal alignment is set through the TextFrame.Paragraphs[0].Alignment property, accepting TextAlignmentType enumeration values. Vertical alignment is controlled through the TextAnchorType property, managing text positioning in the vertical direction within cells.

Feature Demonstration

Comprehensive Example: Creating a Fully Formatted Table

Combining the above features enables creation of professionally formatted complete tables:

from spire.presentation.common import *
from spire.presentation import *
import math

# Create document
presentation = Presentation()

# Define table structure
widths = [120, 100, 100, 100]
heights = [20, 18, 18, 18, 18]

# Add table
left = math.trunc(presentation.SlideSize.Size.Width / 2) - 210
table = presentation.Slides[0].Shapes.AppendTable(left, 80, widths, heights)

# Populate data
headers = ["Product", "Q1", "Q2", "Q3"]
products = [
    ["Product A", "150", "180", "210"],
    ["Product B", "120", "140", "160"],
    ["Product C", "90", "110", "130"]
]

# Set headers
for j in range(len(headers)):
    table[j, 0].TextFrame.Text = headers[j]
    table[j, 0].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Center
    table[j, 0].TextFrame.Paragraphs[0].TextRanges[0].Fill.FillType = FillFormatType.Solid
    table[j, 0].TextFrame.Paragraphs[0].TextRanges[0].Fill.SolidColor.Color = Color.get_White()

# Set data rows
for i in range(len(products)):
    for j in range(len(products[i])):
        table[j, i + 1].TextFrame.Text = products[i][j]
        if j == 0:
            table[j, i + 1].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Left
        else:
            table[j, i + 1].TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Center

# Apply style
table.StylePreset = TableStylePreset.MediumStyle2Accent3

# Set borders
table.SetTableBorder(TableBorderType.InsideHorizontal, 0.5, Color.get_Gray())
table.SetTableBorder(TableBorderType.InsideVertical, 0.5, Color.get_Gray())
table.SetTableBorder(TableBorderType.Top, 1.5, Color.get_DarkBlue())
table.SetTableBorder(TableBorderType.Bottom, 1.5, Color.get_DarkBlue())

# Save document
presentation.SaveToFile("CompleteTable.pptx", FileFormat.Pptx2010)
presentation.Dispose()

This example comprehensively applies data population, style application, border settings, and alignment control to generate a sales data table with clear hierarchical structure. Headers use white font for emphasis, data is left-aligned by category and center-aligned for numerical values, with an overall medium-intensity accent color theme.

Practical Tips

Adjusting Row Heights and Column Widths

After table creation, cell dimensions can be dynamically adjusted based on content:

# Set specific row height
table.TableRows[0].Height = 25

# Set specific column width
table.ColumnsList[0].Width = 150

# Batch set all row heights
for row in table.TableRows:
    row.Height = 20

Filling Cell Background Colors

Background colors can be set for specific rows or cells to highlight important information:

# Set background color for entire row
for cell in table.TableRows[1]:
    cell.Fill.FillType = FillFormatType.Solid
    cell.Fill.SolidColor.Color = Color.get_LightYellow()

# Set background color for single cell
table[0, 2].Fill.FillType = FillFormatType.Solid
table[0, 2].Fill.SolidColor.Color = Color.get_LightGreen()

Identifying Merged Cells

When processing existing tables, detecting which cells have been merged may be necessary:

# Iterate through all cells to identify merge status
for i in range(table.ColumnsList.Count):
    for j in range(table.TableRows.Count):
        cell = table[i, j]
        if cell.IsMergedCell:
            print(f"Cell [{i}, {j}] is a merged cell")

Summary

This article introduces the complete process of creating and formatting tables in PowerPoint using Python, covering everything from basic data population to advanced style customization. Through the Spire.Presentation library, flexible control over all aspects of tables is achievable:

Use the AppendTable method to create tables and define dimensions
Quickly apply preset styles through StylePreset
Precisely control border styles using SetTableBorder
Implement complex cell layouts through MergeCells
Optimize text layout using Alignment and TextAnchorType

These techniques can be applied to automated report generation, batch presentation creation, and data visualization scenarios. Combined with other PowerPoint automation features such as shapes, charts, and SmartArt, richer and more professional presentation content can be constructed.