DEV Community: Allen Yang

Adding and Managing Attachments in PDF Documents Using Python

Allen Yang — Thu, 25 Jun 2026 10:03:18 +0000

In everyday document processing, the PDF attachment feature has a wide range of use cases. For instance, bundling a contract with supporting materials in a single PDF file, or attaching relevant data files and images to a technical document. While doing this manually is possible, it becomes a bottleneck when processing large volumes of documents.

Using Python, you can programmatically add, read, and remove PDF attachments efficiently, making it well-suited for integration into automated workflows.

Environment Setup

To work with PDF documents in Python, install the Spire.PDF library:

pip install Spire.PDF

This library provides a complete set of PDF document processing APIs, including attachment management.

Adding Attachments to a PDF Document

There are two common ways to add attachments to a PDF: as document-level attachments (similar to email attachments) and as attachment annotations displayed as clickable icons on the page.

Adding Document-Level Attachments

Document-level attachments appear in the PDF reader's attachment panel and are not directly visible on the page content:

from spire.pdf.common import *
from spire.pdf import *

# Load the PDF document
doc = PdfDocument()
doc.LoadFromFile("input.pdf")

# Create an attachment object with the file name
attachment = PdfAttachment("data.xlsx")

# Read the file data into the attachment
with open("data.xlsx", "rb") as f:
    attachment.Data = f.read()

# Set the description and MIME type
attachment.Description = "Source data table"
attachment.MimeType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"

# Add the attachment to the document
doc.Attachments.Add(attachment)

# Save the document
doc.SaveToFile("output.pdf")
doc.Close()

Key API notes:

PdfAttachment: Represents an attachment object; the constructor parameter is the display name of the attachment
Data property: Used to set the binary data of the attachment
MimeType property: Specifies the MIME type so the reader can identify the file correctly
Attachments.Add(): Adds the attachment to the document's attachment collection

Adding Attachment Annotations

Attachment annotations appear as icons (such as a paperclip or pushpin) on the PDF page, allowing readers to click and open them directly:

from spire.pdf.common import *
from spire.pdf import *

doc = PdfDocument()
doc.LoadFromFile("input.pdf")
page = doc.Pages[0]

# Read the file data to attach
with open("report.pdf", "rb") as f:
    data = Stream(f.read())

# Create an attachment annotation
bounds = RectangleF(50.0, 100.0, 15.0, 15.0)
annotation = PdfAttachmentAnnotation(bounds, "report.pdf", data)
annotation.Color = PdfRGBColor(Color.get_Teal())
annotation.Icon = PdfAttachmentIcon.Paperclip
annotation.Text = "Attachment: Detailed Report"

# Add it to the page
page.AnnotationsWidget.Add(annotation)

doc.SaveToFile("output.pdf")
doc.Close()

Attachment annotations support various icon styles, including Paperclip, PushPin, Graph, and Tag, allowing you to choose the most appropriate icon based on the content type.

Reading and Extracting Attachments

When you receive a PDF document containing attachments, you may need to inspect the attachment information or extract the files.

Retrieving Attachment Information

from spire.pdf.common import *
from spire.pdf import *

pdf = PdfDocument()
pdf.LoadFromFile("document_with_attachments.pdf")

# Get the attachment collection
collection = pdf.Attachments

if collection.Count > 0:
    for i in range(collection.Count):
        attachment = collection.get_Item(i)
        print(f"File Name: {attachment.FileName}")
        print(f"Description: {attachment.Description}")
        if attachment.CreationDate:
            print(f"Creation Date: {attachment.CreationDate}")
        print("---")

pdf.Close()

Extracting Attachments to Local Files

from spire.pdf.common import *
from spire.pdf import *

pdf = PdfDocument()
pdf.LoadFromFile("document_with_attachments.pdf")

collection = pdf.Attachments

# Extract all attachments
for i in range(collection.Count):
    attachment = collection.get_Item(i)
    attachment.Data.Save(attachment.FileName)

# Or extract a single attachment (e.g., the second one)
attachment = collection.get_Item(1)
attachment.Data.Save(attachment.FileName)

pdf.Close()

The attachment.Data.Save() method saves the attachment data directly to a file, automatically using the original file name.

Deleting Attachments

When cleaning up or repackaging a document, you can remove attachments that are no longer needed:

from spire.pdf.common import *
from spire.pdf import *

doc = PdfDocument()
doc.LoadFromFile("document_with_attachments.pdf")

# Delete all attachments
doc.Attachments.Clear()

doc.SaveToFile("cleaned.pdf")
doc.Close()

If you need to remove only specific attachments, you can access them by index and handle them individually, or match them by file name.

Practical Tips

Before adding attachments, make sure to open files in binary mode ("rb"), otherwise data may become corrupted
Setting the correct MIME type helps PDF readers properly identify and handle the attachment content
The Flags property of attachment annotations controls interaction behavior, such as ReadOnly for read-only and Locked to prevent movement
Document-level attachments and attachment annotations can coexist without conflict

Conclusion

This article covered the basic methods of adding, extracting, and removing attachments in PDF documents using Python. These operations can be easily performed through the Spire.PDF API and are well-suited for integration into batch document processing workflows. Building on this foundation, you can combine these techniques with other PDF operations—such as page merging and text extraction—to create more complex document automation solutions.

Combining and Formatting Shapes in PowerPoint Using Python

Allen Yang — Thu, 18 Jun 2026 09:33:53 +0000

In PowerPoint presentations, shapes are fundamental elements for building visual content. By combining multiple shapes together, you can create complex graphical objects; by applying 3D effects and shadows, you can make shapes more vivid and professional. This article demonstrates how to use Python to combine, ungroup, and apply various visual effects to shapes in PowerPoint.

Why Shape Combination and Formatting Matter

When working with PowerPoint presentations, advanced shape operations offer several advantages:

Unified Management: Once multiple shapes are grouped, they can be moved, resized, or copied as a single unit
Visual Enhancement: 3D effects and shadows can elevate the professionalism and appeal of your presentation
Batch Operations: When formatting changes are applied to grouped shapes, all child shapes update synchronously
Template Creation: Programmatically generate standardized presentation templates containing complex graphics

These capabilities are particularly valuable for creating flowcharts, organizational charts, infographics, and other complex visual content.

Environment Setup

First, install the Spire.Presentation for Python library:

pip install Spire.Presentation

This library provides a comprehensive PowerPoint manipulation API that supports shape creation, formatting, grouping, and special effects processing.

Basic Implementation: Grouping Multiple Shapes

Shape grouping is the operation of merging multiple independent shape objects into a single logical unit. The following example demonstrates how to create two shapes and group them together:

from spire.presentation import *

# Create a presentation instance
ppt = Presentation()

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

# Set background image
rect = RectangleF.FromLTRB(0, 0, ppt.SlideSize.Size.Width, ppt.SlideSize.Size.Height)
slide.Shapes.AppendEmbedImageByPath(ShapeType.Rectangle, "bg.png", rect)
slide.Shapes[0].Line.FillFormat.SolidFillColor.Color = Color.get_FloralWhite()

# Create the first shape - Rectangle
rectangle = slide.Shapes.AppendShape(
    ShapeType.Rectangle, 
    RectangleF.FromLTRB(250, 180, 450, 220))
