DEV Community: jelizaveta

Python TXT to Excel (Automatic Delimiter Detection)

jelizaveta — Thu, 28 May 2026 09:31:29 +0000

In data processing workflows, we often encounter the need to convert TXT text files to Excel format. However, a common challenge is that TXT files may use different delimiters—tabs, commas, semicolons, vertical bars, or even spaces. If the code can only handle a single delimiter, errors will occur frequently. This article introduces how to use the Spire.XLS for Python library to create an intelligent tool that can automatically detect delimiters and complete the conversion.

Why Do We Need Automatic Delimiter Detection?

In practice, the TXT files we receive come in various formats:

Files exported from databases may use tabs (\t)
CSV files typically use commas (,)
Files exported from certain systems use vertical bars (|) or semicolons (;)

The traditional approach is to manually inspect the file and then modify the delimiter in the code. This is not only inefficient but also error-prone. Our goal is to let the program figure it out itself!

Core Technology: Spire.XLS for Python

Spire.XLS is a powerful Excel manipulation library that can create, read, and modify Excel files without needing Microsoft Office installed. Compared to openpyxl and xlswriter, its API design is more intuitive, making it particularly suitable for rapid development.

Installation :

pip install spire.xls

Complete Code Implementation

python

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

def detect_delimiter(file_path, sample_lines=5):
    """Automatically detect the most likely delimiter in a text file"""
    common_delimiters = ["\t", ",", "|", ";", " "]

    with open(file_path, "r") as file:
        sample = [file.readline() for _ in range(sample_lines)]

    delimiter_counts = {}
    for delim in common_delimiters:
        count = sum(line.count(delim) for line in sample)
        if count > 0:
            delimiter_counts[delim] = count

    if not delimiter_counts:
        return "\t"  # Default to tab if no delimiter detected

    return max(delimiter_counts, key=delimiter_counts.get)

# Perform conversion
file_path = "Data.txt"
delimiter = detect_delimiter(file_path)
print(f"Detected delimiter: {repr(delimiter)}")

# Read and split data by delimiter
with open(file_path, "r") as file:
    lines = file.readlines()
data = [line.strip().split(delimiter) for line in lines]

# Create Excel workbook and write data
workbook = Workbook()
sheet = workbook.Worksheets[0]

for row_num, row_data in enumerate(data):
    for col_num, cell_data in enumerate(row_data):
        sheet.Range[row_num + 1, col_num + 1].Value = cell_data
        sheet.Range[1, col_num + 1].Style.Font.IsBold = True  # Bold header row

sheet.AllocatedRange.AutoFitColumns()  # Auto-fit column widths
workbook.SaveToFile("TXTtoExcel.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

Code Explanation

1. Delimiter Detection Mechanism

The detect_delimiter() function reads the first 5 lines of the file, counts occurrences of each candidate delimiter, and returns the one with the highest frequency. The sampling approach avoids reading the entire large file, offering excellent performance.

2. Writing Data to Excel

Using Spire.XLS's object model, cells are directly located via row and column indices. Note that Excel's rows and columns start counting from 1, while Python lists start from 0, hence the need for row_num + 1.

3. Formatting Enhancements

The header row is automatically bolded for better readability
AutoFitColumns() automatically adjusts column widths based on content
Resources are released after conversion (Dispose())

Practical Application Example

Suppose there is a Data.txt file with the following content:

text

Name|Department|Salary|Hire Date
Zhang San|Technical|8500|2023-01-15
Li Si|Marketing|9200|2022-11-20

The program will automatically detect the delimiter as | and generate a properly formatted Excel table with bold headers and auto-adjusted column widths.

Important Notes

File Encoding : UTF-8 encoding is used by default. If the file uses a different encoding like GBK, add the encoding='gbk' parameter to open().
Large Data Processing : The free version of Spire.XLS has row limitations for very large files (max 150 rows). For production environments, consider the commercial version.

Summary

By combining automatic delimiter detection technology with Spire.XLS's powerful writing capabilities, we've implemented a universal TXT to Excel conversion tool. This script can:

✅ Automatically identify 5 common delimiters
✅ Complete conversion without manual intervention
✅ Output beautifully formatted Excel tables

Whether you're a data analyst, operations engineer, or regular office user, you can benefit from this tool. You can save this code as a universal utility to handle text files in various formats at any time, dramatically improving work efficiency!

C# Operate Word Watermarks: Add Text, Add Image, Remove—All in One Guide

jelizaveta — Tue, 26 May 2026 02:37:46 +0000

If you build enterprise software, you’ll eventually face document automation—especially with Word files. Business documents often need visual status and protection cues like:

Confidential / Restricted labels
Draft indicators
Copyright or ownership marks
Approval signatures and brand logos

A watermark is ideal because it doesn’t block reading, yet clearly communicates the document’s attributes.

In this post, I’ll show you how to do three common watermark tasks with Spire.Doc for .NET using clean C#:

Add a text watermark
Add an image watermark
Remove an existing watermark

1. Overview of Spire.Doc for .NET Component

Spire.Doc for .NET is a professional Word document manipulation component. It allows developers to create, read, modify, and convert Word documents directly through code without installing Microsoft Office. The component provides full watermark handling capabilities and supports two main types of watermarks:

Watermark Type	Applicable Scenarios	Core Class
Text Watermark	Confidentiality labels, draft status, copyright statements	`TextWatermark`
Picture Watermark	Company logos, signatures, graphical identifiers	`PictureWatermark`

Unlike complex solutions that simulate watermarks by manipulating headers/footers or inserting shapes, Spire.Doc includes a dedicated watermark object model, making watermark addition and management concise and standardized.

Environment Setup

Before starting to code, you need to install Spire.Doc into your project using the NuGet package manager. In Visual Studio’s “Package Manager Console”, run the following command:

Install-Package Spire.Doc

After installation, you need to import the following namespaces in your code file:

using Spire.Doc;
using Spire.Doc.Documents;
using System.Drawing;  // Used for colors and image operations

2. Add a Text Watermark

A text watermark is the most basic and commonly used form. In essence, a text watermark renders a string of text in a semi-transparent (or specified color) style onto the background layer of every page of the document. The text typically uses a large font size and is arranged diagonally or horizontally, visually distinguishing it from the main content.

Key Property Explanation

The TextWatermark class provides the following configurable properties:

Property	Type	Description
`Text`	string	The watermark text content to display, such as “Confidential” or “DO NOT COPY”
`FontSize`	int	Font size of the watermark text, commonly set to 40–80
`Color`	Color	Watermark text color; it’s recommended to choose a soft or semi-transparent tone
`Layout`	WatermarkLayout	Arrangement direction:`Diagonal`(diagonal) or`Horizontal`(horizontal)

Code Implementation

using System;
using System.Drawing;
using Spire.Doc;
using Spire.Doc.Documents;

namespace InsertTextWatermark
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Create a Document instance
            Document document = new Document();

            // Load the Word document from disk
            document.LoadFromFile("input.docx");

            // Insert a text watermark
            InsertTextWatermark(document);

            // Save the document
            document.SaveToFile("TextWatermark.docx", FileFormat.Docx);
        }

        private static void InsertTextWatermark(Document document)
        {
            TextWatermark txtWatermark = new TextWatermark();
            txtWatermark.Text = "DO NOT COPY";           // Watermark text content
            txtWatermark.FontSize = 50;                   // Font size
            txtWatermark.Color = Color.Blue;              // Text color
            txtWatermark.Layout = WatermarkLayout.Diagonal; // Diagonal layout
            document.Watermark = txtWatermark;
        }
    }
}

