DEV Community: jelizaveta

Convert PDF to JPG in C#: High-Quality Rendering with Spire.PDF

jelizaveta — Thu, 18 Jun 2026 01:26:17 +0000

In document management systems, electronic archiving platforms, and online document preview applications, converting PDF files to images is a fundamental and essential capability. Whether you need to generate document thumbnails, display content across different platforms, or digitally archive historical records, PDF-to-image conversion plays a critical role. For .NET developers, Spire.PDF for .NET provides a powerful and efficient solution that enables high-fidelity PDF-to-image conversion without relying on third-party software such as Adobe Acrobat.

This article starts with the basics and gradually explores more advanced scenarios, including DPI control and stream-based processing, demonstrating how to convert PDF files to JPG images using C# and Spire.PDF.

Environment Setup

Before writing any code, install Spire.PDF into your project through NuGet. In Visual Studio, navigate to Tools > NuGet Package Manager > Manage NuGet Packages for Solution , search for Spire.PDF , and install it. Alternatively, run the following command in the Package Manager Console:

PM> Install-Package Spire.PDF

It is important to note that the free edition of Spire.PDF includes certain limitations, such as converting only a limited number of pages. For full functionality in production environments, a commercial license is required.

The Core Method: SaveAsImage

The SaveAsImage() method provided by the PdfDocument class is the foundation of PDF-to-image conversion. It offers several overloads to accommodate different requirements:

SaveAsImage(int pageIndex, PdfImageType imageType) Converts a specified page to an image, where pageIndex is a zero-based page index and imageType defines the output image format (typically PdfImageType.Bitmap).
SaveAsImage(int pageIndex, PdfImageType imageType, int dpiX, int dpiY) Converts a page while specifying horizontal and vertical DPI values, allowing you to control image quality and file size.

Basic Conversion: Export a Single Page

The following example demonstrates the simplest way to convert the first page of a PDF document to a JPG image:

using Spire.Pdf.Graphics;
using Spire.Pdf;
using System.Drawing.Imaging;
using System.Drawing;

namespace ConvertSpecificPageToPng
{
    class Program
    {
        static void Main(string[] args)
        {
            PdfDocument doc = new PdfDocument();
            doc.LoadFromFile("C:\\Users\\Administrator\\Desktop\\sample.pdf");
            Image image = doc.SaveAsImage(0, PdfImageType.Bitmap);
            image.Save("ToJPG.jpg", ImageFormat.Jpeg);
            doc.Dispose();
        }
    }
}

The conversion workflow consists of four straightforward steps:

Create a PdfDocument instance.
Load the target PDF file.
Call SaveAsImage() to render the specified page into a System.Drawing.Image object.
Save the image as a JPG file using the Image.Save() method.

Batch Conversion: Processing Multi-Page PDFs

In real-world applications, you often need to convert all pages or a subset of pages within a PDF document. By iterating through the doc.Pages collection and calling SaveAsImage() for each page, you can convert an entire document:

for (int i = 0; i < doc.Pages.Count; i++)
{
    Image image = doc.SaveAsImage(i, PdfImageType.Bitmap);
    string fileName = string.Format("Output\\ToJPG-{0}.jpg", i);
    image.Save(fileName, ImageFormat.Jpeg);
}

If only a specific page range is required—for example, the first three pages—you can limit the loop accordingly:

for (int i = 1; i <= 3; i++)
{
    Image image = doc.SaveAsImage(i, PdfImageType.Bitmap);
    string fileName = string.Format("Output\\ToJPG-{0}.jpg", i);
    image.Save(fileName, ImageFormat.Jpeg);
}

DPI Control: Ensuring High-Quality Output

DPI (Dots Per Inch) is one of the most important factors affecting image clarity. Higher DPI values produce images with more pixels and finer details, but they also increase file size. Spire.PDF allows developers to precisely control output resolution by specifying dpiX and dpiY when calling SaveAsImage():

Image image = doc.SaveAsImage(0, PdfImageType.Bitmap, 300, 300);
image.Save("ToJPG.jpg", ImageFormat.Jpeg);

Different use cases require different DPI settings:

96–150 DPI : Suitable for web previews and online viewing.
300 DPI : Recommended for printing and professional document output.
600 DPI or higher : Ideal for high-resolution archiving and preserving fine document details.

