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 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(), обеспечивая ещё большую гибкость при обработке документов.

На рынке есть множество библиотек для обработки документов, но Spire.Doc особенно хорошо справляется с преобразованием между Word и Markdown. Она не только корректно обрабатывает базовый текст, но и отлично распознает и конвертирует сложные структуры — такие как заголовки, абзацы, таблицы и списки. Более того, она поддерживает оба формата Word: .doc и .docx, а также стандартный синтаксис Markdown. Конвертированные документы аккуратно отформатированы и логично структурированы, требуя почти никаких дополнительных правок.

Установка библиотеки Spire.Doc:

pip install spire.doc.free

Word → Markdown: всего три строки ключевого кода

from spire.doc import *

from spire.doc.common import *

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

document = Document()

# Загружаем Word-файл (поддерживает .docx и .doc)

document.LoadFromFile("input.docx")

# Сохраняем как файл Markdown

document.SaveToFile("WordToMarkdown.md", FileFormat.Markdown)

document.Close()

После выполнения кода все уровни заголовков в документе Word автоматически сопоставляются с тегами Markdown #–######, абзацы сохраняют корректные переносы строк, таблицы конвертируются в синтаксис таблиц Markdown, а упорядоченные/неупорядоченные списки распознаются правильно. Весь процесс занимает всего несколько секунд, значительно повышая эффективность работы.

Markdown → Word: так же просто

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

from spire.doc import *

from spire.doc.common import *

document = Document()

# Загружаем файл Markdown

document.LoadFromFile("input.md")

# Сохраняем как документ Word (поддерживает .docx и .doc)

document.SaveToFile("MdToDocx.docx", FileFormat.Docx)

# Если нужен старый формат .doc, можно сохранить отдельно

# document.SaveToFile("MdToDoc.doc", FileFormat.Doc)

document.Close()

Конвертированный документ Word автоматически применяет стили по умолчанию: четкая иерархия заголовков, полные границы таблиц и разумные отступы для списков — документ готов к печати или дальнейшей верстке.

Обработка изображений: проблема встраивания Base64 и решения

При конвертации Word в Markdown есть легко упускаемая из виду проблема: обработка изображений . По умолчанию Spire.Doc конвертирует встраиваемые изображения в Word в кодировку Base64 и напрямую встраивает их в файл Markdown. Плюс этого подхода в том, что один файл становится самодостаточным — им удобно делиться.

Но минус также очевиден: если документ содержит много высокоразрешенных изображений, размер Markdown-файла может резко увеличиться, достигнув десятков или даже сотен мегабайт. Это приводит к лагам в редакторе и раздувает Git-репозитории.

Решение оптимизации: извлечь изображение для внешних ссылок

Лучше извлечь изображения в отдельную папку, а затем ссылаться на них в Markdown через относительные пути. Хотя Spire.Doc напрямую не предоставляет параметр «автоматически внешнее вынесение ссылок на изображения при сохранении», мы можем решить задачу вручную: извлечь изображения и заменить ссылки.

from spire.doc import *

import os

document = Document()

document.LoadFromFile("input.docx")

# Создаем директорию для изображений

image_dir = "images"

os.makedirs(image_dir, exist_ok=True)

# Проходим по всем изображениям и извлекаем их

for i, image inenumerate(document.Images):

withopen(f"{image_dir}/img_{i}.png", "wb") as f:

f.write(image.ImageData)

# Сначала конвертируем в Markdown (все еще со встроенными Base64)

document.SaveToFile("temp.md", FileFormat.Markdown)

# Далее с помощью regex или замены строк заменяем Base64-изображения на локальные ссылки

# Этот шаг нужно выполнить вручную или с помощью дополнительного скрипта

document.Close()

Если документов много, процесс можно полностью автоматизировать: распарсить сгенерированный Markdown-файл, найти блоки Base64-изображений, декодировать их и сохранить локально, затем заменить на формат . Коллекция document.Images в Spire.Doc дает нам возможность извлекать изображения, и в сочетании со скриптингом можно добиться полной автоматизации этой оптимизации.

Практические сценарии применения

Это решение было проверено в нескольких реальных ситуациях:

1. Миграция технической документации : пакетно конвертировать существующие руководства по продуктам в формате Word в Markdown для импорта в VuePress или Docsify базы знаний.

