Jelizaveta

Предварительные требования

Перед тем, как погрузиться в код, убедитесь, что у вас есть следующее:

1. Установленный Python на вашем компьютере.

2. Библиотека Free Spire.Doc для Python . Вы можете установить её с помощью pip:
   bash

   pip install spire.doc.free

3. Текстовый редактор или IDE для написания кода на Python.

4. Примерные файлы DOCX и TXT для тестирования.

Конвертация DOCX в TXT на Python

Следующий код читает документ Word (Sample.docx) и сохраняет его содержимое в качестве простого текстового файла (DocxToTxt.txt).

from spire.doc import *

from spire.doc.common import *

# Создать объект Document

document = Document()

# Загрузить файл docx

document.LoadFromFile("C:/Users/Administrator/Desktop/Sample.docx")

# Сохранить файл docx в формате txt

document.SaveToFile("DocxToTxt.txt", FileFormat.Txt)

document.Close()

В этом коде:

• Создаётся объект Document для работы.

• Метод LoadFromFile используется для загрузки файла DOCX из указанного пути.

• Документ сохраняется в формате TXT с использованием метода SaveToFile.

Конвертация TXT в DOCX на Python

В зависимости от того, хотите ли вы применить форматирование программно, вы можете конвертировать текстовый файл (TXT) в файл DOCX, используя один из следующих двух методов:

Метод 1: Простое решение (без форматирования)

Этот базовый подход создаёт документ Word с содержимым TXT, но без специального форматирования.

from spire.doc import *

from spire.doc.common import *

# Создать объект Document

document = Document()

# Загрузить файл txt

document.LoadFromFile("C:/Users/Administrator/Desktop/Sample.txt")

# Сохранить файл txt как файл docx

document.SaveToFile("TxtToDocx.docx", FileFormat.Docx2016)

document.Close()

В этом коде:

• Создаётся объект Document.

• Файл TXT загружается с помощью метода LoadFromFile.

• Документ затем сохраняется в формате DOCX.

Метод 2: Расширенное решение (с форматированием)

Для более профессиональных результатов вы можете применить форматирование во время конвертации:

from spire.doc import *

# Функция для форматирования textRange

defformat_textRange(textRange, font_name, font_size, color):

# Установить свойства шрифта

textRange.CharacterFormat.FontName = font_name

textRange.CharacterFormat.FontSize = font_size

textRange.CharacterFormat.TextColor = color

# Чтение файла TXT и разделение на абзацы

withopen("C:/Users/Administrator/Desktop/Sample.txt", "r") as file:

content = file.read()

# Разделение содержимого на абзацы с помощью пустых строк

paragraphs = content.split('\n\n')

# Создать новый объект Document

document = Document()

section = document.AddSection()

section.PageSetup.Margins.All = 40

# Обработка каждого абзаца и добавление его в документ

for idx, para inenumerate(paragraphs):

# Удалить пробелы и пропустить пустые абзацы

para = para.strip()

ifnot para:

continue

# Создать новый абзац в документе

new_paragraph = section.AddParagraph()

text_range = new_paragraph.AppendText(para)

# Применить разные форматы в зависимости от индекса абзаца

if idx % 2 == 0: # Пример: четные абзацы

format_textRange(text_range, font_name="Times New Roman", font_size=18, color=Color.get_Red())

else: # Нечётные абзацы

format_textRange(text_range, font_name="Times New Roman", font_size=13, color=Color.get_Blue())

# Добавить пустой абзац после каждого форматированного абзаца

section.AddParagraph()

# Сохранить документ как DOCX

document.SaveToFile("TxtToFormattedDocx.docx", FileFormat.Docx2016)

document.Dispose()

В этом коде:

• Определена функция format_textRange для применения определённых свойств шрифта (название шрифта, размер и цвет) к объекту TextRange.

• Файл TXT открывается, его содержимое читается и разделяется на абзацы на основе пустых строк.

• Создаётся объект Document, и добавляется секция с указанными полями.

• Каждый абзац обрабатывается, форматируется и добавляется в документ. Чётные абзацы оформляются красным цветом и большим размером, а нечётные — синим и меньшим размером.

• Пустой абзац создаётся после каждого форматированного абзаца для улучшения читаемости.

• Наконец, документ сохраняется как файл DOCX.

Заключение

В этом посте блога мы продемонстрировали, как конвертировать DOCX в TXT для извлечения содержимого обычного текста, что делает работу с текстовыми данными более удобной без отвлекающего форматирования.

Кроме того, мы показали, как конвертировать TXT в DOCX, предлагая как базовые, так и расширенные варианты форматирования для улучшения общего представления вашего текста.

Spire.Doc для .NET — это лёгкая, высокопроизводительная сторонняя библиотека для обработки документов Word. Её главное преимущество — независимая работа без опоры на локальную среду Microsoft Office. Она поддерживает полный жизненный цикл операций с файлами Word, включая создание, чтение, редактирование, преобразование форматов, экспорт и сравнение версий.

Библиотека предоставляет простые и хорошо инкапсулированные API. Встроенная функция сравнения документов позволяет интеллектуально выявлять вставку, удаление текста и изменения форматирования. Разработчики могут реализовать сравнение версий Word профессионального уровня без написания сложной бизнес-логики, что отлично вписывается в различные сценарии разработки .NET-проектов.

2. Настройка окружения: установка компонента

Все функции сравнения в этой статье основаны на Spire.Doc для .NET. Перед написанием кода установите библиотеку через NuGet. Вы можете быстро выполнить установку через консоль диспетчера пакетов Visual Studio с помощью следующей команды:

Install-Package Spire.Doc

3. Базовое использование: создание визуальных документов с правками

Наиболее востребованный сценарий сравнения — это сопоставление исходного документа с исправленной версией и создание нового файла с полными отметками о правках. Все изменения отображаются интуитивно через встроенный в Word режим отслеживания изменений. Ниже приведён полный рабочий код на C#:

using Spire.Doc;
namespace CompareDocuments
{
class Program
{
static void Main(string[] args)
{
// Загрузка исходного базового документа
Document originalDoc = new Document("original.docx");
// Загрузка изменённого документа для сравнения
Document revisedDoc = new Document("revised.docx");
// Сравнение документов и указание автора правок
originalDoc.Compare(revisedDoc, "John");
// Сохранение результата сравнения с отметками о правках в новый файл
originalDoc.SaveToFile("Differences.docx", FileFormat.Docx2013);
// Освобождение ресурсов во избежание занятости памяти
originalDoc.Dispose();
}
}
}

Ядро кода — метод Compare(). Он автоматически анализирует различия в содержании и форматировании между двумя файлами и отмечает в исходном документе три типа изменений: вставленный текст, удалённый текст и корректировки форматирования.

Созданный файл Differences.docx можно открыть непосредственно в Microsoft Word. Он использует стандартный режим отслеживания изменений с такой же точностью, как и встроенный профессиональный инструмент сравнения документов Office.

4. Расширенное использование: извлечение структурированных деталей различий

Во многих бизнес-сценариях одних лишь визуальных файлов правок недостаточно. Нам необходимо программно получать точные структурированные данные о различиях — для таких задач, как создание журналов аудита, синхронизация изменений с базами данных, построение пользовательских отчётов о сравнении или интеграция с бизнес-процессами согласования.

Spire.Doc предоставляет класс DifferRevisions для отдельного извлечения всего вставленного и удалённого текстового содержимого, что позволяет структурированно анализировать результаты сравнения. Полный код реализации выглядит так:

using Spire.Doc;
using Spire.Doc.Fields;
using System;
namespace GetDifferencesInList
{
class Program
{
static void Main(string[] args)
{
// Загрузка исходного и изменённого документов
Document originalDoc = new Document("original.docx");
Document revisedDoc = new Document("revised.docx");
// Выполнение сравнения для генерации данных о правках
originalDoc.Compare(revisedDoc, "Author");
// Разбор всех записей о правках
DifferRevisions revisions = new DifferRevisions(originalDoc);
// Получение коллекций правок вставки и удаления
var insertRevisions = revisions.InsertRevisions;
var deleteRevisions = revisions.DeleteRevisions;
int insertCount = 0;
int deleteCount = 0;
// Обход и вывод всего добавленного содержимого
Console.WriteLine("Список добавленного содержимого");
for (int i = 0; i < insertRevisions.Count; i++)
{
if (insertRevisions[i] is TextRange textRange)
{
insertCount++;
Console.WriteLine($"Вставка #{insertCount}: {textRange.Text.Trim()}");
}
}
Console.WriteLine("=====================");
// Обход и вывод всего удалённого содержимого
Console.WriteLine("Список удалённого содержимого");
for (int i = 0; i < deleteRevisions.Count; i++)
{
if (deleteRevisions[i] is TextRange textRange)
{
deleteCount++;
Console.WriteLine($"Удаление #{deleteCount}: {textRange.Text.Trim()}");
}
}
Console.ReadKey();
}
}
}

Этот код точно отфильтровывает значимые текстовые изменения и исключает влияние незначащего форматирования. Разработчики могут выполнять вторичную обработку извлечённых данных о различиях — это основа для создания автоматизированных систем проверки документов и интеллектуального сравнения.

5. Основные сценарии применения и преимущества

Автоматизированная функция сравнения документов Word на основе Spire.Doc способна заменить неэффективное ручное сравнение, значительно повышая эффективность офисной работы и разработки, и применима в различных отраслях и бизнес-сценариях:

5.1 Проверка юридических контрактов

Юридическим отделам и корпоративным юристам часто требуется сравнивать несколько версий контрактов и соглашений. Этот инструмент позволяет одним нажатием создавать полные отчёты о правках, точно фиксируя добавления, удаления и изменения формулировок в пунктах, что эффективно снижает контрактные риски и повышает эффективность проверки.

5.2 Совместная работа над технической документацией в команде

Требования к продуктам, технические руководства и API-документация обычно обновляются совместно несколькими членами команды. Программное сравнение позволяет автоматически отслеживать изменения каждого, делая модификации документов отслеживаемыми и доступными для статистического анализа.

5.3 Управление итерациями версий документов

Для долгосрочно поддерживаемых документов, таких как управленческие политики, проектные планы и официальные уведомления, регулярное автоматическое сравнение различных версий позволяет полностью записывать весь процесс итераций, обеспечивая стандартизированное архивирование версий и полную отслеживаемость изменений.

5.4 Отраслевой комплаенс-аудит

В регулируемых отраслях, включая финансы, здравоохранение и государственное управление, предъявляются строгие требования к аудиту изменений в документах. Автоматизированное сравнение позволяет сохранять каждую запись об изменении в полном объёме, соответствуя стандартам проверки соблюдения требований и отслеживаемости.

6. Советы по разработке и оптимизация производительности

Spire.Doc обеспечивает стабильную совместимость и производительность обработки даже для больших файлов Word. Для обеспечения стабильности программы обратите внимание на следующие ключевые моменты при разработке:

6.1 Стандартизация управления памятью

Сравнение документов потребляет определённые системные ресурсы, особенно при пакетной обработке файлов или больших документов. Рекомендуется активно вызывать метод Dispose() после каждой операции для освобождения ресурсов и избежания накопления памяти, которое может привести к зависанию или сбоям программы.

6.2 Унификация форматов документов

Старайтесь, чтобы оба сравниваемых файла были в формате .docx. Избегайте смешивания форматов .doc и .docx, так как это может вызвать исключения при разборе или неточные результаты сравнения.

6.3 Стандартизация информации об авторе правок

Параметр автора в методе Compare будет отображаться в записях о правках. В официальных бизнес-сценариях указывайте фактического оператора или название отдела, чтобы облегчить последующую проверку ответственности и отслеживаемость изменений.

7. Заключение

С помощью Spire.Doc для .NET разработчики могут реализовать полностью автоматизированное сравнение документов Word с минимальным объёмом кода. Поддерживается как создание интуитивно понятных визуальных файлов правок, так и детализированное структурированное извлечение данных о различиях, что полностью решает проблему низкой эффективности и высокой вероятности ошибок при ручном сравнении.

Эта возможность сравнения может не только удовлетворять базовые потребности в сопоставлении документов, но и служить основой для разработки интеллектуальных платформ управления документами, автоматизированных офисных систем и систем комплаенс-аудита. Помимо сравнения документов, Spire.Doc также поддерживает редактирование документов, преобразование форматов, объединение, разделение, добавление водяных знаков и множество других функций, охватывая большинство потребностей в доработке документов Word.

Представьте, что вы аналитик данных, которому нужно каждую неделю создавать 20-страничный отчет в PowerPoint. Каждая страница содержит различные диаграммы, таблицы и изображения, полученные из последних данных. Выполнение этой задачи вручную отнимает много времени, чревато ошибками и носит повторяющийся характер.

Python предлагает решение. С помощью Free Spire.Presentation for Python вы можете автоматизировать весь процесс — программно создавать презентации, заполнять их данными и сохранять в различных форматах, даже не открывая Microsoft Office.

Эта статья проведет вас через основные возможности Spire.Presentation для создания автоматизированных отчетов: таблицы, диаграммы и изображения. Прочитав ее до конца, вы получите базовые компоненты для создания собственных динамических отчетов PowerPoint.

Часть 1: Настройка окружения

Что такое Free Spire.Presentation for Python?

Free Spire.Presentation for Python — это автономная библиотека для создания, чтения и изменения файлов PowerPoint. Она не требует установки Microsoft Office или каких-либо других зависимостей. Основные возможности включают:

• Создание презентаций с нуля или из шаблонов

• Добавление текста, изображений, таблиц, диаграмм и фигур

• Настройку шрифтов, цветов, фонов и макетов

• Экспорт в форматы PPT, PPTX, PDF или изображения

Установка

Установите библиотеку с помощью pip:

pip install spire.presentation.free

Ваша первая программа: Создание пустой презентации

Начнем с простого примера "Hello World":