Choosing the right DPI involves balancing image quality against storage and bandwidth requirements.

Stream-Based Processing: Saving to Memory

In some scenarios—such as uploading images directly to cloud storage or returning image data through a Web API—saving the converted image to disk is not the most efficient approach. Instead, you can write the image directly to a MemoryStream and obtain the resulting byte array:

using (MemoryStream ms = new MemoryStream())
{
    pdf.SaveAsImage(0, PdfImageType.Bitmap, 300, 300).Save(ms, ImageFormat.Jpeg);
    byte[] imageBytes = ms.ToArray();
}

This approach eliminates the need to create and clean up temporary files, resulting in cleaner code and improved performance. It is especially useful in server-side applications and cloud-based workflows.

Conclusion

With the SaveAsImage() method, Spire.PDF for .NET provides a comprehensive and flexible solution for converting PDF documents to images. From basic single-page exports to batch conversion of multi-page PDFs, from DPI customization to memory-stream output, the library supports a wide range of business requirements.

By combining these techniques according to your application's needs, you can build efficient, reliable, and high-quality PDF-to-JPG conversion workflows while maintaining an optimal balance between image fidelity and system performance.

How to Convert Excel Data to Lists, Dictionaries, and Objects in Python

jelizaveta — Tue, 16 Jun 2026 03:20:37 +0000

In Python backend development, data analytics, and office automation workflows, reading Excel files and converting them into efficient, program-friendly data structures is a common requirement.

Many developers start by accessing spreadsheet data using numeric indexes such as row[2] or col[5]. While this approach is quick to implement, it introduces a serious row/column coupling problem . The code becomes difficult to read and maintain, and even a minor change to the spreadsheet layout—such as reordering, inserting, or removing columns—can break large portions of the application.

In this article, we'll use Spire.XLS for Python to demonstrate a three-level evolution of Excel data modeling:

Raw two-dimensional lists
Lists of dictionaries
Lists of custom business objects

Each approach serves different use cases and complexity levels. By moving beyond hardcoded indexes, you can make your Excel-processing code more readable, maintainable, and scalable.

Prerequisites

All examples in this article use the spire.xls package, which provides Excel reading, writing, formatting, and batch-processing capabilities without requiring Microsoft Excel to be installed.

Install the library with:

pip install spire.xls

Approach 1: Store Excel Data as a Two-Dimensional List

How It Works

This is the most straightforward way to read Excel data. We iterate through the worksheet's used range row by row and cell by cell, storing everything in a two-dimensional list that preserves the original spreadsheet structure.

Complete Example

from spire.xls import Workbook

# Load the workbook and worksheet
workbook = Workbook()
workbook.LoadFromFile("SalesReport.xlsx")
sheet = workbook.Worksheets[0]

# Get the used range
cell_range = sheet.AllocatedRange

# Store all data in a 2D list
excel_data = []

for row_idx in range(cell_range.RowCount):
    single_row = []

    for col_idx in range(cell_range.ColumnCount):
        # Spire.XLS uses 1-based indexes
        single_row.append(
            cell_range[row_idx + 1, col_idx + 1].Value
        )

    excel_data.append(single_row)

# Release resources
workbook.Dispose()

Pros and Cons

Advantages

Extremely simple implementation
Preserves the original row-and-column structure
No additional transformation overhead

Drawbacks

All data access relies on numeric indexes:

excel_data[row][col]

The code contains no semantic meaning. If the spreadsheet structure changes, index references throughout the application must be updated manually, making maintenance difficult and error-prone.

Best For

Quick prototypes
One-off scripts
Matrix calculations
Temporary data inspection

For production applications, this structure is rarely ideal.

Approach 2: Convert Rows into Dictionaries

How It Works

To eliminate hardcoded column indexes, we can use the first row as column headers and map each subsequent row into a dictionary.

Instead of retrieving data by position, we access it by field name. This removes the dependency on column order and greatly improves readability.

Complete Example

from spire.xls import Workbook

workbook = Workbook()
workbook.LoadFromFile("SalesReport.xlsx")
sheet = workbook.Worksheets[0]

cell_range = sheet.AllocatedRange

# Extract headers from the first row
rows = list(cell_range.Rows)