rectangle.Fill.FillType = FillFormatType.Solid
rectangle.Fill.SolidColor.KnownColor = KnownColors.SkyBlue
rectangle.Line.Width = 0.1

# Create the second shape - Ribbon
ribbon = slide.Shapes.AppendShape(
    ShapeType.Ribbon2, 
    RectangleF.FromLTRB(290, 155, 410, 235))
ribbon.Fill.FillType = FillFormatType.Solid
ribbon.Fill.SolidColor.KnownColor = KnownColors.LightPink
ribbon.Line.Width = 0.1

# Add both shapes to a list
arr = []
arr.append(rectangle)
arr.append(ribbon)

# Group the shapes
ppt.Slides[0].GroupShapes(arr)

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

Result Preview:

Key points to note:

Use the AppendShape method to create different types of shapes
Add the shapes you want to group into a list
Call the GroupShapes method and pass the shape list to complete the grouping
Grouped shapes can be manipulated as a single entity

Applying 3D Effects to Shapes

3D effects can give flat shapes a three-dimensional appearance, enhancing visual impact. The following example shows how to add different 3D effects to shapes:

from spire.presentation import *

# Create a presentation
ppt = Presentation()

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

# Add the first shape and fill with color
shape1 = ppt.Slides[0].Shapes.AppendShape(
    ShapeType.RoundCornerRectangle, 
    RectangleF.FromLTRB(150, 150, 300, 300))
shape1.Fill.FillType = FillFormatType.Solid
shape1.Fill.SolidColor.KnownColor = KnownColors.SkyBlue

# Initialize 3D effect for shape1 and set properties
effect1 = shape1.ThreeD.ShapeThreeD
effect1.PresetMaterial = PresetMaterialType.Powder  # Material type
effect1.TopBevel.PresetType = BevelPresetType.ArtDeco  # Bevel type
effect1.TopBevel.Height = 4  # Bevel height
effect1.TopBevel.Width = 12  # Bevel width
effect1.BevelColorMode = BevelColorType.Contour  # Bevel color mode
effect1.ContourColor.KnownColor = KnownColors.LightBlue  # Contour color
effect1.ContourWidth = 3.5  # Contour width

# Add the second shape
shape2 = ppt.Slides[0].Shapes.AppendShape(
    ShapeType.Pentagon, 
    RectangleF.FromLTRB(400, 150, 550, 300))
shape2.Fill.FillType = FillFormatType.Solid
shape2.Fill.SolidColor.KnownColor = KnownColors.LightGreen

# Apply different 3D effects to shape2
effect2 = shape2.ThreeD.ShapeThreeD
effect2.PresetMaterial = PresetMaterialType.SoftEdge
effect2.TopBevel.PresetType = BevelPresetType.SoftRound
effect2.TopBevel.Height = 12
effect2.TopBevel.Width = 12
effect2.BevelColorMode = BevelColorType.Contour
effect2.ContourColor.KnownColor = KnownColors.LawnGreen
effect2.ContourWidth = 5

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

Result Preview:

Main 3D effect properties include:

PresetMaterial: Preset material types such as powder, soft edge, metal, etc.
TopBevel: Type, height, and width of the top bevel
BevelColorMode: Bevel color mode
ContourColor/ContourWidth: Contour color and width

Ungrouping Shapes

When you need to edit individual shapes within a group separately, you can ungroup them first:

from spire.presentation import *

# Load a document containing grouped shapes
ppt = Presentation()
ppt.LoadFromFile("GroupShapes.pptx")

# Get the grouped shape
groupShape = ppt.Slides[0].Shapes[0] if isinstance(ppt.Slides[0].Shapes[0], GroupShape) else None

# Ungroup the shape
ppt.Slides[0].Ungroup(groupShape)

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

After ungrouping, the original child shapes are restored as independent objects and can be edited individually.

Applying Shadow Effects

In addition to 3D effects, shadows are another commonly used decorative effect for shapes:

from spire.presentation import *

# Create a presentation
ppt = Presentation()

# Add a shape
shape = ppt.Slides[0].Shapes.AppendShape(
    ShapeType.Rectangle, 
    RectangleF.FromLTRB(100, 100, 300, 200))
shape.Fill.FillType = FillFormatType.Solid
shape.Fill.SolidColor.KnownColor = KnownColors.LightBlue

# Set shadow effect
shadow = shape.Effect.D presetShadow
shadow.BlurRadius = 10  # Blur radius
shadow.Distance = 5  # Shadow distance
shadow.Direction = 45  # Shadow direction (angle)
shadow.ColorFormat.Color = Color.get_Gray()  # Shadow color

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

Additional Shape Formatting Options

Gradient Fill

from spire.presentation import *

# Create a shape
shape = ppt.Slides[0].Shapes.AppendShape(
    ShapeType.Ellipse, 
    RectangleF.FromLTRB(100, 100, 300, 300))

# Set gradient fill
shape.Fill.FillType = FillFormatType.Gradient
shape.Fill.Gradient.GradientStops.Add(0, Color.get_Blue())
shape.Fill.Gradient.GradientStops.Add(1, Color.get_White())
shape.Fill.Gradient.GradientType = GradientStyleType.Horizontal

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

Pattern Fill

# Set pattern fill
shape.Fill.FillType = FillFormatType.Pattern
shape.Fill.Pattern.PatternType = PatternFillType.DiagonalBrick
shape.Fill.Pattern.ForeColor = Color.get_Red()
shape.Fill.Pattern.BackColor = Color.get_Yellow()

Picture Fill

# Fill shape with an image
shape.Fill.FillType = FillFormatType.Picture
shape.Fill.PictureFill.Picture.Url = "texture.jpg"
shape.Fill.PictureFill.FillType = PictureFillType.Stretch

Practical Tips

Batch Grouping Similar Shapes

When you need to group multiple shapes of the same type, you can simplify the code using loops:

# Collect all rectangle shapes
rectangles = []
for shape in slide.Shapes:
    if shape.ShapeType == ShapeType.Rectangle:
        rectangles.append(shape)

# If multiple rectangles are found, group them
if len(rectangles) > 1:
    slide.GroupShapes(rectangles)

Finding and Replacing Shapes Within Groups

You can identify and locate specific shapes using alternative text (Alt Text):

# Set alternative text for a shape
shape.AlternativeText = "MyCustomShape"

# Find shapes by alternative text
for shape in slide.Shapes:
    if shape.AlternativeText == "MyCustomShape":
        # Perform operations
        shape.Fill.SolidColor.KnownColor = KnownColors.Red

Protecting Shapes from Modification

You can lock shapes to prevent accidental modifications:

# Prevent shape modification
shape.Locking.SelectionProtection = True
shape.Locking.PositionProtection = True
shape.Locking.SizeProtection = True

Summary

This article has introduced various methods for performing advanced shape operations in PowerPoint using Python, including:

Grouping multiple shapes into a single object
Applying 3D effects to shapes (materials, bevels, contours)
Ungrouping shapes for individual editing
Adding shadow effects to enhance visual hierarchy
Filling shapes with gradients, patterns, and images
Managing and locating shapes through alternative text

These techniques can help create more professional and engaging presentations, especially for scenarios requiring complex graphic design. Through programmatic processing, you can also batch-generate standardized graphical elements, improving workflow efficiency.

