DEV Community: Jack9012

Convert Markdown to PDF in Python: Basic Conversion and Page Setup

Jack9012 — Thu, 12 Nov 2026 01:30:46 +0000

Markdown is commonly used for technical documentation, project descriptions, and work notes. Its simple markup organizes headings, paragraphs, and lists, making documents easy to edit and manage with version control. For printing, archiving, or external delivery, however, these documents often need to be converted to PDF with fixed pagination and page layouts.

This article uses Spire.Doc for Python to demonstrate two approaches: converting a Markdown file directly to PDF and customizing the paper size, page orientation, and margins before conversion.

1. Install the Dependency and Prepare a Sample File

Spire.Doc for Python is a Python library for reading, creating, and converting documents. In this article, it is used to load Markdown files and export them as PDFs.

Run the following command in your terminal:

pip install Spire.Doc

Create a file named Sample.md in the Python script's working directory. You can use the following content for testing:

# Document Conversion Project: Weekly Report

> Reporting period: November 2–6, 2026  
> Project lead: Alex Chen  
> Document status: Pending review

## 1. Project Overview

This project converts team-maintained **Markdown documents into PDF files** for printing, archiving, and external delivery.

This week, testing focused on:

- Layout of headings, paragraphs, and lists
- Display of **bold text** and *italic text*
- Conversion of hyperlinks, tables, and code blocks
- A4 paper size, page orientation, and margin settings