headers = [
    cell_range[1, col_idx + 1].Value
    for col_idx in range(cell_range.ColumnCount)
]

# Build a list of dictionaries
data_list = []

for row in rows[1:]:  # Skip header row
    row_dict = {}

    for idx, cell in enumerate(row.Cells):
        row_dict[headers[idx]] = cell.Value

    data_list.append(row_dict)

workbook.Dispose()

Pros and Cons

Advantages

Data can now be accessed using meaningful field names:

data_list[0]["Sales"]

Benefits include:

Improved readability
Independence from column order
Easy JSON serialization
Convenient integration with APIs and data-processing pipelines
Better compatibility with Pandas workflows

Drawbacks

Dictionary-based structures are still weakly typed. Values may require additional validation and type conversion before use.

Best For

Data import/export workflows
Data cleaning tasks
API payload generation
Business reporting
General-purpose Excel processing

For most applications, this is often the best balance between simplicity and maintainability.

Approach 3: Map Rows to Custom Business Objects

How It Works

When working with fixed schemas and more complex business logic, dictionaries can become limiting. They offer no type safety, no IntelliSense support, and no natural place to encapsulate business rules.

A more robust approach is to define a business entity class and map each Excel row to an object instance.

This creates a strongly typed model that supports validation, business methods, and better developer tooling.

Complete Example

# Business entity definition
class Employee:
    def __init__(self, name: str, age: int | None, department: str):
        self.name = name
        self.age = age
        self.department = department

    def is_adult(self) -> bool:
        """Return True if the employee is an adult."""
        return self.age >= 18 if self.age else False


from spire.xls import Workbook

workbook = Workbook()
workbook.LoadFromFile("EmployeeData.xlsx")

sheet = workbook.Worksheets[0]
cell_range = sheet.AllocatedRange

employee_list = []

# Skip the header row
for row in list(cell_range.Rows)[1:]:

    name = row.Cells[0].Value

    age = (
        int(row.Cells[1].Value)
        if row.Cells[1].Value
        else None
    )

    department = row.Cells[2].Value

    employee = Employee(
        name,
        age,
        department
    )

    employee_list.append(employee)

workbook.Dispose()

Advantages and Use Cases

Benefits

Strong typing through explicit type conversion
Better data validation
IDE auto-completion and type hints
Encapsulation of business logic
Improved maintainability
Cleaner object-oriented design

For example:

employee.is_adult()

Business rules can be implemented directly within the entity instead of being scattered throughout the codebase.

Best For

Enterprise applications
Stable, well-defined data schemas
Systems with complex business rules
Long-term maintainable projects

Choosing the Right Structure

The best choice depends on the complexity of your application and how the data will be used.

Structure	Advantages	Drawbacks	Recommended Use Cases
Two-Dimensional List	Simple, fast, minimal transformation	Hardcoded indexes, poor readability, difficult maintenance	Quick scripts, data previews, matrix operations
List of Dictionaries	Readable, flexible, serialization-friendly	Weak typing, limited validation	Data analysis, data synchronization, API integration
List of Custom Objects	Strong typing, extensible, business-logic friendly	Requires additional class definitions	Enterprise projects, stable schemas, complex business workflows

Important: Always Release Workbook Resources

Every example in this article calls:

workbook.Dispose()

This is an important best practice when working with Spire.XLS .

The library maintains file handles while a workbook is open. If resources are not explicitly released, long-running applications or batch-processing jobs may encounter issues such as:

Locked Excel files
Increased memory usage
Inability to modify files later
Resource leaks in server environments

For this reason, you should always dispose of the workbook once processing is complete.

Conclusion

The progression from:

Numeric indexes in two-dimensional lists
Semantic field access with dictionaries
Strongly typed business objects

reflects a broader evolution from data-oriented programming toward business-oriented modeling .

Simple scripts do not require elaborate abstractions. For most real-world Excel-processing tasks, a list of dictionaries offers an excellent balance between flexibility and maintainability. When your application involves complex business rules and stable schemas, custom entity objects become the most robust long-term solution.

Choosing the right data structure can significantly reduce code complexity, improve readability, minimize bugs, and make your Excel-processing workflows easier to maintain as your projects grow.

How to Add a Digital Signature to a Word Document in C#

jelizaveta — Thu, 11 Jun 2026 02:48:20 +0000