Add Speaker Notes to PowerPoint Slides Using Python

Allen Yang — Thu, 18 Jun 2026 07:44:31 +0000

Speaker notes are an invaluable feature when creating presentations. They allow presenters to add comments, prompts, or detailed explanations beneath each slide—content that remains invisible to the audience during presentation mode but helps speakers organize their thoughts and maintain a smooth delivery pace.

In real-world scenarios, we often need to batch-add notes to multiple slides or extract note information from existing presentations. Manual operations are not only time-consuming but also prone to errors. By automating these tasks with Python, you can complete them efficiently and accurately.

This article demonstrates how to add speaker notes to PowerPoint slides using Python, as well as how to extract and manage existing note content. This approach is particularly useful for scenarios requiring batch processing of presentations, such as preparing training materials or organizing meeting presentations.

Environment Setup

First, install the Spire.Presentation library:

pip install Spire.Presentation

This library provides a comprehensive API for PowerPoint document manipulation, supporting the creation, modification, and reading of various presentation elements, including slide notes.

Adding Speaker Notes to Slides

Basic Workflow

The core steps for adding notes to slides include:

Load or create a PowerPoint document
Get the target slide
Access or create the notes page (NotesSlide)
Set the note text content
Save the document

Here's a complete example showing how to add notes to the first slide:

from spire.presentation import *

# Create a PowerPoint document object
presentation = Presentation()

# Load file from disk
presentation.LoadFromFile("Template_Ppt_1.pptx")

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

# Get the slide's notes page; create one if it doesn't exist
notes_slide = slide.NotesSlide
if notes_slide is None:
    notes_slide = slide.AddNotesSlide()

# Set the note text content
notes_slide.NotesTextFrame.Text = "Speaker notes: Introduce company background and project objectives"