Important Notes

A watermark is associated with the entire document object, not with a specific page or section. This means that after you add the watermark once, it will automatically be applied to all pages of the document.
When saving, you need to explicitly specify the format as FileFormat.Docx to ensure watermark information is correctly written into the Word file structure.
If you want the watermark to be displayed centered horizontally, set the Layout property to WatermarkLayout.Horizontal.

3. Add an Image Watermark

Compared with text watermarks, image watermarks are suitable for richer scenarios:

Enterprises add the company logo as a watermark to internal documents
Design teams overlay copyright identifier images on design drafts
Use signature images as approval watermarks in documents

Key Property Explanation

The PictureWatermark class provides the following configurable properties:

Property	Type	Description
`Picture`	Image	The image object to display; supports PNG, JPG, BMP, GIF, etc.
`Scaling`	int	Scaling percentage relative to the original size, e.g., 200 means enlarge to 200%
`IsWashout`	bool	`true`for a washout (faded) effect;`false`keeps the original colors

Code Implementation

using System;
using System.Drawing;
using Spire.Doc;
using Spire.Doc.Documents;

namespace InsertImageWatermark
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Create a Document instance
            Document document = new Document();

            // Load the Word document
            document.LoadFromFile("Input.docx");

            // Insert an image watermark
            InsertImageWatermark(document);

            // Save the document
            document.SaveToFile("InsertImageWatermark.docx", FileFormat.Docx);        
        }

        private static void InsertImageWatermark(Document document)
        {
            PictureWatermark picture = new PictureWatermark();
            picture.Picture = Image.FromFile("watermark.png");  // Load the image file
            picture.Scaling = 200;                               // Scaling ratio (%)
            picture.IsWashout = false;                           // Whether to use a washout effect
            document.Watermark = picture;
        }
    }
}

Two Visual Effects of Image Watermarks

Setting Method	`IsWashout = true`	`IsWashout = false`
Visual Effect	Image is faded and semi-transparent, similar to a background watermark	Image keeps its original color saturation
Applicable Scenarios	Background decoration that does not interfere with reading the main content	Clearly showcases logo or signature details
Typical Uses	General document copyright labeling	Formal contracts and approval documents

4. Remove Watermarks

A document’s lifecycle often goes through multiple stages, and watermark requirements are not permanent. For example, a document in the review stage may need a prominent “Confidential” watermark, but once the review is completed and it is officially published, the watermark may become redundant and needs to be removed.

Design Principle

The design for removing watermarks in Spire.Doc is straightforward: the Document.Watermark property is essentially an object reference. When it points to a TextWatermark or PictureWatermark instance, it indicates that the document currently has a watermark enabled. After setting this reference to a null reference, the watermark is detached from the document.

Code Implementation

using Spire.Doc;

namespace RemoveWatermark
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Document instance
            Document doc = new Document();

            // Load a Word document that contains a watermark
            doc.LoadFromFile("Input.docx");

            // Remove the watermark from the document
            doc.Watermark = null;

            // Save the result document
            doc.SaveToFile("RemoveWatermark.docx", FileFormat.Docx2013);
        }
    }
}

⚠️ Notes

This removal approach is intended for standard watermarks added via Spire.Doc. If the “watermark” in the document was implemented using other non-standard methods (for example, inserting a semi-transparent shape in the header, or embedding a background image directly), then you cannot handle it using this method and must adopt other document content removal strategies.

5. Summary

With Spire.Doc for .NET, developers can use concise and standardized C# code to add and remove Word document watermarks. The core operations covered in this article are summarized below:

Operation	Core Code	Key Class
Add Text Watermark	`document.Watermark = new TextWatermark()`	`TextWatermark`
Add Image Watermark	`document.Watermark = new PictureWatermark()`	`PictureWatermark`
Remove Watermark	`document.Watermark = null`	-

Recommended Use Cases

Text Watermarks : Suitable for scenarios where watermark text needs to be generated dynamically, such as displaying different confidentiality levels based on user permissions.
Image Watermarks : Suitable for brand-standardized scenarios, such as using a company logo as the document background.
Remove Watermarks : Suitable for document handoff scenarios, such as removing watermarks before external release when documents go through internal review stages.

This solution does not rely on Office software environments. It is suitable for deployment in server-side applications or background services, offering good stability and extensibility.

Print Excel Documents Using C# (Detailed Tutorial)

jelizaveta — Thu, 21 May 2026 01:34:33 +0000

Implementing high-quality Excel printing in a .NET environment is not easy. Developers need to precisely control settings such as page margins, paper size, gridline display, and more—while also supporting both physical printers and virtual PDF printers. Without a mature solution, these requirements often consume a lot of time for tuning and adaptation.

This article guides you through building a complete Excel printing solution using Spire.XLS for .NET together with the System.Drawing.Printing namespace. By following this tutorial, you will learn core skills including loading an Excel document, configuring print parameters, printing to a physical printer, and converting Excel to PDF, etc.

1. Preparation

1.1 Environment Requirements

.NET Framework 4.0 or later , or .NET Core/.NET 5+
Visual Studio 2017 or later

1.2 Install Spire.XLS for .NET

Install via the NuGet package manager:

Install-Package Spire.XLS

Or install in Visual Studio by searching for Spire.XLS through the NuGet package manager.

2. Import the Core Namespaces

using Spire.Xls;
using System.Drawing.Printing;

3. Printing to a Physical Printer

3.1 Complete Code Example

using Spire.Xls;
using System.Drawing.Printing;

namespace PrintExcel
{
    class Program
    {
        static void Main(string[] args)
        {
            // 1. Load the Excel document
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Input.xlsx");

            // 2. Iterate through and configure each worksheet
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                Worksheet worksheet = workbook.Worksheets[i];
                PageSetup pageSetup = worksheet.PageSetup;

                // Set margins (unit: inches)
                pageSetup.TopMargin = 0.3;
                pageSetup.BottomMargin = 0.3;
                pageSetup.LeftMargin = 0.3;
                pageSetup.RightMargin = 0.3;

                // Print gridlines
                pageSetup.IsPrintGridlines = true;

                // Fit all columns to one page wide
                pageSetup.FitToPagesWide = 1;
                pageSetup.FitToPagesTall = 0;

                // Set paper size to A4
                pageSetup.PaperSize = PaperSizeType.PaperA4;
            }

            // 3. Get printer settings
            PrinterSettings settings = workbook.PrintDocument.PrinterSettings;

            // 4. Specify printer name
            settings.PrinterName = "Your Printer Name";

            // 5. Execute printing
            workbook.PrintDocument.Print();
        }
    }
}

3.2 Code Explanation

Loading the Excel Document

Workbook workbook = new Workbook();
workbook.LoadFromFile("Input.xlsx");

Create a Workbook object and load the Excel file to be printed using LoadFromFile.

Page Setup (PageSetup)

Loop through each worksheet and apply detailed page configuration:

Page margins : TopMargin, BottomMargin, LeftMargin, RightMargin set margins on all sides (unit: inches).
Gridlines : IsPrintGridlines = true keeps gridlines in the printout, making the data easier to read.
Scaling settings :
- FitToPagesWide = 1: scale all columns to fit on one page width
- FitToPagesTall = 0: do not limit row count; paginate based on actual height
Paper size : PaperSize = PaperSizeType.PaperA4 sets the paper to A4.