When working with electronic contracts, legal documents, or official reports, adding a digital signature to a Word document is often essential. A digital signature helps verify the authenticity of a document, confirms the identity of the signer, and ensures that the content has not been modified after signing.

In this article, you'll learn how to digitally sign a Word document in C# using Free Spire.Doc for .NET . The process requires only a few lines of code and can be implemented in just a few minutes.

Prerequisites

1. Install Free Spire.Doc for .NET

You can install FreeSpire.Doc through the NuGet Package Manager or download the DLL package and add it to your project manually.

2. Prepare a Digital Certificate

You'll need a valid digital certificate in .pfx format along with its password. The certificate can be obtained from a trusted Certificate Authority (CA) or generated locally for testing purposes.

Add a Digital Signature to a Word Document

The following example demonstrates how to load a Word document, apply a digital signature using a certificate, and save the signed document.

using Spire.Doc;

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

            // Load the Word document to be signed
            doc.LoadFromFile("Input.docx");

            // Specify the certificate file and password
            string certificatePath = "certificate.pfx";
            string password = "password";

            // Digitally sign the document and save it
            doc.SaveToFile("DigitallySigned.docx", FileFormat.Docx2013, certificatePath, password);
        }
    }
}

How the Code Works

Load the document The Document.LoadFromFile() method loads the target .docx file into memory.
Configure the certificate The certificatePath and password variables specify the location of the digital certificate and its associated password.
Apply the digital signature The overloaded SaveToFile() method accepts the output format, certificate path, and certificate password. When the document is saved, the digital signature is automatically embedded into the file.

After signing, open the resulting document in Microsoft Word. Word will indicate that the document contains a valid digital signature. You can view signature details by navigating to File > Info > View Signatures .

Important Notes

1. Free Version Limitations

The free edition of Spire.Doc has processing limitations. It supports Word documents containing up to 500 paragraphs or 25 tables , whichever limit is reached first.

For most small business documents, reports, and contracts, this limitation is typically sufficient.

2. Certificate Validity

For production environments, it is recommended to use a certificate issued by a trusted Certificate Authority (CA). Otherwise, Microsoft Word may display warnings indicating that the signature cannot be verified.

3. Supported Output Formats

The FileFormat parameter supports multiple Word versions, including:

Docx2010
Docx2013
Docx2016

Choose the format that best matches your compatibility requirements.

4. The Original Document Remains Unchanged

The digital signature is applied when saving a new file. The original document is not modified unless you explicitly overwrite it.

Conclusion

Free Spire.Doc for .NET provides a simple and efficient way to digitally sign Word documents in C#. With just a few lines of code, you can automate the signing process for contracts, reports, and other business documents.

When using the free edition, be sure to keep its paragraph and table limitations in mind to avoid runtime exceptions. If your documents exceed those limits, consider upgrading to a commercial license or implementing a document-splitting strategy.

By incorporating digital signatures into your workflow, you can improve document security, streamline approval processes, and ensure the integrity of your files with minimal development effort.

Extract Text and Tables from Word Documents Accurately Using Python

jelizaveta — Tue, 09 Jun 2026 02:06:42 +0000

Extracting structured content from Word documents—especially text and tables—is a common requirement in data processing workflows. While Python offers several libraries such as python-docx, handling complex document layouts or extracting both body text and tables reliably can be challenging. In these scenarios, Free Spire.Doc for Python provides a more stable and feature-rich solution.

In this article, you'll learn how to extract text from Word documents and save it to TXT files, as well as how to automatically export table data for further processing.

Prerequisites

Free Spire.Doc for Python is a powerful Word processing library that supports multiple document formats, including .doc and .docx. You can install it easily using pip:

pip install spire.doc.free

By default, the library runs in free mode. The free edition can process documents containing up to 500 paragraphs or 25 tables , which is sufficient for most small documents and testing scenarios.

Extract All Text and Save It to a TXT File

The built-in GetText() method can retrieve all text from a Word document. In practical applications, you'll often want to save the extracted content rather than simply displaying it. The following example reads all text from a Word document and writes it to a .txt file:

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

# Create a Document object and load a Word file
doc = Document()
doc.LoadFromFile("input.docx")

# Extract all plain text from the document
full_text = doc.GetText()

