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 не всегда так надёжна, как кажется. В этой статье мы рассмотрим пять практических способов — от быстрых решений до более продвинутых методов — а также разберём несколько технических нюансов, о которых вы могли не знать.

На этой странице:

• Способ 1: Google Docs — интеллектуальное извлечение через преобразование

• Способ 2: онлайн-конвертер PDF24 — просто, но не забывайте о конфиденциальности

• Способ 3: «Печать в PDF» через браузер — создание новой чистой копии

• Способ 4: скриншот + OCR — работает даже с полностью заблокированными PDF

• Способ 5: автоматизация с Python — пакетная обработка и интеграция в рабочие процессы

• Сравнение способов

• Заключение

Способ 1: Google Docs — интеллектуальное извлечение через преобразование

Этот способ может показаться обходным решением, но его принцип довольно интересен: когда Google Docs открывает PDF, сервис пытается заново восстановить структуру документа — и в процессе часто игнорирует исходные ограничения на копирование.

Шаги:

1. Откройте Google Drive и войдите в аккаунт

2. Загрузите защищённый PDF-файл

3. Щёлкните файл правой кнопкой мыши и выберите Открыть с помощью → Google Docs

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

Почему это работает:
Большинство ограничений PDF представляют собой всего лишь флаги разрешений, а не настоящее шифрование. Когда Google Docs преобразует файл, он создаёт совершенно новую структуру документа, поэтому исходные ограничения обычно не переносятся.

Ограничение:
Этот способ работает хуже, если PDF представляет собой отсканированное изображение, а не документ с настоящим текстовым слоем.

Способ 2: онлайн-конвертер PDF24 — просто, но не забывайте о конфиденциальности

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

Шаги:

1. Откройте инструмент PDF24 PDF to TXT

2. Загрузите защищённый PDF-файл

3. Запустите преобразование и дождитесь завершения обработки

4. Скачайте TXT-файл и свободно копируйте текст

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

• Не требуется установка

• Нет водяных знаков или жёстких ограничений

• Подходит даже начинающим пользователям

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

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

Способ 3: «Печать в PDF» через браузер — создание новой чистой копии

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

Шаги:

1. Откройте защищённый PDF в браузере, например Chrome или Edge

2. Нажмите Ctrl + P

3. Выберите Save as PDF в качестве принтера

4. Сохраните новый файл

5. Откройте новый PDF и попробуйте скопировать текст

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

Когда этот способ работает лучше всего:

• PDF запрещает копирование, но разрешает печать

• Документ содержит настоящий текстовый слой, а не только отсканированные изображения

Ограничение:
Если печать также запрещена, этот способ не сработает.

Способ 4: скриншот + OCR — работает даже с полностью заблокированными PDF

Современные операционные системы и приложения всё чаще включают встроенную поддержку OCR — оптического распознавания символов. Благодаря этому извлекать текст со скриншотов стало гораздо проще.

Как это сделать:

1. Сделайте скриншот нужной части PDF

2. Используйте инструмент с поддержкой OCR, например Windows Snipping Tool, Live Text в macOS или мобильное приложение

3. Выделите распознанный текст и скопируйте его

Почему этот способ полезен:

• Работает даже со сканированными PDF

• Не зависит от ограничений на копирование

• Не требует загрузки файлов в интернет

Недостатки:

• Точность зависит от качества изображения

• Форматирование, включая таблицы и макет страницы, может быть потеряно

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

• Отсканированные документы

• Небольшие фрагменты текста

• Ситуации, когда остальные методы не помогают

Способ 5: автоматизация с Python — пакетная обработка и интеграция в рабочие процессы

Для масштабных задач, связанных с десятками или сотнями PDF-файлов, автоматизация намного эффективнее ручного извлечения текста.

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

Установка:

pip install spire.pdf.free

Пример:

from spire.pdf import *
doc = PdfDocument()
doc.LoadFromFile("Secured.pdf")
for i in range(doc.Pages.Count):
page = doc.Pages[i]
extractor = PdfTextExtractor(page)
options = PdfTextExtractOptions()
options.IsExtractAllText = True
text = extractor.ExtractText(options)
with open(f"output/page-{i+1}.txt", "w", encoding="utf-8") as f:
f.write(text)
doc.Close()

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

• Автоматизирует обработку большого количества файлов

• Может быть встроен в рабочие процессы, например конвейеры обработки данных и ETL-системы

• Позволяет извлекать даже «некопируемый» текст с помощью IsExtractAllText = True