Printer Configuration and Execution

PrinterSettings settings = workbook.PrintDocument.PrinterSettings;
settings.PrinterName = "Your Printer Name";
workbook.PrintDocument.Print();

Get the printer settings object, set the target printer name, then call Print() to start printing.

4. Printing to a Virtual Printer (Microsoft Print to PDF)

4.1 Complete Code Example

using Spire.Xls;
using System.Drawing.Printing;

namespace PrintExcel
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load the Excel document
            Workbook workbook = new Workbook();
            workbook.LoadFromFile("Input.xlsx");

            // Configure worksheets (same as previous example)
            for (int i = 0; i < workbook.Worksheets.Count; i++)
            {
                Worksheet worksheet = workbook.Worksheets[i];
                PageSetup pageSetup = worksheet.PageSetup;
                pageSetup.TopMargin = 0.3;
                pageSetup.BottomMargin = 0.3;
                pageSetup.LeftMargin = 0.3;
                pageSetup.RightMargin = 0.3;
                pageSetup.IsPrintGridlines = true;
                pageSetup.FitToPagesWide = 1;
                pageSetup.FitToPagesTall = 0;
                pageSetup.PaperSize = PaperSizeType.PaperA4;
            }

            // Set the virtual printer
            PrinterSettings settings = workbook.PrintDocument.PrinterSettings;
            settings.PrintToFile = true;  // Enable printing to a file
            settings.PrinterName = "Microsoft Print to PDF";  // Specify virtual printer

            // Execute printing and specify the output PDF path
            workbook.PrintDocument.Print("ToPdf.pdf");
        }
    }
}

4.2 Key Points

The main differences from printing to a physical printer:

Setting	Description
`settings.PrintToFile = true`	Enable “print to file” mode
`settings.PrinterName = "Microsoft Print to PDF"`	Specify the virtual printer name
`workbook.PrintDocument.Print("ToPdf.pdf")`	Use the`Print`method with a parameter to set the output file path

5. Common Printer Name Reference

Default Printer on Windows

// Get default printer name
string defaultPrinter = new PrinterSettings().PrinterName;

Common Printer Names

Printer Type	Example Name
Microsoft Print to PDF	`"Microsoft Print to PDF"`
Microsoft XPS Document Writer	`"Microsoft XPS Document Writer"`
Foxit Reader PDF Printer	`"Foxit Reader PDF Printer"`
Physical printer	e.g.,`"HP LaserJet MFP M227fdw"`

Get All Installed Printers

foreach (string printer in PrinterSettings.InstalledPrinters)
{
    Console.WriteLine(printer);
}

6. More Page Setup Options

6.1 Common PageSetup Properties

// Set print orientation
pageSetup.Orientation = PageOrientationType.Landscape;  // Landscape
pageSetup.Orientation = PageOrientationType.Portrait;   // Portrait

// Set zoom level (1-100)
pageSetup.Zoom = 90;

// Set header/footer margins
pageSetup.HeaderMargin = 0.5;
pageSetup.FooterMargin = 0.5;

// Set print area
pageSetup.PrintArea = "A1:F50";

// Set title rows (repeat print on every page)
pageSetup.PrintTitleRows = "$1:$2";

// Center horizontally/vertically
pageSetup.HorzAlignment = PageSetupHorzAlignment.Center;
pageSetup.VertAlignment = PageSetupVertAlignment.Center;

6.2 Paper Size Types

pageSetup.PaperSize = PaperSizeType.PaperA3;
pageSetup.PaperSize = PaperSizeType.PaperA4;
pageSetup.PaperSize = PaperSizeType.PaperA5;
pageSetup.PaperSize = PaperSizeType.PaperLetter;
pageSetup.PaperSize = PaperSizeType.PaperLegal;

7. Advanced Scenario: Silent Printing

If you need to implement printing without dialogs:

// Hide print dialog
workbook.PrintDocument.PrintController = new StandardPrintController();

// Set number of copies
workbook.PrintDocument.PrinterSettings.Copies = 2;

// Execute printing silently
workbook.PrintDocument.Print();

8. Exception Handling

It’s recommended to add exception handling in real applications:

try
{
    // Check whether the printer exists
    if (!PrinterSettings.InstalledPrinters.Cast<string>().Any(p => p == printerName))
    {
        throw new Exception($"Printer '{printerName}' does not exist");
    }

    workbook.PrintDocument.Print();
    Console.WriteLine("Print successful!");
}
catch (Exception ex)
{
    Console.WriteLine($"Print failed: {ex.Message}");
}

9. Summary

This article provides a complete solution for printing Excel documents using C# and the Spire.XLS library:

Scenario	Key Code
Physical printer	Set`PrinterName`+ call`Print()`
PDF output	Set`PrintToFile = true`+ call`Print("output.pdf")`
Page configuration	Use the`PageSetup`object to set margins, paper, scaling, etc.
Silent printing	Set`PrintController = new StandardPrintController()`

Spire.XLS offers many page setup options, and combined with the printer management capabilities of System.Drawing.Printing, it can flexibly meet various Excel printing requirements. Whether you’re batch-printing reports or converting Excel to PDF for archiving, the code in this article can serve as a reliable foundation.

Adding Page Numbers to PDF with Python (Full Tutorial)

jelizaveta — Tue, 19 May 2026 02:49:53 +0000

When working with PDFs such as contracts, reports, academic papers, and technical documents, adding page numbers is almost an essential requirement. Traditional PDF editing often relies on complex layout tools; however, with Free Spire.PDF for Python, you can use simple code to add page numbers to the PDF footer in center, left, or right alignment .

This article will teach you how to use the powerful Spire.PDF for Python library to automatically add page numbers to PDF files. We provide complete code for three styles: centered, left-aligned, and right-aligned, so you can choose flexibly based on your needs.

1. Preparation

First, install the Spire.PDF for Python library:

pip install spire.pdf

After installation, import the required modules in your Python code:

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

2. Key Concepts Explained

Before writing code, let’s understand the purpose of several key classes in this library:

Class Name	Purpose
PdfDocument	Represents a PDF document, used to load, save, and modify files
PdfPageNumberField	Represents the current page number, filled automatically
PdfPageCountField	Represents the total page count, filled automatically
PdfCompositeField	Combines multiple fields into a formatted string
PdfTrueTypeFont	Creates a TrueType font with full English support

Simply put: PdfPageNumberField and PdfPageCountField are dynamic values, and PdfCompositeField places them into a text template.

3. Complete Code Example (Centered Page Numbers)

Below is the full code to add centered English page numbers to a PDF with clean comments:

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

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

# Set font: Times New Roman
font = PdfTrueTypeFont("Times New Roman", 12.0, PdfFontStyle.Regular, True)
brush = PdfBrushes.get_Black()
pen = PdfPen(brush, 1.0)

# Create page number and total page fields
pageNumberField = PdfPageNumberField()
pageCountField = PdfPageCountField()

# Create English page number format: Page X of Y
compositeField = PdfCompositeField(
    font,
    brush,
    "Page {0} of {1}",
    [pageNumberField, pageCountField]
)

# Set margins (unit: points, 1 point = 1/72 inch)
leftMargin = 54.0
rightMargin = 54.0
bottomMargin = 72.0