# Write the text to a TXT file
with open("output.txt", "w", encoding="utf-8") as file:
    file.write(full_text)

doc.Close()
print("Text extraction completed. Saved to output.txt")

Key Points

GetText() extracts all textual content in reading order, including paragraphs, headings, headers, and footers, while ignoring non-text elements such as images and shapes.
The file is saved using UTF-8 encoding to ensure proper handling of non-English characters.
Always call doc.Close() after processing to release system resources.

Extract and Export All Tables Accurately

Tables in Word documents often contain important business data such as reports, inventories, and records. Spire.Doc provides a clear object hierarchy:

Document → Section → Table → Row → Cell → Paragraph

The following code traverses every table in each section and exports each table as an individual .txt file. Tab characters are used as column separators, making the output easy to import into Excel or other data-processing tools.

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

# Create the output directory
output_dir = "output/Tables"
os.makedirs(output_dir, exist_ok=True)

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

# Traverse all sections
for section_idx in range(doc.Sections.Count):
    section = doc.Sections.get_Item(section_idx)
    tables = section.Tables

    for table_idx in range(tables.Count):
        table = tables.get_Item(table_idx)
        table_data = ""

        # Traverse all rows and cells
        for row_idx in range(table.Rows.Count):
            row = table.Rows.get_Item(row_idx)

            for col_idx in range(row.Cells.Count):
                cell = row.Cells.get_Item(col_idx)

                # Collect text from all paragraphs within the cell
                cell_text = ""
                for para_idx in range(cell.Paragraphs.Count):
                    cell_text += cell.Paragraphs.get_Item(para_idx).Text + " "

                table_data += cell_text.strip()

                # Separate columns with tabs
                if col_idx < row.Cells.Count - 1:
                    table_data += "\t"

            table_data += "\n"  # End of row

        # Save the current table
        output_path = f"{output_dir}/WordTable_{section_idx+1}_{table_idx+1}.txt"

        with open(output_path, "w", encoding="utf-8") as f:
            f.write(table_data)

        print(f"Saved: {output_path}")

doc.Close()

Code Explanation

The nested loops ensure that every table in every section is processed.
Cell content is extracted by iterating through the cell's Paragraphs collection, preventing the loss of text separated by line breaks or formatting.
Output files are named using the pattern SectionIndex_TableIndex, making it easy to identify the source of each exported table.

Note: This example processes only top-level tables. If your document contains nested tables inside cells, you can extend the logic recursively to handle deeper table structures.

Best Practices and Considerations

1. Performance and Memory Usage

For large documents containing hundreds of pages, process only the content you need. If you're interested solely in tables, skip text extraction, and vice versa. Also, make sure doc.Close() is always executed to avoid resource leaks.

2. Handling Merged Cells

When tables contain merged rows or columns, the code above still extracts the text from each cell correctly. However, the exported plain-text output will not preserve merge relationships.

If maintaining the original table structure is important, you can use properties such as Cell.ColumnSpan and Cell.RowSpan to build a matrix that represents merged cells.

3. Free Edition Limitations

The free edition of Spire.Doc can process documents containing up to 500 paragraphs or 25 tables , which is generally sufficient for everyday document-processing tasks and evaluation purposes.

Conclusion

With Free Spire.Doc for Python , you can extract text and tables from Word documents using only a few dozen lines of code. The two techniques demonstrated in this article—saving document text to TXT files and exporting tables individually—can be integrated directly into your data-processing workflows.

Combined with Python's file-handling capabilities and downstream tools such as pandas, these methods make it easy to build automated document-parsing solutions.

If you need to work with more complex layouts or preserve advanced table structures, Spire.Doc also offers additional APIs such as ExportToHtml() and SaveToFile(), providing even greater flexibility for document-processing projects.

How to Convert Word to Markdown (and Back) with Python

jelizaveta — Fri, 05 Jun 2026 01:55:44 +0000

In writing, technical documentation management, and knowledge base construction, Word and Markdown are the two document formats we most frequently deal with. Word, with its powerful typesetting capabilities and mature collaborative review features, dominates enterprise office work and formal reports; while Markdown, with its plain text, lightweight nature, and ease of version control, is deeply loved by programmers and technical writers.