Главное преимущество:
Речь идёт уже не просто о копировании текста, а о создании повторяемой системы обработки документов.

Примечание:
Бесплатная версия Spire.PDF for Python поддерживает обработку документов объёмом до 10 страниц. Для более крупных файлов может потребоваться разделить документ на части или использовать другие решения.

Сравнение способов

Заключение

Каждый способ подходит для своего сценария:

• Быстро и бесплатно: Google Docs

• Быстро и удобно: онлайн-инструменты, если вас устраивают компромиссы в отношении конфиденциальности

• Простой обходной вариант: печать в новый PDF

• Универсальный резервный способ: OCR по скриншотам

• Масштабируемое решение: автоматизация с Python

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

• Инструмент разработки: Visual Studio 2019/2022

• Платформа выполнения: .NET Framework / .NET Core / .NET 5+ (полная совместимость со всеми версиями)

• Основной компонент: Free Spire.Doc for .NET

1.2 Установка компонента

Рекомендуется быстрая установка компонента через менеджер пакетов NuGet. Доступны два способа установки на выбор:

Способ 1: Визуальная установка через NuGet

В Visual Studio щелкните правой кнопкой мыши по проекту → Управление пакетами NuGet → выполните поиск Spire.Doc → нажмите «Установить».

Способ 2: Установка через командную строку NuGet

Откройте консоль диспетчера пакетов и выполните следующую команду:

Install-Package FreeSpire.Doc

2. Базовая функциональность: Быстрая реализация печати документа Word по умолчанию

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

using Spire.Doc;
using System.Drawing.Printing;
namespace PrintWordDocument
{
internal class Program
{
static void Main(string[] args)
{
// 1. Инициализация объекта документа Word
Document doc = new Document();
// 2. Загрузка локального документа Word (поддерживаются форматы docx/doc)
doc.LoadFromFile("Input.docx");
// 3. Получение основного объекта печати документа
PrintDocument printDoc = doc.PrintDocument;
// 4. Вызов системного принтера по умолчанию для выполнения печати
printDoc.Print();
}
}
}

Разбор кода

1. Класс Document : Основной класс документа в Spire.Doc, используемый для загрузки, анализа и управления документами Word;

2. Метод LoadFromFile : Читает файл Word по указанному локальному пути, поддерживает абсолютные и относительные пути;

3. Свойство PrintDocument : Инкапсулирует основной экземпляр печати документа, взаимодействует со службой печати системы;

4. Метод Print : Выполняет команду печати, по умолчанию использует системный принтер по умолчанию и стандартные параметры печати.

3. Расширенная функциональность: Пользовательские параметры печати Word

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

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

PrinterSettings settings = printDoc.PrinterSettings;

3.1 Указание принтера для печати

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

// Введите полное имя установленного в системе принтера
settings.PrinterName = "Your Printer Name";

3.2 Указание диапазона страниц для печати

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

// Печать страниц с 1 по 5
settings.FromPage = 1;
settings.ToPage = 5;

3.3 Установка количества копий

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

// Установка печати 2 копий документа
settings.Copies = 2;

3.4 Включение двусторонней печати

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

// Проверка поддержки двусторонней печати принтером; при поддержке включается режим двусторонней печати по умолчанию
if (settings.CanDuplex)
{
settings.Duplex = Duplex.Default;
}

3.5 Пользовательский размер бумаги для печати

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

// Пользовательский размер бумаги: имя "custom", ширина 800, высота 500
settings.DefaultPageSettings.PaperSize = new PaperSize("custom", 800, 500);

3.6 Печать документа Word в PDF (виртуальная печать)

Используя встроенный виртуальный принтер «Microsoft Print to PDF», можно реализовать функцию конвертации Word в PDF без дополнительных компонентов, одним нажатием экспортировать PDF-файл.

// Включение режима печати в файл
settings.PrintToFile = true;
// Указание виртуального принтера PDF
settings.PrinterName = "Microsoft Print to PDF";
// Установка пути сохранения экспортируемого PDF
settings.PrintFileName = @"C:\Output.pdf";

4. Расширенная функциональность: Бесшумная печать без всплывающих окон

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

Полный код для бесшумной печати:

using Spire.Doc;
using System.Drawing.Printing;
namespace SilentlyPrintWord
{
class Program
{
static void Main(string[] args)
{
// Инициализация и загрузка документа Word
Document doc = new Document();
doc.LoadFromFile("Input.docx");
// Получение объекта печати
PrintDocument printDoc = doc.PrintDocument;
// Отключение всплывающих окон печати, включение режима бесшумной печати
printDoc.PrintController = new StandardPrintController();
// Выполнение фоновой бесшумной печати
printDoc.Print();
}
}
}

Основной принцип

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

5. Часто задаваемые вопросы и важные замечания

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

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

• Совместимость с оборудованием : Двусторонняя печать и нестандартные размеры бумаги требуют поддержки со стороны аппаратного принтера; рекомендуется заранее проверять совместимость оборудования;

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

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

В этой статье на основе компонента Free Spire.Doc for .NET представлено полное решение для печати документов Word в среде C#, охватывающее четыре ключевых сценария: базовая печать по умолчанию, детальная настройка параметров печати, фоновая бесшумная печать и виртуальная печать Word в PDF .

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

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

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

В этой статье мы рассмотрим два практических подхода:

• Разделение документа Word по диапазону страниц

• Разделение документа Word на отдельные файлы по разделам

Установка Spire.Doc for Python

Перед запуском примеров установите Spire.Doc for Python с помощью pip:

pip install Spire.Doc

Затем импортируйте библиотеку:

from spire.doc import *

Следующие примеры работают напрямую с документами Word без необходимости установки Microsoft Word.

Разделение документа Word по диапазону страниц

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

Например, предположим, что документ содержит титульную страницу, введение и основной контент. Вы можете захотеть извлечь страницы 1–3 в один документ и сохранить всё после страницы 3 как другой файл.

Spire.Doc предоставляет метод ExtractPages() для этой цели.

Пример: извлечение страниц 1–3 и оставшихся страниц

from spire.doc import *
# Загрузка документа Word
doc = Document()
doc.LoadFromFile("input.docx")
# Извлечение страниц 1-3
first_part = doc.ExtractPages(0, min(3, doc.PageCount))
first_part.SaveToFile("Page1-3.docx", FileFormat.Docx)
first_part.Dispose()
# Извлечение оставшихся страниц, если в документе более 3 страниц
if doc.PageCount > 3:
second_part = doc.ExtractPages(3, doc.PageCount - 3)
second_part.SaveToFile("Page4-End.docx", FileFormat.Docx)
second_part.Dispose()
doc.Dispose()

Код создаёт до двух выходных файлов:

Page1-3.docx
Page4-End.docx

Как работает извлечение страниц

Ключевой метод:

doc.ExtractPages(startIndex, pageCount)

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

Индексы страниц являются нулевыми , поэтому:

doc.ExtractPages(0, 3)

извлекает страницы 1, 2 и 3.

Аналогично:

doc.ExtractPages(3, doc.PageCount - 3)

начинается с четвёртой страницы и извлекает всё до конца документа.

В первой операции в этом примере используется:

min(3, doc.PageCount)

вместо простого указания 3. Это предотвращает запрос трёх страниц, когда исходный документ содержит менее трёх страниц.

Второе извлечение также обёрнуто в:

if doc.PageCount > 3:

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

Извлечение другого диапазона страниц

Тот же метод можно адаптировать для любого диапазона страниц.

Например, чтобы извлечь страницы с 5 по 10:

part = doc.ExtractPages(4, 6)
part.SaveToFile("Page5-10.docx", FileFormat.Docx)
part.Dispose()

Начальный индекс — 4, потому что индексы страниц начинаются с нуля, а количество извлекаемых страниц — 6.

Это делает ExtractPages() особенно полезным, когда диапазоны страниц поступают из пользовательского ввода, файлов конфигурации или другого рабочего процесса обработки документов.

Разделение документа Word по разделам

Номера страниц не всегда являются наиболее осмысленным способом разделения документа Word.

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

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

Пример: сохранение каждого раздела как отдельного документа Word

from spire.doc import *
# Загрузка документа Word
doc = Document()
doc.LoadFromFile("input.docx")
# Разделение документа по разделам
for i in range(doc.Sections.Count):
new_doc = Document()
# Клонирование текущего раздела и добавление его в новый документ
new_doc.Sections.Add(doc.Sections.get_Item(i).Clone())
# Сохранение раздела как отдельного документа Word
new_doc.SaveToFile(
f"output/SplitDocument/SplitBySectionBreak_{i+1}.docx"
)
new_doc.Close()
doc.Close()

Если исходный документ Word содержит три раздела, скрипт создаёт файлы, такие как:

SplitBySectionBreak_1.docx
SplitBySectionBreak_2.docx
SplitBySectionBreak_3.docx

Как работает разделение по разделам

Количество разделов в документе доступно через:

doc.Sections.Count

Скрипт проходит по каждому разделу:

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

На каждой итерации создаётся новый объект Document.

Затем текущий раздел извлекается и клонируется:

doc.Sections.get_Item(i).Clone()

Клонированный раздел добавляется в новый документ:

new_doc.Sections.Add(...)

Наконец, новый документ сохраняется как независимый файл .docx.

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

Разделение по страницам и по разделам: сравнение

Хотя оба метода создают файлы Word меньшего размера, они решают несколько разные задачи.

Используйте разделение по страницам , когда требование звучит так:

Сохранить страницы 1–3 отдельно, а оставшиеся страницы поместить в другой файл.

Используйте разделение по разделам , когда сам документ уже содержит структурные границы:

Создать отдельный файл Word для каждого раздела в документе.

Это различие важно, потому что страницы и разделы не эквивалентны. Один раздел может занимать несколько страниц, а документ также может содержать несколько разделов с различными настройками форматирования.

Когда разделение по страницам является лучшим выбором

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

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

• Извлечение титульной страницы и резюме

• Отделение выбранных страниц из отчёта

• Создание меньших документов из длинного сгенерированного отчёта

• Обработка только указанного диапазона страниц

• Построение рабочих процессов предпросмотра или распространения документов

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

Например, программа может считывать диапазоны, такие как:

1-5
6-10
11-20

и автоматически создавать один документ Word для каждого диапазона.

Когда разделение по разделам имеет больше смысла

Разделы полезны, когда документ уже организован в логические единицы.

Рассмотрим отчёт, содержащий:

Раздел 1 — Резюме
Раздел 2 — Финансовые результаты
Раздел 3 — Анализ рынка
Раздел 4 — Приложение

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

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

• Верхние и нижние колонтитулы

• Размеры страниц

• Поля

• Ориентации страниц

• Колоночные макеты

• Настройки нумерации страниц

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

Важное замечание о страницах Word

Существует одно важное различие между работой с документами Word и такими форматами, как PDF.

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

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

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

Заключение

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

С помощью Spire.Doc for Python есть два простых подхода:

• Используйте ExtractPages(), когда нужно извлечь определённый диапазон страниц.

• Проходите по doc.Sections, когда хотите создать отдельный документ для каждого раздела Word.

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

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

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

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

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

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

Install-Package Spire.Doc

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Установка

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

pip install spire.presentation.free

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1. Сетка ChartData

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

pip install Spire.PDF

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

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

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

from spire.pdf.common import *

from spire.pdf import *

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

doc = PdfDocument()

doc.LoadFromFile("Sample.pdf")

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

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

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

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

doc.Close()

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

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

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

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

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

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

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

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

from spire.pdf.common import *

from spire.pdf import *

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

doc = PdfDocument()

doc.LoadFromFile("Sample.pdf")

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

newDoc_1 = PdfDocument()

newDoc_2 = PdfDocument()

newDoc_3 = PdfDocument()

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

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

newDoc_1.InsertPage(doc, 0)

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

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

newDoc_2.InsertPageRange(doc, 1, 3)

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

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

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

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

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

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

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

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

doc.Close()

newDoc_1.Close()

newDoc_2.Close()

newDoc_3.Close()

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

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

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

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

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

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

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

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

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

group_size = 2

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

new_doc = PdfDocument()

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

new_doc.InsertPageRange(doc, i, end_index)

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

new_doc.Close()

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pip install pandas openpyxl xlrd

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

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

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

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

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

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

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

import pandas as pd

import xml.etree.ElementTree as ET

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

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

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

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

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

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

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

for _, row in df.iterrows():

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

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

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

for col_name in df.columns:

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

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

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

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

field.text = str(row[col_name])

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

tree = ET.ElementTree(root)

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

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

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

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

if __name__ == "__main__":

excel_to_xml_auto(

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

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

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

)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

import pandas as pd

import xml.etree.ElementTree as ET

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

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

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

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

root = ET.Element("customer_list")

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

for index, row in df.iterrows():

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

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

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

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

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

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

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

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

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

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

tree = ET.ElementTree(root)

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

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

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

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

if __name__ == "__main__":

excel_to_xml_custom(

excel_path="data.xlsx",

xml_save_path="output_custom.xml"

)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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