# Save the document
presentation.SaveToFile("AddSpeakerNotes.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Result Preview

In this example, the NotesSlide property is used to access the slide's notes page. If the slide doesn't have a notes page yet, you need to call the AddNotesSlide() method to create one first. Then, set the note text content through the NotesTextFrame.Text property.

Batch-Adding Notes to Multiple Slides

In practical applications, you often need to add different notes to multiple slides. This can be achieved by iterating through the slide collection:

from spire.presentation import *

# Load the presentation
presentation = Presentation()
presentation.LoadFromFile("Training_Material.pptx")

# Define note content for each slide
speaker_notes = [
    "Opening remarks: Welcome everyone to this training session",
    "Key focus: Explain core concepts of Part 1",
    "Demonstrate real-world examples here",
    "Interactive segment: Q&A and discussion",
    "Summarize key points and preview next training session"
]

# Iterate through slides and add notes
for i, slide in enumerate(presentation.Slides):
    if i < len(speaker_notes):
        # Get or create notes page
        notes_slide = slide.NotesSlide
        if notes_slide is None:
            notes_slide = slide.AddNotesSlide()

        # Set note text
        notes_slide.NotesTextFrame.Text = speaker_notes[i]

# Save the document
presentation.SaveToFile("Training_With_Notes.pptx", FileFormat.Pptx2019)
presentation.Dispose()

This method is especially suitable for handling standardized presentation templates, allowing you to quickly add structured notes to an entire slide deck.

Extracting and Managing Speaker Notes

Besides adding notes, you may sometimes need to extract note information from existing presentations for review, backup, or conversion to other formats.

Extracting Notes from a Single Slide

from spire.presentation import *

# Load the presentation
presentation = Presentation()
presentation.LoadFromFile("Presentation_With_Notes.pptx")

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

# Get the notes page
notes_slide = slide.NotesSlide

if notes_slide is not None:
    # Extract notes text frame content
    note_text = notes_slide.NotesTextFrame.Text
    print(f"Notes for slide 1: {note_text}")
else:
    print("This slide has no notes")

presentation.Dispose()

Batch-Extracting Notes from All Slides

For presentations containing multiple slides, you can iterate through all slides, extract their notes, and save them to a text file:

from spire.presentation import *

def save_notes_to_file(filename, notes_list):
    """Save notes list to a text file"""
    with open(filename, "w", encoding="utf-8") as f:
        for note in notes_list:
            f.write(note + "\n")

# Load the presentation
presentation = Presentation()
presentation.LoadFromFile("Conference_Presentation.pptx")

# Store all notes
all_notes = []

# Iterate through all slides
for i, slide in enumerate(presentation.Slides):
    notes_slide = slide.NotesSlide

    if notes_slide is not None:
        note_text = notes_slide.NotesTextFrame.Text
        note_info = f"Slide {i + 1}: {note_text}"
        all_notes.append(note_info)
    else:
        all_notes.append(f"Slide {i + 1}: No notes")

# Save to text file
save_notes_to_file("Extracted_Speaker_Notes.txt", all_notes)

print(f"Extracted {len(all_notes)} note entries in total")
presentation.Dispose()

This example demonstrates how to extract all notes from a presentation and save them to a text file, making it convenient for subsequent review or use as a speaking script.

Deleting and Modifying Notes

In certain situations, you may need to delete or modify existing note content.

Deleting Notes from a Specific Slide

from spire.presentation import *

# Load the presentation
presentation = Presentation()
presentation.LoadFromFile("Presentation.pptx")

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

# Delete notes from this slide
slide.RemoveNotesSlide()

# Save the document
presentation.SaveToFile("Presentation_No_Notes.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Modifying Existing Notes

If you need to modify existing notes, you can directly reset the NotesTextFrame.Text property:

from spire.presentation import *

# Load the presentation
presentation = Presentation()
presentation.LoadFromFile("Presentation.pptx")

# Get the first slide and its notes
slide = presentation.Slides[0]
notes_slide = slide.NotesSlide

if notes_slide is not None:
    # Append or modify note content
    original_text = notes_slide.NotesTextFrame.Text
    notes_slide.NotesTextFrame.Text = original_text + "\n\nAdditional note: Please add the latest data here"

# Save the document
presentation.SaveToFile("Presentation_Updated.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Practical Tips

Formatting Note Text

Note text supports basic formatting. You can add line breaks, paragraphs, and other elements using rich text:

# Use line breaks to separate different paragraphs
notes_slide.NotesTextFrame.Text = "Part 1: Background Introduction\n\nPart 2: Core Content\n\nPart 3: Summary"

Checking Whether Slides Have Notes

When processing large numbers of slides, you can first check which slides already have notes to avoid duplicate operations:

for i, slide in enumerate(presentation.Slides):
    if slide.NotesSlide is not None:
        print(f"Slide {i + 1} already has notes")
    else:
        print(f"Slide {i + 1} needs notes added")

Relationship Between Notes and Export

It's important to note that when exporting PowerPoint to PDF or image formats, speaker notes are not included in the output files by default. This makes notes truly "behind-the-scenes" content, visible only to the presenter.

Summary

This article demonstrated how to add, extract, modify, and delete speaker notes in PowerPoint slides using Python. Through these techniques, you can efficiently manage note information in presentations and improve your presentation creation workflow.

Key takeaways include:

Using the NotesSlide property to access slide notes pages
Creating new notes pages with the AddNotesSlide() method
Setting and retrieving note text using NotesTextFrame.Text
Batch-processing notes across multiple slides
Extracting notes and saving them to external files

These techniques can be applied to various scenarios, such as preparing training materials, managing meeting presentations, and generating speaking scripts. Combined with other PowerPoint automation features, you can build a complete presentation processing workflow.

Add and Edit Content Controls in Word with Python

Allen Yang — Wed, 17 Jun 2026 10:12:13 +0000

In modern document automation scenarios, content controls provide a structured way to create interactive Word documents. Content controls allow developers to embed interactive elements such as dropdown lists, date pickers, and text input fields into documents, enabling the creation of form templates, surveys, and standardized documents.

This article demonstrates how to programmatically add and manage various types of content controls in Word documents using Python and the Spire.Doc library, including combo boxes, text boxes, picture controls, date pickers, and drop-down lists.

Environment Setup

First, install the Spire.Doc for Python library:

pip install Spire.Doc

Spire.Doc is a feature-rich Word document processing library that supports creating, reading, editing, and converting Word documents without requiring Microsoft Word to be installed.

What Are Content Controls

Content controls (also known as Structured Document Tags - SDT) are container elements in Word documents that define regions for specific types of content. They offer several advantages:

Data Validation: Restrict users to input specific formats or select from predefined options
Structured Data: Facilitate subsequent data extraction and processing
User Experience: Provide intuitive interfaces such as dropdown menus and calendar pickers
Document Standardization: Ensure documents follow consistent formatting and standards

Common content control types include:

Combo Box
Text Box
Picture Control
Date Picker
Drop-Down List

Adding Combo Box Content Controls

Combo boxes allow users to select an item from a predefined list or enter custom values. This is particularly useful in scenarios requiring standardized input, such as selecting product names, departments, or categories.

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

# Create document object
document = Document()
section = document.AddSection()

# Add description text
paragraph = section.AddParagraph()
txtRange = paragraph.AppendText("Add Combo Box Content Control: ")
txtRange.CharacterFormat.Italic = True

# Create structured document tag
sd = StructureDocumentTagInline(document)
paragraph.ChildObjects.Add(sd)

# Set control type to combo box
sd.SDTProperties.SDTType = SdtType.ComboBox

# Create combo box and add options
cb = SdtComboBox()
cb.ListItems.Add(SdtListItem("Spire.Doc"))
cb.ListItems.Add(SdtListItem("Spire.XLS"))
cb.ListItems.Add(SdtListItem("Spire.PDF"))

# Apply control properties
sd.SDTProperties.ControlProperties = cb

# Set default display value
rt = TextRange(document)
rt.Text = cb.ListItems[0].DisplayText
sd.SDTContent.ChildObjects.Add(rt)

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

Output:

In the code above, the StructureDocumentTagInline class is used to create inline content controls. By setting SDTType to ComboBox, we specify the control type. The SdtComboBox object manages list items and allows dynamic addition or removal of options.

Adding Text Content Controls

Text controls allow users to input multi-line text, suitable for free-text fields such as addresses, comments, or descriptions.

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

document = Document()
section = document.AddSection()

# Add description
paragraph = section.AddParagraph()
txtRange = paragraph.AppendText("Add Text Content Control: ")
txtRange.CharacterFormat.Italic = True

# Create text control
sd = StructureDocumentTagInline(document)
paragraph.ChildObjects.Add(sd)
sd.SDTProperties.SDTType = SdtType.Text

# Configure text properties to allow multi-line input
text = SdtText(True)
text.IsMultiline = True
sd.SDTProperties.ControlProperties = text

# Set placeholder text
rt = TextRange(document)
rt.Text = "Enter text here..."
sd.SDTContent.ChildObjects.Add(rt)

document.SaveToFile("TextControl.docx", FileFormat.Docx)
document.Close()

Output:

The SdtText constructor accepts a boolean parameter that specifies whether multi-line input is allowed. When set to True, users can input long text containing line breaks.

Adding Picture Content Controls

Picture controls allow users to insert and manage images in documents, ideal for scenarios requiring dynamic addition of product images, logos, or signatures.

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

document = Document()
section = document.AddSection()

paragraph = section.AddParagraph()
txtRange = paragraph.AppendText("Add Picture Content Control: ")
txtRange.CharacterFormat.Italic = True

# Create picture control
sd = StructureDocumentTagInline(document)
paragraph.ChildObjects.Add(sd)
sd.SDTProperties.SDTType = SdtType.Picture

# Load and add image
pic = DocPicture(document)
pic.Width = 100
pic.Height = 100
pic.LoadImage("./Data/logo.png")
sd.SDTContent.ChildObjects.Add(pic)

document.SaveToFile("PictureControl.docx", FileFormat.Docx)
document.Close()

Output:

Picture controls automatically handle image scaling and layout, allowing users to replace or remove images through the control interface.

Adding Date Picker Content Controls

Date pickers provide a calendar interface that enables users to select dates in a standardized format, avoiding inconsistencies in date formatting.

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

document = Document()
section = document.AddSection()

paragraph = section.AddParagraph()
txtRange = paragraph.AppendText("Add Date Picker Content Control: ")
txtRange.CharacterFormat.Italic = True

# Create date picker
sd = StructureDocumentTagInline(document)
paragraph.ChildObjects.Add(sd)
sd.SDTProperties.SDTType = SdtType.DatePicker

# Configure date format and calendar type
date = SdtDate()
date.CalendarType = CalendarType.Default
date.DateFormat = "yyyy.MM.dd"
date.FullDate = DateTime.get_Now()
sd.SDTProperties.ControlProperties = date

# Set default date
rt = TextRange(document)
rt.Text = "2024.01.15"
sd.SDTContent.ChildObjects.Add(rt)

document.SaveToFile("DatePickerControl.docx", FileFormat.Docx)
document.Close()

Output:

The SdtDate object allows customization of date format strings, supporting various common date representations such as "yyyy-MM-dd" or "MM/dd/yyyy".

Adding Drop-Down List Content Controls

Unlike combo boxes, drop-down lists only allow users to select from predefined options without manual input. This is suitable for scenarios requiring strict input value restrictions.

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

document = Document()
section = document.AddSection()

paragraph = section.AddParagraph()
txtRange = paragraph.AppendText("Add Drop-Down List Content Control: ")
txtRange.CharacterFormat.Italic = True

# Create drop-down list
sd = StructureDocumentTagInline(document)
paragraph.ChildObjects.Add(sd)
sd.SDTProperties.SDTType = SdtType.DropDownList

# Add list items
sddl = SdtDropDownList()
sddl.ListItems.Add(SdtListItem("Engineering"))
sddl.ListItems.Add(SdtListItem("Marketing"))
sddl.ListItems.Add(SdtListItem("Human Resources"))
sd.SDTProperties.ControlProperties = sddl

# Set default option
rt = TextRange(document)
rt.Text = sddl.ListItems[0].DisplayText
sd.SDTContent.ChildObjects.Add(rt)

document.SaveToFile("DropDownListControl.docx", FileFormat.Docx)
document.Close()

Output:

Practical Tips

Locking Content Controls

To prevent users from modifying the structure of content controls, you can lock them:

# Lock control to prevent deletion or modification
sd.SDTProperties.LockContents = True
sd.SDTProperties.LockControl = True

Customizing Control Appearance

You can customize the display style of controls:

# Set control color
sd.SDTProperties.Color = Color.get_LightBlue()

# Set display appearance
sd.SDTProperties.Appearance = SdtAppearance.BoundingBox

Extracting Control Data

Extract values from content controls in existing documents:

# Iterate through all content controls in the document
for sdt in document.GetChildObjects(True, ObjectType.StructureDocumentTagInline):
    tag = sdt if isinstance(sdt, StructureDocumentTagInline) else None
    if tag:
        # Get control type
        control_type = tag.SDTProperties.SDTType
        # Get control content
        content = tag.SDTContent.Text
        print(f"Type: {control_type}, Content: {content}")

Conclusion

Content controls provide powerful interactivity for Word document automation. Using Python and the Spire.Doc library, we can programmatically create and manage various types of content controls, including:

Combo Boxes and Drop-Down Lists: Provide standardized option selection
Text Boxes: Support free-form text input
Picture Controls: Simplify image management
Date Pickers: Ensure consistent date formatting

These controls are particularly useful for creating form templates, contracts, surveys, and standardized reports. By combining different types of content controls appropriately, you can build interactive Word documents that are both aesthetically pleasing and practical, significantly improving document processing efficiency and accuracy.

In real-world projects, it is recommended to select appropriate control types based on specific requirements and consider adding data validation logic to ensure input quality. Additionally, reasonable control layout and clear labeling can greatly enhance user experience.

How to Manage Track Changes in Word with Python

Allen Yang — Fri, 12 Jun 2026 09:59:20 +0000

In collaborative environments, Word's revision tracking feature is essential for document review and version control. By enabling revision tracking, you can record all insertions, deletions, and formatting changes while tracking each modification's author and timestamp. This article demonstrates how to automate Word document revision tracking management using Python, including enabling revisions, extracting revision information, and accepting or rejecting changes.

Why Programmatic Revision Management Matters

Manually handling Word document revision tracking presents several challenges:

Batch Processing Difficulties: Manual operations become inefficient when processing multiple documents simultaneously
Cumbersome Information Extraction: Filtering specific authors or change types from numerous revisions is time-consuming
Automation Requirements: Automatically accepting standard revisions or flagging anomalous changes within document workflows

Managing revision tracking programmatically with Python enables you to:

Batch enable or disable revision tracking across documents
Automatically extract detailed revision information (author, type, timestamp)
Bulk accept or reject specific revisions based on rules
Set or modify revision author information

Environment Setup

Start by installing the Spire.Doc for Python library:

pip install Spire.Doc

This library provides comprehensive Word document operation APIs, supporting all core revision tracking functionalities.

Enabling and Disabling Revision Tracking

The most fundamental operation is enabling or disabling a document's revision tracking feature. When revision tracking is enabled, all modifications to the document are recorded.

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

# Create a Word document object
document = Document()
# Load file from disk
document.LoadFromFile("Sample.docx")

# Enable revision tracking
document.TrackChanges = True

# Save the document
document.SaveToFile("EnableTrackChanges.docx", FileFormat.Docx2013)
document.Close()

By setting the TrackChanges property to True, you enable revision tracking. Subsequently, any modifications to the document (text insertion, content deletion, formatting adjustments, etc.) are recorded as revisions. To disable revision tracking, simply set this property to False.

Extracting Revision Information

Extracting revision information is one of the most common tasks in revision management. You can iterate through all paragraphs and text ranges in a document to retrieve detailed information about each revision, including revision type, author, and timestamp.

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

def write_revisions_to_file(filename, content):
    """Write revision information to a text file"""
    with open(filename, "w", encoding="utf-8") as fp:
        for line in content:
            fp.write(line + "\n")

# Load a document containing revisions
document = Document()
document.LoadFromFile("GetRevisions.docx")

insert_revisions = ["Insert Revisions:"]
delete_revisions = ["Delete Revisions:"]
insert_index = 0
delete_index = 0

# Iterate through all sections in the document
for section_idx in range(document.Sections.Count):
    section = document.Sections.get_Item(section_idx)

    # Iterate through all child objects in the section body
    for body_idx in range(section.Body.ChildObjects.Count):
        doc_item = section.Body.ChildObjects.get_Item(body_idx)

        # Handle paragraph-level revisions
        if isinstance(doc_item, Paragraph):
            paragraph = doc_item

            # Check for insert revisions
            if paragraph.IsInsertRevision:
                insert_index += 1
                insert_revisions.append(f"Index: {insert_index}")

                revision = paragraph.InsertRevision
                insert_revisions.append(f"Type: {revision.Type.name}")
                insert_revisions.append(f"Author: {revision.Author}")
                insert_revisions.append("")

            # Check for delete revisions
            elif paragraph.IsDeleteRevision:
                delete_index += 1
                delete_revisions.append(f"Index: {delete_index}")

                revision = paragraph.DeleteRevision
                delete_revisions.append(f"Type: {revision.Type.name}")
                delete_revisions.append(f"Author: {revision.Author}")
                delete_revisions.append("")

            # Iterate through all child objects in the paragraph (text ranges)
            for text_idx in range(paragraph.ChildObjects.Count):
                obj = paragraph.ChildObjects.get_Item(text_idx)

                if isinstance(obj, TextRange):
                    text_range = obj

                    # Check for insert revisions in text ranges
                    if text_range.IsInsertRevision:
                        insert_index += 1
                        insert_revisions.append(f"Index: {insert_index}")

                        revision = text_range.InsertRevision
                        insert_revisions.append(f"Type: {revision.Type.name}")
                        insert_revisions.append(f"Author: {revision.Author}")
                        insert_revisions.append("")

                    # Check for delete revisions in text ranges
                    elif text_range.IsDeleteRevision:
                        delete_index += 1
                        delete_revisions.append(f"Index: {delete_index}")

                        revision = text_range.DeleteRevision
                        delete_revisions.append(f"Type: {revision.Type.name}")
                        delete_revisions.append(f"Author: {revision.Author}")
                        delete_revisions.append("")

# Save revision information to files
write_revisions_to_file("insert_revisions.txt", insert_revisions)
write_revisions_to_file("delete_revisions.txt", delete_revisions)

This code demonstrates how to systematically extract all revision information from a document:

Traverse Document Structure: Sequentially access each Section, Paragraph, and TextRange
Identify Revision Types: Determine revision types using IsInsertRevision and IsDeleteRevision properties
Retrieve Revision Details: Use InsertRevision or DeleteRevision properties to obtain revision objects, extracting type and author information
Categorize Storage: Save insert and delete revisions separately into different lists

This approach can be used to generate revision reports, filter modifications by specific authors, or analyze document change statistics.

Setting Revision Author Information

In certain scenarios, you may need to uniformly set or modify revision author information. For example, when merging documents from multiple authors, you can standardize all revision authors to a unified identifier.

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

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

# Iterate through all sections in the document
for i in range(document.Sections.Count):
    section = document.Sections.get_Item(i)

    # Iterate through all child objects in the section body
    for j in range(section.Body.ChildObjects.Count):
        doc_item = section.Body.ChildObjects.get_Item(j)

        if isinstance(doc_item, Paragraph):
            paragraph = doc_item

            # Set author for paragraph-level insert revisions
            if paragraph.IsInsertRevision:
                paragraph.InsertRevision.Author = "E-iceblue"

            # Set author for paragraph-level delete revisions
            elif paragraph.IsDeleteRevision:
                paragraph.DeleteRevision.Author = "E-iceblue"

            # Iterate through text ranges in the paragraph
            for k in range(paragraph.ChildObjects.Count):
                text_range = paragraph.ChildObjects.get_Item(k)

                if isinstance(text_range, TextRange):
                    # Set author for text range insert revisions
                    if text_range.IsInsertRevision:
                        text_range.InsertRevision.Author = "E-iceblue"

                    # Set author for text range delete revisions
                    elif text_range.IsDeleteRevision:
                        text_range.DeleteRevision.Author = "E-iceblue"

# Save the modified document
document.SaveToFile("SetRevisionAuthor.docx", FileFormat.Docx2013)
document.Close()

By modifying the Revision.Author property, you can uniformly set revision author names. This proves valuable in document standardization processes or anonymized review scenarios.

Accepting or Rejecting Revisions

After completing document review, you typically need to accept or reject specific revisions. This operation can be performed on entire documents, specific sections, or individual paragraphs.

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

# Load a document containing revisions
document = Document()
document.LoadFromFile("AcceptOrRejectTrackedChanges.docx")

# Get the first section and paragraph to process
section = document.Sections[0]
paragraph = section.Paragraphs[0]

# Accept all revisions
paragraph.Document.AcceptChanges()

# Or reject all revisions
# paragraph.Document.RejectChanges()

# Save the processed document
document.SaveToFile("AcceptOrRejectTrackedChanges_out.docx", FileFormat.Docx2013)
document.Close()

The AcceptChanges() method applies all revisions, making the document content reflect the final modified state. Conversely, the RejectChanges() method reverses all revisions, restoring the document to its pre-revision state.

For more granular control, you can combine this with the revision extraction functionality described earlier—first filtering specific revisions, then selectively accepting or rejecting them. For instance, you might accept only revisions from a particular author, or accept insert-type revisions while rejecting deletions.

Practical Application Techniques

Batch Processing Multiple Documents

In real-world scenarios, you often need to batch process revision tracking across multiple documents. This can be automated by combining Python's file operations:

import os
from spire.doc import *

def batch_enable_track_changes(folder_path):
    """Batch enable revision tracking for all Word documents in a folder"""
    for filename in os.listdir(folder_path):
        if filename.endswith(".docx"):
            filepath = os.path.join(folder_path, filename)

            document = Document()
            document.LoadFromFile(filepath)
            document.TrackChanges = True

            output_path = os.path.join(folder_path, f"tracked_{filename}")
            document.SaveToFile(output_path, FileFormat.Docx2013)
            document.Close()

            print(f"Processed: {filename}")

Filtering Revisions by Specific Authors

By extending the revision extraction functionality, you can filter revisions from specific authors:

def filter_revisions_by_author(document, author_name):
    """Filter revisions by a specific author"""
    filtered_revisions = []

    for section in document.Sections:
        for body_item in section.Body.ChildObjects:
            if isinstance(body_item, Paragraph):
                if body_item.IsInsertRevision and body_item.InsertRevision.Author == author_name:
                    filtered_revisions.append(body_item)

                for child in body_item.ChildObjects:
                    if isinstance(child, TextRange):
                        if child.IsInsertRevision and child.InsertRevision.Author == author_name:
                            filtered_revisions.append(child)

    return filtered_revisions

Generating Revision Statistics Reports

You can count various revision types in a document to generate summary reports:

def generate_revision_report(document):
    """Generate a revision statistics report"""
    stats = {
        "insert_count": 0,
        "delete_count": 0,
        "authors": set()
    }

    for section in document.Sections:
        for body_item in section.Body.ChildObjects:
            if isinstance(body_item, Paragraph):
                if body_item.IsInsertRevision:
                    stats["insert_count"] += 1
                    stats["authors"].add(body_item.InsertRevision.Author)
                elif body_item.IsDeleteRevision:
                    stats["delete_count"] += 1
                    stats["authors"].add(body_item.DeleteRevision.Author)

                for child in body_item.ChildObjects:
                    if isinstance(child, TextRange):
                        if child.IsInsertRevision:
                            stats["insert_count"] += 1
                            stats["authors"].add(child.InsertRevision.Author)
                        elif child.IsDeleteRevision:
                            stats["delete_count"] += 1
                            stats["authors"].add(child.DeleteRevision.Author)

    return stats

Conclusion

This article has covered the core techniques for managing Word document revision tracking using Python, including enabling revision tracking, extracting revision information, setting revision authors, and accepting or rejecting revisions. These capabilities enable automation of document review workflows, improving team collaboration efficiency.

In practical applications, you can combine these features according to specific requirements—such as batch document processing, filtering specific revisions, or generating review reports. The comprehensive API support provided by Spire.Doc for Python simplifies these tasks, making them ideal for integration into various document management workflows.

Add and Manage Comments and Replies in Word Using Python

Allen Yang — Fri, 12 Jun 2026 02:17:19 +0000

In modern document collaboration scenarios, the commenting feature is an essential tool for team review and feedback. Whether it's code reviews, contract revisions, or academic paper modifications, you need to insert comments, reply to discussions, and extract comment content for organization within documents.

This article demonstrates how to perform the following operations in Word documents using Python:

Add comments to specific text
Reply to existing comments
Extract all comments from a document

Using the Spire.Doc for Python library, we can implement comment management in Word documents through Python code, making it suitable for batch processing document comments or automating document review workflows.

Environment Setup

First, install the Spire.Doc library:

pip install Spire.Doc

This library provides a complete API for Word document operations, supporting features such as adding, modifying, replying to, and extracting comments.

Adding Comments to Specific Text

In practical applications, we often need to add annotations or notes to specific paragraphs or keywords in a document. The following example demonstrates how to find specified text and add comments to it.

Implementation Steps

Load the Word document
Find the target text
Create comment markers (start and end)
Set comment content and author information
Insert the comment into the document

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

def add_comment_to_text(doc, keystring):
    """Add a comment to specified text"""
    # Find the target text
    find = doc.FindString(keystring, False, True)

    # Create comment markers
    commentmarkStart = CommentMark(doc)
    commentmarkStart.Type = CommentMarkType.CommentStart
    commentmarkStart.CommentId = 1

    commentmarkEnd = CommentMark(doc)
    commentmarkEnd.CommentId = 1
    commentmarkEnd.Type = CommentMarkType.CommentEnd

    # Set comment content
    comment = Comment(doc)
    comment.Format.CommentId = 1
    comment.Body.AddParagraph().Text = "This is a test comment"
    comment.Format.Author = "John Smith"

    # Get text range and locate paragraph
    range_list = find.GetRanges()
    para = range_list[0].OwnerParagraph

    # Get the index position of text in the paragraph
    index = para.ChildObjects.IndexOf(range_list[0])

    # Insert comment markers and comment content
    para.ChildObjects.Insert(index, commentmarkStart)
    para.ChildObjects.Insert(index + len(range_list) + 1, commentmarkEnd)
    para.ChildObjects.Add(comment)

# Load document
document = Document()
document.LoadFromFile("SampleDocument.docx")

# Add comment to target text
add_comment_to_text(document, "Important Clause")

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

Resulting document:

In the above code, CommentMark is used to identify the comment range, while the Comment object stores the specific content and metadata of the comment. The FindString method allows precise positioning of the text where comments need to be added.

Replying to Comments

When multiple people collaborate on document review, they need to reply to existing comments for discussion. Spire.Doc supports adding replies to comments, forming a complete discussion thread.

Implementation Method

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

# Load document containing comments
doc = Document()
doc.LoadFromFile("AddComment.docx")

# Get the first comment
original_comment = doc.Comments.get_Item(0)

# Create a reply comment
reply_comment = Comment(doc)
reply_comment.Format.Author = "Jane Doe"
reply_comment.Body.AddParagraph().AppendText(
    "I agree with this point. It would be beneficial to add more implementation details."
)

# Link the new comment as a reply to the original comment
original_comment.ReplyToComment(reply_comment)

# You can also add images to replies
docPicture = DocPicture(doc)
docPicture.LoadImage("AnnotationImage.png")
reply_comment.Body.Paragraphs[0].ChildObjects.Add(docPicture)

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

Execution result:

Through the ReplyToComment method, newly created comments can be linked to existing comments, forming a hierarchical discussion structure. This is particularly useful in collaborative team reviews, enabling clear tracking of each issue's discussion process.

Extracting All Comments from a Document

When processing large volumes of documents, you may need to extract all comments for summary analysis or to generate review reports. The following code demonstrates how to iterate through and extract all comment content from a document.

Extraction Logic

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

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

content = ''

# Iterate through all comments
for i in range(doc.Comments.Count):
    comment = doc.Comments.get_Item(i)

    # Get comment author
    author = comment.Format.Author

    # Extract comment body content
    for j in range(comment.Body.Paragraphs.Count):
        paragraph = comment.Body.Paragraphs.get_Item(j)
        content += f"[Author: {author}]\n"
        content += paragraph.Text
        content += '\n\n'

# Save extracted content to a text file
with open("ExtractedComments.txt", "w", encoding="utf-8") as f:
    f.write(content)

print(f"Total comments extracted: {doc.Comments.Count}")

Execution result:

This code iterates through the doc.Comments collection to access each comment object sequentially. For each comment, you can retrieve author information, comment content, and other metadata. The extracted content can be saved to a text file for subsequent processing or report generation.

Deleting and Replacing Comments

In certain scenarios, you may need to clean up outdated comments or update comment content. Spire.Doc provides functionality for deleting and replacing comments.

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

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

# Delete the second comment (reply content)
if doc.Comments.Count > 1:
    doc.Comments.RemoveAt(1)

# Or replace comment content
if doc.Comments.Count > 0:
    comment = doc.Comments.get_Item(0)
    # Clear existing content
    comment.Body.Paragraphs.Clear()
    # Add new content
    comment.Body.AddParagraph().Text = "Updated comment content"
    comment.Format.Author = "Robert Johnson"

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

Execution result:

Practical Application Scenarios

Comment management features are particularly useful in the following scenarios:

Batch Document Review: Automatically add standard comments to key clauses across multiple documents
Comment Summary Reports: Extract all comments to generate review summaries, allowing project managers to quickly understand issues
Version Comparison Support: Record change reasons and decision rationale through comments during document version iterations
Automated Workflows: Combine with other systems to automatically add or reply to comments based on specific rules

Important Considerations

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

Comment ID Management: Ensure each comment's CommentId is unique to avoid conflicts
Text Positioning Accuracy: When using FindString, consider case sensitivity and whole-word matching options
Reply Hierarchy: Replies to comments create nested structures that require recursive processing during extraction
Format Preservation: Comments can contain rich text and images; pay attention to format handling during extraction

Conclusion

This article has introduced the complete workflow for managing comments in Word documents using Python, including adding comments, replying to comments, extracting comment content, and deleting or replacing comments. Through these capabilities, you can automate document review processes and improve team collaboration efficiency.

The comment API provided by Spire.Doc for Python covers common document collaboration requirements. When combined with other document processing features, it enables the construction of comprehensive document automation solutions. In actual projects, you can combine these features according to specific needs to implement more complex document processing workflows.

Create Box and Whisker Charts in PowerPoint Using Python

Allen Yang — Mon, 08 Jun 2026 08:24:01 +0000

In data analysis and statistical reporting, box and whisker charts (also known as box plots) are essential visualization tools. They clearly display data distribution characteristics, including the median, quartiles, and outliers, enabling viewers to quickly grasp the overall picture of a dataset. When creating presentations, embedding box and whisker charts directly into PowerPoint slides makes data analysis results more intuitive and professional.

This article demonstrates how to create and customize box and whisker charts in PowerPoint presentations using Python and the Spire.Presentation for Python library. With this approach, developers can automate the generation of presentations containing statistical analysis charts, improving work efficiency and ensuring consistency in data presentation.

Why Choose Box and Whisker Charts

Box and whisker charts are particularly useful in the following scenarios:

Comparing Multiple Datasets: Display the distribution of multiple data groups simultaneously for easy cross-comparison
Identifying Outliers: Automatically mark data points that fall outside the normal range
Showing Data Dispersion: Visually represent data variability through boxes and whiskers
Statistical Analysis Reporting: Provide professional-grade data visualization in business reports and academic presentations

Environment Setup

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

pip install Spire.Presentation

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

Creating a Basic Box and Whisker Chart

The core steps for creating a box and whisker chart include: initializing the presentation, adding a chart, setting up the data source, configuring chart properties, and finally saving the file. Here's a complete example:

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

# Create a PowerPoint document
ppt = Presentation()

# Add a box and whisker chart to the first slide
# Parameters: chart type, position rectangle, whether to create from template
chart = ppt.Slides[0].Shapes.AppendChartInit(
    ChartType.BoxAndWhisker, 
    RectangleF.FromLTRB(50, 50, 550, 450), 
    False
)

# Set series labels
seriesLabel = ["Series 1", "Series 2", "Series 3"]
for i in range(len(seriesLabel)):
    chart.ChartData[0, i + 1].Text = seriesLabel[i]

# Set category labels
categories = [
    "Category 1", "Category 1", "Category 1", "Category 1", 
    "Category 1", "Category 1", "Category 1",
    "Category 2", "Category 2", "Category 2", "Category 2", 
    "Category 2", "Category 2",
    "Category 3", "Category 3", "Category 3", "Category 3", 
    "Category 3"
]
for i in range(len(categories)):
    chart.ChartData[i + 1, 0].Text = categories[i]

# Set numeric data
values = [
    [-7, -3, -24], [-10, 1, 11], [-28, -6, 34], 
    [47, 2, -21], [35, 17, 22], [-22, 15, 19], 
    [17, -11, 25], [-30, 18, 25], [49, 22, 56], 
    [37, 22, 15], [-55, 25, 31], [14, 18, 22], 
    [18, -22, 36], [-45, 25, -17], [-33, 18, 22], 
    [18, 2, -23], [-33, -22, 10], [10, 19, 22]
]

# Populate data into the chart
for i in range(len(seriesLabel)):
    for j in range(len(categories)):
        chart.ChartData[j + 1, i + 1].NumberValue = values[j][i]

# Bind data source to chart series
chart.Series.SeriesLabel = chart.ChartData[0, 1, 0, len(seriesLabel)]
chart.Categories.CategoryLabels = chart.ChartData[1, 0, len(categories), 0]

# Assign data values to each series
for i in range(len(seriesLabel)):
    chart.Series[i].Values = chart.ChartData[1, i + 1, len(categories), i + 1]

# Set chart title
chart.ChartTitle.TextProperties.Text = "Box and Whisker Chart Example"

# Display legend and set position
chart.HasLegend = True
chart.ChartLegend.Position = ChartLegendPositionType.Top

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

Result document:

This code creates a box and whisker chart with three data series. The AppendChartInit method inserts a chart at a specified position on the slide, while RectangleF.FromLTRB defines the chart's position and size (left, top, right, bottom boundaries).

Customizing Box and Whisker Chart Styles

Box and whisker charts offer various customization options to adjust data display and visual effects. Here are several commonly used configuration options:

Displaying Outliers and Mean Markers

You can control whether to display inner points, outliers, mean markers, and mean lines by setting series properties:

# Configure the first series
chart.Series[0].ShowInnerPoints = False      # Do not display inner data points
chart.Series[0].ShowOutlierPoints = True     # Display outliers
chart.Series[0].ShowMeanMarkers = True       # Display mean markers
chart.Series[0].ShowMeanLine = True          # Display mean line

# Set quartile calculation method
chart.Series[0].QuartileCalculationType = QuartileCalculation.ExclusiveMedian

The meanings of these properties are as follows:

ShowInnerPoints: Controls whether to display data points within the box
ShowOutlierPoints: Controls whether to display outliers (points outside the whisker range)
ShowMeanMarkers: Controls whether to display mean marker points
ShowMeanLine: Controls whether to display the mean line
QuartileCalculationType: Sets the quartile calculation method, with options ExclusiveMedian (excluding the median) or InclusiveMedian (including the median)

Applying Different Configurations to Different Series

You can set different display options for each data series to meet different analysis requirements:

# First series: Use exclusive median method
chart.Series[0].ShowInnerPoints = False
chart.Series[0].ShowOutlierPoints = True
chart.Series[0].ShowMeanMarkers = True
chart.Series[0].ShowMeanLine = True
chart.Series[0].QuartileCalculationType = QuartileCalculation.ExclusiveMedian

# Second series: Use inclusive median method
chart.Series[1].ShowInnerPoints = False
chart.Series[1].ShowOutlierPoints = True
chart.Series[1].ShowMeanMarkers = True
chart.Series[1].ShowMeanLine = True
chart.Series[1].QuartileCalculationType = QuartileCalculation.InclusiveMedian

# Third series: Use exclusive median method
chart.Series[2].ShowInnerPoints = False
chart.Series[2].ShowOutlierPoints = True
chart.Series[2].ShowMeanMarkers = True
chart.Series[2].ShowMeanLine = True
chart.Series[2].QuartileCalculationType = QuartileCalculation.ExclusiveMedian

This flexibility allows you to compare results from different statistical methods within the same chart.

Complete Example

Combining all the features mentioned above, here is a complete example for creating a box and whisker chart:

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

outputFile = "CreateBoxAndWhiskerChart.pptx"

# Create a PowerPoint document
ppt = Presentation()

# Add a box and whisker chart to the first slide
chart = ppt.Slides[0].Shapes.AppendChartInit(
    ChartType.BoxAndWhisker, 
    RectangleF.FromLTRB(50, 50, 550, 450), 
    False
)

# Set series labels
seriesLabel = ["Series 1", "Series 2", "Series 3"]
for i in range(len(seriesLabel)):
    chart.ChartData[0, i + 1].Text = seriesLabel[i]

# Set category labels
categories = [
    "Category 1", "Category 1", "Category 1", "Category 1", 
    "Category 1", "Category 1", "Category 1",
    "Category 2", "Category 2", "Category 2", "Category 2", 
    "Category 2", "Category 2",
    "Category 3", "Category 3", "Category 3", "Category 3", 
    "Category 3"
]
for i in range(len(categories)):
    chart.ChartData[i + 1, 0].Text = categories[i]

# Set numeric data
values = [
    [-7, -3, -24], [-10, 1, 11], [-28, -6, 34], 
    [47, 2, -21], [35, 17, 22], [-22, 15, 19], 
    [17, -11, 25], [-30, 18, 25], [49, 22, 56], 
    [37, 22, 15], [-55, 25, 31], [14, 18, 22], 
    [18, -22, 36], [-45, 25, -17], [-33, 18, 22], 
    [18, 2, -23], [-33, -22, 10], [10, 19, 22]
]

# Populate data into the chart
for i in range(len(seriesLabel)):
    for j in range(len(categories)):
        chart.ChartData[j + 1, i + 1].NumberValue = values[j][i]

# Bind data source
chart.Series.SeriesLabel = chart.ChartData[0, 1, 0, len(seriesLabel)]
chart.Categories.CategoryLabels = chart.ChartData[1, 0, len(categories), 0]

# Assign data values to each series and set display options
for i in range(len(seriesLabel)):
    chart.Series[i].Values = chart.ChartData[1, i + 1, len(categories), i + 1]
    chart.Series[i].ShowInnerPoints = False
    chart.Series[i].ShowOutlierPoints = True
    chart.Series[i].ShowMeanMarkers = True
    chart.Series[i].ShowMeanLine = True

    # Set different quartile calculation methods based on series index
    if i == 1:
        chart.Series[i].QuartileCalculationType = QuartileCalculation.InclusiveMedian
    else:
        chart.Series[i].QuartileCalculationType = QuartileCalculation.ExclusiveMedian

# Display legend
chart.HasLegend = True
chart.ChartLegend.Position = ChartLegendPositionType.Top

# Set chart title
chart.ChartTitle.TextProperties.Text = "BoxAndWhisker"

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

Result document:

After running this code, a PowerPoint file named CreateBoxAndWhiskerChart.pptx will be generated, containing a formatted box and whisker chart.

Practical Application Recommendations

In real-world work scenarios, you can apply box and whisker charts to the following situations:

Quality Control Reports: Display the distribution of product dimensions, weights, and other metrics to identify non-conforming items
Financial Analysis: Compare the distribution of revenue and expenses across different quarters or departments
Academic Research: Present statistical characteristics and outliers of experimental data
Performance Monitoring: Visualize the fluctuation range of system response times, throughput, and other metrics

By automating the generation of these charts, you can reduce manual operations, ensure timely data updates, and maintain a professional appearance in your presentations.

Summary

This article demonstrated how to create box and whisker charts in PowerPoint using Python and the Spire.Presentation library. We learned how to set up chart data, configure display options, customize quartile calculation methods, and combine these features into a complete solution.

Box and whisker charts are powerful tools in statistical analysis, capable of intuitively displaying data distribution characteristics. By programmatically generating these charts, you can not only improve work efficiency but also ensure consistency and accuracy in data presentation. Developers can further explore other chart types and customization options based on specific needs to create richer data visualization presentations.

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.