# Loop through all pages and add page numbers
for i in range(doc.Pages.Count):
    page = doc.Pages.get_Item(i)
    pageSize = page.Size

    # Draw a separator line
    lineY = pageSize.Height - bottomMargin + 25.0
    page.Canvas.DrawLine(pen, leftMargin, lineY, pageSize.Width - rightMargin, lineY)

    # Measure text size for accurate centering
    pageNumberSize = font.MeasureString(f"Page {i + 1} of {doc.Pages.Count}")

    # Set centered position
    compositeField.Location = PointF(
        (pageSize.Width - pageNumberSize.Width) / 2,
        pageSize.Height - bottomMargin + 30.0
    )

    # Draw page number on the canvas
    compositeField.Draw(page.Canvas, 0.0, 0.0)

# Save the output file and release resources
doc.SaveToFile("Output.pdf")
doc.Dispose()

4. Left and Right Alignment

To switch alignment, simply modify the X coordinate of compositeField.Location.

4.1 Left-Aligned Page Numbers

# Left alignment: X = left margin
compositeField.Location = PointF(
    leftMargin,
    pageSize.Height - bottomMargin + 30.0
)

Result: "Page 1 of 10" appears at the bottom left .

4.2 Right-Aligned Page Numbers

# Right alignment: X = page width - text width - right margin
compositeField.Location = PointF(
    pageSize.Width - pageNumberSize.Width - rightMargin,
    pageSize.Height - bottomMargin + 30.0
)

Result: "Page 1 of 10" appears at the bottom right .

5. More English Page Number Styles

In addition to "Page X of Y", you can use these common styles:

5.1 Simple Style

compositeField = PdfCompositeField(
    font, brush, "{0} / {1}", 
    [pageNumberField, pageCountField]
)
# Output: 1 / 10

5.2 With Decorators

compositeField = PdfCompositeField(
    font, brush, "- {0} / {1} -", 
    [pageNumberField, pageCountField]
)
# Output: - 1 / 10 -

5.3 Page Number Only

compositeField = PdfCompositeField(
    font, brush, "{0}", 
    [pageNumberField]
)
# Output: 1

6. Recommended Fonts for English

Font Name	Description	Usage
Times New Roman	Formal, standard	Papers, reports
Arial	Clean, modern	Business, web
Calibri	Smooth, readable	Office documents

Example:

font = PdfTrueTypeFont("Arial", 12.0, PdfFontStyle.Regular, True)

7. Parameter Tuning Guide

7.1 Margin Adjustment

leftMargin = 54.0      # Increase → move right (left-aligned)
rightMargin = 54.0     # Increase → move left (right-aligned)
bottomMargin = 72.0    # Increase → move up; decrease → move down

7.2 Vertical Position Adjustment

# Separator line position
lineY = pageSize.Height - bottomMargin + 15.0

# Page number vertical position
compositeField.Location = PointF(x, pageSize.Height - bottomMargin + 18.0)

Increase values → move down
Decrease values → move up

7.3 Font Size

# Change to 14pt
font = PdfTrueTypeFont("Times New Roman", 14.0, PdfFontStyle.Regular, True)

8. Common Issues & Solutions

Q1: Text displays incorrectly?

A: Use standard English fonts: Times New Roman, Arial, Calibri.

Q2: Page numbers appear in header instead of footer?

A: Increase the Y position value to move them down.

Q3: Page numbers overlap content?

A: Increase bottomMargin to create more space.

Q4: Skip the title page?

A: Start the loop from index 1:

for i in range(1, doc.Pages.Count):

Q5: Add page numbers only to specific pages?

A: Add a condition:

for i in range(doc.Pages.Count):
    if 2 <= i <= 10:
        # Draw page numbers here

9. Summary

With Spire.PDF for Python, you can add professional English page numbers to PDFs in just a few lines of code. The library supports centered, left, and right alignment.

Core steps:

Load the PDF
Define font and fields
Create the page number format
Loop and draw on each page
Save the document

This method is efficient, reusable, and works for documents of any size.

Adding or Reading Excel Formulas with C#: A Complete Guide

jelizaveta — Thu, 14 May 2026 01:27:19 +0000

In office data processing tasks, Excel formulas and functions serve as the foundation for automated calculations and data analysis. For .NET developers, being able to programmatically inject formulas into Excel files or extract formula logic from existing spreadsheets is a common and practical need. This article will demonstrate how to add and read Excel formulas using C# with Free Spire.XLS for .NET , a lightweight and free component.

Preparation: Installing Free Spire.XLS

Before coding, we need to add Free Spire.XLS for .NET to our project. This component can be easily installed via the NuGet Package Manager by executing the following command in the Package Console:

Install-Package FreeSpire.XLS

Once installed, we can access all Excel operation-related classes and methods through the using Spire.Xls; namespace in our code.

Part 1: Adding Formulas to Excel

The scenarios for adding formulas are extensive, such as batch-calculating total sales, averaging student scores, generating dynamic reports, and more. The following example demonstrates how to create a new Excel workbook, write basic data into it, and then add formulas to specific cells.

using Spire.Xls;

Workbook workbook = new Workbook();
Worksheet sheet = workbook.Worksheets[0];

// Add basic numeric data
sheet.Range[1, 1].NumberValue = 1;
sheet.Range[1, 2].NumberValue = 2;
sheet.Range[1, 3].NumberValue = 3;
sheet.Range[1, 4].NumberValue = 4;
sheet.Range[1, 5].NumberValue = 5;
sheet.Range[1, 6].NumberValue = 6;

// Add function formula: AVERAGE
string averageFormula = "=AVERAGE(Sheet1!$A$1:A$6)";
sheet.Range[2, 1].Formula = averageFormula;

// Add arithmetic formula
string calcFormula = "=1+2+3+4+5-6-7+8-9";
sheet.Range[3, 1].Formula = calcFormula;

workbook.SaveToFile("AddFormulasAndFunctions.xlsx", ExcelVersion.Version2016);
workbook.Dispose();

Code breakdown:

Use the sheet.Range[row, column].Formula property to directly assign a formula string to a cell. The syntax is identical to native Excel formulas.
Formulas support both absolute references (e.g., $D$2) and relative references (e.g., F$2), consistent with Excel behavior.
You can add not only simple arithmetic operations but also built-in functions like AVERAGE, SUM, IF, and more.

Part 2: Reading Existing Formulas from Excel

In real-world business scenarios, we often need to parse Excel reports created by others to extract calculation logic for auditing, migration, or documentation. The following code demonstrates how to load an existing Excel file, iterate through all used cells, and identify those containing formulas.

using Spire.Xls;
using System.IO;
using System.Text;

Workbook workbook = new Workbook();
workbook.LoadFromFile("Formulas.xlsx");

Worksheet sheet = workbook.Worksheets[0];
StringBuilder sb = new StringBuilder();
CellRange usedRange = sheet.AllocatedRange;

foreach (CellRange cell in usedRange)
{
    if (cell.HasFormula)
    {
        string cellName = cell.RangeAddressLocal;
        string formula = cell.Formula;
        sb.AppendLine($"{cellName} contains formula: {formula}");
    }
}

File.WriteAllText("ReadFormulasAndFunctions.txt", sb.ToString());

Code breakdown:

The cell.HasFormula property is a boolean value used to quickly determine whether a cell contains a formula.
cell.Formula returns the formula as a string, for example =AVERAGE(D2:F2).
Using AllocatedRange gets the range of used data in the worksheet, avoiding iteration over the entire blank worksheet and improving efficiency.
The extracted formula information is ultimately written to a text file for subsequent analysis or archiving.

Part 3: Practical Application Scenarios

By mastering the addition and reading of formulas, we can build many useful automation tools:

Report Generator : Automatically writes raw data into Excel templates and dynamically adds statistical formulas like SUM, COUNTIF, etc.
Formula Audit Tool : Batch-reads complex formulas in financial reports to verify their logic and prevent human errors.
Formula Migration Assistant : Extracts formulas from older Excel files and applies them in batch to corresponding locations in new templates.
Teaching Assistant System : Automatically grades Excel assignments submitted by students by reading formulas to determine whether the solution steps are correct.

Part 4: Notes and Recommendations

Formula strings must start with an equals sign =; otherwise, the component will treat them as plain text.
Cell ranges referenced in formulas must be valid. If referencing non-existent data, Excel may display a #REF! error when opening the file.
Free Spire.XLS is a free version but has certain page limitations (maximum of 5 pages per worksheet). This is sufficient for most small to medium-sized projects.
If you need to process very large files or remove the page limitation, consider upgrading to the commercial version Spire.XLS.

Conclusion

Through the sample code in this article, we can clearly see that using Free Spire.XLS for .NET to manipulate Excel formulas in C# is highly intuitive and efficient. Whether injecting complex calculation logic into spreadsheets or reverse-engineering existing formula structures, this component provides comprehensive and easy-to-use API interfaces. I hope this article helps you handle Excel formula-related development tasks more effectively in your real-world projects.

Create Your Own QR Code with Python — Possibly the Most Detailed Guide

jelizaveta — Tue, 12 May 2026 08:35:24 +0000

Imagine this scenario: you’re in charge of designing promotional materials for an offline event, and you need to put a QR code on posters, stands, or banners. A regular black-and-white QR code works, but it feels a bit plain — you can’t show your brand colors, and there’s no logo.

Actually, generating a QR code that’s both visually appealing and practical with Python is much easier than you think. Today, we’re going to explore how.

Getting Started: One Line of Code

First, install the library you’ll need. Open your terminal and run:

pip install spire.barcode

After installation, it’s recommended to request a temporary license from the official source. It’s not mandatory, but with a license, the generated QR code won’t have a watermark and the quality will be better.

Your First QR Code: Up and Running in 5 Minutes

Let’s start with the basics. The following code generates a QR code containing a website URL:

from spire.barcode import *

def save_image(filename, data):
    with open(filename, "wb") as f:
        f.write(data)

# Activate license (replace with your own)
License.SetLicenseKey("YOUR_LICENSE_KEY")

# Configure QR code settings
settings = BarcodeSettings()
settings.Type = BarCodeType.QRCode
settings.Data2D = "https://your-website.com"
settings.X = 3  # Controls QR code precision
settings.ShowText = False  # Hide text below

# Generate and save
generator = BarCodeGenerator(settings)
image = generator.GenerateImage()
save_image("output/MyFirstQR.png", image)

Run this code, and you’ll find your QR code image in the output folder.

Making QR Codes More “Durable”: Error Correction Levels

QR codes have a useful feature: even if part of the code is covered or damaged, it can still be read. This is thanks to error correction. Spire.Barcode provides four levels:

Level	Recovery Ability	Suitable Use Case
L	7%	Short URLs, numeric only
M	15%	Everyday use (recommended)
Q	25%	QR codes with logos
H	30%	Critical info, harsh environments

If you plan to add a logo in the center of the QR code, choose at least Q or H, otherwise the blank space may affect scanning.

Set it easily like this:

settings.QRCodeECL = QRCodeECL.H  # Highest error correction

Data Encoding Mode: Avoid Garbled Chinese

QR codes support multiple data encoding modes. Usually, “Auto” works fine, but it’s helpful to understand the options:

Auto : Library decides automatically, hassle-free, best for most cases
Numeric : Only encodes 0–9, highest efficiency, good for phone numbers or product codes
AlphaNumber : Supports uppercase letters, numbers, and limited symbols, good for short English text
Byte : Supports Chinese, Emoji, and complex content

settings.QRCodeDataMode = QRCodeDataMode.Auto  # Default is fine

Appearance Customization: Add Your Brand Touch

Black-and-white QR codes are classic, but changing the color can make them fit your design better. Here are some common options:

# Change colors
settings.BackColor = Color.get_White()
settings.ForeColor = Color.get_DeepSkyBlue()  # Bright blue QR code

# Add border
settings.HasBorder = True
settings.BorderWidth = 1
settings.BorderColor = Color.get_Gray()

# Adjust margins (unit: module width)
settings.LeftMargin = 2
settings.RightMargin = 2
settings.TopMargin = 2
settings.BottomMargin = 2

# Set print resolution (higher DPI = clearer)
settings.DpiX = 300
settings.DpiY = 300

Tip: Make sure the foreground and background colors have sufficient contrast, otherwise scanners may struggle. Dark foreground + light background is the safest combination.

Add Text Below the QR Code

Sometimes we want to show the encoded info or a short message under the QR code. This helps users know what the QR code is for even without scanning it.

# Change colors
settings.BackColor = Color.get_White()
settings.ForeColor = Color.get_DeepSkyBlue()  # Bright blue QR code

# Add border
settings.HasBorder = True
settings.BorderWidth = 1
settings.BorderColor = Color.get_Gray()

# Adjust margins (unit: module width)
settings.LeftMargin = 2
settings.RightMargin = 2
settings.TopMargin = 2
settings.BottomMargin = 2

# Set print resolution (higher DPI = clearer)
settings.DpiX = 300
settings.DpiY = 300

Add a Logo: Key Step for Branding

Many brands or official accounts put a small logo in the center of their QR code. This is easy to do:

settings.SetQRCodeLogoImage("/path/to/your/logo.png")

Just one line. Spire.Barcode automatically handles the size and placement, centering it in the QR code.

Tips:

Use a simple, clear logo — complex designs may affect scanning
Make sure the logo color contrasts with the QR code’s foreground
Test with a phone scanner after adding the logo

Full Example: A Beautiful QR Code with Logo

Putting it all together, a complete example looks like this:

from spire.barcode import *

def save_image(filename, data):
    with open(filename, "wb") as f:
        f.write(data)

License.SetLicenseKey("YOUR_LICENSE_KEY")

settings = BarcodeSettings()
settings.Type = BarCodeType.QRCode
settings.Data2D = "https://your-site.com/special-offer"
settings.QRCodeDataMode = QRCodeDataMode.Auto
settings.QRCodeECL = QRCodeECL.Q  # Increase error correction for logo
settings.X = 4

# Appearance
settings.BackColor = Color.get_White()
settings.ForeColor = Color.get_DarkOrange()
settings.HasBorder = True
settings.BorderWidth = 0.5

# Add text below
settings.ShowBottomText = True
settings.BottomText = "Scan to get your coupon"
settings.SetBottomTextFont("Microsoft YaHei", 12, FontStyle.Bold)

# Add logo
settings.SetQRCodeLogoImage("logo.png")

# Generate
generator = BarCodeGenerator(settings)
image = generator.GenerateImage()
save_image("output/PromoQR.png", image)

Final Notes

QR codes seem simple, but making them effective requires attention to a few details:

Error Correction : Choose at least Q if adding a logo
Color Contrast : Dark foreground, light background
Resolution : At least 300 DPI for print; 72–150 DPI is enough for screens
Testing : Scan with a phone before using

Spire.Barcode handles most of the underlying logic, so we can focus on style and content. Whether for event materials, product packaging, or internal systems, this solution should cover your needs.

Hope this guide helps. Feel free to share questions in the comments!

Merge Word Documents in C# (No More Manual Copy-Paste)

jelizaveta — Sat, 09 May 2026 01:38:47 +0000

Many projects need to combine multiple Word documents into a single finished file—for example, combining materials from different chapters into one report, or merging submissions from various sources for delivery. At the same time, questions like whether the formatting stays correct after merging, whether pagination matches expectations, and whether the code is clean enough often determine whether the solution can be implemented smoothly.

Below are two common merging strategies, both implemented using Spire.Doc for .NET:

Method 1: Append the entire second document to the end of the first (usually creates a "start on a new page" style result)
Method 2: Iterate through the second document's Sections, clone their content objects, and append them to the last Section of the first (ideal for more fine-grained structure control)

Spire.Doc: Purpose & Installation

Spire.Doc is a .NET component library for reading, editing, and generating Word documents (DOC/DOCX). It provides a structure-oriented API—for example, loading documents, inserting content, traversing Section/Body/object collections, copying document elements, and saving as DOCX. Compared with manually parsing the DOCX zip package and XML, using Spire.Doc can significantly reduce development effort.

Installation (recommended via NuGet):

Open your project in Visual Studio
Right-click the project → Manage NuGet Packages
Search for and install Spire.Doc for .NET
Add the namespace reference in your code: using Spire.Doc;

After installation, you can load and manipulate Word files directly through the Document class.

Method 1: Append Entire Document (New Page Effect)

When your goal is to treat Doc2 as a whole and attach it to Doc1 afterward, and you want the merged result to feel close to Word's intuitive "Insert Document / Append Content" experience, you can use InsertTextFromFile.

Approach:

Create a Document object to hold the merged document
Load the main document (Doc1)
Insert another Word document entirely into the main document
Save the result as a new merged file

Sample code:

using Spire.Doc;

namespace MergeWord
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create a Document instance
            Document document = new Document();

            // Load the original Word document
            document.LoadFromFile("Doc1.docx", FileFormat.Docx);

            // Insert another Word document entirely to the original document
            document.InsertTextFromFile("Doc2.docx", FileFormat.Docx);

            // Save the result document
            document.SaveToFile("MergedWord.docx", FileFormat.Docx);
        }
    }
}

When to Use Method 1

Less code, faster development
Best for "overall append" merges by document boundaries
Less control at the Section level, but usually sufficient for common consolidation needs

Method 2: Append to Last Section (Precise Control)

If the merge requires more precision—e.g., keeping content continuous within the same Section as much as possible, or appending the second document's objects one by one to the end of the first—you can use the second approach: iterate through doc2.Sections, clone each section's Body.ChildObjects, and add them to doc1.LastSection.Body.ChildObjects.

Approach:

Load doc1 and doc2
Iterate through doc2.Sections
For each section, iterate through section.Body.ChildObjects
Add cloned objects to doc1.LastSection.Body.ChildObjects
Save doc1 as the merged result

Sample code:

using Spire.Doc;

namespace MergeWord
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load two Word documents
            Document doc1 = new Document("Doc1.docx");
            Document doc2 = new Document("Doc2.docx");

            // Loop through the second document to get all the sections
            foreach (Section section in doc2.Sections)
            {
                // Loop through child objects in the section body
                foreach (DocumentObject obj in section.Body.ChildObjects)
                {
                    // Get the last section of the first document
                    Section lastSection = doc1.LastSection;

                    // Add cloned objects to the last section of the first document
                    lastSection.Body.ChildObjects.Add(obj.Clone());
                }
            }

            // Save the result document
            doc1.SaveToFile("MergeDocuments.docx", FileFormat.Docx);
        }
    }
}

When to Use Method 2

Closest to "concatenate content objects directly into the last section"
Uses Clone() to copy objects safely and avoid direct-reference issues
Better suited for complex cases (multi-section documents, header/footer, pagination rules)—final results still depend on your templates

Method 1 vs. Method 2: How to Choose

If you want a quick merge and an intuitive "append starting on a new page" effect: Method 1 is easier.
If you need stronger structure control and want to append doc2 content into the last Section of doc1: Method 2 is a better match.
If your templates include headers/footers, different page orientations (landscape/portrait), or complex section configurations: It's recommended to test with Method 2 first.
For ordinary text and table merges: Method 1 is typically faster and more reliable.

Downloading a Word Document from a URL Using C#

jelizaveta — Thu, 07 May 2026 02:49:00 +0000

When developing desktop or server-side applications, it’s often necessary to fetch a Word document from a network address and then process it or save it. This article explains how to use Free Spire.Doc for .NET with C# to implement the complete workflow of downloading a Word document from a specified URL and saving it locally.

Prerequisites

First, you need to add the Free Spire.Doc component to your project. You can search for "FreeSpire.Doc" in the NuGet package manager and install it, or download the DLL from the official website and add a reference manually.

In addition, you must import the required namespaces at the top of the code file: Spire.Doc, System.IO, and System.Net.

Implementation

The core idea is to use the WebClient class to download the remote document as a binary data stream, then load that memory stream into a Spire.Doc Document object, and finally save it as a local Word file.

Example code:

using Spire.Doc;
using System.IO;
using System.Net;

namespaceDownloadfromURL
{
    classProgram
    {
        staticvoidMain(string[] args)
        {
            Document doc = new Document();
            WebClient webClient = new WebClient();

            using (MemoryStream ms = new MemoryStream(webClient.DownloadData("http://www.example.com/sample.docx")))
            {
                doc.LoadFromStream(ms, FileFormat.Docx);
            }

            doc.SaveToFile("result.docx", FileFormat.Docx);
        }
    }
}

Key Steps Explained

Create a Document object

The Document class is the core class of Spire.Doc and represents a Word document instance.

Download data using WebClient

WebClient.DownloadData retrieves the remote resource from the specified URL and returns it as a byte[] binary array.

Wrap bytes in a memory stream and load the document

Use MemoryStream to wrap the byte array into a readable stream, then load it into the Document object using LoadFromStream, specifying the file format as Docx. The using statement ensures the memory stream is disposed properly after use.

Save to a local file

Call SaveToFile to write the document content to the local file system, again selecting Docx as the format.

Notes

Network exception handling:

In production, it’s recommended to add a try-catch block around DownloadData to handle possible WebException (e.g., network interruptions, invalid URL, etc.).

File format recognition:

LoadFromStream requires you to explicitly specify the file format. In this example, the URL points to a .docx file. If the remote file is an older .doc format, you should use FileFormat.Doc.

Memory and performance:

For large Word files, using MemoryStream directly can consume a lot of memory. Consider downloading to a temporary file first and then loading it.

HTTPS support:

WebClient supports HTTPS by default. If you encounter certificate validation issues, you can configure ServicePointManager.SecurityProtocol.

Extended Usage

This method is not limited to saving files. After loading the document, you can also edit its content, convert it to other formats (such as PDF or HTML), or extract text. Spire.Doc provides a rich API for handling elements like paragraphs, tables, and images in Word documents, so you can further expand functionality based on your needs.