2. Публикации в нескольких форматах : писать в Markdown и конвертировать в Word, чтобы соответствовать требованиям клиента или руководителя к официальным документам.

3. Совместный обзор : команда просматривает изменения в режиме Word «Отслеживание изменений», затем возвращает обратно в Markdown одним кликом, чтобы продолжить разработку.

Итоги

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

pip install pandas openpyxl

2. Основной код: Извлечение таблиц из PDF

Следующий код демонстрирует, как извлечь таблицы с первой страницы PDF и вывести содержимое ячеек построчно:

from spire.pdf import PdfDocument, PdfTableExtractor

# 1. Загрузить PDF-файл

pdf = PdfDocument()

pdf.LoadFromFile("sample.pdf")

# 2. Создать экстрактор таблиц

table_extractor = PdfTableExtractor(pdf)

# 3. Извлечь все таблицы с первой страницы

tables = table_extractor.ExtractTable(0)

# 4. Пройтись по каждой таблице

for table in tables:

row_count = table.GetRowCount()

column_count = table.GetColumnCount()

# Извлечь содержимое ячеек построчно

for i in range(row_count):

row_data = []

for j in range(column_count):

cell_text = table.GetText(i, j)

row_data.append(cell_text)

print(row_data)

Пояснение к коду

• LoadFromFile(): Загружает PDF-файл из указанного пути

• PdfTableExtractor(): Создаёт экземпляр экстрактора таблиц

• ExtractTable(номер страницы): Извлекает все таблицы с указанной страницы, нумерация страниц начинается с 0

• GetRowCount() / GetColumnCount(): Получает количество строк и столбцов таблицы

• GetText(строка, столбец): Получает текстовое содержимое указанной ячейки

3. Расширенная обработка: Пакетное извлечение из многостраничного PDF

Если PDF содержит несколько страниц, вы можете использовать цикл для пакетного извлечения всех таблиц:

from spire.pdf import PdfDocument, PdfTableExtractor

pdf = PdfDocument()

pdf.LoadFromFile("multi_page_report.pdf")

# Пройтись по всем страницам

for page_index in range(pdf.Pages.Count):

extractor = PdfTableExtractor(pdf)

tables = extractor.ExtractTable(page_index)

print(f"\n=== Страница {page_index + 1} найдено {len(tables)} таблиц ===")

for t, table in enumerate(tables):

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

rows = table.GetRowCount()

cols = table.GetColumnCount()

for i in range(rows):

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

print(row)

4. Экспорт данных: Сохранение в файлы CSV или Excel

Извлечённые табличные данные можно легко преобразовать в другие форматы. Следующий пример сохраняет данные в CSV-файл:

import csv

from spire.pdf import PdfDocument, PdfTableExtractor

pdf = PdfDocument()

pdf.LoadFromFile("sample.pdf")

extractor = PdfTableExtractor(pdf)

tables = extractor.ExtractTable(0)

if tables:

table = tables[0]

rows = table.GetRowCount()

cols = table.GetColumnCount()

# Собрать все данные

data = []

for i in range(rows):

row_data = [table.GetText(i, j) for j in range(cols)]

data.append(row_data)

# Записать в CSV-файл

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

writer = csv.writer(f)

writer.writerows(data)

print(f"Успешно экспортировано {rows} строк × {cols} столбцов данных в output.csv")

Чтобы экспортировать данные в Excel-файл, вы можете использовать pandas:

import pandas as pd

# Предположим, что data — это извлечённый выше двумерный список

df = pd.DataFrame(data[1:], columns=data[0]) # Первая строка как заголовки столбцов

df.to_excel("output.xlsx", index=False)

print("Данные сохранены как output.xlsx")

5. Часто возникающие проблемы и советы

1. Неполное распознавание таблицы? Проверьте, имеет ли таблица в PDF чёткие границы. Для отсканированных документов или PDF на основе изображений требуется технология OCR; Spire.PDF в основном подходит для текстовых PDF.

2. Обработка объединённых ячеек: Spire.PDF автоматически обрабатывает объединённые ячейки. GetText() возвращает содержимое ячейки в верхнем левом углу объединённой области, а для остальных позиций возвращает пустую строку.

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

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

1. Обзор компонента Spire.Doc for .NET

Free Spire.Doc for .NET — это профессиональный компонент для работы с документами Word, который позволяет разработчикам создавать, читать, изменять и конвертировать документы Word напрямую через код без установки Microsoft Office. Компонент предоставляет полный набор возможностей для работы с водяными знаками и поддерживает два основных типа:

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

