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, предлагая как базовые, так и расширенные варианты форматирования для улучшения общего представления вашего текста.

Сталкивались ли вы когда-нибудь с такой ситуацией: вы получаете 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 по мере роста проекта.

• Задача 1: Генерация документов Word из шаблонов

• Задача 2: Извлечение структурированных данных из файлов Word

• Задача 3: Сравнение двух документов Word на предмет изменений

• Задача 4: Конвертация документов Word в PDF

• Задача 5: Объединение нескольких документов Word в один

• Заключение

Задача 1: Генерация документов Word из шаблонов

Зачем это автоматизировать?

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

• Счета и квитанции

• Трудовые договоры

• Сертификаты о завершении

• Ежемесячные клиентские отчёты

Ручное редактирование каждого экземпляра — повторяющаяся и медленная задача. Используя шаблон и подставляя данные, вы можете сгенерировать сотни документов за секунды.

Рекомендуемый инструмент: python-docx-template

Эта библиотека построена на основе python-docx и интегрирует шаблонизатор Jinja2. Вы просто размещаете заполнители вида {{ customer_name }} внутри шаблона .docx, а затем визуализируете его с вашими данными.

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

• Открытый исходный код (лицензия MIT)

• Сохраняет всё форматирование шаблона

• Поддерживает циклы и условия (используя синтаксис Jinja2)

Ограничение: Очень сложная логика или вложенные таблицы могут потребовать дополнительной осторожности, но для 95% случаев использования библиотека работает безупречно.

Пример кода

Сначала установите библиотеку:

pip install python-docx-template

Создайте файл шаблона invoice_template.docx с заполнителями:

Счёт для {{ customer_name }}

Дата: {{ date }}

Итоговая сумма: ${{ total }}

Затем сгенерируйте итоговый документ:

from docxtpl import DocxTemplate

doc = DocxTemplate("invoice_template.docx")

context = {

"customer_name": "Алиса Джонсон",

"date": "2026-06-03",

"total": "1299.99"

}

doc.render(context)

doc.save("invoice_alice.docx")

Лучшие сценарии использования

• Автоматизированные системы выставления счетов

• Генерация кадровых документов

• Создание сертификатов для онлайн-курсов

Задача 2: Извлечение структурированных данных из файлов Word

Зачем это автоматизировать?

Вы часто получаете документы Word, содержащие ценные данные в таблицах, формах или результатах опросов. Копирование и вставка этих данных в базу данных или CSV-файл — утомительное занятие, чреватое ошибками. Автоматизация извлечения позволяет передавать данные напрямую в ваш конвейер обработки.

Рекомендуемый инструмент: python-docx

python-docx — это фактический стандарт для чтения и записи файлов .docx. Он предоставляет доступ к абзацам, таблицам, элементам форматирования (runs) и стилям. Хотя он не поддерживает файлы .doc (старый двоичный формат), они становятся всё более редкими.

Ограничения, о которых следует знать:

• Библиотека сначала читает все абзацы, затем все таблицы — вы не можете легко восстановить смешанный макет (текст → таблица → текст).

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

Пример кода

from docx import Document

doc = Document("survey_results.docx")

# Извлечение всех данных из таблиц

for idx, table in enumerate(doc.tables):

print(f"--- Таблица {idx+1} ---")

for row in table.rows:

row_data = [cell.text.strip() for cell in row.cells]

print(", ".join(row_data))

Если вам нужно экспортировать данные в CSV-файл:

import csv

with open("extracted_data.csv", "w", newline="", encoding="utf-8") as f:

writer = csv.writer(f)

for table in doc.tables:

for row in table.rows:

writer.writerow([cell.text.strip() for cell in row.cells])

Лучшие сценарии использования

• Перенос устаревших данных из форм Word в базу данных

• Агрегация финансовых данных из нескольких ежемесячных отчётов

• Анализ содержимого больших коллекций документов

Задача 3: Сравнение двух документов Word на предмет изменений

Зачем это автоматизировать?

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

Рекомендуемый инструмент: difflib + python-docx

Поскольку создать чистое open-source решение для получения вывода Word с отслеживанием изменений очень сложно, мы будем использовать встроенный в Python модуль difflib для сравнения необработанного текста двух документов. Это даёт вам быстрый, поддающийся скриптованию способ обнаружения различий.

Ограничения:

• Он не создаёт документ Word с отметками о правках (красной строкой).

• Он сравнивает абзацы, а не символы (но вы можете его адаптировать).

• Старые файлы .doc не поддерживаются.

Для юридически значимого сравнения (отслеживание изменений внутри файла Word) вам понадобится коммерческая библиотека, такая как Aspose.Words. Однако для большинства внутренних проверок и обнаружения изменений подхода на основе текста вполне достаточно.

Пример кода

from docx import Document

import difflib

def get_paragraph_texts(docx_path):

doc = Document(docx_path)

return [p.text for p in doc.paragraphs if p.text.strip()]

original = get_paragraph_texts("contract_v1.docx")