Summary

By combining Free Spire.Doc for .NET with C# WebClient, you can elegantly download and save a Word document from a URL using only a small amount of code. This approach is stable and concise, making it suitable for scenarios such as data collection and document automation.

Automate PDF Difference Checks with Python (No More Manual Proofreading)

jelizaveta — Thu, 30 Apr 2026 01:47:36 +0000

In scenarios such as document version control, contract review, and report proofreading, accurately identifying differences between two PDF files is a common need. Traditional manual page-by-page comparison is inefficient and prone to missing changes. This article explains how to use the Spire.PDF for Python library to automate PDF document difference comparison through programming.

Install the Required Library

First, install the Spire.PDF library via pip:

pip install Spire.PDF

This library provides full PDF processing capabilities. The PdfComparer class is specifically designed for document comparison. Note that this is a commercial product, but it offers a free version with basic functionality so developers can evaluate it.

Full Document Comparison

When you need to compare all contents of two PDF documents, you can use the following approach:

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

# Load the first document
doc_one = PdfDocument("PDF_ONE.pdf")       

# Load the second document
doc_two = PdfDocument("PDF_TWO.pdf")  

# Create a PdfComparer object, using doc_two as the base document and doc_one as the target document
comparer = PdfComparer(doc_two, doc_one)

# Run the comparison and save the results to a new PDF file
comparer.Compare("ComparisonResults.pdf") 

# Release document resources
doc_one.Dispose()
doc_two.Dispose()

After running the code above, the program will generate a difference report named ComparisonResults.pdf. In the report, differences between documents are highlighted with different colors, making it easy for users to quickly find the changed sections.

Parameter Explanation : In the PdfComparer constructor, the first parameter is the base version, and the second parameter is the version to be compared. The output difference report is annotated with the base version as the reference.

Compare Specific Pages

In real-world applications, users may only care about certain pages of the documents. The following code demonstrates how to limit the comparison to a specified page range:

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

# Load two PDF documents
doc_one = PdfDocument("PDF_ONE.pdf")       
doc_two = PdfDocument("PDF_TWO.pdf")  

# Create a PdfComparer instance
comparer = PdfComparer(doc_two, doc_one)

# Set page ranges: compare pages 1 to 3 of the first document with pages 1 to 3 of the second document
comparer.PdfCompareOptions.SetPageRanges(1, 3, 1, 3)

# Execute the comparison for the specified page range
comparer.Compare("ComparePageRanges.pdf") 

# Release resources
doc_one.Dispose()
doc_two.Dispose()

SetPageRanges(start1, end1, start2, end2) uses the first two parameters to specify the starting and ending page numbers of the base document, and the last two parameters to specify the starting and ending page numbers of the document to compare. This method supports cases where the page ranges on both sides are not identical; the system will strictly compare pages according to the ranges you set, page by page.

Interpreting the Difference Report

The generated comparison results PDF follows these marking conventions:

Yellow highlight : indicates newly added content
Red highlight : indicates deleted content

By using a side-by-side viewing mode, users can clearly identify the exact differences between the two versions.

Typical Use Cases

Legal contract review : quickly identify revisions to contract clauses
Academic paper proofreading : locate text changes between different versions
Technical document version management : track changes in product manual updates
Financial statement reconciliation : verify numerical changes in data reports

Notes

The free version has a page limit (typically the first 10 pages). Full functionality requires a commercial license.
This comparison feature works for text-based PDF documents. For PDFs stored as images (scanned documents), the comparison results may be limited.
After completing the comparison, be sure to call Dispose() to release document objects and free system resources to prevent memory leaks.

Summary

Spire.PDF for Python provides a simple yet powerful way to compare PDF documents. With just a small amount of code, developers can automate difference analysis. Whether comparing an entire document or only specific pages, this library can effectively improve the efficiency and accuracy of document review workflows.

Read PDFs in Python: Extract Text and Images

jelizaveta — Tue, 28 Apr 2026 07:12:15 +0000

In daily work and study, we often need to batch-extract text or images from PDF files. For example, organizing clauses from a scanned contract, or collecting all the images from a product manual.

Dealing with PDFs used to be a headache, but with the right libraries, everything becomes simple. Today, we’ll introduce how to use Spire.PDF for Python —a powerful library that can extract text and images from PDFs with just a few lines of code.

Before you start, make sure you have installed the Spire.PDF library:

pip install Spire.PDF

1. Load the PDF Document

Before doing anything else, we need to load the PDF file into our code. Spire.PDF is very flexible and supports loading from a file path as well as loading from a data stream (Stream) .

Method 1: Load from a file

This is the most direct approach for fixed files on your local disk.

from spire.pdf import PdfDocument

# Create a PdfDocument instance
pdf = PdfDocument()
# Load a local PDF document
pdf.LoadFromFile("sample.pdf")

Method 2: Load from a data stream

If your PDF data is received from a network interface or generated in memory as byte data, this method is very useful.

from spire.pdf import PdfDocument, Stream

# Read the file as a byte array (demo: read from file; it can also come from a network)
withopen("sample.pdf", "rb") as f:
    byte_data = f.read()

# Create a stream object
pdfStream = Stream(byte_data)
# Load the PDF from the stream
pdf = PdfDocument(pdfStream)

2. Extract Text

Text extraction is one of the most common tasks when processing documents. The following code demonstrates how to iterate through all pages in a PDF and concatenate the text from each page.

It mainly uses two helper classes: PdfTextExtractor and PdfTextExtractOptions. Setting IsExtractAllText = True helps ensure that most visible text on the page is extracted.

# Assume the pdf object has already been loaded using the method above
all_text = ""

# Loop through each page
for pageIndex in range(pdf.Pages.Count):
    # Get the current page by index
    page = pdf.Pages.get_Item(pageIndex)

    # Create a text extractor
    text_extractor = PdfTextExtractor(page)

    # Configure extraction options
    options = PdfTextExtractOptions()
    options.IsExtractAllText = True
    options.IsSimpleExtraction = True

    # Extract and accumulate
    all_text += text_extractor.ExtractText(options)

# Print the result
print(all_text)

3. Extract Images

In many cases, key information in a PDF is actually hidden in illustrations or charts. Spire.PDF also provides a very convenient image extraction solution.

Using the PdfImageHelper helper class, we can directly get image information from a page, and then save each image as an image file (such as .png).

# Get the first page (index is 0)
page = pdf.Pages.get_Item(0)

# Create an image helper object
image_helper = PdfImageHelper()
# Get all image information on the page
images_info = image_helper.GetImagesInfo(page)

# Loop through and save each image
for i in range(len(images_info)):
    # Save as PNG format
    images_info[i].Image.Save(f"output/Images/image_{i}.png")

print(f"Successfully extracted {len(images_info)} images")

Note : If it’s a scanned PDF (image-based), what you extract is essentially the entire scanned image. If it’s an electronically generated PDF, it can accurately extract embedded standalone icons or photos.

4. Advanced Tips

Although the code above covers the basics, there are a few things worth paying attention to in real applications:

Page handling : The example extracts all text for demonstration purposes. If you want to process page by page, just control pageIndex in the loop.
Chinese support : The library supports Chinese well. When extracting Chinese PDFs, just ensure your encoding environment is UTF-8.
Free edition limitations : If you are using the free version of Spire.PDF, note that it usually has a limit on the number of pages it can process (for example, only the first 10 pages). If you need to handle many pages, you may need to evaluate the commercial version.