However, the format barrier between the two often causes headaches — does it mean we have to manually copy, paste, and adjust formats paragraph by paragraph? Of course not. This article will detail how to use Spire.Doc in a Python environment to efficiently achieve bidirectional conversion between Word and Markdown.

Why Choose Spire.Doc?

There are many document processing libraries on the market, but Spire.Doc excels in converting between Word and Markdown. It not only handles basic text content but also perfectly recognizes and converts complex structures such as headings, paragraphs, tables, and lists. More importantly, it supports both .doc and .docx Word formats as well as standard Markdown syntax. The converted documents are cleanly formatted and clearly structured, requiring almost no secondary adjustments.

Installing the Spire.Doc library:

pip install Spire.Doc

Word to Markdown: Three Lines of Core Code

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

# Create a Document object
document = Document()
# Load a Word file (supports .docx and .doc)
document.LoadFromFile("input.docx")

# Save as a Markdown file
document.SaveToFile("WordToMarkdown.md", FileFormat.Markdown)
document.Close()

After running the above code, all heading levels in the Word document are automatically mapped to Markdown's # to ###### tags, paragraphs retain appropriate line breaks, tables are converted to Markdown table syntax, and ordered/unordered lists are correctly recognized. The whole process takes only a few seconds, greatly improving work efficiency.

Markdown to Word: Equally Simple

The code structure for the reverse conversion is almost identical, with only the load and save formats swapped:

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

document = Document()
# Load a Markdown file
document.LoadFromFile("input.md")

# Save as a Word document (supports .docx and .doc)
document.SaveToFile("MdToDocx.docx", FileFormat.Docx)

# If you need the older .doc format, you can also save separately
# document.SaveToFile("MdToDoc.doc", FileFormat.Doc)
document.Close()

The converted Word document automatically applies default styles, with clear heading hierarchies, complete table borders, and reasonable list indentation, ready for printing or further typesetting.

Image Handling: The Base64 Embedding Problem and Solutions

In the process of converting Word to Markdown, there is an easily overlooked issue: image handling . By default, Spire.Doc converts embedded images in Word into Base64 encoding and directly embeds them into the Markdown file. The advantage of this approach is that the single file is self-contained, making it easy to share.

However, the downside is also obvious — when the document contains many high-resolution images, the Markdown file size can balloon dramatically, reaching tens or even hundreds of megabytes, causing editor lag and bloated Git repositories.

Optimization Solution: Extract Image for External References

A better approach is to extract images into a separate folder and then reference them via relative paths in Markdown. Although Spire.Doc does not directly provide a parameter to "automatically externalize image links when saving", we can solve this by manually extracting images and replacing references:

from spire.doc import *
import os

document = Document()
document.LoadFromFile("input.docx")

# Create a directory for images
image_dir = "images"
os.makedirs(image_dir, exist_ok=True)

# Iterate and extract all images
for i, image in enumerate(document.Images):
    with open(f"{image_dir}/img_{i}.png", "wb") as f:
        f.write(image.ImageData)

# First convert to Markdown (still Base64 embedded)
document.SaveToFile("temp.md", FileFormat.Markdown)

# Subsequently, use regex or string replacement to replace Base64 images with local path references
# This step needs to be done manually or with an additional script
document.Close()

If there are many documents, you can also fully automate the process: parse the generated Markdown file, locate Base64 image blocks, decode them and save locally, then replace them with the ![](images/img_x.png) format. Spire.Doc's document.Images collection provides us with the ability to extract images, and combined with scripting, full automation of this optimization can be achieved.

Practical Application Scenarios

This solution has been validated in multiple real-world scenarios:

Technical documentation migration : Batch convert existing Word-format product manuals to Markdown for import into VuePress or Docsify knowledge bases.
Multi-format publishing : Write in Markdown and convert to Word to meet client or supervisor requirements for formal document formats.
Collaborative review : Team members review using Word's "Track Changes" mode, then convert back to Markdown with one click to continue development.

Summary

With the Spire.Doc library, Python developers can achieve bidirectional conversion between Word and Markdown with just a few lines of code, while fully preserving core structures such as headings, paragraphs, tables, and lists. For documents with many images, combining image extraction with external reference solutions can effectively control file sizes and improve document management experience. If you often switch between the two formats, give this solution a try and bid farewell to tedious manual typesetting.

A Quick Guide to Extracting PDF Tables with Python