revised = get_paragraph_texts("contract_v2.docx")

diff = difflib.unified_diff(

original, revised,

fromfile="Оригинал",

tofile="Изменённый",

lineterm=""

)

for line in diff:

print(line)

Чтобы сделать вывод более читаемым, вы можете записать его в HTML-отчёт:

html_diff = difflib.HtmlDiff()

with open("diff_report.html", "w") as f:

f.write(html_diff.make_file(original, revised, "Оригинал", "Изменённый"))

Лучшие сценарии использования

• Аудит изменений в юридических контрактах

• Отслеживание обновлений в нормативных документах

• Сравнение студенческих работ с эталонным документом

Задача 4: Конвертация документов Word в PDF

Зачем это автоматизировать?

PDF — это универсальный формат для распространения, печати и архивирования. Ручная конвертация (открыть Word → Сохранить как PDF) становится узким местом, когда вам нужно ежедневно конвертировать десятки или сотни файлов. Автоматизация устраняет этот шаг и встраивает конвертацию в ваш конвейер обработки.

Основная рекомендация: docx2pdf (бесплатное, наивысшее качество)

docx2pdf — это не парсер, а тонкая обёртка, которая использует сам Microsoft Word для выполнения конвертации — точно так же, как операция «Сохранить как PDF», которую вы делаете вручную. Поэтому макет, шрифты, таблицы, колонтитулы воспроизводятся идеально.

Требования:

• Microsoft Word должен быть установлен на компьютере (Windows или macOS).

• Скрипт запускается в той же операционной системе, где доступен Word.

Ограничения:

• Не работает на Linux-серверах (нет Word).

• Головные серверные среды (например, Docker без графического интерфейса) не могут надёжно запускать эту библиотеку.

Если вы соответствуете требованиям, это лучшее бесплатное решение из доступных.

Пример кода

pip install docx2pdf

from docx2pdf import convert

# Конвертация одного файла

convert("report.docx", "report.pdf")

# Конвертация всех .docx файлов в папке

convert("input_folder/", "output_folder/")

Запасное решение: Spire.Doc для Python (когда Word недоступен)

Если вы работаете на Linux-сервере или в среде, где Microsoft Office не может быть установлен, вы можете использовать коммерческую библиотеку, такую как Spire.Doc. Она не зависит от Word и работает полностью автономно.

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

pip install Spire.Doc

from spire.doc import Document, FileFormat

doc = Document()

doc.LoadFromFile("report.docx")

doc.SaveToFile("report.pdf", FileFormat.PDF)

doc.Close()

Альтернатива (полностью открытый исходный код, кросс-платформенная): Вы можете вызвать LibreOffice из командной строки, используя subprocess:

import subprocess

subprocess.run(["libreoffice", "--headless", "--convert-to", "pdf", "report.docx"])

Это работает на Linux, Windows и macOS, но требует отдельной установки LibreOffice.

Итоги по задаче 4

Задача 5: Объединение нескольких документов Word в один

Зачем это автоматизировать?

Типичные сценарии включают:

• Объединение ежемесячных финансовых отчётов в квартальную сводку

• Слияние отдельных разделов контракта в основной договор

• Сборка пакета документации из нескольких глав

Выполнение этого вручную (копирование-вставка) часто разрушает форматирование и крайне медленно для большого количества файлов.

Рекомендуемый инструмент: docxcompose

docxcompose принимает один документ в качестве «основного» и добавляет к нему другие, сохраняя базовое форматирование. Библиотека легковесна и проста в использовании.

Ограничения (важно):

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

• Текстовые поля, сложные вложенные таблицы и некоторые пользовательские стили могут не сохраниться при слиянии.

• Проект не поддерживался активно с 2018 года.

Для простых документов (обычный текст, простые таблицы, немного стилей) библиотека работает удивительно хорошо. Для сложных отчётов с разными колонтитулами для каждой главы потребуется более надёжное (скорее всего, коммерческое) решение, или вы можете вручную копировать элементы с помощью python-docx — это больше работы, но полностью контролируемо.

Пример кода

pip install docxcompose

from docxcompose.composer import Composer

from docx import Document

master = Document("chapter1.docx")

composer = Composer(master)

composer.append(Document("chapter2.docx"))

composer.append(Document("chapter3.docx"))

composer.save("full_report.docx")

Если docxcompose не работает с вашими документами, вот более надёжный (но более длинный) подход: перебрать все элементы каждого документа и добавить их в новый основной документ, используя чистый python-docx. Упрощённый фрагмент:

from docx import Document

master = Document()

for file in ["part1.docx", "part2.docx"]:

doc = Document(file)

for element in doc.element.body:

master.element.body.append(element)

master.save("merged.docx")

Имейте в виду, что эта низкоуровневая манипуляция XML может нарушить стили, если выполнять её неаккуратно.

Лучшие сценарии использования

• Объединение простых отчётов с большим объёмом текста

• Добавление приложений к основному документу

• Сборка наборов документации из Markdown, сконвертированных в Word

Заключение