Summary

With Spire.PDF for Python , you’ll find that processing PDF files is surprisingly easy. Whether it’s reading a file, analyzing text page by page, or saving precious illustrations, you can get everything done with just a short handful of lines of code. This greatly improves document processing efficiency, letting you focus on the next steps—data analysis or business logic.

Try it now and let code free your hands!

Python Tutorial: Extracting Images and Text from PPT

jelizaveta — Thu, 23 Apr 2026 02:13:33 +0000

When we need to grab materials like images and text from a PowerPoint presentation, doing it manually—copying and pasting one by one—is not only time-consuming but also easy to miss things or make mistakes. Today, I'll share a simple way to batch extract images and text from PPT using Python.

Preparation

First, you need to install Spire.Presentation for Python. You can install it via the pip command:

pip install Spire.Presentation

Once the installation is complete, you can start writing the code.

Extracting Images from PPT

Often, the images in a PPT are the materials we need. The following code demonstrates how to batch extract all images from a PPT and save them locally:

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

# Create a Presentation instance
ppt = Presentation()

# Load the PowerPoint document
ppt.LoadFromFile("sample.pptx")

# Iterate through all images in the document
for i, image in enumerate(ppt.Images):
    # Extract and save the image
    ImageName = "ExtractImage/Images_" + str(i) + ".png"
    image.Image.Save(ImageName)

ppt.Dispose()

How it works:

Presentation(): Creates a PPT document object
LoadFromFile(): Loads the PPT file to be processed
ppt.Images: Gets the collection of all images in the document
image.Image.Save(): Saves the image in PNG format

After running, all images will be saved sequentially to the ExtractImage folder, named Images_0.png, Images_1.png, and so on.

Extracting Text from PPT

Besides images, extracting text content is also a common requirement. The following code iterates through each slide and extracts text from all shapes:

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

# Create a Presentation object
pres = Presentation()

# Load the PowerPoint presentation
pres.LoadFromFile("Sample.pptx")

text = []
# Iterate through each slide
for slide in pres.Slides:
    # Iterate through each shape
    for shape in slide.Shapes:
        # Check if the shape is of IAutoShape type (can contain text)
        if isinstance(shape, IAutoShape):
            # Extract text from the shape
            for paragraph in shape.TextFrame.Paragraphs:
                text.append(paragraph.Text)

# Write the extracted text to a file
with open("output/SlideText.txt", "w", encoding='utf-8') as f:
    for s in text:
        f.write(s + "\n")

pres.Dispose()

How it works:

pres.Slides: Gets the collection of all slides
slide.Shapes: Gets all shapes in each slide
IAutoShape: Represents the auto-shape type that can contain text
shape.TextFrame.Paragraphs: Gets the collection of paragraphs in the shape
Finally, all text is written to the SlideText.txt file, with one paragraph per line

Important Notes

Resource Release : After using the Presentation object, be sure to call the Dispose() method to release resources and avoid memory leaks.
File Paths : Ensure the PPT file path is correct. The directories for saving images and text need to be created in advance or created automatically using code.
Text Encoding : Use utf-8 encoding when writing to text files to properly handle non-English characters such as Chinese.
Image Format : The Save() method saves images in PNG format by default. Refer to the official documentation if you need other formats.
Shape Types : The text extraction only handles the IAutoShape type. If text is located in other shape types like tables or charts, additional processing is required.

Summary

With Spire.Presentation for Python, you can batch extract images and text from PPT with just a dozen lines of code. This library is powerful and easy to use, making it ideal for office automation scenarios. I hope this article helps you improve your work efficiency!

If you have more requirements for PPT automation processing, such as creating PPTs, modifying content, adding charts, etc., Spire.Presentation offers many more rich features waiting for you to explore.

Convert Markdown to HTML Using Python (3 Methods)

jelizaveta — Tue, 21 Apr 2026 06:18:02 +0000

In day-to-day technical writing and document management, Markdown—thanks to its concise syntax—has become the preferred choice for many developers. However, when we need to publish content to the web, HTML is still the irreplaceable presentation format. This article introduces three methods to convert Markdown to HTML using Python, each suited to different use cases.

Method 1: Use markdown2 (a lightweight open-source solution)

If you prefer an open-source approach, markdown2 is an excellent choice. It claims to be a “fast and complete Python Markdown implementation,” with support for many extension features.

First, install it via pip:

pip install markdown2

Then use the following code to perform the conversion:

import markdown2

# Read the Markdown file
withopen("example.md", "r", encoding="utf-8") as f:
    md_content = f.read()

# Convert to HTML
html_content = markdown2.markdown(md_content)

# Save the result
withopen("example.html", "w", encoding="utf-8") as f:
    f.write(html_content)

markdown2 supports a wide range of extended syntax, such as fenced code blocks, tables, footnotes, table-of-contents generation, and more. You can enable these via the extras parameter:

html = markdown2.markdown(md_content, extras=["fenced-code-blocks", "tables", "toc"])

Pros : Open-source and free, easy to install, rich extensions, excellent performance.

Cons : Functionality is relatively basic, and it has limited ability to preserve formatting in complex documents.

Method 2: Use the standard library markdown (the most versatile option)

The most commonly used Markdown conversion library in the Python community is the markdown module. It is also open-source and easy to use.

Installation:

pip install markdown

Example:

import markdown

withopen("example.md", "r", encoding="utf-8") as f:
    md_content = f.read()

# Support extension features
html = markdown.markdown(md_content, extensions=['extra', 'codehilite', 'tables'])

withopen("example.html", "w", encoding="utf-8") as f:
    f.write(html)

The markdown module also supports many extensions. The extra extension includes commonly used features such as tables, fenced code blocks, smart quotes, and more.

Pros : Most active community, well-documented, and a rich extension ecosystem.

Cons : Performance is slightly lower than markdown2.

Method 3: Use Spire.Doc for Python (an enterprise-grade solution)

Spire.Doc for Python is a powerful document processing library. It supports converting Markdown files directly to HTML while perfectly preserving the original format and structure.

Installation:

pip install spire.doc

Example:

from spire.doc import *

# Create a Document object
doc = Document()

# Load the Markdown file
doc.LoadFromFile("example.md", FileFormat.Markdown)

# Save as an HTML file
doc.SaveToFile("example.html", FileFormat.Html)

# Close the document to release resources
doc.Close()

This method is especially suitable for scenarios that require batch processing or higher conversion-quality requirements. You can also easily extend it into a batch conversion script—iterate through all .md files in a folder and automatically generate the corresponding HTML files.

Pros : Complete format preservation, supports image embedding, simple and easy-to-use APIs, supports batch processing.

Cons : Requires installing a commercial library (a free version is provided, but with limitations on the watermark).

Comparison and recommendations

Method	Open-source	Format Preservation	Performance	Suitable for
markdown2	Yes	Good	Excellent	Personal projects, quick conversion
markdown	Yes	Good	Medium	General use cases, community support
Spire.Doc	No	Excellent	Good	Enterprise applications, batch processing

Recommendations :

Prefer open-source and need high performance → choose markdown2
Need the widest community support and extension ecosystem → choose markdown
Prioritize conversion quality and perfect formatting → choose Spire.Doc

No matter which method you choose, you can set up a Markdown-to-HTML conversion workflow in just a few minutes, creating a seamless connection between content creation and web publishing.