jelizaveta — Wed, 03 Jun 2026 01:34:35 +0000

In data analysis work, we often encounter scenarios where we need to extract tabular data from PDF files. However, directly copying tables from PDF often results in formatting chaos and data misalignment. This article will guide you step by step on how to use the Spire.PDF for Python library to quickly and accurately identify and extract tables from PDF, and save the data in common formats such as CSV and Excel.

1. Preparation: Installing Required Libraries

First, you need to install the Spire.PDF library. Open the terminal or command line and execute the following command:

pip install Spire.PDF

If you plan to export the extracted data to Excel format, it is recommended to also install pandas and openpyxl:

pip install pandas openpyxl

2. Core Code: Extracting Tables from PDF

The following code demonstrates how to extract tables from the first page of a PDF and print the cell contents row by row:

from spire.pdf import PdfDocument, PdfTableExtractor

# 1. Load PDF file
pdf = PdfDocument()
pdf.LoadFromFile("sample.pdf")

# 2. Create table extractor
table_extractor = PdfTableExtractor(pdf)

# 3. Extract all tables from the first page
tables = table_extractor.ExtractTable(0)

# 4. Iterate through each table
for table in tables:
    row_count = table.GetRowCount()
    column_count = table.GetColumnCount()

    # Extract cell contents row by row
    for i in range(row_count):
        row_data = []
        for j in range(column_count):
            cell_text = table.GetText(i, j)
            row_data.append(cell_text)
        print(row_data)

Code Explanation

Method	Purpose
`LoadFromFile()`	Loads a PDF file from the specified path
`PdfTableExtractor()`	Creates a table extractor instance
`ExtractTable(page number)`	Extracts all tables from the specified page, page number starts from 0
`GetRowCount()` / `GetColumnCount()`	Gets the number of rows and columns of the table
`GetText(row, column)`	Gets the text content of the specified cell

3. Advanced Processing: Batch Extraction from Multi-page PDF

If the PDF contains multiple pages, you can use a loop to batch extract all tables:

from spire.pdf import PdfDocument, PdfTableExtractor

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

# Iterate through all pages
for page_index in range(pdf.Pages.Count):
    extractor = PdfTableExtractor(pdf)
    tables = extractor.ExtractTable(page_index)

    print(f"\n=== Page {page_index + 1} found {len(tables)} table(s) ===")

    for t, table in enumerate(tables):
        print(f"--- Table {t+1} ---")
        rows = table.GetRowCount()
        cols = table.GetColumnCount()

        for i in range(rows):
            row = [table.GetText(i, j) for j in range(cols)]
            print(row)

4. Exporting Data: Saving as CSV or Excel Files

The extracted table data can be easily converted to other formats. The following example saves the data as a CSV file:

import csv
from spire.pdf import PdfDocument, PdfTableExtractor

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

extractor = PdfTableExtractor(pdf)
tables = extractor.ExtractTable(0)

if tables:
    table = tables[0]
    rows = table.GetRowCount()
    cols = table.GetColumnCount()

    # Collect all data
    data = []
    for i in range(rows):
        row_data = [table.GetText(i, j) for j in range(cols)]
        data.append(row_data)

    # Write to CSV file
    with open("output.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.writer(f)
        writer.writerows(data)

    print(f"Successfully exported {rows} rows × {cols} columns of data to output.csv")

To export to an Excel file, you can use pandas:

import pandas as pd

# Assume data is the 2D list extracted above
df = pd.DataFrame(data[1:], columns=data[0])  # First row as column headers
df.to_excel("output.xlsx", index=False)
print("Data saved as output.xlsx")

5. Common Issues and Tips

Incomplete table recognition? Check whether the table in the PDF has clear borders. Scanned documents or image-based PDFs require OCR technology; Spire.PDF is mainly suitable for text-based PDFs.
Handling merged cells: Spire.PDF automatically handles merged cells. GetText() returns the content of the cell in the upper-left corner of the merged area, and returns an empty string for other positions.
Performance optimization: When processing large PDFs, it is recommended to extract and save page by page to avoid loading all tables into memory at once.

Through the above steps, you have mastered the complete process of extracting PDF tables using Python. This solution can be easily integrated into automated data processing pipelines, greatly improving work efficiency.

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!