В таблице ниже обобщены рекомендуемые инструменты и их компромиссы.

Автоматизируя эти пять задач, вы можете сэкономить часы повторяющейся ручной работы. Начните с решений с открытым исходным кодом — они покроют большинство повседневных потребностей. Для критически важного форматирования корпоративного уровня (юридически значимое сравнение, идеальная конвертация в PDF на Linux, безупречное слияние) рассмотрите коммерческие библиотеки, такие как Aspose.Words. Но для большинства Python-разработчиков код, показанный выше, уже преобразит то, как вы работаете с документами Word.

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

pip install spire.doc.free

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

Извлечение всего текста и сохранение в TXT-файл

Встроенный метод GetText() позволяет получить весь текст из документа Word. На практике часто требуется не только вывести текст, но и сохранить его для дальнейшего использования. В следующем примере весь текст документа извлекается и записывается в файл .txt:

from spire.doc import *

from spire.doc.common import *

# Создание объекта Document и загрузка файла Word

doc = Document()

doc.LoadFromFile("input.docx")

# Извлечение всего текста из документа

full_text = doc.GetText()

# Запись текста в TXT-файл

with open("output.txt", "w", encoding="utf-8") as file:

file.write(full_text)

doc.Close()

print("Извлечение текста завершено. Результат сохранён в output.txt")

Основные моменты

• Метод GetText() извлекает весь текст в порядке чтения, включая абзацы, заголовки, верхние и нижние колонтитулы, игнорируя изображения, фигуры и другие нетекстовые элементы.

• Для корректной обработки национальных символов используется кодировка UTF-8.

• После завершения работы обязательно вызывайте doc.Close(), чтобы освободить системные ресурсы.

Точное извлечение и экспорт всех таблиц

Таблицы в документах Word часто содержат важные данные, такие как отчёты, списки и инвентаризационные ведомости. Spire.Doc предоставляет удобную иерархию объектов:

Документ → Раздел → Таблица → Строка → Ячейка → Абзац

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

from spire.doc import *

from spire.doc.common import *

import os

# Создание выходной директории

output_dir = "output/Tables"

os.makedirs(output_dir, exist_ok=True)

# Загрузка документа Word

doc = Document()

doc.LoadFromFile("Sample.docx")

# Перебор всех разделов

for section_idx in range(doc.Sections.Count):

section = doc.Sections.get_Item(section_idx)

tables = section.Tables

for table_idx in range(tables.Count):

table = tables.get_Item(table_idx)

table_data = ""

# Перебор всех строк и ячеек

for row_idx in range(table.Rows.Count):

row = table.Rows.get_Item(row_idx)

for col_idx in range(row.Cells.Count):

cell = row.Cells.get_Item(col_idx)

# Сбор текста из всех абзацев внутри ячейки

cell_text = ""

for para_idx in range(cell.Paragraphs.Count):

cell_text += cell.Paragraphs.get_Item(para_idx).Text + " "

table_data += cell_text.strip()

# Разделение столбцов символом табуляции

if col_idx < row.Cells.Count - 1:

table_data += "\t"

table_data += "\n" # Конец строки

# Сохранение текущей таблицы

output_path = f"{output_dir}/WordTable_{section_idx+1}_{table_idx+1}.txt"

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

f.write(table_data)

print(f"Сохранено: {output_path}")

doc.Close()

Разбор кода

• Вложенные циклы обеспечивают обработку всех таблиц во всех разделах документа.

• Содержимое каждой ячейки извлекается через коллекцию Paragraphs, что позволяет сохранить текст, разделённый переносами строк или форматированием.

• Выходные файлы именуются по шаблону SectionIndex_TableIndex, что упрощает определение источника данных.

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

Рекомендации и важные замечания

1. Производительность и использование памяти

При работе с большими документами, содержащими сотни страниц, рекомендуется обрабатывать только необходимый тип данных. Если нужны только таблицы, можно пропустить извлечение текста, и наоборот. Кроме того, обязательно вызывайте doc.Close(), чтобы избежать утечек ресурсов.

2. Обработка объединённых ячеек

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

Если необходимо сохранить исходную структуру таблицы, можно использовать свойства Cell.ColumnSpan и Cell.RowSpan для построения матрицы с учётом объединённых ячеек.

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

Бесплатная версия Spire.Doc позволяет обрабатывать документы, содержащие до 500 абзацев или 25 таблиц , чего обычно достаточно для большинства повседневных задач обработки документов и тестирования библиотеки.

Заключение

С помощью Free Spire.Doc for Python можно извлекать текст и таблицы из документов Word всего несколькими десятками строк кода. Два подхода, рассмотренные в этой статье — сохранение текста в TXT-файлы и экспорт таблиц по отдельности — легко интегрируются в существующие процессы обработки данных.

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

Если вам требуется работать со сложными макетами документов или сохранять расширенную структуру таблиц, Spire.Doc также предоставляет дополнительные API, такие как ExportToHtml() и SaveToFile(), обеспечивая ещё большую гибкость при обработке документов.