For Markdown syntax, see the [Markdown Guide](https://www.markdownguide.org/basic-syntax/). Submit generated PDF files to the [Project Document Center](https://example.com/documents).

## 2. Weekly Task Progress

| Task ID | Task | Owner | Status | Completion |
| --- | --- | --- | --- | --- |
| DOC-101 | Organize the product user guide | Alex Chen | Completed | 100% |
| DOC-102 | Write the conversion script | Emma Li | Completed | 100% |
| DOC-103 | Verify Chinese text layout | Sophie Wang | In progress | 80% |
| DOC-104 | Check tables and code blocks | Ryan Zhao | In progress | 60% |
| DOC-105 | Review delivery documents | Chris Liu | Not started | 0% |

......

Save the Markdown file using UTF-8 encoding. The examples below automatically create an output directory to store the generated PDFs.

2. Convert a Markdown File Directly to PDF

If you do not have specific paper size or margin requirements, you can load the Markdown file and save it directly in PDF format.

Here is the complete code:

from pathlib import Path
from spire.doc import *
from spire.doc.common import *

# Create the output directory
Path("output").mkdir(parents=True, exist_ok=True)

# Create a document object
doc = Document()

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

# Save the document as a PDF
doc.SaveToFile("output/MarkdownToPDF.pdf", FileFormat.PDF)

# Release document resources
doc.Dispose()

The conversion primarily involves two methods:

Method	Purpose
`LoadFromFile("Sample.md", FileFormat.Markdown)`	Loads the source file in Markdown format
`SaveToFile("output/MarkdownToPDF.pdf", FileFormat.PDF)`	Exports the loaded document as a PDF

The conversion parses the Markdown document structure and generates formatted pages, rather than placing the raw Markdown source into a PDF as plain text. For example, headings, lists, and emphasis markers in the source file are used to format the document.

After running the script, you can find MarkdownToPDF.pdf in the output directory.

3. Customize Page Settings Before Conversion

Markdown primarily describes content structure. The source file typically does not specify A4 paper, landscape orientation, or print margins. To control these settings, modify the document's PageSetup after loading the file and before exporting it to PDF.

The following example uses A4 paper in landscape orientation with 50-point margins on all four sides:

from pathlib import Path
from spire.doc import *
from spire.doc.common import *

# Create the output directory
Path("output").mkdir(parents=True, exist_ok=True)

# Create a document object
doc = Document()

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

# Get the first section of the document
section = doc.Sections.get_Item(0)

# Get the page settings
page_setup = section.PageSetup

# Set the paper size, page orientation, and margins
page_setup.PageSize = PageSize.A4()
page_setup.Orientation = PageOrientation.Landscape
page_setup.Margins.All = 50

# Save the document as a PDF
doc.SaveToFile("output/MarkdownToPDFPageSetup.pdf", FileFormat.PDF)

# Release document resources
doc.Dispose()

Compared with the basic conversion example, this code adds steps to access a document section and configure its page layout. The settings are explained below:

Setting	Example Value	Description
`PageSize`	`PageSize.A4()`	Uses A4 paper
`Orientation`	`PageOrientation.Landscape`	Uses landscape orientation
`Margins.All`	`50`	Sets the top, bottom, left, and right margins to the same value

Margins are measured in points (pt), not millimeters. One inch equals 72 points, so 50 points is approximately 17.64 millimeters. To use 20-millimeter margins, convert the value to points:

page_setup.Margins.All = 20 * 72 / 25.4

Page settings affect the available content width and pagination. Landscape orientation provides more horizontal space, making it suitable for documents with wide content. Standard documentation can use portrait orientation according to its printing requirements.

Note that doc.Sections.get_Item(0) retrieves the document's first section, not its first page. Page settings apply to the pages within that section. If a document contains multiple sections and requires a consistent layout throughout, configure each section separately.

4. What Should You Check After Conversion?

After exporting the PDF, check the following:

Chinese fonts: Ensure that the required Chinese fonts are installed in the runtime environment and that the exported text displays correctly.
Image resources: If the Markdown file references images, ensure that the resources are accessible and that the corresponding images appear in the output.
Wide content: Check line wrapping and page boundaries for tables and long lines of code. Adjust the page orientation or margins if necessary.
Extended syntax: Support for extended syntax can vary between Markdown parsers. For documents containing formulas, embedded HTML, or specialized diagrams, verify the conversion using actual files.

Page settings control the paper and content area, but the layout of individual elements still needs to be checked. Before converting files in bulk, test a representative document to identify potential issues with fonts, resource paths, and pagination.

5. Summary

The basic workflow for converting Markdown to PDF with Spire.Doc for Python is to create a document object, load the Markdown file, export it as a PDF, and release the resources. To control the print layout, use PageSetup to configure the paper size, page orientation, and margins before exporting.

Basic conversion provides a starting point for ordinary notes and documentation. For materials that need to be printed or delivered in a consistent format, add page settings to the same workflow and review the final pagination.

Reorder PDF Pages in C#: Custom Page Order and Full Document Reversal

Jack9012 — Tue, 10 Nov 2026 01:34:49 +0000

After merging scanned files, you may find that the pages are in the wrong order, or you may want to move pages from the end of a document to the beginning. You can reorder PDF pages by specifying page indices, without first converting the PDF into images.

This article uses Spire.PDF for .NET to demonstrate two approaches: arranging pages in a custom order and reversing the page order of an entire document. Both examples use the same method, PdfPageCollection.ReArrange(int[] orderArray). The difference lies in how the ordering array is generated.

1. Install Spire.PDF for .NET

Spire.PDF for .NET is a library for reading, creating, and processing PDF files in .NET applications. This article uses its document loading, page reordering, and file saving APIs.

Run the following command in the NuGet Package Manager Console in Visual Studio:

Install-Package Spire.PDF

Alternatively, use the .NET CLI from your project directory:

dotnet add package Spire.PDF

The examples below use C# top-level statements. Each example can be placed in the Program.cs file of a console project that supports this syntax and run separately. If you use a relative path for the input file, place the file in the application's working directory. You can also use an absolute path.

2. Understand Page Indices and the Ordering Array

Before reordering pages, distinguish between the page positions shown in a PDF reader and the page indices used in code: indices start at 0, so page 1 corresponds to index 0, page 2 corresponds to index 1, and so on.

ReArrange() accepts an integer array. Each value represents a page index in the original document, and the sequence of values determines the new page order.

For example, consider the following array for a four-page PDF:

new int[] { 1, 0, 2, 3 }

The mapping is as follows:

Position After Reordering	Index in the Array	Page in the Original Document
Page 1	1	Original page 2
Page 2	0	Original page 1
Page 3	2	Original page 3
Page 4	3	Original page 4

This array swaps the first two pages and leaves the remaining two in their original order.

This article focuses on reordering while retaining all pages. The array should therefore include every page index from the original document exactly once, with values ranging from 0 to pdf.Pages.Count - 1.

3. Reorder PDF Pages in a Custom Sequence

Custom ordering is useful when you already know the desired page sequence, such as when swapping the first two pages or moving a cover page to the beginning of a document.

The following example uses a PDF containing exactly four pages. It places the original second page before the first, producing this sequence: original page 2, original page 1, original page 3, and original page 4.

using Spire.Pdf;

// Create a document object and load the PDF
PdfDocument pdf = new PdfDocument();
pdf.LoadFromFile("input.pdf");

// Reorder using the original page indices: swap the first two pages
pdf.Pages.ReArrange(new int[] { 1, 0, 2, 3 });

// Save to a new file and close the document
pdf.SaveToFile("ChangeOrder.pdf");
pdf.Close();

The code follows three steps:

Load the original PDF with LoadFromFile().
Call pdf.Pages.ReArrange() to reorder the pages according to the original page indices in the array.
Save the result with SaveToFile(), then call Close() to close the document.

To move the last page of this four-page document to the beginning, simply change the array to { 3, 0, 1, 2 }.

The array in this example is hard-coded for a four-page document. For files with a different number of pages, construct a complete array based on the actual page count instead of using this array directly.

4. Reverse the Page Order of an Entire PDF

To place the last page first, the second-to-last page second, and so on until the original first page becomes the last, you can automatically generate a reversed index array based on the total page count.

Compared with entering the array manually, this approach is better suited to documents with varying page counts.

using Spire.Pdf;
using System.Linq;

// Create a document object and load the PDF
PdfDocument pdf = new PdfDocument();
pdf.LoadFromFile("Input.pdf");

// Get the total page count
int pageCount = pdf.Pages.Count;

// Generate page indices in reverse order
int[] reverseOrder = Enumerable.Range(0, pageCount)
    .Reverse()
    .ToArray();

// Reorder the pages using the reversed indices
pdf.Pages.ReArrange(reverseOrder);

// Save as a PDF file and close the document
pdf.SaveToFile("Reversed.pdf", FileFormat.PDF);
pdf.Close();

The reversed array is generated as follows:

Enumerable.Range(0, pageCount) generates pageCount consecutive integers starting at 0, covering all page indices.
Reverse() reverses the index sequence.
ToArray() converts the result into the integer array required by ReArrange().

For example, a five-page document initially produces the indices { 0, 1, 2, 3, 4 }. Reversing them gives { 4, 3, 2, 1, 0 }, so the output document contains the original pages in the order 5, 4, 3, 2, and 1.

5. Practical Considerations

1. Page Order and Printed Page Numbers Are Different

Reordering changes a page's position within the document. It does not rewrite page numbers in headers or footers to match the new positions. For example, if the original page 5 is moved to the beginning, any existing “Page 5” text on that page must be handled separately.

If the document contains a table of contents, bookmarks, or internal links, check that they point to the expected destinations after saving. A correct page sequence alone does not guarantee that all navigation elements have been updated accordingly.

2. Match the Custom Array to the Actual Page Count

When reordering while retaining all pages, check the array length, index range, and duplicate values before calling the method. The numbers in the array represent original page indices; do not enter the one-based page numbers shown in a PDF reader directly.

3. Use Different Input and Output Paths

The examples save the results as new files to make comparison easier. When checking the output, confirm the page count first, then inspect the first page, the last page, and any pages that were moved.

4. Distinguish Example Code from Production Code

Exception handling is omitted here to keep the core page reordering logic clear. Production applications should also handle invalid input paths, file reading failures, and unwritable output directories. They should ensure that the document is closed and related resources are released even if an exception occurs.

Also, Spire.PDF for .NET and Free Spire.PDF for .NET are different packages. When using a trial license or the free edition, check the licensing terms and processing limits for your specific version so that these restrictions are not mistaken for problems with the page reordering logic.

6. Conclusion

The key to reordering PDF pages with Spire.PDF for .NET is to construct an array of original page indices that represents the desired sequence. If the target order is already known, specify the array directly. To reverse an entire document, generate the indices from Pages.Count and reverse them using LINQ.

With either approach, remember that indices start at 0, and check both the actual page order and the document's navigation elements after saving.

PDF Attachments with Python: Embed Files and Extract Them

Jack9012 — Thu, 05 Nov 2026 01:35:26 +0000

A complete project report often includes more than the PDF itself. It may also come with Excel spreadsheets used for calculations, original images, or supplementary notes. When these files are sent separately, recipients have to download and organize them individually—and may overlook a file along the way.

PDF attachments offer another way to organize these materials: embed supporting files directly in the PDF so the main document and related resources can be delivered together. For example, you can attach a source workbook to a financial report, sample files to a product manual, or supplementary materials to a contract.

This article explains how to use Spire.PDF for Python to perform two tasks: add attachments to a PDF and extract attachments from a PDF.

How Do PDF Attachments Differ from Page Content?

Think of a PDF with attachments as a document with its own built-in folder: the pages display the main content, while the attachments hold the supporting files.

Embedding a file this way differs from inserting an image or adding a hyperlink:

Operation	How the file is stored in the PDF	What readers see
Insert an image into a page	The image becomes part of the page content	The image is visible when the page is opened
Add a file hyperlink	Usually, only the destination URL or path is stored	Clicking the link opens the destination
Add an attachment	The file itself is embedded in the PDF	The file can be viewed or saved using a reader that supports attachments

Therefore, attaching an Excel file to a PDF does not convert its worksheets into PDF pages . After extracting the attachment, recipients can still open and edit the original workbook in Excel.

Attachment support varies between PDF readers. To access attachments, use a desktop reader with an attachments panel, such as Adobe Acrobat. Some browser-based PDF viewers may not provide an option to access embedded files.

Environment Setup

Spire.PDF for Python is a library for creating and processing PDF documents. This article uses its attachment APIs to work directly with files stored inside a PDF, without manually opening a reader to add or export them.

First, install the library:

pip install Spire.PDF

Import the required modules in your code:

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

The following examples demonstrate how to add and extract attachments. Before running them, replace the file paths with the actual paths on your computer.

1. Add Attachments to a PDF

Suppose you have a PDF report and want to deliver its source data, Report.xlsx, and a supporting image, Logo.png, together. Embedding them as attachments allows recipients to keep the main document and both supporting files in a single PDF.

The process consists of four steps:

Load the target PDF.
Create attachment objects from external files.
Add the attachments to the document’s attachment collection.
Save a new PDF containing the attachments.

Code Example

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

# Create a PDF document object
doc = PdfDocument()

# Load the target PDF
doc.LoadFromFile("Input.pdf")

# Create attachment objects from external files
attachment_one = PdfAttachment("Report.xlsx")
attachment_two = PdfAttachment("Logo.png")

# Add the attachments to the PDF
doc.Attachments.Add(attachment_one)
doc.Attachments.Add(attachment_two)

# Save as a new PDF file
doc.SaveToFile("Attachments.pdf")

# Release resources
doc.Close()

Code Explanation and Checking the Result

PdfAttachment("Report.xlsx") creates an attachment object from the specified file. Calling doc.Attachments.Add() then adds it to the current PDF. To attach more files, create additional attachment objects and add them to the collection.

Attachments do not take up page space or change the layout of the main content. When you open the saved Attachments.pdf, its pages may look exactly like those in the original document. However, a reader that supports attachments will list the embedded files in its “Attachments” or “Attached Files” panel.

This example uses different input and output filenames, so the original Input.pdf is preserved, while the version containing attachments is saved as Attachments.pdf.

File size is another consideration. Attachments contain the actual file data, so large workbooks or high-resolution images may significantly increase the PDF’s size. If you plan to send the PDF by email or upload it to a system, check the file size limits of that delivery channel.

2. Extract Attachments from a PDF

After receiving a PDF with attachments, you may need to edit an embedded workbook, organize supporting images, or pass the files to another program. You can extract the attachments as separate files for these purposes.

Extracting attachments does not require parsing PDF pages or performing OCR. The program reads the document’s attachment collection directly and writes the stored file data to disk.

The process is as follows:

Load the PDF containing attachments.
Get the document’s attachment collection.
Iterate through the attachments and read their filenames and data.
Save each attachment to the specified directory.

Code Example

Before running the code, create the Output\ExtractedFiles folder.

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

# Create a PdfDocument object
doc = PdfDocument()
# Load a PDF file
doc.LoadFromFile("Attachments.pdf")
# Get the attachment collection from the document
collection = doc.Attachments
# Loop through the collection
if collection.Count > 0:
    for i in range(collection.Count):
        # Get a specific attachment
        attachment = collection.get_Item(i)
        # Get the file name and data of the attachment
        fileName = attachment.FileName
        data = attachment.Data
        # Save it to a specified folder
        data.Save("Output\\ExtractedFiles\\" + fileName)
doc.Close()

Code Explanation and Checking the Result

doc.Attachments returns the document’s attachment collection, and collection.Count indicates how many attachments it contains. If there are no attachments, the example skips the save operation.

During iteration, get_Item(i) retrieves an attachment by index, FileName provides its filename, and Data.Save(path) writes its data to the specified location.

For the PDF created in the previous example, the output directory will contain Report.xlsx and Logo.png after extraction. You can open these files in their respective applications without accessing them through a PDF reader.

Details to Consider When Extracting Attachments

First, check the output directory. The example assumes that Output\ExtractedFiles already exists. In an actual project, you can use Python’s os.makedirs() to create the directory automatically before extraction.

Next, handle duplicate filenames. Different PDFs may contain attachments named Report.xlsx. Saving them all to the same folder could cause files to be overwritten. When extracting attachments in batches, create a separate subfolder for each PDF. For attachments with identical names within the same PDF, you can add an index to the beginning of each filename.

Also, sanitize filenames before saving. When processing PDFs from external sources, use os.path.basename() to obtain the filename portion of an attachment’s name, then combine it with the target directory. This avoids using path information from the attachment name directly as the save location.

Frequently Asked Questions

Q1. Why do the PDF pages look the same after adding attachments?

Attachments are stored inside the document and are not part of the content displayed on its pages. Use a reader that supports attachments and check its attachments panel.

Q2. Do I still need to send the original files after attaching them?

Once the attachments have been saved inside the PDF, recipients can extract them from it. Before delivery, however, open the output PDF and confirm that all the required files have been added.

Q3. Is extracting attachments the same as extracting images from a PDF?

No. Extracting attachments retrieves independent files embedded in the PDF. Extracting page images retrieves image resources used by the pages. An image displayed on a PDF page does not necessarily belong to the attachment collection.

Q4. Can I process multiple PDFs in batches?

Yes. Place the processing logic for a single PDF inside a loop that iterates through the input files. For batch extraction, create separate output directories based on the PDF filenames to help track the source of each attachment and reduce filename conflicts.

Conclusion

PDF attachments provide a practical way to keep the main document and its supporting materials together. The pages retain their readable layout, while original workbooks, images, and supplementary files travel with the document.

With Spire.PDF for Python, you can add attachments using PdfAttachment and doc.Attachments.Add(), or iterate through doc.Attachments to save existing attachments as separate files. In practical use, pay attention to reader compatibility, file size, and the handling of output directories and filenames during extraction.

Working with PDF Metadata in C#: A Complete Guide to Setting and Extracting Document Properties

Jack9012 — Tue, 03 Nov 2026 01:19:44 +0000

PDF document properties are metadata embedded within a file, including its title, author, subject, keywords, and producer name. Although this information does not appear directly on PDF pages, it is useful for document searches, archive management, and automated workflows. In C# projects, Free Spire.PDF for .NET provides a straightforward way to write and read these properties. This article explains both operations and highlights several implementation details.

Environment Setup

Free Spire.PDF for .NET is a standalone PDF processing library that runs without Adobe Acrobat or other third-party software. Install it in your project through NuGet:

Install-Package FreeSpire.PDF

Note that the free edition limits PDF loading and creation to 10 pages; pages beyond this limit are truncated. For lightweight tasks such as setting and reading properties, you can verify the examples using files that stay within this limit.

Set PDF Document Properties

The DocumentInformation property of the PdfDocument class provides access to standard document properties. It returns a PdfDocumentInformation object whose fields—including Title, Author, Subject, Keywords, and Producer—are readable and writable string properties.

The following example demonstrates the complete process of loading an existing PDF, updating its properties, and saving it as a new file. The sample property values contain practical information related to project archiving:

using Spire.Pdf;

namespace PdfPropertyDemo
{
    class SetProperties
    {
        static void Main(string[] args)
        {
            PdfDocument pdf = new PdfDocument();
            pdf.LoadFromFile("ProjectReport_Original.pdf");

            pdf.DocumentInformation.Title = "Q2 2026 Project Summary Report";
            pdf.DocumentInformation.Author = "Technical Documentation Team";
            pdf.DocumentInformation.Subject = "Summary of Project Progress and Resource Usage";
            pdf.DocumentInformation.Keywords = "Project Management, Quarterly Report, Progress Tracking";
            pdf.DocumentInformation.Producer = "Internal Document Generation Tool";

            pdf.SaveToFile("ProjectReport_Tagged.pdf");
            pdf.Close();
        }
    }
}

After execution, ProjectReport_Tagged.pdf retains the original document content and carries the updated property information. The Producer field typically identifies the application that generated the PDF, making it useful for tracing a file’s origin in automated workflows.

If a property does not exist in the original PDF, reading it may return null or an empty string. This does not affect writing: you can assign a value directly.

Read PDF Document Properties

Reading properties also relies on DocumentInformation. The following example loads the PDF whose properties were updated, extracts each field, and writes the results to a text file for verification or archiving:

using Spire.Pdf;
using System.IO;
using System.Text;

namespace PdfPropertyDemo
{
    class GetProperties
    {
        static void Main(string[] args)
        {
            PdfDocument pdf = new PdfDocument();
            pdf.LoadFromFile("ProjectReport_Tagged.pdf");

            StringBuilder content = new StringBuilder();
            content.AppendLine("Title: " + pdf.DocumentInformation.Title);
            content.AppendLine("Author: " + pdf.DocumentInformation.Author);
            content.AppendLine("Subject: " + pdf.DocumentInformation.Subject);
            content.AppendLine("Keywords: " + pdf.DocumentInformation.Keywords);
            content.AppendLine("Producer: " + pdf.DocumentInformation.Producer);

            File.WriteAllText("ExtractedProperties.txt", content.ToString(), Encoding.UTF8);
            pdf.Close();
        }
    }
}

This version uses AppendLine instead of explicit \r\n sequences and explicitly specifies UTF-8 encoding in File.WriteAllText. Specifying the encoding is particularly useful when property values contain Chinese or other non-ASCII characters: an encoding mismatch between the written file and the application reading it can produce garbled text. AppendLine also keeps the code concise while placing each field on a separate line.

Implementation Notes

As these examples show, Free Spire.PDF provides a direct interface for working with document properties. The property names largely correspond to entries in the PDF specification’s Info dictionary. Writing and reading use the same property accessors, with no need to parse the underlying structure separately.

Two details deserve attention in practical use. First, explicitly calling the PdfDocument object’s Close method after reading or writing helps release file handles promptly, especially when a subsequent operation needs immediate access to the same file. Second, properties that have not been set may return empty values. Before passing these values to downstream logic, such as conditional checks or database operations, it is sensible to check for null or empty values.

In addition to standard properties, PDFs can contain custom properties. These can be managed through the SetCustomProperty and GetCustomProperty methods and are useful for storing business information such as internal identifiers or version labels. Although custom properties are outside the scope of these examples, they can complement standard metadata in a document management system.

Conclusion

This article demonstrated the complete workflow for setting and reading PDF document properties in C# using Free Spire.PDF for .NET. To set properties, assign values directly to the string properties exposed by DocumentInformation. To read them, retrieve the corresponding values, collect them in a StringBuilder, and save the results to a text file.

The key implementation details are to specify the text encoding explicitly, close the document after processing, and handle potentially empty property values before using them in downstream operations. These small steps contribute to reliable behavior in real-world projects.

Sorting Excel Data with Python: Three Scenarios and Implementations

Jack9012 — Thu, 29 Oct 2026 01:58:26 +0000

Sorting is one of the most common operations in Excel data processing. Manual sorting is perfectly adequate for small datasets and occasional tasks. However, when data changes frequently, multiple files need batch processing, or records must follow custom business rules, automating the process with code can produce more consistent and reproducible results.

This article uses Spire.XLS for Python. We will first explain a shared preprocessing step, then demonstrate three sorting scenarios: sorting a single column, sorting an entire table by a specific column, and sorting by a custom sequence.

1. Environment Setup and a Shared Prerequisite

Install and Import the Library

Install Spire.XLS for Python using pip:

pip install Spire.XLS

Once installed, add the following import statement at the beginning of your code:

from spire.xls import *

Convert Formulas to Static Values Before Sorting

The first two examples share the same preprocessing step: iterate through the sorting range and replace formulas with their calculated values. This lets the sorting operation work with static cell values and avoids potential changes to formula references when cells move.

The following code performs this conversion. We explain it here once rather than repeating the explanation in each example:

for cell in cellRange:
    if cell.HasFormula:
        value = cell.FormulaValue
        cell.Clear(ExcelClearOptions.ClearContent)
        cell.Value = value

Also, the column index used by SortColumns.Add() is zero-based: column A corresponds to 0, column B corresponds to 1, and so on. Check the index against your worksheet structure when configuring the sort.

2. Three Sorting Scenarios

Scenario 1: Sort a Single Column

This approach rearranges the values within one column only. Other columns remain unchanged.

from spire.xls import *

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

worksheet = workbook.Worksheets[0]
cellRange = worksheet["G1:G13"]

# Convert formulas to static values (as explained in Section 1)
for cell in cellRange:
    if (cell.HasFormula):
        value = cell.FormulaValue
        cell.Clear(ExcelClearOptions.ClearContent)
        cell.Value = value

# Sort by column G (zero-based index 6), by value in descending order
workbook.DataSorter.SortColumns.Add(6, SortComparsionType.Values, OrderBy.Descending)
workbook.DataSorter.Sort(cellRange)

workbook.SaveToFile("output/SortByColumn.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

Key points: The sorting range is G1:G13, which includes only the target column. The value 6 in SortColumns.Add(6, ...) is the zero-based index for column G. Values are sorted in descending order.

Scenario 2: Sort an Entire Table by a Specific Column

Use one column as the sorting key to rearrange entire rows while preserving the relationships between values within each row.

from spire.xls import *

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

worksheet = workbook.Worksheets[0]
cellRange = worksheet["A1:G13"]

# Convert formulas to static values (as explained in Section 1)
for cell in cellRange:
    if (cell.HasFormula):
        value = cell.FormulaValue
        cell.Clear(ExcelClearOptions.ClearContent)
        cell.Value = value

# Use column G (zero-based index 6) as the key, sorting by value in descending order
workbook.DataSorter.SortColumns.Add(6, SortComparsionType.Values, OrderBy.Descending)
workbook.DataSorter.Sort(cellRange)

workbook.SaveToFile("output/SortByColumns.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

Key points: Compared with Scenario 1, the sorting key remains the same. Only the sorting range changes—from G1:G13 to A1:G13. When Sort() runs, each row within the range moves according to its value in column G. The contents of columns A through F move with the row.

This approach is more suitable for typical business data. For example, when sorting a sales table by the Sales Amount column, the product, region, date, and other information in each row must move together to keep the records aligned.

Scenario 3: Sort by a Custom Sequence

Ascending and descending order cover only some sorting requirements. Sometimes, records need to follow a business-defined sequence, such as High, Medium, and Low priority, or a predefined order of identifiers. A custom sort list handles these cases.

from spire.xls import *

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

worksheet = workbook.Worksheets[0]
cellRange = worksheet["A1:G13"]

# Explicitly define the sorting order
customList = ["6", "5", "4", "3", "2", "1", "12", "11", "10", "9", "8", "7"]

# Sort by column A (zero-based index 0) using the custom sequence
workbook.DataSorter.SortColumns.Add(0, customList)
workbook.DataSorter.Sort(cellRange)

workbook.SaveToFile("output/CustomSortList.xlsx", ExcelVersion.Version2016)
workbook.Dispose()

Key points: Values in the sorting column follow their order in customList rather than their numerical magnitude. The Sort() operation still applies to the entire A1:G13 range, with the rows arranged according to the custom sequence of values in column A.

Keep two points in mind:

The element types in the custom list should match the data type of the sorting column. In this example, the numbers are provided as strings. Otherwise, values may not match correctly.
If the sorting column contains values that are absent from the custom list, verify their placement in the actual output. Check that the data and custom list correspond before running the final sort.

3. Comparing the Three Scenarios

Scenario	Sorting Range	Sorting Rule	Suitable Use
Single-column sorting	Target column only	Values in ascending or descending order	Rearrange values within one column
Entire-table sorting	Entire table, using a specific column as the key	Values in the key column in ascending or descending order	Sort complete rows by a key
Custom-sequence sorting	Entire table	Order defined in a custom list	Follow a predefined business sequence

The central distinction is the sorting range : it determines which cells move, while the sorting key determines their order. The code for single-column sorting and entire-table sorting is almost identical; only the range passed to Sort() changes. Custom-sequence sorting replaces value comparison with the order defined in a list.

4. Conclusion

When sorting with Spire.XLS for Python, keep three points in mind:

Handle formulas first: If you need static values for sorting, convert formulas to their calculated values beforehand to avoid potential reference changes.
Choose the correct sorting range: Pass a single-column range to rearrange that column alone, or a full-table range to move complete rows together.
Remember that column indexes start at 0: Check the column index against your worksheet structure when configuring SortColumns.Add().

Apply these points to your data, then use the appropriate example above to handle common Excel sorting tasks.

Import Word Table Data into Excel Using Python

Jack9012 — Tue, 27 Oct 2026 05:44:36 +0000

Tables in Word documents often contain structured data, but Excel is better suited for analyzing, filtering, and charting that data. When a document contains multiple tables, copying and pasting them manually can be time-consuming and may introduce errors during conversion.

This article explains how to use Spire.Doc for Python and Spire.XLS for Python to import each table from a Word document into a separate Excel worksheet. It also describes what the solution can handle and where its limitations lie.

Install the Required Libraries

Before you begin, install two libraries: Spire.Doc reads and parses the table structure in Word documents, while Spire.XLS creates and writes Excel files. Run the following commands:

pip install Spire.Doc
pip install Spire.XLS

Spire products also offer free editions, such as spire.doc.free and spire.xls.free, which you can install with pip install spire.doc.free spire.xls.free. The free editions have certain limitations. For example, Free Spire.Doc supports up to 500 paragraphs and 25 tables per document. The free editions may be sufficient for smaller documents, while larger documents or those containing more tables require the full versions.

Both libraries support Windows, Linux, and macOS, and neither requires Microsoft Office or Word to be installed.

How the Conversion Works

The conversion process can be divided into two stages:

Extraction: Load the Word document and iterate through each section, then through each table in that section. For every cell, read and combine the text from all its paragraphs to retain content that spans multiple paragraphs.

Writing: Create a new Excel workbook and a separate worksheet for each Word table. Write the extracted text to the corresponding cells in row and column order, automatically adjust the column widths, and save the file.

Complete Code Example

The following code implements this process. It is written for the full versions of the Spire libraries. If you use the free editions, adjust the import statements to from spire.doc import * and from spire.xls import *, respectively.

from spire.doc import *
from spire.xls import *

# Load the Word document
doc = Document()
doc.LoadFromFile('input.docx')

# Create an Excel workbook and remove the default worksheets
wb = Workbook()
wb.Worksheets.Clear()

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

    # Iterate through all tables in the section
    for j in range(section.Tables.Count):
        table = section.Tables.get_Item(j)

        # Create a worksheet for each table, using the section and table numbers
        ws = wb.Worksheets.Add(f'Table_{i+1}_{j+1}')

        # Write data one row and one cell at a time
        for row in range(table.Rows.Count):
            tableRow = table.Rows.get_Item(row)

            for cell in range(tableRow.Cells.Count):
                tableCell = tableRow.Cells.get_Item(cell)

                # Combine the text of all paragraphs in the cell
                cellText = ''
                for paragraph in range(tableCell.Paragraphs.Count):
                    paragraph = tableCell.Paragraphs.get_Item(paragraph)
                    cellText = cellText + (paragraph.Text + ' ')

                # Assign text starting with "00" directly to prevent
                # Excel from automatically converting it to a number
                if cellText.startswith('00'):
                    ws.Range[row + 1, cell + 1].Text = cellText
                else:
                    ws.SetCellValue(row + 1, cell + 1, cellText)

        # Automatically adjust column widths to fit the content
        ws.AllocatedRange.AutoFitColumns()

# Save in Excel 2016 format
wb.SaveToFile('output/WordTableToExcel.xlsx', FileFormat.Version2016)

doc.Close()
wb.Dispose()

Before running the script, make sure input.docx is in the same directory as the script and that the output folder already exists. You can also modify the paths to suit your environment.

Key Details in the Code

Combining multiple paragraphs in a cell. A Word table cell can contain multiple paragraphs. Reading only the first paragraph would omit the rest. The code iterates through tableCell.Paragraphs, combines their text in order, and adds a space after each paragraph to separate the content.

Protecting text that starts with "00". When a string is written with SetCellValue, Excel may recognize a value such as "001" as the number 1. The code checks for this case and assigns the value through ws.Range[row + 1, cell + 1].Text = cellText instead, which is intended to preserve it as text. This protection only covers values beginning with "00"; other formats that may be misinterpreted, such as long numeric strings or date-like text, are not handled.

Naming worksheets. The format Table_{section number}_{table number} makes it easier to identify the location of each source table in the Word document.

Cases Not Covered

The current code handles basic two-dimensional text tables. It does not correctly handle the following common cases:

Merged cells. When iterating through a Word table with merged cells, tableRow.Cells.Count and the cell indices may not correspond to the visual grid. The code traverses the Cells collection in order and does not read properties such as GridSpan or VerticalMerge. As a result, merged regions may be split in Excel, and text may be duplicated or placed in the wrong position. Handling this requires reading the merge properties and applying corresponding Merge operations in Excel.
Images inside cells. The code extracts paragraph text only. Images and other non-text objects embedded in cells are ignored and will not appear in the Excel output.
Text formatting. Only plain text strings are written to Excel. Font names, font sizes, bold formatting, colors, alignment, and other formatting from Word cells are not transferred. Paragraph breaks are also lost because the code joins paragraphs with spaces. The Excel cells contain the text values without the original visual styling.
Context outside tables. Table captions, explanatory paragraphs, and cross-references outside the tables are not included in the Excel output. Each table is placed on a separate worksheet, and the numbering in the worksheet names provides the only indication of their positions in the source document.

When to Use This Approach

This code is suitable for consistently structured Word tables with no merged cells, plain-text cell contents, and no requirement to preserve formatting. Under these conditions, it can quickly export multiple tables and save the time needed to copy them individually.

If the source tables contain the more complex elements described above, you will need to add detection and handling logic to the code. Otherwise, the exported data may differ from the original tables.

Add Page Numbers to PDF Footers Using Python

Jack9012 — Thu, 22 Oct 2026 01:29:16 +0000

When processing PDF documents in batches, you often need to add consistent page numbering to existing files. With Spire.PDF for Python, you can draw dynamic page numbers directly on the canvas of an existing PDF, without creating a separate PDF and merging it afterward.

This article demonstrates how to center page numbers in a PDF footer, with a focus on customizing the page number format —such as Page X or X / Y—and using coordinates to position them anywhere on the page, including the left, center, or right of the footer, or any location in the header.

Coordinate units: PDF coordinates are measured in points, where 1 point = 1/72 inch. The page coordinate system starts at the upper-left corner, with X increasing to the right and Y increasing downward.

Prerequisites

Install the required library:

pip install spire.pdf

Understanding the Two Dynamic Fields

Page numbering relies on two dynamic fields:

PdfPageNumberField : Represents the current page number and resolves to the actual number when rendered.
PdfPageCountField : Represents the total number of pages and resolves to the page count when rendered.

These fields are dynamic rather than hardcoded strings, allowing page numbering to reflect the document’s page count when rendered.

Control the Format with PdfCompositeField

PdfCompositeField combines a static text template with dynamic fields to produce a complete line of text. The template string determines the page number format , so changing the format only requires updating this string.

Basic syntax:

compositeField = PdfCompositeField(font, brush, "Template text", [field1, field2, ...])

Here, {0} refers to the first field in the list, {1} refers to the second field, and so on.

Complete Code: Centered Footer with “Page X of Y”

The following example uses the Page {0} of {1} format, centers the page numbers in the footer, and adds a separator line:

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

# Create a PdfDocument object
doc = PdfDocument()
# Load a local PDF file
doc.LoadFromFile("input.pdf")

# Define the font, brush, and pen
font = PdfTrueTypeFont("Arial", 14.0, PdfFontStyle.Regular, True)
brush = PdfBrushes.get_Black()
pen = PdfPen(brush, 1.0)

# Set margins
leftMargin = 54.0
rightMargin = 54.0
bottomMargin = 72.0

# Create fields for the current page number and total page count
pageNumberField = PdfPageNumberField()
pageCountField = PdfPageCountField()
# Combine the fields using an English page number template
compositeField = PdfCompositeField(
    font, brush, "Page {0} of {1}", [pageNumberField, pageCountField]
)

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

    # Draw a separator line in the footer
    page.Canvas.DrawLine(
        pen,
        leftMargin,
        pageSize.Height - bottomMargin + 15.0,
        pageSize.Width - rightMargin,
        pageSize.Height - bottomMargin + 15.0
    )

    # Measure the page number text to calculate its centered position
    text = "Page {} of {}".format(i + 1, doc.Pages.Count)
    pageNumberSize = font.MeasureString(text)
    # Set the page number position: horizontally centered
    compositeField.Location = PointF(
        (pageSize.Width - pageNumberSize.Width) / 2,
        pageSize.Height - bottomMargin + 18.0
    )
    # Draw the page number
    compositeField.Draw(page.Canvas, 0.0, 0.0)

# Save the new file
doc.SaveToFile("Output/CenterAlignedPageNumbers.pdf")
# Release resources
doc.Dispose()

Customize the Page Number Format

The page number format depends on the template string and the dynamic fields supplied. Below are several common formats. Replace the third argument of PdfCompositeField and adjust the field list as needed.

Format 1: Current Page Only — `Page X`

This format requires only the page number field:

compositeField = PdfCompositeField(    
    font, brush, "Page {0}", [pageNumberField])

Format 2: Compact Numeric Format — `X / Y`

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

Format 3: Current Page and Total Pages — `Page X / Total Y Pages`

compositeField = PdfCompositeField(    
    font, brush, "Page {0} / Total {1} Pages",    [pageNumberField, pageCountField])

Format 4: Total Page Count Only — `Total Y Pages`

compositeField = PdfCompositeField(    
    font, brush, "Total {1} Pages", [pageNumberField, pageCountField])

Note: A field can be included in the list without appearing in the template; it simply will not be displayed. You can combine field placeholders in any order and customize surrounding text or separators, such as “Page,” “of,” “Total,” or “/,” to suit your layout.

Customize the Position with Coordinates

The page number position is controlled by compositeField.Location = PointF(x, y):

Center: x = (page width - text width) / 2
Left: x = leftMargin
Right: x = pageSize.Width - pageNumberSize.Width - rightMargin
Vertical position: Adjust Y to move the text up or down. Smaller Y values move it toward the top of the page, allowing placement in the header.

The following example combines a custom format and position: a right-aligned footer using X / Y.

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

for i in range(doc.Pages.Count):
    page = doc.Pages.get_Item(i)
    pageSize = page.Size

    text = "{} / {}".format(i + 1, doc.Pages.Count)
    pageNumberSize = font.MeasureString(text)

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

Things to Keep in Mind

The example uses Arial. If it is unavailable in your environment, replace it with another installed font. For Chinese or other multilingual text, choose a font that supports the required characters.
If page numbers overlap existing content, adjust their coordinates to place them in an unused area. The margin variables in these examples control drawing positions; they do not create additional blank space or reflow existing content.

Conclusion

This approach lets you customize the page number format and its position independently. Change the template string to switch between formats such as Page X, X / Y, and Page X of Y, then adjust the Location coordinates to place the text anywhere in the footer or header. This flexibility makes it useful for applying consistent page numbering when processing PDFs in batches.

Convert HTML to PDF in C#: A Chrome-Based Approach

Jack9012 — Tue, 20 Oct 2026 01:25:44 +0000

Converting HTML or web pages to PDF is a common requirement in business applications, from exporting reports and printing invoices to archiving web pages and generating PDFs from dynamic HTML content.

Common approaches include:

HTML rendering libraries that work without a browser but offer limited support for complex CSS and JavaScript.
Headless browser solutions such as PhantomJS or Puppeteer, which require deploying a browser engine.
Rendering with a locally installed Chrome browser , which reuses Google Chrome on the target machine and uses its native rendering engine to handle modern CSS, JavaScript, images, fonts, and complex page layouts.

This article introduces the Spire.Additions.Chrome module included with Spire.PDF for Python . It wraps the process of exporting PDFs through a local Chrome installation, allowing you to convert a web page URL to PDF with just a few lines of C# code.

⚠️ Important prerequisites

Install Google Chrome on the machine that will run the code, and locate the chrome.exe executable.

Close all Chrome windows before running the application ; otherwise, the conversion will fail.

Both web page URLs and local HTML files are supported.

Environment Setup

Install Spire.PDF for Python

The project requires Spire.PDF for Python. The Spire.Additions.Chrome namespace is included with the product, so no separate component needs to be installed.

Locate the Chrome Executable

The default Chrome installation path on Windows is:

C:\Program Files\Google\Chrome\Application\chrome.exe

If Chrome is installed in a different directory, update the chromeLocation value in the code accordingly.

Complete C# Code Example

using Spire.Additions.Chrome;

namespace ConvertHtmlToPdfUsingChrome
{
    internal class Program
    {
        static void Main(string[] args)
        {
            // Input web page URL
            string inputUrl = @"https://www.example.com/webpage.html";

            // Output PDF file path
            string outputFile = @"HtmlToPDF.pdf";

            // Path to the local Chrome executable
            string chromeLocation = @"C:\Program Files\Google\Chrome\Application\chrome.exe";

            // Create a Chrome HTML converter instance
            ChromeHtmlConverter converter = new ChromeHtmlConverter(chromeLocation);

            // Configure conversion options
            ConvertOptions options = new ConvertOptions();

            // Set the conversion timeout in milliseconds
            options.Timeout = 10 * 3000;

            // Set the PDF page size and margins:
            // A4 paper in inches, with no margins
            options.PageSettings = new PageSettings()
            {
                PaperWidth = 8.27,
                PaperHeight = 11.69,
                MarginTop = 0,
                MarginLeft = 0,
                MarginRight = 0,
                MarginBottom = 0
            };

            // Convert the web page URL to PDF
            converter.ConvertToPdf(inputUrl, outputFile, options);
        }
    }
}

Understanding the Code

1. ChromeHtmlConverter

ChromeHtmlConverter is the main conversion class in the Spire.Additions.Chrome namespace, which is included with Spire.PDF for Python .

Its constructor accepts the path to chrome.exe, allowing the converter to launch the local Chrome browser in headless mode and render the page.

Note: Chrome must be closed when you run the code. The library automatically launches a headless Chrome process and closes it when the conversion finishes.

2. ConvertOptions

ConvertOptions controls the conversion settings:

Timeout: The conversion timeout in milliseconds. Increase this value for pages that take longer to load. In this example, 10 * 3000 sets a timeout of 30 seconds.
PageSettings: The PDF page dimensions and margins, measured in inches. The example uses A4 paper, measuring 8.27 × 11.69 inches, with all margins set to zero for edge-to-edge output.

You can change the width and height to use a custom paper size, or adjust the margin properties to add whitespace around the page content.

3. ConvertToPdf()

ConvertToPdf() performs the conversion. It accepts a web page URL and saves the resulting PDF to the specified local file path.

In addition to URLs, the API also supports local HTML file paths.

Advantages and Limitations

Advantages

Native Chrome rendering Chrome’s rendering engine handles complex web pages, CSS3, dynamically rendered JavaScript content, SVG, and web fonts.
No additional browser engine to bundle Reusing the Chrome installation on the target machine helps reduce the application’s package size.
Simple configuration and API The converter avoids the need to write complex headless browser command-line arguments.
Included with the product Spire.Additions.Chrome is built into Spire.PDF for Python and is available after installing the product.

Limitations

Google Chrome must be installed on the target machine, and all Chrome windows must be closed during conversion.
Server deployments require Chrome to be installed on the server. Container environments also require additional Chrome configuration.
The solution depends on the locally installed browser version, so Chrome updates may affect compatibility.

Common Issues and Troubleshooting

1. Conversion Fails Because of a Chrome Process Conflict

Cause: One or more Chrome windows are still open.

Solution: Close all Chrome windows, then run the application again.

2. The Application Cannot Find chrome.exe

Cause: The configured path is incorrect, or Chrome is installed in a user-specific directory such as AppData\Local.

Solution: Locate chrome.exe in File Explorer and copy its actual path into the code.

3. The Output Is Blank or Images Are Missing

Check for network problems or page-loading timeouts. Increase options.Timeout if necessary.

Also check whether the page requires a login session or cookie-based authentication.

4. The Page Layout Looks Incorrect

Adjust the paper dimensions and margins in PageSettings.

Responsive layouts may also affect the output. If you control the HTML, consider adding print-specific CSS to improve the PDF layout.

Additional Notes on Spire.PDF for Python

Although the example above is written in C#, this Chrome-based HTML-to-PDF capability is provided by Spire.PDF for Python , with Spire.Additions.Chrome included as a built-in namespace. The Python API follows the same general design as the C# API.

The overall workflow is:

Install the Spire.PDF for Python package to access the namespace.
Install Chrome locally and close it before running the script.
Configure the Chrome path, page dimensions, and timeout, then call the conversion method to export the PDF.

Recommended Use Cases

This approach is suitable for:

Exporting web-based reports and preview pages from internal management systems.
Archiving static web pages, invoices, and other business documents as PDFs.
Generating PDFs that need to retain complex front-end layouts and web styling.

Conclusion

Combining the Spire.Additions.Chrome namespace included with Spire.PDF for Python and a local Google Chrome installation provides a straightforward way to convert HTML to PDF with minimal C# code.

Chrome’s rendering engine offers strong support for complex web pages compared with custom HTML rendering engines. The converter also provides a higher-level interface than Puppeteer, reducing the need to manage browser processes manually.

Splitting Word Documents by Page or Section Using Python

Jack9012 — Thu, 15 Oct 2026 01:55:21 +0000

In document processing, it is often necessary to split a large Word document into multiple separate files. For example, splitting a hundreds-page report by chapters, or extracting a specified page range for separate distribution.

Common libraries for processing Word documents with Python include python-docx and Spire.Doc for Python. python-docx excels at paragraph-level reading and writing, but it does not natively support direct access to page break information after document rendering. In contrast, Spire.Doc for Python can directly read a document’s page layout and Section structure. It supports two widely used splitting strategies:

Split by page range : Extract a specified page range to generate a new document based on the final rendered page layout of the file.
Split by document section : Save each section as an individual file according to Word section breaks, ideal for documents divided by chapters.

Note: Spire.Doc for Python is a standalone document processing library. Microsoft Word does not need to be installed in the runtime environment.

Environment Setup

Install the dependency package directly via pip:

pip install Spire.Doc

Method 1: Split Word Documents by Page Range

The ExtractPages(startIndex, count) method extracts a continuous range of pages according to the rendered page layout and creates a new document. Page indices start at 0 . startIndex refers to the starting page index, and count is the number of pages to extract.

Example requirement: Extract the first 3 pages into one file and save the remaining pages as another file.

from spire.doc import *
# Load the Word document
doc = Document()
doc.LoadFromFile("input.docx")
# Extract pages 1-3
first_part = doc.ExtractPages(0, min(3, doc.PageCount))
first_part.SaveToFile("Page1-3.docx", FileFormat.Docx)
first_part.Dispose()
# Extract the remaining pages if the document has more than 3 pages
if doc.PageCount > 3:
    second_part = doc.ExtractPages(3, doc.PageCount - 3)
    second_part.SaveToFile("Page4-End.docx", FileFormat.Docx)
    second_part.Dispose()
doc.Dispose()

Code Explanation

doc.LoadFromFile("input.docx"): Load the source Word document.
doc.PageCount: Get the total number of pages in the document.
min(3, doc.PageCount): Boundary protection to prevent errors when the document has fewer than 3 pages.
ExtractPages returns a new Document object. Call SaveToFile to export it as a docx file.
Dispose(): Release document resources to avoid memory consumption.

Attention: Page-based splitting relies on the final typesetting layout of the document. Changes to fonts, images or page margins will affect pagination results, which match the pages you see when opening the file in Word.

Method 2: Split Word Documents by Document Section

A Word Section is defined by section breaks. Sections are commonly used to separate different chapters, distinct headers and footers, mixed portrait and landscape orientation, and other content. This approach works well for books, papers, manuals and other documents naturally divided into chapters with section breaks.

Logic: Iterate over all Sections of the document, clone each Section, add it to a new Document object, and save each as a separate file.

from spire.doc import *
# Load the Word document
doc = Document()
doc.LoadFromFile("Sample.docx")
# Split the document by section
for i in range(doc.Sections.Count):
    new_doc = Document()
    # Clone the current section and add it to the new document
    new_doc.Sections.Add(doc.Sections.get_Item(i).Clone())
    # Save the section as an individual Word document
    new_doc.SaveToFile(
        f"output/SplitDocument/SplitBySectionBreak_{i+1}.docx"
    )
    new_doc.Close()
doc.Close()

Code Explanation

doc.Sections.Count: Get the total number of sections inside the document.
doc.Sections.get_Item(i).Clone(): Clone the current section. Cloning fully preserves page settings, headers, footers and styles of that section.
Create a blank document in each loop iteration, add the cloned section, then save it as an independent file.
new_doc.Close(): Close the sub-document and release resources.

Tip: You need to manually create the output/SplitDocument directory before running the code; otherwise, a path-not-found exception will be thrown when saving files.

Comparison of the Two Splitting Approaches

Splitting Method	Basis for Splitting	Applicable Scenarios	Limitations
Split by page range	Rendered page layout of the document	Extract fixed page ranges, cut documents by page count	Pagination positions will change after document content is modified
Split by section	Word section breaks	Documents with chapters divided by section breaks and independent headers/footers	If no section breaks are inserted in the document, there will only be one section and splitting cannot be performed

General Notes

Resource release : Always call Dispose() / Close() after finishing using Document objects to prevent memory leaks during long-running batch document processing.
Pre-create directories : When outputting files to subfolders, use os.makedirs() to create folders.
Trial version limitations : The trial version of Spire.Doc adds watermarks to output documents and has partial function restrictions. Refer to the official licensing instructions for production environment use.
File encoding and paths : On Windows, English paths are recommended for files containing Chinese characters to avoid encoding issues.

Extended Ideas

Batch splitting: Traverse all .docx files in a folder and run the splitting script in a loop.
Single-page splitting: Call ExtractPages(i,1) in a loop to save each page as a separate document.
Hybrid strategy: Split by sections first, then extract pages from each split document.

Summary

Spire.Doc for Python provides two straightforward ways to split Word documents. Splitting by page range suits visual page cutting, while splitting by section is designed for chapter splitting based on document structure (section breaks). Automated document splitting can be achieved with just dozens of lines of code, eliminating repetitive manual copy work. It can be integrated into office automation scripts and data processing pipelines.

If needed, I can also provide a fully runnable batch single-page splitting script , or an enhanced version with automatic output directory creation and exception handling.

How to Print PDFs in Java: Silent Printing and Print Dialog Selection

Jack9012 — Tue, 13 Oct 2026 05:56:35 +0000

PDF printing is a common business requirement in daily Java backend and desktop development scenarios, such as report printing, document slip printing, and document archiving printing. Java natively provides the core printing API java.awt.print. However, this native API cannot directly parse and render PDF documents. Third-party PDF parsing libraries are required to work alongside it to achieve full printing capabilities.

This article combines two technologies: Spire.PDF for Java (for PDF parsing and rendering) and java.awt.print (for system print job scheduling). It implements two mainstream PDF printing scenarios: silent printing to the default printer without pop-up windows, and printing with a dialog for manual printer selection. Complete runnable code and detailed explanations of underlying principles are provided.

1. Tech Stack and Environment Setup

1.1 Core Dependency Overview

java.awt.print : The built-in JDK printing toolkit with no extra dependencies required. It is mainly responsible for retrieving system printers, configuring print page formats, scheduling print jobs, and catching printing exceptions. It serves as the foundational core for Java printing functions.
Spire.PDF for Java : A professional PDF parsing library used to load local PDF files and render PDF page content. It adapts to the print rendering interface of the native printing API and addresses the limitation that vanilla Java cannot print PDFs directly.

1.2 Project Dependency Configuration

For Maven projects, add the Spire.PDF dependency in pom.xml:

<repositories>
    <repository>
        <id>com.e-iceblue</id>
        <name>e-iceblue</name>
        <url>https://repo.e-iceblue.com/nexus/content/groups/public/</url>
    </repository>
</repositories>
<dependencies>
    <dependency>
        <groupId>e-iceblue</groupId>
        <artifactId>spire.pdf</artifactId>
        <version>12.9.0</version>
    </dependency>
</dependencies>

2. Scenario 1: Silent Printing to Default Printer (No Print Dialog)

This scenario applies to background automatic printing with no manual intervention . The system directly sends print jobs to the default printer without popping up any print configuration windows, running silently throughout the process.

Core implementation logic: Obtain the system default print job via PrinterJob, customize the printable area of the print page, load the PDF document and bind it to the print job, then trigger printing directly.

Full Runnable Code

import com.spire.pdf.PdfDocument;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
/**
 * PDF Silent Printing (Default Printer, No Dialog)
 */
public class PrintWithDefaultPrinter {
    public static void main(String[] args) {
        // 1. Get print job object for the system default printer
        PrinterJob printerJob = PrinterJob.getPrinterJob();
        // 2. Initialize page format and retrieve default page size and orientation
        PageFormat pageFormat = printerJob.defaultPage();
        // 3. Get paper object for the page and customize printable area
        Paper paper = pageFormat.getPaper();
        // Set full printable area of the paper (remove default margins to fit full PDF page)
        paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
        // Bind customized paper settings to page format
        pageFormat.setPaper(paper);
        // 4. Load local PDF document
        PdfDocument pdf = new PdfDocument();
        // Replace with your actual local PDF file path
        pdf.loadFromFile("input.pdf");
        // 5. Bind PDF document with page format to prepare print rendering
        printerJob.setPrintable(pdf, pageFormat);
        // 6. Execute silent print job
        try {
            printerJob.print();
            System.out.println("PDF silent print job completed");
        } catch (PrinterException e) {
            e.printStackTrace();
            System.err.println("PDF silent printing failed: " + e.getMessage());
        }
    }
}

Key Code Explanations

PrinterJob.getPrinterJob(): Retrieves the system default print job instance and automatically binds to the machine’s default printer.
paper.setImageableArea(): Resets the paper printable area and removes default margin padding, preventing incomplete PDF output or excessive white space on printed pages.
printerJob.print(): Triggers the print job directly with no interactive dialog, ideal for automated printing workflows.

3. Scenario 2: Printing with Dialog Popup (Manual Printer Configuration)

This scenario is suitable for cases where users need to select printers and adjust print parameters . After the program starts, the native system print dialog opens. Users may switch printers, set print copies, page ranges, portrait/landscape orientation and other parameters before confirming to print.

Core implementation logic: Based on the silent printing logic, add a print dialog check. The print job will only execute after user confirmation, offering greater flexibility.

Full Runnable Code

import com.spire.pdf.PdfDocument;
import java.awt.print.PageFormat;
import java.awt.print.Paper;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
/**
 * PDF Printing with Dialog (Manual Printer Selection & Parameter Configuration)
 */
public class PrintWithPrintDialog {
    public static void main(String[] args) {
        // 1. Initialize print job
        PrinterJob printerJob = PrinterJob.getPrinterJob();
        // 2. Configure print page and paper format
        PageFormat pageFormat = printerJob.defaultPage();
        Paper paper = pageFormat.getPaper();
        paper.setImageableArea(0, 0, pageFormat.getWidth(), pageFormat.getHeight());
        pageFormat.setPaper(paper);
        // 3. Load local PDF file
        PdfDocument pdf = new PdfDocument();
        pdf.loadFromFile("input.pdf");
        // 4. Bind PDF document and print format
        printerJob.setPrintable(pdf, pageFormat);
        // 5. Bring up system print dialog and check user confirmation
        if (printerJob.printDialog()) {
            try {
                // Execute printing after user confirmation
                printerJob.print();
                System.out.println("PDF print job with dialog completed");
            } catch (PrinterException e) {
                e.printStackTrace();
                System.err.println("PDF printing with dialog failed: " + e.getMessage());
            }
        } else {
            System.out.println("User cancelled the print job");
        }
    }
}

Key Code Explanations

printerJob.printDialog(): Launches the native system print dialog and returns a boolean value. true means the user confirms printing; false means the user cancels.
All print parameters (printer selection, copy count, page numbers) are configured via the system dialog instead of hardcoding in code, accommodating diverse printing requirements.
Custom printable area configuration is retained to ensure complete and intact PDF print layout.

4. Common Issues and Notes

4.1 File Path Compatibility

The example uses Windows absolute paths. When deployed on Linux or macOS, modify the paths to match the target operating system and ensure the application has read permissions for the PDF file.

4.2 Incomplete Printed Content / Excessive White Margins

The primary solution is the paper.setImageableArea() method shown in code. It resets the printable area and overrides default system margin restrictions to match the original PDF dimensions.

4.3 Print Exception Handling

PrinterException is caught in the code, which can capture printing failures such as offline printers, out-of-paper status, or corrupted files, enabling business-layer alerting and logging.

5. Summary

This article implements two core PDF printing solutions in Java using the native java.awt.print API together with Spire.PDF:

Silent Printing : No dialog window, fully automatic execution for background automated printing tasks.
Dialog-Based Printing : Supports manual parameter configuration with high flexibility for user-initiated printing on the frontend.

Both code samples are concise, reusable and free of redundant logic. They can be directly adopted in Java desktop and backend projects. The implementation solves the core limitation that native Java cannot print PDFs directly while ensuring reliable and complete print layout rendering.

Extracting Table Data from PDFs Using Python

Jack9012 — Sat, 10 Oct 2026 01:33:31 +0000

PDF is one of the most common document formats in daily work, but its "tables" are a different thing from tables in Excel: a PDF file itself does not store structured table data. A table on a page is merely a visual effect presented by text and lines according to their positional relationships. Therefore, reading PDF tables programmatically is essentially about letting a library analyze the page layout and identify the structure of rows and columns.

This article uses Spire.PDF for Python's PdfTableExtractor to demonstrate how to detect tables in a PDF page by page and read each cell as text. The overall process has only three steps: load the document → extract tables page by page → iterate through rows and columns to read cells.

1. Environment Setup

Install the library via pip:

pip install Spire.PDF

If you are just learning or handling small documents, you can also install the free version:

pip install Spire.Pdf.Free

Note that the free version has a page limit when loading and processing PDFs (at most the first 10 pages). Documents longer than 10 pages need to be split before processing, or you need to use the full PyPI version.

2. Core Code

from spire.pdf import PdfDocument, PdfTableExtractor

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

# Create a PdfTableExtractor object
table_extractor = PdfTableExtractor(pdf)

# Extract tables from each page
for i in range(pdf.Pages.Count):
    tables = table_extractor.ExtractTable(i)
    for table_index, table in enumerate(tables):
        print(f"Table {table_index + 1} on page {i + 1}:")
        for row in range(table.GetRowCount()):
            row_data = []
            for col in range(table.GetColumnCount()):
                text = table.GetText(row, col).replace("\n", " ")
                row_data.append(text.strip())
            print("\t".join(row_data))

3. Step-by-Step Code Explanation

1. Load the PDF document

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

PdfDocument is the document entry object. LoadFromFile() loads the PDF by passing in the file path. The file path can be either relative or absolute.

2. Create the table extractor

table_extractor = PdfTableExtractor(pdf)

PdfTableExtractor is responsible for analyzing the layout page by page and detecting table structures. When constructing it, you need to pass in the already loaded PdfDocument object.

3. Extract tables page by page

for i in range(pdf.Pages.Count):
    tables = table_extractor.ExtractTable(i)

pdf.Pages.Count is the total number of pages in the document, and ExtractTable(i) returns all tables detected on page i. Note that it returns a list — a single page may contain multiple tables at the same time; if there are no tables on that page, it returns an empty list.

4. Iterate through the table's rows and columns

for row in range(table.GetRowCount()):
    row_data = []
    for col in range(table.GetColumnCount()):
        text = table.GetText(row, col).replace("\n", " ")
        row_data.append(text.strip())
    print("\t".join(row_data))

GetRowCount() / GetColumnCount() get the number of rows and columns in the table;
GetText(row, col) reads the text of the specified cell. A cell may contain line breaks; here \n is replaced with a space, and then strip() removes leading and trailing whitespace to avoid extra blank lines in the output;
Finally, \t (tab) is used to join the cells of a row for output, making it easy to copy into Excel or use as TSV.

4. Running Effect

Running the above code on a PDF containing a simple table produces output roughly as follows:

Table 1 on page 1:
Name    Department  Salary
Zhang San   Technical Department    12000
Li Si   Marketing Department    9800
Wang Wu Finance Department  10500

Each line corresponds to a row in the table, and cells are separated by tabs, so it can be pasted directly into spreadsheet software.

5. Advanced: Save the Results as CSV

Printing to the console is only suitable for quick viewing. If you want to save the results, you can use Python's built-in csv module, with no need to install an additional library:

import csv
from spire.pdf import PdfDocument, PdfTableExtractor

pdf = PdfDocument()
pdf.LoadFromFile("input.pdf")
extractor = PdfTableExtractor(pdf)

with open("output.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    for i in range(pdf.Pages.Count):
        for table in extractor.ExtractTable(i):
            for row in range(table.GetRowCount()):
                row_data = [
                    table.GetText(row, col).replace("\n", " ").strip()
                    for col in range(table.GetColumnCount())
                ]
                writer.writerow(row_data)

pdf.Close()

When writing with csv.writer, the program automatically handles special characters such as commas and quotation marks contained in cells, which is more reliable than manually concatenating strings.

6. Notes and Limitations

1. Suitable for tables with clear borders. PdfTableExtractor relies on analyzing the page layout. It recognizes tables with clear borders and regular structures relatively well; for tables without visible borders, cells spanning multiple lines, or complex layouts where headers are not clearly identified, it may fail to detect them or produce incomplete structures.

2. Scanned documents require OCR first. If the PDF is a scanned image (without a text layer), no text-based tool can directly read the content. You need to use OCR first to convert the image into text. This library does not provide OCR functionality.

3. Page limit of the free version. The free version can process at most the first 10 pages. When handling long documents, it is recommended to add a min(pdf.Pages.Count, 10) limit in the loop, or split the document by page.

4. Release resources after use. When batch processing a large number of files, remember to call pdf.Close() at the end to release resources.

7. Other Optional Libraries

If you encounter complex tables that Spire.PDF cannot handle, you can try the following open-source libraries as supplements:

pdfplumber : Based on pdfminer.six, it provides finer-grained access to page objects and is suitable for handling complex layouts;
camelot : Identifies structures by detecting table lines and works well for bordered tables;
tabula-py : Wraps Java's tabula, and its output is directly compatible with pandas DataFrame.

In actual projects, you can combine them according to the table type: regular tables can be handled by any library, while for complex ones, it is better to test on a small sample first before choosing.

8. Summary

The process of extracting PDF tables with Spire.PDF for Python is very straightforward: load the document → create PdfTableExtractor → call ExtractTable() page by page → iterate through rows and columns to read cells. It is suitable for handling bordered, clearly structured tables, and with the csv module, the results can be saved to disk. For special cases such as borderless tables and scanned documents, OCR or other libraries are needed as supplements.

Downloading PDF Documents from URLs with Python

Jack9012 — Thu, 08 Oct 2026 01:31:01 +0000

In scenarios such as automated office work, document collection, and batch resource fetching, it is often necessary to download PDF files from the network programmatically. Directly writing the binary stream returned by an interface to a local file can easily lead to corrupted files or format anomalies. This article uses requests to handle network requests, combined with Spire.PDF for .NET to complete PDF stream validation and persistent saving, providing a ready-to-run download solution with built-in file validity checking.

1. Installing Environment Dependencies

1.1 Network Request Library: requests

Used to make HTTP requests and retrieve remote PDF binary data:

pip install requests

1.2 PDF Processing Library

This example relies on this library for in-memory stream loading, PDF validation, and local file export. The installation command is as follows:

pip install spire.pdf

2. Complete Runnable Code

import requests
from spire.pdf import *

def download_pdf_from_url():
    # Specify the remote PDF resource URL
    url = "resource/sample.pdf"

    # Send a GET request to fetch the file's binary data
    response = requests.get(url)
    # Automatically raise 4xx/5xx HTTP errors to catch dead links and server issues in advance
    response.raise_for_status()
    # Wrap the downloaded byte data as an in-memory stream
    stream = Stream(response.content)
    # Load the PDF document from the memory stream, automatically validating whether the file is a legitimate PDF
    document = PdfDocument(stream)
    # Save the validated PDF to a local file
    document.SaveToFile("Downloaded.pdf")
    # Close the document to release memory resources
    document.Close()
    print("PDF downloaded and saved successfully!")

if __name__ == "__main__":
    download_pdf_from_url()

3. Line-by-Line Code Breakdown

3.1 Module Imports

import requests
from spire.pdf import *

requests: a general-purpose Python HTTP library, responsible for remote file downloads;
The PDF-related namespace: from Spire.PDF for .NET, providing full capabilities for stream reading and PDF document operations.

3.2 Remote Request and Exception Handling

response = requests.get(url)
response.raise_for_status()

raise_for_status() is crucial fault-tolerant logic: when a link returns 404, the server returns 500, or access is denied, the program throws an exception directly instead of generating a corrupted blank file.

3.3 Loading the PDF from a Memory Stream (Core Advantage)

The conventional download logic directly uses open to write the byte stream to a file, without being able to determine whether the returned data is a valid PDF.

This solution first converts the binary data returned by the interface into a Stream, then hands it to PdfDocument for loading:

Automatically validates whether the data stream conforms to the PDF standard;
Filters out anomalies such as interrupted downloads and HTML error pages returned in place of the file;
Processes everything in memory, without generating temporary cache files.

3.4 Saving the File and Releasing Resources

SaveToFile supports custom output locations via relative or absolute paths. After processing, call Close() to release the memory occupied by the document, which effectively prevents memory overflow during long batch download loops.

4. Practical Usage Notes

URL requirements In the example, resource/sample.pdf is a relative resource path; in production, replace it with a full http/https public PDF link. For private links requiring login authentication or Cookie validation, add the headers and cookies parameters to requests.get.
Extended exception handling The basic code only intercepts HTTP errors. In a production environment, it is recommended to wrap the logic in try except to catch exceptions such as PDF parsing failures and insufficient file-write permissions:

   try:
       # Complete download logic
   except requests.exceptions.RequestException as http_err:
       print(f"Network request failed: {http_err}")
   except Exception as pdf_err:
       print(f"PDF processing failed, the file may be corrupted: {pdf_err}")

Batch download adaptation Store multiple PDF URLs in a list, call download_pdf_from_url in a loop, and modify the output file names to avoid overwriting, enabling batch archiving of remote PDFs.

5. Summary

This download solution combines the network capabilities of requests with Spire.PDF for .NET's PDF parsing capabilities. Its biggest highlight is validating file legitimacy at download time, solving the pain point of ordinary download methods easily producing corrupted PDFs. The code is compact and highly extensible, making it suitable for various development scenarios such as script automation, backend document synchronization, and crawler resource collection.

DEV Community: Jack9012

Convert Markdown to PDF in Python: Basic Conversion and Page Setup

1. Install the Dependency and Prepare a Sample File

2. Convert a Markdown File Directly to PDF

3. Customize Page Settings Before Conversion

4. What Should You Check After Conversion?

5. Summary

Reorder PDF Pages in C#: Custom Page Order and Full Document Reversal

1. Install Spire.PDF for .NET

2. Understand Page Indices and the Ordering Array

3. Reorder PDF Pages in a Custom Sequence

4. Reverse the Page Order of an Entire PDF

5. Practical Considerations

1. Page Order and Printed Page Numbers Are Different

2. Match the Custom Array to the Actual Page Count

3. Use Different Input and Output Paths

4. Distinguish Example Code from Production Code

6. Conclusion

PDF Attachments with Python: Embed Files and Extract Them

How Do PDF Attachments Differ from Page Content?

Environment Setup

1. Add Attachments to a PDF

Code Example

Code Explanation and Checking the Result

2. Extract Attachments from a PDF

Code Example

Code Explanation and Checking the Result

Details to Consider When Extracting Attachments

Frequently Asked Questions

Conclusion

Working with PDF Metadata in C#: A Complete Guide to Setting and Extracting Document Properties

Environment Setup

Set PDF Document Properties

Read PDF Document Properties

Implementation Notes

Conclusion

Sorting Excel Data with Python: Three Scenarios and Implementations

1. Environment Setup and a Shared Prerequisite

Install and Import the Library

Convert Formulas to Static Values Before Sorting

2. Three Sorting Scenarios

Scenario 1: Sort a Single Column

Scenario 2: Sort an Entire Table by a Specific Column

Scenario 3: Sort by a Custom Sequence

3. Comparing the Three Scenarios

4. Conclusion

Import Word Table Data into Excel Using Python

Install the Required Libraries

How the Conversion Works

Complete Code Example

Key Details in the Code

Cases Not Covered

When to Use This Approach

Add Page Numbers to PDF Footers Using Python

Prerequisites

Understanding the Two Dynamic Fields

Control the Format with PdfCompositeField

Complete Code: Centered Footer with “Page X of Y”

Customize the Page Number Format

Format 1: Current Page Only — Page X

Format 2: Compact Numeric Format — X / Y

Format 3: Current Page and Total Pages — Page X / Total Y Pages

Format 4: Total Page Count Only — Total Y Pages

Customize the Position with Coordinates

Things to Keep in Mind

Conclusion

Convert HTML to PDF in C#: A Chrome-Based Approach

Environment Setup

Install Spire.PDF for Python

Locate the Chrome Executable

Complete C# Code Example

Understanding the Code

1. ChromeHtmlConverter

2. ConvertOptions

3. ConvertToPdf()

Advantages and Limitations

Advantages

Limitations

Common Issues and Troubleshooting

1. Conversion Fails Because of a Chrome Process Conflict

Format 1: Current Page Only — `Page X`

Format 2: Compact Numeric Format — `X / Y`

Format 3: Current Page and Total Pages — `Page X / Total Y Pages`

Format 4: Total Page Count Only — `Total Y Pages`