from spire.presentation.common import *
from spire.presentation import *
# Создание объекта Presentation
presentation = Presentation()
# Установка размера слайда на широкоэкранный
presentation.SlideSize.Type = SlideSizeType.Screen16x9
# Добавление нового слайда (по умолчанию уже существует один слайд)
presentation.Slides.Append()
# Сохранение документа
presentation.SaveToFile("BlankPresentation.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Этот код создает пустой файл PowerPoint с двумя слайдами.

Часть 2: Работа с таблицами

Таблицы необходимы для представления структурированных данных в отчетах. Spire.Presentation позволяет легко создавать и стилизовать таблицы.

Создание базовой таблицы

Следующий код добавляет таблицу на первый слайд:

# Получение первого слайда
first_slide = presentation.Slides[0]
# Определение ширины столбцов и высоты строк
widths = [200, 200, 200]
heights = [18, 18, 18, 18]
# Определение данных таблицы
data = [
["Slide Number", "Title", "Content Type"],
["1", "Introduction", "Text/Image"],
["2", "Project Overview", "Chart/Graph"],
["3", "Key Findings", "Text/List"]
]
# Добавление таблицы на слайд с координатами (30, 60)
table = first_slide.Shapes.AppendTable(30, 60, widths, heights)
# Заполнение ячеек таблицы данными
for row_num, row_data in enumerate(data):
for col_num, cell_data in enumerate(row_data):
cell = table[col_num, row_num]
cell.TextFrame.Text = cell_data
# Форматирование текста
text_range = cell.TextFrame.Paragraphs[0].TextRanges[0]
text_range.LatinFont = TextFont("Times New Roman")
text_range.FontHeight = 20
cell.TextFrame.Paragraphs[0].Alignment = TextAlignmentType.Center
# Применение встроенного стиля таблицы
table.StylePreset = TableStylePreset.MediumStyle2Accent1

Метод AppendTable принимает координаты X и Y, ширину столбцов и высоту строк. Свойство StylePreset применяет предопределенные стили для придания таблице профессионального вида.

Часть 3: Работа с диаграммами

Диаграммы оживляют данные. Spire.Presentation поддерживает различные типы диаграмм, включая гистограммы, линейчатые, круговые и многие другие.

Создание диаграммы

Вот как добавить гистограмму на слайд:

# Получение первого слайда
slide = presentation.Slides[0]
# Добавление кластеризованной гистограммы
rect = RectangleF.FromLTRB(40, 80, 700, 450)
chart = slide.Shapes.AppendChartInit(ChartType.ColumnClustered, rect, False)
# Установка заголовка диаграммы
chart.ChartTitle.TextProperties.Text = "Sales by Region"
chart.ChartTitle.TextProperties.IsCentered = True
chart.ChartTitle.Height = 25
chart.HasTitle = True
# --- 1. Настройка структуры данных диаграммы ---
# Строка 0: Метки рядов (заголовки столбцов)
chart.ChartData[0,0].Text = "Region"
chart.ChartData[0,1].Text = "North"
chart.ChartData[0,2].Text = "South"
chart.ChartData[0,3].Text = "East"
chart.ChartData[0,4].Text = "West"
# Столбец 0: Метки категорий (заголовки строк)
chart.ChartData[1,0].Text = "Q1 Sales"
chart.ChartData[2,0].Text = "Q2 Sales"
# --- 2. Корректное заполнение всех значений данных ---
# Данные о продажах: [Продажи Q1, Продажи Q2] для каждого региона
sales_data = {
"North": [120, 85],
"South": [150, 95],
"East": [110, 130],
"West": [90, 105]
}
# Индекс столбца для каждого региона (от 1 до 4)
region_columns = {"North": 1, "South": 2, "East": 3, "West": 4}
# Заполнение данных: строки 1 и 2 соответствуют Q1 и Q2
for region, col_index in region_columns.items():
# Продажи Q1 (строка 1)
chart.ChartData[1, col_index].NumberValue = sales_data[region][0]
# Продажи Q2 (строка 2)
chart.ChartData[2, col_index].NumberValue = sales_data[region][1]
# --- 3. Установка рядов данных и категорий диаграммы ---
# Установка меток рядов (названия регионов в строке 0, столбцы 1-4)
chart.Series.SeriesLabel = chart.ChartData["B1","E1"]
# Установка меток категорий (Q1, Q2 в столбце 0, строки 1-2)
chart.Categories.CategoryLabels = chart.ChartData["A2","A3"]
# Установка значений для каждого ряда (каждый ряд соответствует региону)
# Ряд 0: Север (столбец B, строки 1-2)
chart.Series[0].Values = chart.ChartData["B2","B3"]
# Ряд 1: Юг (столбец C, строки 1-2)
chart.Series[1].Values = chart.ChartData["C2","C3"]
# Ряд 2: Восток (столбец D, строки 1-2)
chart.Series[2].Values = chart.ChartData["D2","D3"]
# Ряд 3: Запад (столбец E, строки 1-2)
chart.Series[3].Values = chart.ChartData["E2","E3"]
# --- 4. Настройка внешнего вида диаграммы ---
# Установка ширины промежутка между столбцами
chart.GapWidth = 350
# Установка перекрытия между рядами (отрицательное значение означает отсутствие перекрытия)
chart.OverLap = -50
# Установка цвета заливки для каждого ряда
chart.Series[0].Fill.FillType = FillFormatType.Solid
chart.Series[0].Fill.SolidColor.Color = Color.get_CadetBlue()
chart.Series[1].Fill.FillType = FillFormatType.Solid
chart.Series[1].Fill.SolidColor.Color = Color.get_LightBlue()
chart.Series[2].Fill.FillType = FillFormatType.Solid
chart.Series[2].Fill.SolidColor.Color = Color.get_Orange()
chart.Series[3].Fill.FillType = FillFormatType.Solid
chart.Series[3].Fill.SolidColor.Color = Color.get_LightGreen()
# Добавление подписей данных для всех рядов
for series in chart.Series:
for i in range(2): # Две категории: Q1 и Q2
series.DataLabels.Add()

Как это работает

Создание диаграммы с помощью Spire.Presentation требует понимания ее базовой модели данных, которая функционирует как миниатюрная электронная таблица.

1. Сетка ChartData

Свойство ChartData предоставляет доступ к двумерной сетке ячеек, индексируемой как [строка, столбец]. Вы заполняете эту сетку своими данными, различая текст (для меток) и числа (для значений).

2. Определение структуры данных

В нашем примере мы структурируем данные следующим образом:

• Строка 0 : Содержит метки рядов (заголовки столбцов), которые являются названиями регионов.

• Столбец 0 : Содержит метки категорий (заголовки строк), которые являются названиями кварталов.

• Ячейки (1,1) - (2,4) : Содержат собственно числовые данные о продажах.

Эта структура напоминает стандартную таблицу Excel, что делает ее интуитивно понятной для организации.

3. Сопоставление данных с элементами диаграммы

После заполнения сетки вы должны явно указать диаграмме, какие диапазоны использовать для трех ее основных компонентов:

# 1. Метки рядов: имена рядов данных (например, "North", "South")
# Берется текст из строки 0, столбцы с 1 по 4.
chart.Series.SeriesLabel = chart.ChartData["B1","E1"]
# 2. Метки категорий: имена категорий (например, "Q1 Sales", "Q2 Sales")
# Берется текст из столбца 0, строки с 1 по 2.
chart.Categories.CategoryLabels = chart.ChartData["A2","A3"]
# 3. Значения рядов: фактические точки данных для каждого ряда.
# Каждый ряд получает свой собственный диапазон.
# Ряд 0 ("Север") берет числовые значения из столбца B, строки с 1 по 2.
chart.Series[0].Values = chart.ChartData["B2","B3"]

Строки диапазонов (например, "B1","E1") похожи на нотацию Excel и определяют прямоугольный блок ячеек.

4. Настройка внешнего вида диаграммы

Помимо привязки данных, вы можете значительно улучшить читаемость и визуальную привлекательность диаграммы:

• Цвета : Назначьте различные цвета каждому ряду с помощью chart.Series[i].Fill.SolidColor.Color.

• Подписи данных : Добавьте числа над каждым столбцом с помощью series.DataLabels.Add().

• Макет : Настройте расстояние между столбцами с помощью chart.GapWidth и перекрытие между рядами с помощью chart.OverLap.

Часть 4: Работа с изображениями и фигурами

Изображения и фигуры делают отчеты более привлекательными визуально. Вы можете вставлять изображения, устанавливать фоны и объединять фигуры в группы.

Вставка изображения

# Получение первого слайда
first_slide = presentation.Slides[0]
# Загрузка файла изображения
image_path = r"C:\Users\Administrator\Desktop\image.png"
stream = Stream(image_path)
image_data = presentation.Images.AppendStream(stream)
# Установка размера и положения
width = image_data.Width * 0.8
height = image_data.Height * 0.8
rect = RectangleF.FromLTRB(50, 50, 50 + width, 50 + height)
# Вставка изображения
image = first_slide.Shapes.AppendEmbedImageByImageData(
ShapeType.Rectangle, image_data, rect)
image.Line.FillType = FillFormatType.none # Удаление границы

Метод AppendEmbedImageByImageData встраивает изображение на слайд в указанном месте и с указанным размером.

Установка фонового изображения

Вы также можете установить изображение в качестве фона слайда:

background = first_slide.SlideBackground
background.Type = BackgroundType.Custom
background.Fill.FillType = FillFormatType.Picture
background.Fill.PictureFill.FillType = PictureFillType.Stretch
background.Fill.PictureFill.Picture.EmbedImage = image_data

Это растягивает изображение, чтобы заполнить весь слайд.

Часть 5: Важные замечания и лучшие практики

Ограничения бесплатной версии

Бесплатная версия Spire.Presentation для Python имеет два основных ограничения:

• Ограничение на количество страниц : Вы можете создавать презентации только до 10 страниц

• Ограничение на конвертацию : Экспорт в PDF, изображения или XPS поддерживает только первые 3 страницы

Для производственного использования рассмотрите возможность обновления до коммерческой версии для снятия этих ограничений.

Управление ресурсами

Всегда вызывайте Dispose() после сохранения презентации, чтобы освободить системные ресурсы:

presentation.SaveToFile("output.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Советы по производительности

• Используйте абсолютные пути к файлам при загрузке изображений или шаблонов, чтобы избежать проблем с разрешением путей

• Оборачивайте файловые операции в блоки try-except для корректной обработки отсутствующих файлов

• Для больших отчетов рассмотрите возможность обработки слайдов партиями для управления использованием памяти

Заключение

Free Spire.Presentation предоставляет полный набор инструментов для автоматизации создания отчетов PowerPoint. В этой статье мы рассмотрели три основных строительных блока:

1. Таблицы — для представления структурированных данных с настраиваемыми стилями

2. Диаграммы — для визуализации тенденций и сравнений

3. Изображения — для добавления визуальных элементов и фонов

С помощью этих возможностей вы можете программно создавать презентации на основе данных, экономя бесчисленные часы ручной работы. Создаете ли вы еженедельные отчеты о продажах, ежеквартальные обзоры бизнеса или операционные панели мониторинга, автоматизация на Python делает этот процесс масштабируемым и воспроизводимым.

Начните создавать свой автоматизированный конвейер отчетности уже сегодня — установите Free Spire.Presentation и превращайте данные в презентации с помощью кода.

Сталкивались ли вы когда-нибудь с такой ситуацией: вы получаете PDF-отчёт на сотни страниц, пытаетесь переслать его коллеге, но вложение в письме превышает допустимый размер и отклоняется? Или вам нужна только конкретная глава, но приходится вручную извлекать её постранично из сотен страниц? Эти «громоздкие» файлы всегда доставляют головную боль при обмене, печати или архивировании. Решение на самом деле довольно простое — просто разделите PDF на несколько меньших файлов по требованию, и проблема решена.

В этой статье мы покажем, как использовать библиотеку Spire.PDF for Python для реализации двух основных режимов разделения с минимальным количеством кода: разделение на одностраничные PDF-файлы одним нажатием и гибкое разделение по произвольным диапазонам страниц .

Предварительные требования: настройка окружения и импорт библиотеки

Spire.PDF for Python — это профессиональный компонент для работы с PDF, который работает полностью независимо от внешних программ, таких как Adobe Acrobat, что делает его идеальным для интеграции в серверы или автоматизированные скрипты.

Команда установки:

pip install Spire.PDF

После установки импортируйте необходимые модули в начале файла с кодом, чтобы приступить к работе.

Режим 1: Разделение каждой страницы на отдельные одностраничные PDF-файлы

Если ваша бизнес-задача требует сохранить каждую страницу многодесятистраничного контракта, тендерной документации или электронной книги как отдельный PDF-файл, метод Split() является самым удобным выбором.

from spire.pdf.common import *

from spire.pdf import *

# 1. Инициализация и загрузка исходного PDF-документа

doc = PdfDocument()

doc.LoadFromFile("Sample.pdf")

# 2. Разделение: сохранение каждой страницы как независимого одностраничного PDF-файла

# {0} — это заполнитель номера страницы; второй параметр 1 указывает, что нумерация начинается с 1

doc.Split("Output/SplitDocument-{0}.pdf", 1)

# 3. Освобождение ресурсов

doc.Close()

Пояснение метода:

Полная сигнатура метода Split() — Split(string fileName, int startNumber), и его функция заключается в строго фиксированном разделении каждой страницы PDF на независимый одностраничный PDF-файл — это поведение нельзя изменить с помощью параметров.

Два параметра означают следующее:

• fileName : Путь для выходного файла и шаблон имени. {0} внутри является заполнителем, который будет автоматически заменён фактическим номером страницы при сохранении.

• startNumber : Задаёт начальный номер для заполнителя {0}. Он влияет только на нумерацию в имени файла и не имеет отношения к логике разделения .

Режим 2: Разделение по требованию путём выбора диапазонов страниц

Иногда нам не нужно разделять каждую страницу, а хочется разбить PDF на логические части. Например: Часть 1 (обложка) , Часть 2 (основной текст, главы 1–3) , Часть 3 (приложение) .

В этом случае мы можем создать несколько объектов PdfDocument и использовать метод InsertPageRange() для точного извлечения определённых страниц из исходного документа.

from spire.pdf.common import *

from spire.pdf import *

# Загрузка исходного документа

doc = PdfDocument()

doc.LoadFromFile("Sample.pdf")

# Создание трёх пустых PDF-объектов для хранения разделённого содержимого

newDoc_1 = PdfDocument()

newDoc_2 = PdfDocument()

newDoc_3 = PdfDocument()

# 1. Извлечение страницы 1 (обложка)

# Примечание: индексы страниц начинаются с 0, поэтому страница 1 соответствует индексу 0

newDoc_1.InsertPage(doc, 0)

# 2. Извлечение страниц со 2 по 4 (начало основного текста)

# Параметры InsertPageRange: (исходный_документ, начальный_индекс, конечный_индекс)

newDoc_2.InsertPageRange(doc, 1, 3)

# 3. Извлечение страниц с 5 по последнюю (оставшаяся часть)

# doc.Pages.Count получает общее количество страниц; вычитание 1 даёт индекс последней страницы

newDoc_3.InsertPageRange(doc, 4, doc.Pages.Count - 1)

# Сохранение трёх разделённых документов по отдельности

newDoc_1.SaveToFile("Output1/Split-1.pdf")

newDoc_2.SaveToFile("Output1/Split-2.pdf")

newDoc_3.SaveToFile("Output1/Split-3.pdf")

# Закрытие всех объектов документа для освобождения памяти

doc.Close()

newDoc_1.Close()

newDoc_2.Close()

newDoc_3.Close()

Правила индексации страниц (очень важно):

В Spire.PDF нумерация страниц следует общепринятому в программировании соглашению — начиная с 0 . То есть doc.Pages[0] представляет первую страницу PDF. Понимание этого критически важно для точного извлечения диапазонов:

• InsertPage(doc, 0): вставляет страницу 1.

• InsertPageRange(doc, 1, 3): вставляет страницы со 2 по 4 включительно.

• InsertPageRange(doc, 4, doc.Pages.Count - 1): начинается со страницы 5 и до физической последней страницы.

Преимущество такого подхода к разделению — его исключительная гибкость: вы можете комбинировать страницы по любым правилам или даже извлекать страницы из разных исходных файлов и объединять их в новый PDF (используя возможность InsertPage работать с разными документами).

Расширение: Разделение по фиксированным группам страниц

Стоит отметить, что метод Split() не может выполнить требование «объединять каждые N страниц в один PDF» (например, объединять каждые 2 страницы в один файл). Если вам требуется такое групповое разделение, необходимо использовать InsertPageRange в цикле для ручной реализации:

# Пример: объединение каждых 2 страниц в один PDF

group_size = 2

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

new_doc = PdfDocument()

end_index = min(i + group_size - 1, doc.Pages.Count - 1)

new_doc.InsertPageRange(doc, i, end_index)

new_doc.SaveToFile(f"Output/Group-{i // group_size + 1}.pdf")

new_doc.Close()

Рекомендации по выбору между двумя режимами

Заключение

Как показано в приведённых примерах, с помощью Spire.PDF for Python мы можем выполнять сложные задачи по разделению PDF, используя всего лишь чуть более десятка строк основного кода. Будь то пакетная обработка архивных файлов или интеграция функциональности управления документами в систему, это решение может значительно сэкономить время разработки.

Надеемся, эта статья поможет вам эффективно решать задачи по разделению PDF! Если вы столкнётесь с другими проблемами на практике, не стесняйтесь изучать их дальше.

Если вы новичок в Python и вам нужно преобразовать данные Excel в XML (для систем, API или инструментов, которые этого требуют), это руководство для вас. Мы рассмотрим два простых, подходящих для начинающих метода: Автоматическое преобразование (быстро, без лишней работы) и Пользовательское преобразование (полный контроль над структурой XML). Никаких предварительных знаний XML или продвинутого Python не требуется — просто копируйте код и следуйте инструкциям.

1. Зачем преобразовывать Excel в XML?

Excel отлично подходит для редактирования человеком, но XML является универсальным форматом для обмена данными между системами. Основные причины для преобразования:

• Кроссплатформенная совместимость : XML работает с любым программным обеспечением/API, без проблем с форматированием Excel.

• Структурированные данные : XML поддерживает иерархические связи (например, вложенные узлы), которые Excel не может четко представить.

• Интеграция систем : Многие корпоративные инструменты и веб-сервисы требуют XML для импорта/экспорта данных.

• Целостность данных : Теги XML (например, <name>Иван</name>) устраняют неоднозначность в значении данных.

2. Предварительные требования

Мы будем использовать две библиотеки Python — не волнуйтесь, их установка проста:

1. pandas: Библиотека, удобная для начинающих, для чтения файлов Excel (она превращает данные Excel в удобный для работы «DataFrame»).

2. openpyxl + xlrd: Помогают pandas читать файлы .xlsx (современный Excel) и .xls (старый Excel).

Установите их одной командой в вашем терминале/командной строке:

pip install pandas openpyxl xlrd

Всё! Вы готовы начать преобразование.

3. Метод 1: Автоматическое преобразование (без лишних хлопот, полный экспорт данных)

Метод автоматического преобразования идеален, когда вы хотите экспортировать все данные Excel в XML без лишней работы . Он берет каждый столбец и строку из вашего файла Excel и превращает их в простую структуру XML — не нужно определять теги или структуру самостоятельно.

3.1 Пример данных Excel

Давайте используем простой файл Excel (с именем data.xlsx) с информацией о клиентах. Вот как он выглядит (строки = клиенты, столбцы = детали):

3.2 Код автоматического преобразования

Этот код читает ваш файл Excel, преобразует все данные в XML и сохраняет как output_auto.xml. Я добавил подробные комментарии к каждой строке, чтобы вы точно понимали, что происходит:

import pandas as pd

import xml.etree.ElementTree as ET

def excel_to_xml_auto(excel_path, xml_save_path, sheet_name=0):

# 1. Читаем файл Excel (pandas автоматически определяет заголовки)

# fillna("") заменяет пустые ячейки на пустые строки (избегаем "NaN" в XML)

df = pd.read_excel(excel_path, sheet_name=sheet_name).fillna("")

# 2. Создаем корневой узел XML (верхнеуровневый тег)

root = ET.Element("customers") # Назовите это так, как имеет смысл для ваших данных

# 3. Проходим по каждой строке в файле Excel

for _, row in df.iterrows():

# Создаем узел "customer" для каждой строки (один на строку Excel)

customer = ET.SubElement(root, "customer")

# 4. Проходим по каждому столбцу в строке (один на столбец Excel)

for col_name in df.columns:

# Создаем тег для каждого столбца (используем заголовок Excel как имя тега)

# Заменяем пробелы в именах столбцов на подчеркивания (в XML-тегах не может быть пробелов)

field = ET.SubElement(customer, col_name.replace(" ", "_"))

# Добавляем значение ячейки в XML-тег

field.text = str(row[col_name])

# 5. Сохраняем XML-файл (с форматированием для удобочитаемости)

tree = ET.ElementTree(root)

with open(xml_save_path, "wb") as f:

tree.write(f, encoding="utf-8", xml_declaration=True, method="xml")

print(f"✅ Автоматическое преобразование выполнено! XML сохранен в: {xml_save_path}")

# ------------------- ИСПОЛЬЗОВАНИЕ ФУНКЦИИ -------------------

if __name__ == "__main__":

excel_to_xml_auto(

excel_path="data.xlsx", # Путь к ВАШЕМУ файлу Excel

xml_save_path="output_auto.xml", # Куда сохранить XML

sheet_name=0 # 0 для первого листа (или "Sheet1" по имени)

)

Когда вы запустите код, он создаст output_auto.xml со следующей структурой. Обратите внимание, как каждый столбец Excel становится тегом, а каждая строка — узлом <customer>:

3.3 Когда использовать автоматическое преобразование

Автоматическое преобразование идеально, если:

• Вам нужен быстрый способ экспортировать все данные Excel в XML.

• Вам не важна настройка структуры XML (например, имена тегов, вложенные узлы).

• Вы тестируете или нуждаетесь во временном XML-файле.

4. Метод 2: Пользовательское преобразование (полный контроль над структурой XML)

Автоматическое преобразование отлично подходит для скорости, но иногда XML должен соответствовать определенной структуре (например, для API, требования клиента или интеграции с корпоративной системой). Здесь на помощь приходит пользовательское преобразование — оно позволяет:

• Экспортировать только нужные столбцы (игнорировать ненужные данные).

• Переименовывать теги (например, использовать <full_name> вместо name из Excel).

• Добавлять вложенные узлы (например, поместить name и email внутрь узла <contact_info>).

• Добавлять атрибуты (например, <customer id="1">).

4.1 Те же данные Excel (используем тот же пример)

Мы будем использовать тот же файл data.xlsx, что и раньше — ничего менять не нужно.

4.2 Код пользовательского преобразования

Допустим, нам нужно, чтобы XML:

• Включал только name, age и email (игнорировал city).

• Переименовал name в full_name, а email в contact_email.

• Добавлял атрибут id каждому <customer> (например, <customer id="1">).

• Вкладывал full_name и contact_email внутрь узла <contact_details>.

Вот код, который это делает — снова с подробными комментариями:

import pandas as pd

import xml.etree.ElementTree as ET

def excel_to_xml_custom(excel_path, xml_save_path, sheet_name=0):

# 1. Читаем файл Excel (так же, как в автоматическом преобразовании)

df = pd.read_excel(excel_path, sheet_name=sheet_name).fillna("")

# 2. Создаем корневой узел (пользовательское имя: "customer_list")

root = ET.Element("customer_list")

# 3. Проходим по строкам (добавляем индекс для атрибута "id")

for index, row in df.iterrows():

# Создаем узел "customer" с атрибутом id (index + 1, чтобы начинать с 1, а не с 0)

customer = ET.SubElement(root, "customer", id=str(index + 1))

# 4. Добавляем вложенный узел: <contact_details>

contact_details = ET.SubElement(customer, "contact_details")

# 5. Добавляем пользовательские теги (только нужные столбцы, с пользовательскими именами)

ET.SubElement(contact_details, "full_name").text = str(row["name"])

ET.SubElement(contact_details, "contact_email").text = str(row["email"])

# 6. Добавляем age как прямой дочерний элемент "customer" (не вложенный)

ET.SubElement(customer, "age").text = str(row["age"])

# 7. Сохраняем XML-файл (так же, как в автоматическом преобразовании)

tree = ET.ElementTree(root)

with open(xml_save_path, "wb") as f:

tree.write(f, encoding="utf-8", xml_declaration=True, method="xml")

print(f"✅ Пользовательское преобразование выполнено! XML сохранен в: {xml_save_path}")

# ------------------- ИСПОЛЬЗОВАНИЕ ФУНКЦИИ -------------------

if __name__ == "__main__":

excel_to_xml_custom(

excel_path="data.xlsx",

xml_save_path="output_custom.xml"

)

Запустите код, и вы получите output_custom.xml с точно той структурой, которую мы хотели — обратите внимание на вложенные узлы, пользовательские теги и атрибут id:

4.3 Когда использовать пользовательское преобразование

Пользовательское преобразование необходимо, если:

• Вам нужно, чтобы XML соответствовал определенному формату (например, для API или клиента).

• Вы хотите исключить ненужные столбцы.

• Вам нужны вложенные узлы или атрибуты.

• Вы используете XML в рабочей среде (не только для тестирования).

5. Важные замечания для начинающих (избегайте распространенных ошибок!)

Как новичок, обратите внимание на несколько подводных камней — это сэкономит вам время и нервы:

• Обработка пустых ячеек

В файлах Excel часто встречаются пустые ячейки, которые pandas читает как NaN (Not a Number). Если не обработать это, в XML появятся значения NaN, что недопустимо в большинстве систем. Поэтому мы используем .fillna(""), чтобы заменить пустые ячейки на пустые строки.

• В тегах XML не может быть пробелов

Заголовки столбцов Excel часто содержат пробелы (например, «Full Name»), но в XML-тегах пробелы не допускаются. В коде автоматического преобразования мы используем col_name.replace(" ", "_"), чтобы исправить это (например, «Full Name» становится Full_Name).

• Преобразование всех значений в строки

В Excel есть разные типы данных (числа, даты, текст), но XML хранит только текст. Использование str(row[col_name]) преобразует все значения в строки, обеспечивая совместимость.

• Используйте правильный лист Excel

Если в вашем файле Excel несколько листов, используйте sheet_name="Sheet2" (замените на имя вашего листа) вместо sheet_name=0 (это первый лист).

• Пути к файлам имеют значение

Если ваш файл Excel не находится в той же папке, что и скрипт Python, используйте полный путь (например, excel_path="C:/Users/YourName/Documents/data.xlsx" в Windows или "/Users/YourName/Documents/data.xlsx" в Mac/Linux).

6. Ключевые идеи для начинающих

Вот несколько дополнительных советов, которые помогут вам освоить преобразование Excel в XML:

• Начните с простого : Сначала используйте метод автоматического преобразования, чтобы освоиться с процессом. Когда поймете, как Excel и XML соотносятся друг с другом, переходите к пользовательскому преобразованию.

• Тестируйте на небольших данных : Не начинайте с огромного файла Excel — используйте небольшой образец (например, наш пример с 3 строками), чтобы протестировать код. Так будет легче исправлять ошибки.

• Просматривайте вывод XML : Всегда открывайте сгенерированный XML-файл, чтобы проверить, правильно ли он выглядит. Можно использовать любой текстовый редактор (Блокнот, VS Code) или средство просмотра XML для лучшей читаемости.

• Настраивайте дальше : Вы можете добавить более продвинутые функции в пользовательский код, например:

  • Добавить схему (XSD) для проверки XML.

  • Форматировать даты (например, преобразовывать даты Excel в формат ISO 8601).

  • Фильтровать строки (например, экспортировать только клиентов старше 30 лет).

7. Итоговое резюме

Преобразование Excel в XML на Python — полезный навык для любого начинающего, работающего с данными. Подведем итог:

• Автоматическое преобразование : Быстро, просто, экспортирует все данные — идеально для тестирования или временных файлов.

• Пользовательское преобразование : Полный контроль над структурой XML — необходимо для рабочей среды или интеграции систем.

Представленный код удобен для начинающих, готов к копированию и работает с большинством файлов Excel. Немного практики — и вы сможете настроить XML под любые требования.

Шаблоны Excel имеют ряд преимуществ:

• Просты в изменении для бизнес-пользователей

• Встроенная поддержка формул и вычислений

• Привычная среда проектирования

• Не нужно жёстко прописывать макеты в коде

• Простой экспорт в PDF

Вместо того чтобы воссоздавать макет счёта в коде, вы можете позволить Excel заниматься форматированием, в то время как ваше приложение сосредоточится на предоставлении данных.

Процесс выглядит так:

Данные счёта

↓

Шаблон Excel

↓

Заполнение ячеек

↓

Пересчёт формул

↓

Экспорт в PDF

Проектирование шаблона счёта

Наш шаблон счёта содержит три раздела:

Верхняя часть счёта

Верхняя часть включает информацию о компании и реквизиты счёта.

Эти ячейки будут заполняться программно.

Позиции счёта

Раздел позиций начинается со строки 16 и реализован как таблица Excel .

Этот выбор важен, поскольку таблицы Excel предоставляют несколько встроенных возможностей:

• Автоматическое чередование цветов строк

• Автоматическое распространение формул

• Динамическое расширение таблицы

• Упрощённое обслуживание

Например:

Шаблон уже содержит формулы для расчёта итогов по строкам.

Итоговый раздел

Нижний раздел содержит формулы для:

• Промежуточного итога

• Налога

• Общего итога

Вот как выглядит мой шаблон:

Установка Free Spire.XLS для Python

Установите библиотеку с помощью pip:

pip install spire.xls.free

Загрузка шаблона счёта

Сначала загрузите шаблон Excel в книгу.

from spire.xls import *

from spire.xls.common import *

workbook = Workbook()

workbook.LoadFromFile("InvoiceTemplate.xlsx")

sheet = workbook.Worksheets[0]

На этом этапе всё форматирование, формулы и определения таблиц из шаблона доступны.

Определение данных счёта

В реальных приложениях данные счёта обычно поступают из базы данных, API или ERP-системы.

В этом примере мы сохраним данные в словаре Python.

invoice = {

"company_name": "ABC Corporation",

"address_1": "123 Main Street",

"address_2": "New York, NY 10001",

"phone": "+1 (555) 123-4567",

"invoice_number": "INV-2026-001",

"customer_id": "CUST-1001",

"items": [

{

"qty": 2,

"description": "Laptop Computer",

"unit_price": 899.00

},

{

"qty": 1,

"description": "Wireless Mouse",

"unit_price": 29.99

},

{

"qty": 3,

"description": "USB-C Cable",

"unit_price": 12.50

}

]

}

Эта структура очень похожа на данные, возвращаемые многими бизнес-системами.

Заполнение информации о счёте

Далее заполним верхнюю часть счёта.

sheet.Range["C7"].Text = invoice["company_name"]

sheet.Range["C8"].Text = invoice["address_1"]

sheet.Range["C9"].Text = invoice["address_2"]

sheet.Range["C10"].Text = invoice["phone"]

sheet.Range["E8"].Text = invoice["invoice_number"]

sheet.Range["E9"].Text = invoice["customer_id"]

Эти значения заменяют заполнители, определённые в шаблоне.

Заполнение позиций счёта

Таблица позиций начинается со строки 16.

Мы можем записать каждую позицию в рабочий лист с помощью простого цикла.

start_row = 16

for index, item in enumerate(invoice["items"]):

row = start_row + index

sheet.Range[f"B{row}"].NumberValue = item["qty"]

sheet.Range[f"C{row}"].Text = item["description"]

sheet.Range[f"D{row}"].NumberValue = item["unit_price"]

Поскольку в шаблоне уже есть формулы для столбца «Line Total», нет необходимости вычислять суммы в коде.

Excel выполняет вычисления автоматически.

Почему стоит использовать таблицу Excel для позиций счёта?

Одна из самых больших проблем при генерации счетов — обработка переменного количества товаров.

Традиционные шаблоны часто требуют от разработчиков:

• Вручную копировать формулы

• Дублировать форматирование

• Пересчитывать диапазоны

• Обновлять итоги

Таблицы Excel устраняют большую часть этой сложности.

При вставке новых строк:

• Чередование цветов строк сохраняется

• Формулы автоматически распространяются на новые строки

• Ссылки на таблицу обновляются автоматически

• Итоги продолжают работать корректно

В результате приложению нужно только сосредоточиться на вставке данных.

Такое разделение обязанностей делает код гораздо чище и проще в обслуживании.

Обработка более шести позиций счёта

Наш шаблон резервирует шесть строк для товаров.

Если счёт содержит более шести позиций, можно динамически добавить дополнительные строки.

base_rows = 6

if len(invoice["items"]) > base_rows:

sheet.InsertRow(

22,

len(invoice["items"]) - base_rows

)

Поскольку список товаров реализован как таблица Excel, новые вставленные строки автоматически наследуют форматирование и формулы таблицы.

Никакого дополнительного кода для стилизации не требуется.

Пересчёт формул

Перед экспортом пересчитайте все формулы в книге.

workbook.CalculateAllValue()

Это гарантирует, что итоги по строкам, промежуточные итоги, налоги и общие итоги будут отражать актуальные данные.

Управление макетом страницы и масштабированием PDF

Перед экспортом счёта в PDF часто стоит настроить параметры страницы рабочего листа.

Без правильной конфигурации в сгенерированном PDF могут быть большие поля, избыточные отступы или содержимое, неоправданно уменьшенное в масштабе.

Следующие настройки помогают максимально использовать полезную площадь страницы и обеспечить чистое отображение счёта.

sheet.PageSetup.LeftMargin = 0.0

sheet.PageSetup.RightMargin = 0.0

sheet.PageSetup.TopMargin = 0.0

sheet.PageSetup.BottomMargin = 0.0

# Вместить рабочий лист на одну страницу

workbook.ConverterSetting.SheetFitToPage = True

Эти настройки:

• Убирают ненужные поля

• Максимизируют доступное пространство

• Улучшают читаемость

• Дают более профессиональный вид PDF

Обработка длинных счетов

Если счёт может содержать много товаров и занимать несколько страниц, размещение всего листа на одной странице обычно нежелательно, потому что содержимое становится слишком мелким.

В этом случае настройте лист на соответствие ширине страницы, разрешив неограниченную высоту.

sheet.PageSetup.FitToPagesWide = 1

sheet.PageSetup.FitToPagesTall = 0

Это указывает Excel:

• Уместить счёт в пределах ширины одной страницы

• Автоматически создавать дополнительные страницы по вертикали при необходимости

В результате длинные счета остаются читаемыми, сохраняя исходное форматирование.

Экспорт счёта в PDF

Наконец, сохраните книгу как PDF-документ.

workbook.SaveToFile(

"Invoice.pdf",

FileFormat.PDF

)

Поскольку макет листа уже оптимизирован, экспортированный PDF сохраняет предполагаемый внешний вид счёта.

Сгенерированная PDF-счет выглядит так:

Полный пример

from spire.xls import Workbook, FileFormat

# Создание книги

workbook = Workbook()

workbook.LoadFromFile(r"C:\Users\Administrator\Desktop\invoice-template.xlsx")

# Получение рабочего листа

sheet = workbook.Worksheets[0]

# ==========================================

# Данные счёта

# ==========================================

invoice = {

"company_name": "ABC Corporation",

"address_1": "123 Main Street",

"address_2": "New York, NY 10001",

"phone": "+1 (555) 123-4567",

"invoice_number": "INV-2026-001",

"customer_id": "CUST-1001",

"items": [

{

"qty": 2,

"description": "Laptop Computer",

"unit_price": 899.00

},

{

"qty": 1,

"description": "Wireless Mouse",

"unit_price": 29.99

},

{

"qty": 3,

"description": "USB-C Cable",

"unit_price": 12.50

}

]

}

# ==========================================

# Заполнение информации о счёте

# ==========================================

# C7-C10

sheet.Range["C7"].Text = invoice["company_name"]

sheet.Range["C8"].Text = invoice["address_1"]

sheet.Range["C9"].Text = invoice["address_2"]

sheet.Range["C10"].Text = invoice["phone"]

# E8-E9

sheet.Range["E8"].Text = invoice["invoice_number"]

sheet.Range["E9"].Text = invoice["customer_id"]

# ==========================================

# Заполнение позиций счёта

# ==========================================

start_row = 16

for index, item in enumerate(invoice["items"]):

row = start_row + index

sheet.Range[f"B{row}"].NumberValue = item["qty"]

sheet.Range[f"C{row}"].Text = item["description"]

sheet.Range[f"D{row}"].NumberValue = item["unit_price"]

# ==========================================

# Пересчёт формул

# ==========================================

workbook.CalculateAllValue()

# ==========================================

# Экспорт в PDF

# ==========================================

sheet.PageSetup.LeftMargin = 0.0

sheet.PageSetup.RightMargin = 0.0

sheet.PageSetup.TopMargin = 0.0

sheet.PageSetup.BottomMargin = 0.0

# Вместить лист на одну страницу

workbook.ConverterSetting.SheetFitToPage = True

# Для длинного счёта, превышающего одну страницу, установите FitToPagesTall = 0,

# чтобы разрешить размещение на нескольких страницах по вертикали

# sheet.PageSetup.FitToPagesWide = 1

# sheet.PageSetup.FitToPagesTall = 0

workbook.SaveToFile(

"Invoice.pdf",

FileFormat.PDF

)

workbook.Dispose()

Заключение

Использование Excel в качестве движка для шаблонов счетов может значительно упростить генерацию счетов. Храня макеты, формулы и форматирование в электронной таблице, разработчики могут сосредоточиться на предоставлении данных, а не на управлении деталями представления.

Сочетание шаблона Excel с Free Spire.XLS для Python позволяет автоматизировать весь процесс — от заполнения данных счёта до создания профессиональных PDF-документов — с удивительно небольшим количеством кода.

Когда раздел позиций счёта реализован как таблица Excel, решение становится ещё более поддерживаемым. Форматирование, формулы и расширение таблицы обрабатываются автоматически, что упрощает поддержку счетов любого размера, сохраняя вашу кодовую базу чистой и простой.

Spire.Doc for .NET предлагает мощный и простой в использовании API, позволяющий создавать, редактировать и конвертировать документы без установки Microsoft Office на сервере. Он обеспечивает высокое качество преобразования:

• Сохранение стилей: полная поддержка текстовых форматов, цветов, выравнивания и других CSS-стилей из HTML.

• Обработка изображений: автоматическое распознавание и встраивание изображений из тегов <img> в HTML.

• Табличная структура: сохранение исходной вёрстки HTML-таблиц без искажений.

• Простота разработки: лаконичный API и низкий порог вхождения.

Подготовка: установка Spire.Doc

Перед началом кодирования необходимо добавить ссылку на Spire.Doc в проект. Рекомендуется выполнить установку через консоль диспетчера пакетов NuGet с помощью следующей команды:

Install-Package Spire.Doc

Сценарий 1: преобразование HTML-строки в Word

Этот сценарий очень гибок и подходит для случаев, когда HTML-содержимое получается из базы данных, API-интерфейсов или других динамических источников данных, и требуется мгновенно сгенерировать документ Word.

В приведённом ниже коде показано, как прочитать содержимое HTML-файла (в виде строки) и преобразовать его в файл .docx:

using Spire.Doc;

using Spire.Doc.Documents;

using System.IO;

namespace ConvertHtmlStringToWord

{

class Program

{

static void Main(string[] args)

{

// 1. Создание объекта Document

Document document = new Document();

// 2. Добавление раздела (Section)

Section section = document.AddSection();

// Опционально: установка полей страницы

section.PageSetup.Margins.All = 2;

// 3. Добавление абзаца (Paragraph)

Paragraph paragraph = section.AddParagraph();

// 4. Чтение HTML-строки из файла

string htmlFilePath = @"C:\Users\Administrator\Desktop\Html.html";

string htmlString = File.ReadAllText(htmlFilePath, System.Text.Encoding.UTF8);

// 5. Вставка HTML-строки в абзац

paragraph.AppendHTML(htmlString);

// 6. Сохранение в документ Word

document.SaveToFile("AddHtmlStringToWord.docx", FileFormat.Docx);

// 7. Освобождение ресурсов

document.Dispose();

}

}

}

Описание ключевых методов :

• Paragraph.AppendHTML(htmlString) — это основной метод преобразования. Он анализирует переданную HTML-строку и полностью преобразует её форматирование, изображения и структуру в содержимое абзаца Word.

• С помощью document.SaveToFile() можно указать формат вывода FileFormat.Docx.

Сценарий 2: прямое преобразование HTML-файла в Word

Если у вас уже есть готовый HTML-файл, который вы хотите напрямую преобразовать в документ Word, код будет ещё более лаконичным:

using Spire.Doc;

namespace ConvertHtmlToWord

{

class Program

{

static void Main(string[] args)

{

// 1. Создание объекта Document

Document document = new Document();

// 2. Непосредственная загрузка HTML-файла

document.LoadFromFile(@"C:\Users\Administrator\Desktop\MyHtml.html", FileFormat.Html);

// 3. Сохранение в документ Word

document.SaveToFile("HtmlToWord.docx", FileFormat.Docx);

// 4. Освобождение ресурсов

document.Dispose();

}

}

}

Этот способ позволяет выполнить преобразование за один шаг — метод Document.LoadFromFile() напрямую поддерживает загрузку файлов в формате FileFormat.Html, избавляя от необходимости вручную считывать содержимое файла.

Важные замечания

На практике следует обратить внимание на несколько аспектов, чтобы добиться наилучшего результата преобразования:

1. Поддержка CSS-стилей : Spire.Doc поддерживает большинство распространённых CSS-свойств, таких как font-size, color, text-align и др. Однако для очень сложных CSS-макетов возможны незначительные расхождения в итоговом отображении.

2. Пути к изображениям : теги <img> в HTML автоматически преобразуются в изображения в Word. Убедитесь, что пути к изображениям (как локальные, так и URL-адреса) доступны во время конвертации.

3. Табличная вёрстка : для сложных таблиц рекомендуется избегать специальных свойств вроде table-layout: fixed, чтобы обеспечить корректное отображение таблиц в Word.

4. Производительность : для больших файлов с большим объёмом содержимого или изображениями высокого разрешения рекомендуется выполнять преобразование в фоновом потоке или асинхронной задаче, чтобы не блокировать основной поток.

Заключение

С помощью Spire.Doc for .NET разработчики могут реализовать высококачественное и высокоточное взаимное преобразование HTML и Word в проектах на C#, используя минимальный объём кода. Будь то обработка динамически генерируемых HTML-строк или пакетное преобразование существующих HTML-файлов — эта библиотека предлагает стабильное и эффективное решение. Она помогает быстро выстроить автоматизированный процесс работы с документами, позволяя сосредоточиться на бизнес-логике приложения.

Каждый подход подходит для определённых сценариев и уровней сложности. Отказавшись от жёстко заданных индексов, вы сможете сделать код обработки Excel более читаемым, поддерживаемым и масштабируемым.

Предварительные требования

Во всех примерах статьи используется пакет spire.xls, который позволяет читать, записывать, форматировать и пакетно обрабатывать файлы Excel без установки Microsoft Excel.

Установите библиотеку командой:

pip install spire.xls.free

Подход 1. Хранение данных Excel в виде двумерного списка

Как это работает

Это самый простой способ чтения данных Excel. Мы последовательно перебираем используемый диапазон листа по строкам и ячейкам, сохраняя все данные в двумерный список, который полностью повторяет структуру исходной таблицы.

Полный пример

from spire.xls import Workbook

# Загружаем книгу и рабочий лист

workbook = Workbook()

workbook.LoadFromFile("SalesReport.xlsx")

sheet = workbook.Worksheets[0]

# Получаем используемый диапазон

cell_range = sheet.AllocatedRange

# Сохраняем все данные в двумерный список

excel_data = []

for row_idx in range(cell_range.RowCount):

single_row = []

for col_idx in range(cell_range.ColumnCount):

# В Spire.XLS используются индексы, начинающиеся с 1

single_row.append(

cell_range[row_idx + 1, col_idx + 1].Value

)

excel_data.append(single_row)

# Освобождаем ресурсы

workbook.Dispose()

Преимущества и недостатки

Преимущества

• Максимально простая реализация

• Полностью сохраняет исходную структуру строк и столбцов

• Не требует дополнительного преобразования данных

Недостатки

Доступ к данным осуществляется только через числовые индексы:

excel_data[row][col]

Такой код не несёт смысловой нагрузки. Если структура таблицы изменится, все ссылки на индексы придётся обновлять вручную, что усложняет поддержку и повышает риск ошибок.

Подходит для

• Быстрых прототипов

• Одноразовых скриптов

• Матричных вычислений

• Временного анализа данных

Для производственных приложений такая структура обычно не является оптимальным решением.

Подход 2. Преобразование строк в словари

Как это работает

Чтобы избавиться от жёстко заданных индексов столбцов, можно использовать первую строку как заголовки столбцов и преобразовать каждую последующую строку в словарь.

Вместо доступа к данным по позиции мы получаем доступ по имени поля. Это устраняет зависимость от порядка столбцов и значительно улучшает читаемость кода.

Полный пример

from spire.xls import Workbook

workbook = Workbook()

workbook.LoadFromFile("SalesReport.xlsx")

sheet = workbook.Worksheets[0]

cell_range = sheet.AllocatedRange

# Извлекаем заголовки из первой строки

rows = list(cell_range.Rows)

headers = [

cell_range[1, col_idx + 1].Value

for col_idx in range(cell_range.ColumnCount)

]

# Формируем список словарей

data_list = []

for row in rows[1:]: # Пропускаем строку заголовков

row_dict = {}

for idx, cell in enumerate(row.Cells):

row_dict[headers[idx]] = cell.Value

data_list.append(row_dict)

workbook.Dispose()

Преимущества и недостатки

Преимущества

Теперь данные можно получать по понятным именам полей:

data_list[0]["Sales"]

Преимущества такого подхода:

• Более высокая читаемость кода

• Независимость от порядка столбцов

• Простая сериализация в JSON

• Удобная интеграция с API и конвейерами обработки данных

• Хорошая совместимость с Pandas

Недостатки

Структуры на основе словарей по-прежнему являются слабо типизированными. Перед использованием данных может потребоваться дополнительная проверка и преобразование типов.

Подходит для

• Импорта и экспорта данных

• Очистки и подготовки данных

• Генерации полезной нагрузки для API

• Бизнес-отчётности

• Универсальной обработки Excel

Для большинства приложений это оптимальный баланс между простотой и удобством сопровождения.

Подход 3. Сопоставление строк с пользовательскими бизнес-объектами

Как это работает

При работе с фиксированными схемами данных и более сложной бизнес-логикой словари могут оказаться недостаточно удобными. Они не обеспечивают типобезопасность, поддержку IntelliSense и не предоставляют естественного места для размещения бизнес-правил.

Более надёжный подход заключается в создании класса бизнес-сущности и преобразовании каждой строки Excel в экземпляр этого класса.

В результате получается строго типизированная модель, поддерживающая валидацию, бизнес-методы и более удобные инструменты разработки.

Полный пример

# Определение бизнес-сущности

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:

"""Возвращает True, если сотрудник является совершеннолетним."""

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 = []

# Пропускаем строку заголовков

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()

Преимущества и сценарии использования

Преимущества

• Строгая типизация благодаря явному преобразованию типов

• Более качественная проверка данных

• Автодополнение и подсказки IDE

• Инкапсуляция бизнес-логики

• Улучшенная поддерживаемость кода

• Более чистый объектно-ориентированный дизайн

Например:

employee.is_adult()

Бизнес-правила могут быть реализованы непосредственно внутри сущности, а не распределены по всему приложению.

Подходит для

• Корпоративных приложений

• Стабильных и хорошо определённых схем данных

• Систем со сложными бизнес-правилами

• Долгосрочных проектов, требующих удобной поддержки

Как выбрать подходящую структуру

Оптимальный выбор зависит от сложности приложения и способа использования данных.

Заключение

Переход от:

• Числовых индексов в двумерных списках

• Семантического доступа через словари

• Строго типизированных бизнес-объектов

отражает более широкий переход от ориентированного на данные программирования к моделированию, ориентированному на бизнес-логику.

Простые скрипты не требуют сложных абстракций. Для большинства реальных задач обработки Excel список словарей обеспечивает отличный баланс между гибкостью и удобством сопровождения. Если же приложение содержит сложные бизнес-правила и использует стабильные схемы данных, пользовательские объекты-сущности становятся наиболее надёжным долгосрочным решением.

Правильный выбор структуры данных позволяет значительно снизить сложность кода, повысить его читаемость, уменьшить количество ошибок и упростить сопровождение процессов обработки Excel по мере роста проекта.