Настройка окружения

Перед началом кодирования необходимо установить Free Spire.Doc в проект через диспетчер пакетов NuGet. Выполните следующую команду в «Консоли диспетчера пакетов» Visual Studio:

Install-Package FreeSpire.Doc

После установки необходимо подключить следующие пространства имён в файле кода:

using Spire.Doc;

using Spire.Doc.Documents;

using System.Drawing; // Для работы с цветами и изображениями

2. Добавление текстового водяного знака

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

Описание основных свойств

Класс TextWatermark предоставляет следующие настраиваемые свойства:

Реализация кода

using System;

using System.Drawing;

using Spire.Doc;

using Spire.Doc.Documents;

namespace InsertTextWatermark

{

internal class Program

{

static void Main(string[] args)

{

// Создание экземпляра объекта Document

Document document = new Document();

// Загрузка документа Word с диска

document.LoadFromFile("input.docx");

// Вставка текстового водяного знака

InsertTextWatermark(document);

// Сохранение документа

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

}

private static void InsertTextWatermark(Document document)

{

TextWatermark txtWatermark = new TextWatermark();

txtWatermark.Text = "НЕ КОПИРОВАТЬ"; // Текст водяного знака

txtWatermark.FontSize = 50; // Размер шрифта

txtWatermark.Color = Color.Blue; // Цвет текста

txtWatermark.Layout = WatermarkLayout.Diagonal; // Диагональное расположение

document.Watermark = txtWatermark;

}

}

}

Ключевые моменты

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

• При сохранении необходимо явно указать формат FileFormat.Docx, чтобы информация о водяном знаке была корректно записана в структуру файла Word.

• Если требуется горизонтальное центрированное отображение водяного знака, установите свойство Layout в WatermarkLayout.Horizontal.

3. Добавление водяного знака-изображения

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

• Добавление логотипа компании в качестве водяного знака во внутренние документы

• Наложение изображений с авторскими правами на дизайнерские макеты

• Использование изображения подписи как утверждающего водяного знака документа

Описание основных свойств

Класс PictureWatermark предоставляет следующие настраиваемые свойства:

Реализация кода

using System;

using System.Drawing;

using Spire.Doc;

using Spire.Doc.Documents;

namespace InsertImageWatermark

{

internal class Program

{

static void Main(string[] args)

{

// Создание экземпляра объекта Document

Document document = new Document();

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

document.LoadFromFile("Input.docx");

// Вставка водяного знака-изображения

InsertImageWatermark(document);

// Сохранение документа

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

}

private static void InsertImageWatermark(Document document)

{

PictureWatermark picture = new PictureWatermark();

picture.Picture = Image.FromFile("watermark.png"); // Загрузка изображения

picture.Scaling = 200; // Масштаб (%)

picture.IsWashout = false; // Использовать ли эффект выцветания

document.Watermark = picture;

}

}

}

Два визуальных эффекта для водяного знака-изображения

4. Удаление водяного знака

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

Принцип работы

В Spire.Doc удаление водяного знака реализовано очень просто: свойство Document.Watermark по сути является ссылкой на объект. Когда оно указывает на экземпляр TextWatermark или PictureWatermark, это означает, что водяной знак активен. Если же присвоить этому свойству пустую ссылку, водяной знак будет удалён из документа.

Реализация кода

using Spire.Doc;

namespace RemoveWatermark

{

class Program

{

static void Main(string[] args)

{

// Создание экземпляра Document

Document doc = new Document();

// Загрузка документа Word с водяным знаком

doc.LoadFromFile("Input.docx");

// Удаление водяного знака

doc.Watermark = null;

// Сохранение результата

doc.SaveToFile("RemoveWatermark.docx", FileFormat.Docx2013);

}

}

}

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

Этот способ удаления работает только для стандартных водяных знаков, добавленных через Spire.Doc. Если «водяной знак» реализован нестандартным способом (например, полупрозрачная фигура в колонтитуле или встроенное фоновое изображение), данный метод не сработает — потребуется использовать другие стратегии удаления содержимого документа.

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

С помощью Spire.Doc for .NET разработчики могут легко и стандартизированно добавлять и удалять водяные знаки в документах Word с использованием C#. Основные операции, рассмотренные в статье:

Рекомендации по применению

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

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

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

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