Извлечение изображений из Word DOC/DOCX — одна из самых распространенных повседневных задач для студентов, маркетологов, дизайнеров и офисных работников. Если вы хотите повторно использовать изображения в презентации, редактировать их в Photoshop, делиться визуальными материалами в социальных сетях или организовывать медиатеку, знание того, как эффективно извлекать изображения из документа Word, сэкономит вам часы повторяющейся работы.

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

• Зачем извлекать изображения из Word?
• Способ 1: Сохранить как изображение через правую кнопку мыши
• Способ 2: Сохранить как веб-страницу
• Способ 3: Трюк с ZIP-файлом
• Способ 4: Бесплатные онлайн-извлекатели изображений из Word
• Способ 5: Бесплатные программные решения
• Краткое сравнение всех методов
• Часто задаваемые вопросы об извлечении изображений из Word

Зачем извлекать изображения из Word?

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

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

Способ 1: Сохранить как изображение через правую кнопку мыши

Лучше всего подходит для: Пользователей, которые уже работают в Microsoft Word и которым нужно быстро извлечь 1–3 изображения.

«Сохранить как изображение» — это самый интуитивно понятный метод извлечения изображений из Word, когда вам нужно всего одно или два изображения. Он не требует технических знаний и выполняется за секунды.

Пошаговая инструкция:

• Откройте ваш документ Word в Microsoft Word.
• Щелкните правой кнопкой мыши по изображению, которое хотите сохранить.
• В контекстном меню выберите Сохранить как изображение.

• В диалоговом окне:
  • Выберите папку назначения
  • Переименуйте файл (необязательно, но рекомендуется)
  • Выберите предпочитаемый формат (PNG для прозрачности, JPG для фотографий, GIF для простой графики)
  • Нажмите Сохранить.

✔ Плюсы: Бесплатно, встроенная функция, операция в 1 клик, нативная функция Microsoft Word

✘ Минусы: Чрезвычайно медленно для пакетного извлечения (только одно изображение за раз)

Хотя документы Word распространены, вам также может понадобиться извлекать изображения из PDF. Ознакомьтесь с нашим полным руководством по извлечению изображений из PDF — включая бесплатные инструменты и продвинутые методы.

Способ 2: Сохранить как веб-страницу

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

Microsoft Word включает мощную скрытую функцию: сохранение в виде веб-страницы автоматически экспортирует каждое встроенное изображение в отдельную папку. Это один из старейших и самых надежных методов извлечения изображений из файлов Word doc или docx.

Полное руководство:

• Откройте документ Word.
• Нажмите Файл → Сохранить как и выберите место сохранения на вашем устройстве.
• В выпадающем списке «Тип файла» выберите *Веб-страница (.htm; *.html)**.
  • Примечание: НЕ выбирайте «Веб-страница в одном файле» — это упакует все в один файл.

• Нажмите Сохранить — Word создаст два элемента в выбранной вами папке:
  • HTML-файл веб-страницы.
  • Папку с именем [ИмяВашегоДокумента]_files (например, Report_files).
• Откройте эту папку, чтобы получить доступ ко всем извлеченным изображениям (в их исходных форматах, таких как PNG/JPG).

✔ Плюсы: Встроенный инструмент Word, мгновенно извлекает все изображения пакетом, сохраняет хорошее качество

✘ Минусы: Создает лишние HTML-файлы, генерирует дубликаты изображений, если они повторно используются в документе

Способ 3: Трюк с ZIP-файлом

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

Вот малоизвестный факт: современные документы Word (.docx) на самом деле являются сжатыми ZIP-архивами. Это означает, что вы можете извлекать изображения из файлов docx, даже не открывая Microsoft Word.

Почему это работает:

Начиная с Microsoft Office 2007, Word использует формат Open XML. Файл .docx по сути является контейнером с XML-файлами и специальной папкой /word/media/, содержащей все встроенные изображения.

Подробные шаги:

• Найдите ваш DOCX-файл и сделайте копию (чтобы защитить оригинал).
• Щелкните правой кнопкой мыши по файлу и выберите Переименовать.
• Измените расширение файла с .docx на .zip (например, report.docx → report.zip).
• Нажмите Enter, чтобы подтвердить изменение расширения.
• Нажмите Да, если появится предупреждение.
• Дважды щелкните, чтобы открыть как обычную папку (в Проводнике Windows или Finder на Mac).
• Перейдите по пути: word → media.
• Скопируйте все изображения в нужную вам папку.

✔ Плюсы: 100% бесплатно, пакетное извлечение, сохраняет исходное высокое разрешение

✘ Минусы: Работает только для файлов DOCX.

Краткий совет: Для массового извлечения изображений из устаревших файлов .doc используйте Способ 2 (Сохранить как веб-страницу) или сначала преобразуйте DOC в DOCX, прежде чем применять этот метод.

Способ 4: Бесплатные онлайн-извлекатели изображений из Word

Лучше всего подходит для: Пользователей, которые не хотят устанавливать программное обеспечение или нуждаются в быстром кроссплатформенном решении (работает на Windows, Mac, мобильных устройствах).

Специализированные онлайн-инструменты, такие как ExtractAssets или Groupdocs, обрабатывают как DOC, так и DOCX файлы, извлекая все изображения и предоставляя их в виде загружаемого ZIP-файла — никаких технических шагов не требуется.

Шаги для извлечения изображений из Word онлайн:

• Перейдите на веб-сайт инструмента (например, ExtractAssets Word Image Extractor)
• Загрузите ваш документ Word.
• Нажмите Извлечь изображения.
• Загрузите изображения в виде ZIP-файла.

✔ Плюсы: Не требует установки, кроссплатформенность, работает с файлами DOC и DOCX

✘ Минусы: Требуется интернет; ограничения на размер файла для бесплатных пользователей

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

Способ 5: Бесплатные программные решения

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

Для бизнеса и разработчиков Free Spire.Doc for .NET — это мощная библиотека, которая позволяет программно извлекать изображения из Word на C# с полным контролем над форматом вывода.

C# код для извлечения изображений из Word:

using Spire.Doc;
using Spire.Doc.Documents;
using Spire.Doc.Fields;

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Загрузить документ Word
            Document document = new Document("input.docx");
            int index = 0;

            // Проход по каждой секции в документе
            foreach (Section section in document.Sections)
            {
                // Проход по каждому параграфу в текущей секции
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Проход по каждому объекту документа в текущем параграфе
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Проверка, является ли текущий объект документа изображением
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Сохранение извлеченного изображения в виде файла PNG
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

Код загружает документ Word и обходит его иерархически: Документ → Секция → Параграф → ОбъектДокумента, фильтруя только объекты типа изображения, а затем сохраняя их как отдельные PNG-файлы.

Ключевые технические возможности:

• Поддержка форматов: DOC, DOCX, DOT, DOTX, DOCM, RTF и другие
• Форматы вывода: Сохраняйте извлеченные изображения как PNG, JPG, BMP, EMF, GIF, TIFF
• Пакетная обработка: Обрабатывайте тысячи документов одним скриптом
• Выборочное извлечение: Извлекайте изображения из определенных секций, параграфов

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

✘ Минусы: Требуются базовые знания программирования; бесплатная версия имеет определенные ограничения

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

Краткое сравнение всех методов

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

Часто задаваемые вопросы об извлечении изображений из Word

В1: Могу ли я извлечь изображения из защищенного паролем документа Word?

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

В2: Как получить изображения высокого разрешения из Word?

О: Используйте трюк с ZIP для файлов .docx. Для файлов .doc метод «Сохранить как веб-страницу» обычно сохраняет лучшее качество, чем сохранение через правую кнопку мыши.

В3: Какие форматы изображений я могу извлечь из Word?

О: Word поддерживает встроенные изображения в различных форматах, включая:

• JPEG/JPG (фотографии)
• PNG (графика с прозрачностью)
• GIF (анимации, простая графика)
• BMP (растровые изображения)
• TIFF (изображения высокого разрешения)
• EMF/WMF (векторная графика)
• SVG (масштабируемая векторная графика — в новых версиях Word)

В4: Могу ли я извлечь изображения из нескольких документов Word одновременно?

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

Заключительные слова

Теперь у вас есть 5 бесплатных и эффективных способов извлечь изображения из документа Word, каждый из которых подходит для разных потребностей и уровней технических навыков. Для быстрых одиночных изображений используйте сохранение через правую кнопку мыши. Для пакетного извлечения трюк с ZIP — лучший бесплатный выбор. Онлайн-инструменты работают на ходу, а профессиональное программное обеспечение, такое как Spire.Doc, обеспечивает высококачественные, автоматизированные результаты для интенсивного использования.

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

Смотрите также

• Как объединить документы Word: сохранить или унифицировать форматирование
• Преобразование текста в PDF легко: 4 быстрых и профессиональных метода
• Преобразование Word в PNG: 3 практических способа, которые вы действительно можете использовать
• C#/VB.NET: Извлечение текста и изображений из Word
• Java: Извлечение текста и изображений из Word

Em aplicações modernas, JSON é um dos formatos de dados mais comuns para APIs, arquivos de configuração e troca de dados. No entanto, embora o JSON seja ideal para máquinas, nem sempre é legível por humanos. Exportar JSON para uma tabela PDF pode ajudar a apresentar informações estruturadas de forma clara em relatórios, painéis ou documentação interna.

Neste tutorial, você aprenderá como converter JSON para uma tabela PDF bem formatada usando Python e Spire.XLS, incluindo:

• Detectar automaticamente conjuntos de dados para exportação de tabelas
• Achatar campos JSON aninhados
• Gerar PDFs com aparência profissional

Também abordaremos a extração manual de conjuntos de dados para estruturas profundamente aninhadas, dando a você controle total sobre arquivos JSON complexos.

Por que converter JSON para PDF nem sempre é simples

O JSON vem em todas as formas e tamanhos:

• Matrizes planas: fáceis de converter diretamente em linhas
• Objetos aninhados: por exemplo, um dicionário de especificações dentro de cada produto
• Matrizes dentro de matrizes: por exemplo, uma lista de produtos dentro de um departamento
• Chaves inconsistentes: alguns objetos têm campos adicionais ou ausentes

Por exemplo, considere esta estrutura para o inventário de uma loja:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

Achatar isso em uma tabela não é trivial, porque campos aninhados precisam ser convertidos em colunas, e matrizes podem precisar ser expandidas ou unidas em strings. Nossa solução oferece um tratamento robusto para a maioria das estruturas JSON, ao mesmo tempo que oferece uma opção para extração manual em casos excepcionalmente complexos.

Para uma rápida atualização sobre a sintaxe e estrutura do JSON, consulte: Introdução ao JSON

Passo 1 — Carregar dados JSON

Antes de processar, carregue seu arquivo JSON no Python. Usar o módulo json integrado garante que o conteúdo seja analisado em dicionários e listas nativos do Python:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

O que este passo faz:

• Lê um arquivo JSON do disco
• Converte-o em objetos Python (dict e list) para processamento posterior

Dica: Sempre especifique encoding="utf-8" para evitar problemas com caracteres não-ASCII.

Passo 2 — Detectar automaticamente o conjunto de dados a ser exportado

Muitos arquivos JSON contêm várias listas aninhadas. Frequentemente, precisamos da lista de objetos que representa a “tabela principal” — geralmente a maior lista de dicionários. A função a seguir procura automaticamente o conjunto de dados mais semelhante a uma tabela:

def find_dataset(obj):
    """Recursively search JSON and return the most table-like dataset."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No suitable dataset found.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

Como funciona:

• Percorre recursivamente a estrutura JSON
• Pontua listas candidatas com base no número de chaves × número de itens
• Escolhe o conjunto de dados mais rico como a tabela principal

Limitações:

• Não mesclará automaticamente listas profundamente aninhadas (por exemplo, produtos de vários departamentos)
• Alguns campos podem exigir extração manual para visibilidade total

Opcional — Extração manual de conjunto de dados

Para conjuntos de dados profundamente aninhados ou personalizados, extraia os dados manualmente:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

Essa abordagem garante que você capture exatamente os campos de que precisa, incluindo a adição de contexto, como o departamento de cada produto.

Passo 3 — Achatar e normalizar o JSON

Para converter JSON em uma tabela, as estruturas aninhadas devem ser achatadas:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

O que este passo faz:

• Converte dicionários aninhados em nomes de colunas como specs_CPU, specs_RAM
• Converte listas de primitivos em strings separadas por vírgulas
• Preserva a primeira chave vista como a primeira coluna

Passo 4 — Exportar para PDF via Excel

Depois que os dados são achatados, exporte-os como um PDF usando Spire.XLS para Python. Em vez de renderizar o PDF diretamente, usamos o Excel como uma camada de layout intermediária. Essa abordagem oferece controle total sobre a estrutura da tabela, formatação, margens e dimensionamento antes de exportar para PDF.

Instalar dependência:

pip install spire.xls

Exportar JSON para PDF usando Spire.XLS:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

Dicas para formatação de PDF:

• Ajustar colunas automaticamente ao conteúdo
• Definir margens para legibilidade
• Habilitar linhas de grade para melhor visualização da tabela

Você também pode gostar: Converter Excel para PDF em Python

Passo 5 — Exemplo: Exportar produtos de um arquivo JSON complexo

Combine os passos anteriores:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatic detection
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manual extraction for nested structure
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

Pontos chave:

• A detecção automática funciona para a maioria das matrizes JSON
• A extração manual garante controle sobre conjuntos de dados aninhados e hierárquicos

Saída:

Exemplo completo em Python: JSON para PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Atoumatically Detect dataset
# ---------------------------
def find_dataset(obj):
    """
    Recursively search JSON and return the most table-like dataset.

    Strategy:
    - Find lists containing dictionaries
    - Score datasets based on number of fields
    - Choose the dataset with the richest structure
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Count unique keys across objects
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No suitable dataset found.")

    # choose best scored dataset
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robust Recursive JSON Flattener
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Recursively flattens nested dictionaries and lists.

    Rules:
    - Nested dict → key_subkey
    - List of primitives → comma-separated string
    - List of dicts → indexed columns (key_0_name, key_1_name)
    - Mixed lists / arrays-of-arrays → recursively indexed (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Empty list
                if not value:
                    items[new_key] = ""

                # List of primitives
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Mixed or nested lists
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Top-level lists
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalize JSON Data (First-Seen Column Order)
# ---------------------------
def normalize_json(data):
    """
    Flatten JSON objects and align headers, preserving the first-seen order.
    The first key in the first JSON object will be the first column.
    """
    if not isinstance(data, list):
        raise ValueError("Data must be a list of objects.")

    flattened_rows = [flatten_json(item) for item in data]

    # Track headers in first-seen order
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Align all rows to include all keys
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Export to PDF via Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write header
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

# ===========================
# Example: Complex JSON Dataset
# ===========================

# Load JSON from file
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Automatically detect dataset (work for most cases)
dataset = find_dataset(data)

'''
# Option 2. Manually extract dataset (work for complex unusual structures)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalize (first-seen key becomes first column)
rows, headers = normalize_json(dataset)

# Export to PDF
export_to_pdf(rows, headers, "output/Products.pdf")

Conclusão

Converter JSON para uma tabela PDF pode ser complicado, especialmente com estruturas aninhadas ou chaves inconsistentes. Usando Python e Spire.XLS, você pode achatar automaticamente o JSON e preservar uma ordem lógica de colunas, transformando conjuntos de dados complexos em tabelas limpas e legíveis, adequadas para relatórios ou documentação.

A detecção automática de conjuntos de dados lida com a maioria dos arquivos JSON, enquanto a extração manual permite capturar dados aninhados específicos quando necessário. Essa abordagem oferece uma maneira flexível e confiável de converter JSON em tabelas PDF profissionais sem perder estrutura ou contexto.

Perguntas frequentes

Isso pode lidar com qualquer arquivo JSON?

A detecção automática funciona para a maioria, mas a extração manual pode ser necessária para dados profundamente aninhados.

Como a ordem das colunas é determinada?

As colunas aparecem na ordem da primeira aparição nos objetos JSON.

Vários conjuntos de dados podem ser mesclados?

Sim, você pode concatenar conjuntos de dados antes de achatar.

Como lidar com campos ausentes?

Valores ausentes são representados automaticamente como células vazias.

Posso personalizar o layout do PDF?

Sim, margens, linhas de grade e opções de ajuste automático são totalmente configuráveis via Spire.XLS.

Veja também

• JSON para CSV em Python – Guia completo para JSON plano e aninhado
• Converter JSON para/de Excel em Python – Guia completo com exemplos
• Como converter CSV para JSON em Python: plano, aninhado e NDJSON

최신 애플리케이션에서 JSON은 API, 구성 파일 및 데이터 교환을 위한 가장 일반적인 데이터 형식 중 하나입니다. 그러나 JSON은 기계에 이상적이지만 항상 사람이 읽을 수 있는 것은 아닙니다. JSON을 PDF 테이블로 내보내면 보고서, 대시보드 또는 내부 문서에서 구조화된 정보를 명확하게 표시하는 데 도움이 될 수 있습니다.

이 튜토리얼에서는 Python과 Spire.XLS를 사용하여 JSON을 잘 형식화된 PDF 테이블로 변환하는 방법을 배우게 됩니다. 포함된 내용:

• 테이블 내보내기를 위한 데이터 세트 자동 감지
• 중첩된 JSON 필드 평탄화
• 전문적인 PDF 생성

또한 깊이 중첩된 구조에 대한 수동 데이터 세트 추출을 다루어 복잡한 JSON 파일을 완벽하게 제어할 수 있도록 합니다.

JSON을 PDF로 변환하는 것이 항상 간단하지 않은 이유

JSON은 모든 모양과 크기로 제공됩니다:

• 플랫 배열: 행으로 직접 변환하기 쉬움
• 중첩된 객체: 예: 각 제품 내부의 사양 사전
• 배열 내 배열: 예: 부서 내 제품 목록
• 일관성 없는 키: 일부 객체에는 추가 필드 또는 누락된 필드가 있음

예를 들어, 상점의 재고에 대한 다음 구조를 고려하십시오:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

중첩된 필드를 열로 변환해야 하고 배열을 확장하거나 문자열로 결합해야 할 수 있으므로 이를 테이블로 평탄화하는 것은 간단하지 않습니다. 저희 솔루션은 대부분의 JSON 구조에 대한 강력한 처리를 제공하는 동시에 매우 복잡한 경우를 위한 수동 추출 옵션을 제공합니다.

JSON 구문 및 구조에 대한 빠른 복습은 다음을 참조하십시오: JSON 소개

1단계 — JSON 데이터 로드

처리하기 전에 JSON 파일을 Python으로 로드하십시오. 내장된 json 모듈을 사용하면 콘텐츠가 기본 Python 사전 및 목록으로 구문 분석됩니다:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

이 단계의 역할:

• 디스크에서 JSON 파일 읽기
• 추가 처리를 위해 Python 객체(dict 및 list)로 변환

팁: 비 ASCII 문자와의 문제를 피하려면 항상 encoding="utf-8"을 지정하십시오.

2단계 — 내보낼 데이터 세트 자동 감지

많은 JSON 파일에는 여러 개의 중첩된 목록이 포함되어 있습니다. 종종 "기본 테이블"을 나타내는 객체 목록이 필요합니다. 이는 일반적으로 가장 큰 사전 목록입니다. 다음 함수는 가장 테이블과 유사한 데이터 세트를 자동으로 검색합니다:

def find_dataset(obj):
    """Recursively search JSON and return the most table-like dataset."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No suitable dataset found.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

작동 방식:

• JSON 구조를 재귀적으로 순회
• 키 수 × 항목 수를 기준으로 후보 목록 점수 매기기
• 가장 풍부한 데이터 세트를 기본 테이블로 선택

제한 사항:

• 깊이 중첩된 목록(예: 여러 부서의 제품)을 자동으로 병합하지 않음
• 일부 필드는 전체 가시성을 위해 수동 추출이 필요할 수 있음

선택 사항 — 수동 데이터 세트 추출

깊이 중첩되거나 사용자 정의된 데이터 세트의 경우 데이터를 수동으로 추출하십시오:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

이 접근 방식은 각 제품에 대한 부서와 같은 컨텍스트를 추가하는 것을 포함하여 필요한 정확한 필드를 캡처하도록 보장합니다.

3단계 — JSON 평탄화 및 정규화

JSON을 테이블로 변환하려면 중첩된 구조를 평탄화해야 합니다:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

이 단계의 역할:

• 중첩된 사전을 specs_CPU, specs_RAM과 같은 열 이름으로 변환
• 기본 형식 목록을 쉼표로 구분된 문자열로 변환
• 처음 본 키를 첫 번째 열로 유지

4단계 — Excel을 통해 PDF로 내보내기

데이터가 평탄화되면 Spire.XLS for Python을 사용하여 PDF로 내보냅니다. PDF를 직접 렌더링하는 대신 Excel을 중간 레이아웃 레이어로 사용합니다. 이 접근 방식은 PDF로 내보내기 전에 테이블 구조, 서식, 여백 및 크기 조정을 완벽하게 제어할 수 있도록 합니다.

종속성 설치:

pip install spire.xls

Spire.XLS를 사용하여 JSON을 PDF로 내보내기:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

PDF 서식 지정 팁:

• 내용에 맞게 열 자동 맞춤
• 가독성을 위해 여백 설정
• 더 나은 테이블 시각화를 위해 눈금선 활성화

관심 있을 만한 다른 글: Python에서 Excel을 PDF로 변환

5단계 — 예: 복잡한 JSON 파일에서 제품 내보내기

이전 단계를 결합합니다:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatic detection
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manual extraction for nested structure
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

핵심 사항:

• 자동 감지는 대부분의 JSON 배열에서 작동합니다
• 수동 추출은 중첩되고 계층적인 데이터 세트에 대한 제어를 보장합니다

출력:

전체 Python 예제: JSON을 PDF로

from spire.xls import Workbook
import json
import os

# ---------------------------
# Atoumatically Detect dataset
# ---------------------------
def find_dataset(obj):
    """
    Recursively search JSON and return the most table-like dataset.

    Strategy:
    - Find lists containing dictionaries
    - Score datasets based on number of fields
    - Choose the dataset with the richest structure
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Count unique keys across objects
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No suitable dataset found.")

    # choose best scored dataset
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robust Recursive JSON Flattener
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Recursively flattens nested dictionaries and lists.

    Rules:
    - Nested dict → key_subkey
    - List of primitives → comma-separated string
    - List of dicts → indexed columns (key_0_name, key_1_name)
    - Mixed lists / arrays-of-arrays → recursively indexed (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Empty list
                if not value:
                    items[new_key] = ""

                # List of primitives
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Mixed or nested lists
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Top-level lists
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalize JSON Data (First-Seen Column Order)
# ---------------------------
def normalize_json(data):
    """
    Flatten JSON objects and align headers, preserving the first-seen order.
    The first key in the first JSON object will be the first column.
    """
    if not isinstance(data, list):
        raise ValueError("Data must be a list of objects.")

    flattened_rows = [flatten_json(item) for item in data]

    # Track headers in first-seen order
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Align all rows to include all keys
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Export to PDF via Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write header
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

# ===========================
# Example: Complex JSON Dataset
# ===========================

# Load JSON from file
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Automatically detect dataset (work for most cases)
dataset = find_dataset(data)

'''
# Option 2. Manually extract dataset (work for complex unusual structures)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalize (first-seen key becomes first column)
rows, headers = normalize_json(dataset)

# Export to PDF
export_to_pdf(rows, headers, "output/Products.pdf")

결론

JSON을 PDF 테이블로 변환하는 것은 특히 중첩된 구조나 일관성 없는 키가 있는 경우 까다로울 수 있습니다. Python과 Spire.XLS를 사용하면 JSON을 자동으로 평탄화하고 논리적인 열 순서를 유지하여 복잡한 데이터 세트를 보고서나 문서에 적합한 깨끗하고 읽기 쉬운 테이블로 바꿀 수 있습니다.

자동 데이터 세트 감지는 대부분의 JSON 파일을 처리하는 반면, 수동 추출은 필요할 때 특정 중첩 데이터를 캡처할 수 있도록 합니다. 이 접근 방식은 구조나 컨텍스트를 잃지 않고 JSON을 전문적인 PDF 테이블로 변환하는 유연하고 신뢰할 수 있는 방법을 제공합니다.

자주 묻는 질문

이것으로 모든 JSON 파일을 처리할 수 있습니까?

자동 감지는 대부분의 경우에 작동하지만, 깊이 중첩된 데이터의 경우 수동 추출이 필요할 수 있습니다.

열 순서는 어떻게 결정됩니까?

열은 JSON 객체에서 처음 나타나는 순서대로 표시됩니다.

여러 데이터 세트를 병합할 수 있습니까?

예, 평탄화하기 전에 데이터 세트를 연결할 수 있습니다.

누락된 필드는 어떻게 처리합니까?

누락된 값은 자동으로 빈 셀로 표시됩니다.

PDF 레이아웃을 사용자 정의할 수 있습니까?

예, 여백, 눈금선 및 자동 맞춤 옵션은 Spire.XLS를 통해 완전히 구성할 수 있습니다.

참고 항목

• Python에서 JSON을 CSV로 – 플랫 및 중첩 JSON에 대한 완벽 가이드
• Python에서 JSON을 Excel로/Excel에서 JSON으로 변환 – 예제가 포함된 전체 가이드
• Python에서 CSV를 JSON으로 변환하는 방법: 플랫, 중첩 및 NDJSON

Nelle applicazioni moderne, JSON è uno dei formati di dati più comuni per API, file di configurazione e scambio di dati. Tuttavia, sebbene JSON sia ideale per le macchine, non è sempre leggibile dall'uomo. L'esportazione di JSON in una tabella PDF può aiutare a presentare le informazioni strutturate in modo chiaro in report, dashboard o documentazione interna.

In questo tutorial imparerai come convertire JSON in una tabella PDF ben formattata utilizzando Python e Spire.XLS, tra cui:

• Rilevamento automatico dei set di dati per l'esportazione in tabelle
• Appiattimento dei campi JSON nidificati
• Generazione di PDF dall'aspetto professionale

Copriremo anche l'estrazione manuale dei set di dati per strutture profondamente nidificate, offrendoti il pieno controllo su file JSON complessi.

Perché la conversione da JSON a PDF non è sempre semplice

JSON è disponibile in tutte le forme e dimensioni:

• Array piatti: facili da convertire direttamente in righe
• Oggetti nidificati: ad es. un dizionario di specifiche all'interno di ciascun prodotto
• Array all'interno di array: ad es. un elenco di prodotti all'interno di un reparto
• Chiavi incoerenti: alcuni oggetti hanno campi aggiuntivi o mancanti

Ad esempio, considera questa struttura per l'inventario di un negozio:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

Appiattire questo in una tabella non è banale, perché i campi nidificati devono essere convertiti in colonne e gli array potrebbero dover essere espansi o uniti in stringhe. La nostra soluzione fornisce una gestione solida per la maggior parte delle strutture JSON, offrendo al contempo un'opzione per l'estrazione manuale per casi insolitamente complessi.

Per un rapido ripasso della sintassi e della struttura JSON, vedere: Introduzione a JSON

Passaggio 1 — Carica i dati JSON

Prima dell'elaborazione, carica il tuo file JSON in Python. L'utilizzo del modulo json integrato garantisce che il contenuto venga analizzato in dizionari ed elenchi Python nativi:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

Cosa fa questo passaggio:

• Legge un file JSON dal disco
• Lo converte in oggetti Python (dict e list) per un'ulteriore elaborazione

Suggerimento: specificare sempre encoding="utf-8" per evitare problemi con caratteri non ASCII.

Passaggio 2 — Rileva automaticamente il set di dati da esportare

Molti file JSON contengono più elenchi nidificati. Spesso, abbiamo bisogno dell'elenco di oggetti che rappresenta la "tabella principale", di solito l'elenco più grande di dizionari. La seguente funzione cerca automaticamente il set di dati più simile a una tabella:

def find_dataset(obj):
    """Recursively search JSON and return the most table-like dataset."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No suitable dataset found.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

Come funziona:

• Attraversa ricorsivamente la struttura JSON
• Assegna un punteggio agli elenchi di candidati in base al numero di chiavi × numero di elementi
• Sceglie il set di dati più ricco come tabella principale

Limitazioni:

• Non unirà automaticamente elenchi profondamente nidificati (ad es. prodotti di più reparti)
• Alcuni campi potrebbero richiedere l'estrazione manuale per una visibilità completa

Opzionale — Estrazione manuale del set di dati

Per set di dati profondamente nidificati o personalizzati, estrai manualmente i dati:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

Questo approccio garantisce di acquisire i campi esatti di cui hai bisogno, inclusa l'aggiunta di contesto come il reparto per ogni prodotto.

Passaggio 3 — Appiattisci e normalizza JSON

Per convertire JSON in una tabella, le strutture nidificate devono essere appiattite:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

Cosa fa questo passaggio:

• Converte i dizionari nidificati in nomi di colonna come specs_CPU, specs_RAM
• Converte elenchi di primitive in stringhe separate da virgole
• Conserva la prima chiave vista come prima colonna

Passaggio 4 — Esporta in PDF tramite Excel

Una volta che i dati sono stati appiattiti, esportali come PDF utilizzando Spire.XLS for Python. Invece di eseguire il rendering diretto del PDF, utilizziamo Excel come livello di layout intermedio. Questo approccio fornisce il pieno controllo sulla struttura della tabella, sulla formattazione, sui margini e sul ridimensionamento prima dell'esportazione in PDF.

Installa dipendenza:

pip install spire.xls

Esporta JSON in PDF utilizzando Spire.XLS:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

Suggerimenti per la formattazione PDF:

• Adatta automaticamente le colonne al contenuto
• Imposta i margini per la leggibilità
• Abilita le linee della griglia per una migliore visualizzazione della tabella

Potrebbe piacerti anche: Converti Excel in PDF in Python

Passaggio 5 — Esempio: esporta prodotti da un file JSON complesso

Combina i passaggi precedenti:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatic detection
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manual extraction for nested structure
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

Punti chiave:

• Il rilevamento automatico funziona per la maggior parte degli array JSON
• L'estrazione manuale garantisce il controllo su set di dati nidificati e gerarchici

Output:

Esempio completo di Python: da JSON a PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Atoumatically Detect dataset
# ---------------------------
def find_dataset(obj):
    """
    Recursively search JSON and return the most table-like dataset.

    Strategy:
    - Find lists containing dictionaries
    - Score datasets based on number of fields
    - Choose the dataset with the richest structure
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Count unique keys across objects
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No suitable dataset found.")

    # choose best scored dataset
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robust Recursive JSON Flattener
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Recursively flattens nested dictionaries and lists.

    Rules:
    - Nested dict → key_subkey
    - List of primitives → comma-separated string
    - List of dicts → indexed columns (key_0_name, key_1_name)
    - Mixed lists / arrays-of-arrays → recursively indexed (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Empty list
                if not value:
                    items[new_key] = ""

                # List of primitives
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Mixed or nested lists
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Top-level lists
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalize JSON Data (First-Seen Column Order)
# ---------------------------
def normalize_json(data):
    """
    Flatten JSON objects and align headers, preserving the first-seen order.
    The first key in the first JSON object will be the first column.
    """
    if not isinstance(data, list):
        raise ValueError("Data must be a list of objects.")

    flattened_rows = [flatten_json(item) for item in data]

    # Track headers in first-seen order
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Align all rows to include all keys
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Export to PDF via Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write header
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

# ===========================
# Example: Complex JSON Dataset
# ===========================

# Load JSON from file
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Automatically detect dataset (work for most cases)
dataset = find_dataset(data)

'''
# Option 2. Manually extract dataset (work for complex unusual structures)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalize (first-seen key becomes first column)
rows, headers = normalize_json(dataset)

# Export to PDF
export_to_pdf(rows, headers, "output/Products.pdf")

Conclusione

La conversione di JSON in una tabella PDF può essere complicata, specialmente con strutture nidificate o chiavi incoerenti. Utilizzando Python e Spire.XLS, puoi appiattire automaticamente JSON e preservare un ordine logico delle colonne, trasformando set di dati complessi in tabelle pulite e leggibili adatte per report o documentazione.

Il rilevamento automatico del set di dati gestisce la maggior parte dei file JSON, mentre l'estrazione manuale consente di acquisire dati nidificati specifici quando necessario. Questo approccio offre un modo flessibile e affidabile per convertire JSON in tabelle PDF professionali senza perdere struttura o contesto.

Domande frequenti

Può gestire qualsiasi file JSON?

Il rilevamento automatico funziona per la maggior parte, ma potrebbe essere necessaria l'estrazione manuale per dati profondamente nidificati.

Come viene determinato l'ordine delle colonne?

Le colonne vengono visualizzate nell'ordine della prima apparizione negli oggetti JSON.

È possibile unire più set di dati?

Sì, è possibile concatenare i set di dati prima dell'appiattimento.

Come gestire i campi mancanti?

I valori mancanti vengono rappresentati automaticamente come celle vuote.

Posso personalizzare il layout del PDF?

Sì, margini, linee della griglia e opzioni di adattamento automatico sono completamente configurabili tramite Spire.XLS.

Vedi anche

• Da JSON a CSV in Python – Guida completa per JSON piatti e nidificati
• Converti JSON da/a Excel in Python – Guida completa con esempi
• Come convertire CSV in JSON in Python: piatto, nidificato e NDJSON

Dans les applications modernes, le JSON est l'un des formats de données les plus courants pour les API, les fichiers de configuration et l'échange de données. Cependant, bien que le JSON soit idéal pour les machines, il n'est pas toujours lisible par l'homme. L'exportation de JSON dans un tableau PDF peut aider à présenter des informations structurées de manière claire dans des rapports, des tableaux de bord ou de la documentation interne.

Dans ce tutoriel, vous apprendrez à convertir du JSON en un tableau PDF bien formaté en utilisant Python et Spire.XLS, y compris :

• Détecter automatiquement les ensembles de données pour l'exportation en tableau
• Aplatir les champs JSON imbriqués
• Générer des PDF d'aspect professionnel

Nous aborderons également l'extraction manuelle d'ensembles de données pour les structures profondément imbriquées, vous donnant un contrôle total sur les fichiers JSON complexes.

Pourquoi la conversion de JSON en PDF n'est pas toujours simple

Le JSON se présente sous toutes les formes et tailles :

• Tableaux plats : faciles à convertir directement en lignes
• Objets imbriqués : par ex., un dictionnaire de spécifications à l'intérieur de chaque produit
• Tableaux dans des tableaux : par ex., une liste de produits à l'intérieur d'un département
• Clés incohérentes : certains objets ont des champs supplémentaires ou manquants

Par exemple, considérez cette structure pour l'inventaire d'un magasin :

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

Aplatir cela en un tableau n'est pas trivial, car les champs imbriqués doivent être convertis en colonnes, et les tableaux peuvent avoir besoin d'être développés ou joints en chaînes de caractères. Notre solution offre une gestion robuste pour la plupart des structures JSON tout en proposant une option d'extraction manuelle pour les cas exceptionnellement complexes.

Pour un rappel rapide sur la syntaxe et la structure JSON, voir : Introduction à JSON

Étape 1 — Charger les données JSON

Avant le traitement, chargez votre fichier JSON dans Python. L'utilisation du module json intégré garantit que le contenu est analysé en dictionnaires et listes natifs de Python :

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

Ce que fait cette étape :

• Lit un fichier JSON depuis le disque
• Le convertit en objets Python (dict et list) pour un traitement ultérieur

Conseil : Spécifiez toujours encoding="utf-8" pour éviter les problèmes avec les caractères non-ASCII.

Étape 2 — Détecter automatiquement l'ensemble de données à exporter

De nombreux fichiers JSON contiennent plusieurs listes imbriquées. Souvent, nous avons besoin de la liste d'objets qui représente le « tableau principal » — généralement la plus grande liste de dictionnaires. La fonction suivante recherche automatiquement l'ensemble de données le plus semblable à un tableau :

def find_dataset(obj):
    """Recursively search JSON and return the most table-like dataset."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No suitable dataset found.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

Comment ça marche :

• Parcourt récursivement la structure JSON
• Note les listes candidates en fonction du nombre de clés × le nombre d'éléments
• Choisit l'ensemble de données le plus riche comme tableau principal

Limites :

• Ne fusionnera pas automatiquement les listes profondément imbriquées (par ex., les produits de plusieurs départements)
• Certains champs peuvent nécessiter une extraction manuelle pour une visibilité complète

Optionnel — Extraction manuelle de l'ensemble de données

Pour les ensembles de données profondément imbriqués ou personnalisés, extrayez manuellement les données :

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

Cette approche garantit que vous capturez les champs exacts dont vous avez besoin, y compris l'ajout de contexte tel que le département pour chaque produit.

Étape 3 — Aplatir et normaliser le JSON

Pour convertir du JSON en tableau, les structures imbriquées doivent être aplaties :

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

Ce que fait cette étape :

• Convertit les dictionnaires imbriqués en noms de colonnes comme specs_CPU, specs_RAM
• Convertit les listes de primitives en chaînes de caractères séparées par des virgules
• Préserve la première clé rencontrée comme première colonne

Étape 4 — Exporter en PDF via Excel

Une fois les données aplaties, exportez-les en PDF à l'aide de Spire.XLS for Python. Plutôt que de rendre le PDF directement, nous utilisons Excel comme une couche de mise en page intermédiaire. Cette approche offre un contrôle total sur la structure du tableau, le formatage, les marges et la mise à l'échelle avant l'exportation en PDF.

Installer la dépendance :

pip install spire.xls

Exporter du JSON en PDF avec Spire.XLS :

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

Conseils pour le formatage PDF :

• Ajuster automatiquement les colonnes au contenu
• Définir les marges pour la lisibilité
• Activer le quadrillage pour une meilleure visualisation du tableau

Vous aimerez peut-être aussi : Convertir Excel en PDF en Python

Étape 5 — Exemple : Exporter des produits à partir d'un fichier JSON complexe

Combinez les étapes précédentes :

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatic detection
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manual extraction for nested structure
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

Points clés :

• La détection automatique fonctionne pour la plupart des tableaux JSON
• L'extraction manuelle assure le contrôle sur les ensembles de données imbriqués et hiérarchiques

Sortie :

Exemple Python complet : JSON en PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Atoumatically Detect dataset
# ---------------------------
def find_dataset(obj):
    """
    Recursively search JSON and return the most table-like dataset.

    Strategy:
    - Find lists containing dictionaries
    - Score datasets based on number of fields
    - Choose the dataset with the richest structure
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Count unique keys across objects
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No suitable dataset found.")

    # choose best scored dataset
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robust Recursive JSON Flattener
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Recursively flattens nested dictionaries and lists.

    Rules:
    - Nested dict → key_subkey
    - List of primitives → comma-separated string
    - List of dicts → indexed columns (key_0_name, key_1_name)
    - Mixed lists / arrays-of-arrays → recursively indexed (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Empty list
                if not value:
                    items[new_key] = ""

                # List of primitives
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Mixed or nested lists
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Top-level lists
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalize JSON Data (First-Seen Column Order)
# ---------------------------
def normalize_json(data):
    """
    Flatten JSON objects and align headers, preserving the first-seen order.
    The first key in the first JSON object will be the first column.
    """
    if not isinstance(data, list):
        raise ValueError("Data must be a list of objects.")

    flattened_rows = [flatten_json(item) for item in data]

    # Track headers in first-seen order
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Align all rows to include all keys
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Export to PDF via Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write header
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

# ===========================
# Example: Complex JSON Dataset
# ===========================

# Load JSON from file
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Automatically detect dataset (work for most cases)
dataset = find_dataset(data)

'''
# Option 2. Manually extract dataset (work for complex unusual structures)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalize (first-seen key becomes first column)
rows, headers = normalize_json(dataset)

# Export to PDF
export_to_pdf(rows, headers, "output/Products.pdf")

Conclusion

La conversion de JSON en tableau PDF peut être délicate, en particulier avec des structures imbriquées ou des clés incohérentes. En utilisant Python et Spire.XLS, vous pouvez automatiquement aplatir le JSON et préserver un ordre de colonnes logique, transformant des ensembles de données complexes en tableaux propres et lisibles, adaptés aux rapports ou à la documentation.

La détection automatique d'ensembles de données gère la plupart des fichiers JSON, tandis que l'extraction manuelle permet de capturer des données imbriquées spécifiques si nécessaire. Cette approche offre un moyen flexible et fiable de convertir du JSON en tableaux PDF professionnels sans perdre la structure ni le contexte.

FAQ

Cela peut-il gérer n'importe quel fichier JSON ?

La détection automatique fonctionne pour la plupart, mais une extraction manuelle peut être nécessaire pour les données profondément imbriquées.

Comment l'ordre des colonnes est-il déterminé ?

Les colonnes apparaissent dans l'ordre de leur première apparition dans les objets JSON.

Plusieurs ensembles de données peuvent-ils être fusionnés ?

Oui, vous pouvez concaténer les ensembles de données avant l'aplatissement.

Comment gérer les champs manquants ?

Les valeurs manquantes sont automatiquement représentées par des cellules vides.

Puis-je personnaliser la mise en page du PDF ?

Oui, les marges, le quadrillage et les options d'ajustement automatique sont entièrement configurables via Spire.XLS.

Voir aussi

• JSON vers CSV en Python – Guide complet pour JSON plat et imbriqué
• Convertir JSON vers/depuis Excel en Python – Guide complet avec exemples
• Comment convertir CSV en JSON en Python : Plat, Imbriqué & NDJSON

En las aplicaciones modernas, JSON es uno de los formatos de datos más comunes para API, archivos de configuración e intercambio de datos. Sin embargo, aunque JSON es ideal para las máquinas, no siempre es legible por humanos. Exportar JSON a una tabla PDF puede ayudar a presentar información estructurada de forma clara en informes, paneles o documentación interna.

En este tutorial, aprenderá a convertir JSON a una tabla PDF bien formateada usando Python y Spire.XLS, incluyendo:

• Detección automática de conjuntos de datos para exportación a tablas
• Aplanamiento de campos JSON anidados
• Generación de PDF con aspecto profesional

También cubriremos la extracción manual de conjuntos de datos para estructuras profundamente anidadas, dándole control total sobre archivos JSON complejos.

Por Qué Convertir JSON a PDF No Siempre es Sencillo

JSON viene en todas las formas y tamaños:

• Arreglos planos: fáciles de convertir directamente en filas
• Objetos anidados: p. ej., un diccionario de especificaciones dentro de cada producto
• Arreglos dentro de arreglos: p. ej., una lista de productos dentro de un departamento
• Claves inconsistentes: algunos objetos tienen campos adicionales o faltantes

Por ejemplo, considere esta estructura para el inventario de una tienda:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

Aplanar esto en una tabla no es trivial, porque los campos anidados deben convertirse en columnas, y los arreglos pueden necesitar ser expandidos o unidos en cadenas. Nuestra solución proporciona un manejo robusto para la mayoría de las estructuras JSON, al tiempo que ofrece una opción para la extracción manual en casos inusualmente complejos.

Para un repaso rápido sobre la sintaxis y estructura de JSON, consulte: Introducción a JSON

Paso 1 — Cargar Datos JSON

Antes de procesar, cargue su archivo JSON en Python. Usar el módulo incorporado json asegura que el contenido se analice en diccionarios y listas nativas de Python:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

Lo que hace este paso:

• Lee un archivo JSON del disco
• Lo convierte en objetos de Python (dict y list) para su posterior procesamiento

Consejo: Siempre especifique encoding="utf-8" para evitar problemas con caracteres que no son ASCII.

Paso 2 — Detectar Automáticamente el Conjunto de Datos a Exportar

Muchos archivos JSON contienen múltiples listas anidadas. A menudo, necesitamos la lista de objetos que representa la “tabla principal”, generalmente la lista más grande de diccionarios. La siguiente función busca automáticamente el conjunto de datos más parecido a una tabla:

def find_dataset(obj):
    """Busca recursivamente en el JSON y devuelve el conjunto de datos más parecido a una tabla."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No se encontró ningún conjunto de datos adecuado.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Uso
dataset = find_dataset(data)

Cómo funciona:

• Recorre recursivamente la estructura JSON
• Puntúa las listas candidatas según el número de claves × el número de elementos
• Elige el conjunto de datos más rico como la tabla principal

Limitaciones:

• No fusionará automáticamente listas profundamente anidadas (p. ej., productos de múltiples departamentos)
• Algunos campos pueden requerir extracción manual para una visibilidad completa

Opcional — Extracción Manual del Conjunto de Datos

Para conjuntos de datos profundamente anidados o personalizados, extraiga los datos manualmente:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

Este enfoque garantiza que capture los campos exactos que necesita, incluida la adición de contexto como el departamento para cada producto.

Paso 3 — Aplanar y Normalizar JSON

Para convertir JSON a una tabla, las estructuras anidadas deben aplanarse:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

Lo que hace este paso:

• Convierte diccionarios anidados en nombres de columna como especs_CPU, especs_RAM
• Convierte listas de primitivos en cadenas separadas por comas
• Conserva la primera clave vista como la primera columna

Paso 4 — Exportar a PDF a través de Excel

Una vez que los datos están aplanados, expórtelos como PDF usando Spire.XLS para Python. En lugar de renderizar el PDF directamente, usamos Excel como una capa de diseño intermedia. Este enfoque proporciona un control total sobre la estructura de la tabla, el formato, los márgenes y el escalado antes de exportar a PDF.

Instalar dependencia:

pip install spire.xls

Exportar JSON a PDF usando Spire.XLS:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Escribir encabezados
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Escribir filas de datos
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formato
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF guardado: {output_path}")

Consejos para el formato de PDF:

• Ajustar automáticamente las columnas al contenido
• Establecer márgenes para la legibilidad
• Habilitar líneas de cuadrícula para una mejor visualización de la tabla

También te puede interesar: Convertir Excel a PDF en Python

Paso 5 — Ejemplo: Exportar Productos desde un Archivo JSON Complejo

Combine los pasos anteriores:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Opción 1: Detección automática
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Opción 2: Extracción manual para estructura anidada
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

Puntos clave:

• La detección automática funciona para la mayoría de los arreglos JSON
• La extracción manual asegura el control sobre conjuntos de datos anidados y jerárquicos

Salida:

Ejemplo Completo de Python: JSON a PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Detectar Automáticamente el Conjunto de Datos
# ---------------------------
def find_dataset(obj):
    """
    Busca recursivamente en el JSON y devuelve el conjunto de datos más parecido a una tabla.

    Estrategia:
    - Encontrar listas que contienen diccionarios
    - Puntuar conjuntos de datos según el número de campos
    - Elegir el conjunto de datos con la estructura más rica
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Contar claves únicas en todos los objetos
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No se encontró ningún conjunto de datos adecuado.")

    # elegir el conjunto de datos con la mejor puntuación
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Aplanador JSON Recursivo Robusto
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Aplana recursivamente diccionarios y listas anidados.

    Reglas:
    - Dict anidado → clave_subclave
    - Lista de primitivos → cadena separada por comas
    - Lista de dicts → columnas indexadas (clave_0_nombre, clave_1_nombre)
    - Listas mixtas / arreglos de arreglos → indexados recursivamente (clave_0_0, clave_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Lista vacía
                if not value:
                    items[new_key] = ""

                # Lista de primitivos
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Listas mixtas o anidadas
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Listas de nivel superior
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalizar Datos JSON (Orden de Columnas según Primera Aparición)
# ---------------------------
def normalize_json(data):
    """
    Aplanar objetos JSON y alinear encabezados, conservando el orden de la primera aparición.
    La primera clave en el primer objeto JSON será la primera columna.
    """
    if not isinstance(data, list):
        raise ValueError("Los datos deben ser una lista de objetos.")

    flattened_rows = [flatten_json(item) for item in data]

    # Rastrear encabezados en el orden de primera aparición
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Alinear todas las filas para incluir todas las claves
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Exportar a PDF a través de Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Escribir encabezado
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Escribir filas de datos
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formato
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF guardado: {output_path}")

# ===========================
# Ejemplo: Conjunto de Datos JSON Complejo
# ===========================

# Cargar JSON desde archivo
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Opción 1. Detectar automáticamente el conjunto de datos (funciona para la mayoría de los casos)
dataset = find_dataset(data)

'''
# Opción 2. Extraer manualmente el conjunto de datos (funciona para estructuras complejas e inusuales)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalizar (la primera clave vista se convierte en la primera columna)
rows, headers = normalize_json(dataset)

# Exportar a PDF
export_to_pdf(rows, headers, "output/Products.pdf")

Conclusión

Convertir JSON a una tabla PDF puede ser complicado, especialmente con estructuras anidadas o claves inconsistentes. Usando Python y Spire.XLS, puede aplanar automáticamente JSON y preservar un orden lógico de columnas, convirtiendo conjuntos de datos complejos en tablas limpias y legibles adecuadas para informes o documentación.

La detección automática de conjuntos de datos maneja la mayoría de los archivos JSON, mientras que la extracción manual permite capturar datos anidados específicos cuando es necesario. Este enfoque ofrece una forma flexible y confiable de convertir JSON en tablas PDF profesionales sin perder estructura ni contexto.

Preguntas Frecuentes

¿Puede manejar cualquier archivo JSON?

La detección automática funciona para la mayoría, pero puede ser necesaria la extracción manual para datos profundamente anidados.

¿Cómo se determina el orden de las columnas?

Las columnas aparecen en el orden de su primera aparición en los objetos JSON.

¿Se pueden fusionar múltiples conjuntos de datos?

Sí, puede concatenar conjuntos de datos antes de aplanarlos.

¿Cómo manejar los campos faltantes?

Los valores faltantes se representan automáticamente como celdas vacías.

¿Puedo personalizar el diseño del PDF?

Sí, los márgenes, las líneas de cuadrícula y las opciones de autoajuste son totalmente configurables a través de Spire.XLS.

Ver También

• JSON a CSV en Python – Guía Completa para JSON Plano y Anidado
• Convertir JSON a/desde Excel en Python – Guía Completa con Ejemplos
• Cómo Convertir CSV a JSON en Python: Plano, Anidado y NDJSON

In modernen Anwendungen ist JSON eines der gebräuchlichsten Datenformate für APIs, Konfigurationsdateien und den Datenaustausch. Obwohl JSON ideal für Maschinen ist, ist es nicht immer für Menschen lesbar. Der Export von JSON in eine PDF-Tabelle kann helfen, strukturierte Informationen in Berichten, Dashboards oder interner Dokumentation klar darzustellen.

In diesem Tutorial erfahren Sie, wie Sie mit Python und Spire.XLS JSON in eine gut formatierte PDF-Tabelle konvertieren, einschließlich:

• Automatisches Erkennen von Datensätzen für den Tabellenexport
• Abflachen verschachtelter JSON-Felder
• Erstellen professionell aussehender PDFs

Wir werden auch die manuelle Datensatzextraktion für tief verschachtelte Strukturen behandeln, die Ihnen die volle Kontrolle über komplexe JSON-Dateien gibt.

Warum die Konvertierung von JSON in PDF nicht immer einfach ist

JSON gibt es in allen Formen und Größen:

• Flache Arrays: einfach direkt in Zeilen zu konvertieren
• Verschachtelte Objekte: z. B. ein Spezifikationswörterbuch in jedem Produkt
• Arrays in Arrays: z. B. eine Liste von Produkten innerhalb einer Abteilung
• Inkonsistente Schlüssel: Einige Objekte haben zusätzliche oder fehlende Felder

Betrachten Sie zum Beispiel diese Struktur für das Inventar eines Geschäfts:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

Dies in eine Tabelle abzuflachen ist nicht trivial, da verschachtelte Felder in Spalten umgewandelt und Arrays möglicherweise erweitert oder zu Zeichenfolgen zusammengefügt werden müssen. Unsere Lösung bietet eine robuste Handhabung für die meisten JSON-Strukturen und bietet gleichzeitig eine Option zur manuellen Extraktion für ungewöhnlich komplexe Fälle.

Für eine schnelle Auffrischung der JSON-Syntax und -Struktur siehe: Einführung in JSON

Schritt 1 — JSON-Daten laden

Laden Sie vor der Verarbeitung Ihre JSON-Datei in Python. Die Verwendung des integrierten json-Moduls stellt sicher, dass der Inhalt in native Python-Wörterbücher und -Listen geparst wird:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

Was dieser Schritt bewirkt:

• Liest eine JSON-Datei von der Festplatte
• Konvertiert sie zur weiteren Verarbeitung in Python-Objekte (dict und list)

Tipp: Geben Sie immer encoding="utf-8" an, um Probleme mit Nicht-ASCII-Zeichen zu vermeiden.

Schritt 2 — Den zu exportierenden Datensatz automatisch erkennen

Viele JSON-Dateien enthalten mehrere verschachtelte Listen. Oft benötigen wir die Liste der Objekte, die die „Haupttabelle“ darstellt – normalerweise die größte Liste von Wörterbüchern. Die folgende Funktion sucht automatisch nach dem tabellenähnlichsten Datensatz:

def find_dataset(obj):
    """Durchsuchen Sie JSON rekursiv und geben Sie den tabellenähnlichsten Datensatz zurück."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("Kein passender Datensatz gefunden.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

Wie es funktioniert:

• Durchläuft rekursiv die JSON-Struktur
• Bewertet Kandidatenlisten basierend auf der Anzahl der Schlüssel × der Anzahl der Elemente
• Wählt den reichhaltigsten Datensatz als Haupttabelle aus

Einschränkungen:

• Verschmilzt nicht automatisch tief verschachtelte Listen (z. B. Produkte mehrerer Abteilungen)
• Einige Felder erfordern möglicherweise eine manuelle Extraktion für volle Sichtbarkeit

Optional — Manuelle Datensatzextraktion

Extrahieren Sie für tief verschachtelte oder benutzerdefinierte Datensätze die Daten manuell:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

Dieser Ansatz garantiert, dass Sie genau die Felder erfassen, die Sie benötigen, einschließlich des Hinzufügens von Kontext wie der Abteilung für jedes Produkt.

Schritt 3 — JSON abflachen und normalisieren

Um JSON in eine Tabelle zu konvertieren, müssen verschachtelte Strukturen abgeflacht werden:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

Was dieser Schritt bewirkt:

• Konvertiert verschachtelte Wörterbücher in Spaltennamen wie specs_CPU, specs_RAM
• Konvertiert Listen von Primitiven in durch Kommas getrennte Zeichenfolgen
• Behält den zuerst gesehenen Schlüssel als erste Spalte bei

Schritt 4 — Über Excel in PDF exportieren

Sobald die Daten abgeflacht sind, exportieren Sie sie als PDF mit Spire.XLS for Python. Anstatt PDF direkt zu rendern, verwenden wir Excel als zwischengeschaltete Layout-Ebene. Dieser Ansatz bietet die volle Kontrolle über Tabellenstruktur, Formatierung, Ränder und Skalierung vor dem Export in PDF.

Abhängigkeit installieren:

pip install spire.xls

JSON mit Spire.XLS in PDF exportieren:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF gespeichert: {output_path}")

Tipps zur PDF-Formatierung:

• Spalten automatisch an den Inhalt anpassen
• Ränder für die Lesbarkeit festlegen
• Gitternetzlinien für eine bessere Tabellenvisualisierung aktivieren

Das könnte Ihnen auch gefallen: Excel in Python in PDF konvertieren

Schritt 5 — Beispiel: Produkte aus einer komplexen JSON-Datei exportieren

Kombinieren Sie die vorherigen Schritte:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatische Erkennung
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manuelle Extraktion für verschachtelte Strukturen
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

Wichtige Punkte:

• Die automatische Erkennung funktioniert für die meisten JSON-Arrays
• Die manuelle Extraktion gewährleistet die Kontrolle über verschachtelte und hierarchische Datensätze

Ausgabe:

Vollständiges Python-Beispiel: JSON zu PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Datensatz automatisch erkennen
# ---------------------------
def find_dataset(obj):
    """
    Durchsuchen Sie JSON rekursiv und geben Sie den tabellenähnlichsten Datensatz zurück.

    Strategie:
    - Listen finden, die Wörterbücher enthalten
    - Datensätze basierend auf der Anzahl der Felder bewerten
    - Wählen Sie den Datensatz mit der reichhaltigsten Struktur
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Eindeutige Schlüssel über Objekte hinweg zählen
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("Kein passender Datensatz gefunden.")

    # bestbewerteten Datensatz auswählen
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robuster rekursiver JSON-Abflacher
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Flacht verschachtelte Wörterbücher und Listen rekursiv ab.

    Regeln:
    - Verschachteltes dict → key_subkey
    - Liste von Primitiven → durch Kommas getrennte Zeichenfolge
    - Liste von dicts → indizierte Spalten (key_0_name, key_1_name)
    - Gemischte Listen / Arrays-von-Arrays → rekursiv indiziert (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Leere Liste
                if not value:
                    items[new_key] = ""

                # Liste von Primitiven
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Gemischte oder verschachtelte Listen
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Listen der obersten Ebene
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# JSON-Daten normalisieren (Spaltenreihenfolge nach erstem Auftreten)
# ---------------------------
def normalize_json(data):
    """
    JSON-Objekte abflachen und Kopfzeilen ausrichten, wobei die Reihenfolge des ersten Auftretens beibehalten wird.
    Der erste Schlüssel im ersten JSON-Objekt wird die erste Spalte sein.
    """
    if not isinstance(data, list):
        raise ValueError("Daten müssen eine Liste von Objekten sein.")

    flattened_rows = [flatten_json(item) for item in data]

    # Kopfzeilen in der Reihenfolge des ersten Auftretens verfolgen
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Alle Zeilen ausrichten, um alle Schlüssel einzuschließen
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Über Excel in PDF exportieren
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Kopfzeile schreiben
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Datenzeilen schreiben
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatierung
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF gespeichert: {output_path}")

# ===========================
# Beispiel: Komplexer JSON-Datensatz
# ===========================

# JSON aus Datei laden
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Datensatz automatisch erkennen (funktioniert in den meisten Fällen)
dataset = find_dataset(data)

'''
# Option 2. Datensatz manuell extrahieren (funktioniert für komplexe ungewöhnliche Strukturen)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalisieren (der zuerst gesehene Schlüssel wird zur ersten Spalte)
rows, headers = normalize_json(dataset)

# In PDF exportieren
export_to_pdf(rows, headers, "output/Products.pdf")

Fazit

Die Konvertierung von JSON in eine PDF-Tabelle kann schwierig sein, insbesondere bei verschachtelten Strukturen oder inkonsistenten Schlüsseln. Mit Python und Spire.XLS können Sie JSON automatisch abflachen und eine logische Spaltenreihenfolge beibehalten, wodurch komplexe Datensätze in saubere, lesbare Tabellen umgewandelt werden, die für Berichte oder Dokumentationen geeignet sind.

Die automatische Datensatzerkennung verarbeitet die meisten JSON-Dateien, während die manuelle Extraktion bei Bedarf das Erfassen spezifischer verschachtelter Daten ermöglicht. Dieser Ansatz bietet eine flexible und zuverlässige Möglichkeit, JSON in professionelle PDF-Tabellen zu konvertieren, ohne Struktur oder Kontext zu verlieren.

Häufig gestellte Fragen

Kann dies jede JSON-Datei verarbeiten?

Die automatische Erkennung funktioniert für die meisten, aber für tief verschachtelte Daten kann eine manuelle Extraktion erforderlich sein.

Wie wird die Spaltenreihenfolge bestimmt?

Die Spalten erscheinen in der Reihenfolge ihres ersten Auftretens in den JSON-Objekten.

Können mehrere Datensätze zusammengeführt werden?

Ja, Sie können Datensätze vor dem Abflachen verketten.

Wie werden fehlende Felder behandelt?

Fehlende Werte werden automatisch als leere Zellen dargestellt.

Kann ich das PDF-Layout anpassen?

Ja, Ränder, Gitternetzlinien und Auto-Fit-Optionen sind über Spire.XLS vollständig konfigurierbar.

Siehe auch

• JSON zu CSV in Python – Vollständiger Leitfaden für flaches & verschachteltes JSON
• JSON in/aus Excel in Python konvertieren – Vollständiger Leitfaden mit Beispielen
• Wie man CSV in JSON in Python konvertiert: Flach, verschachtelt & NDJSON

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

В этом руководстве вы узнаете, как преобразовать JSON в хорошо отформатированную таблицу PDF с помощью Python и Spire.XLS, включая:

• Автоматическое определение наборов данных для экспорта в таблицу
• Выравнивание вложенных полей JSON
• Создание профессионально выглядящих PDF-файлов

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

Почему преобразование JSON в PDF не всегда просто

JSON бывает всех форм и размеров:

• Плоские массивы: легко конвертировать непосредственно в строки
• Вложенные объекты: например, словарь спецификаций внутри каждого продукта
• Массивы внутри массивов: например, список продуктов внутри отдела
• Несогласованные ключи: некоторые объекты имеют дополнительные или отсутствующие поля

Например, рассмотрим эту структуру для инвентаря магазина:

{
  "store": {
    "departments": [
      {
        "name": "Computers",
        "products": [{"id": 1, "name": "Laptop", "specs": {"CPU": "i7"}}]
      },
      {
        "name": "Accessories",
        "products": [{"id": 101, "name": "Mouse", "colors": ["Black", "White"]}]
      }
    ]
  }
}

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

Для краткого обзора синтаксиса и структуры JSON см.: Введение в JSON

Шаг 1 — Загрузка данных JSON

Перед обработкой загрузите ваш файл JSON в Python. Использование встроенного модуля json гарантирует, что содержимое будет проанализировано в нативные словари и списки Python:

import json

file_path = r"C:\Users\Administrator\Desktop\Products.json"

with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

Что делает этот шаг:

• Читает файл JSON с диска
• Преобразует его в объекты Python (dict и list) для дальнейшей обработки

Совет: Всегда указывайте encoding="utf-8", чтобы избежать проблем с символами, не относящимися к ASCII.

Шаг 2 — Автоматическое определение набора данных для экспорта

Многие файлы JSON содержат несколько вложенных списков. Часто нам нужен список объектов, который представляет «основную таблицу» — обычно это самый большой список словарей. Следующая функция автоматически ищет наиболее похожий на таблицу набор данных:

def find_dataset(obj):
    """Recursively search JSON and return the most table-like dataset."""
    candidates = []

    def search(node):
        if isinstance(node, list):
            if node and all(isinstance(i, dict) for i in node):
                keys = set()
                for item in node:
                    keys.update(item.keys())
                score = len(keys) * len(node)
                candidates.append((score, node))
            for item in node:
                search(item)
        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)
    if not candidates:
        raise ValueError("No suitable dataset found.")
    candidates.sort(key=lambda x: x[0], reverse=True)
    return candidates[0][1]

# Usage
dataset = find_dataset(data)

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

• Рекурсивно обходит структуру JSON
• Оценивает списки-кандидаты на основе количества ключей × количества элементов
• Выбирает самый богатый набор данных в качестве основной таблицы

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

• Не будет автоматически объединять глубоко вложенные списки (например, продукты нескольких отделов)
• Некоторые поля могут потребовать ручного извлечения для полной видимости

Необязательно — Ручное извлечение набора данных

Для глубоко вложенных или настраиваемых наборов данных извлекайте данные вручную:

dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)

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

Шаг 3 — Выравнивание и нормализация JSON

Чтобы преобразовать JSON в таблицу, вложенные структуры должны быть выровнены:

def flatten_json(obj, parent_key="", sep="_"):
    items = {}
    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key
            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))
            elif isinstance(value, list):
                if not value:
                    items[new_key] = ""
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))
            else:
                items[new_key] = value
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))
    else:
        items[parent_key] = obj
    return items

def normalize_json(data):
    flattened_rows = [flatten_json(item) for item in data]
    all_keys_ordered, seen_keys = [], set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]
    return aligned_rows, all_keys_ordered

rows, headers = normalize_json(dataset)

Что делает этот шаг:

• Преобразует вложенные словари в имена столбцов, такие как specs_CPU, specs_RAM
• Преобразует списки примитивов в строки, разделенные запятыми
• Сохраняет первый встреченный ключ в качестве первого столбца

Шаг 4 — Экспорт в PDF через Excel

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

Установить зависимость:

pip install spire.xls

Экспорт JSON в PDF с помощью Spire.XLS:

from spire.xls import Workbook
import os

def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write headers
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

Советы по форматированию PDF:

• Автоподбор ширины столбцов по содержимому
• Установите поля для удобства чтения
• Включите линии сетки для лучшей визуализации таблицы

Вам также может понравиться: Преобразование Excel в PDF на Python

Шаг 5 — Пример: Экспорт продуктов из сложного файла JSON

Объедините предыдущие шаги:

file_path = r"C:\Users\Administrator\Desktop\Products.json"
with open(file_path, "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1: Automatic detection
dataset = find_dataset(data)
rows, headers = normalize_json(dataset)

# Option 2: Manual extraction for nested structure
# dataset = []
# for dept in data["store"]["departments"]:
#     for prod in dept["products"]:
#         prod["department"] = dept["name"]
#         dataset.append(prod)
# rows, headers = normalize_json(dataset)

export_to_pdf(rows, headers, "output/Products.pdf")

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

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

Вывод:

Полный пример на Python: JSON в PDF

from spire.xls import Workbook
import json
import os

# ---------------------------
# Atoumatically Detect dataset
# ---------------------------
def find_dataset(obj):
    """
    Recursively search JSON and return the most table-like dataset.

    Strategy:
    - Find lists containing dictionaries
    - Score datasets based on number of fields
    - Choose the dataset with the richest structure
    """

    candidates = []

    def search(node):
        if isinstance(node, list):

            if node and all(isinstance(i, dict) for i in node):

                # Count unique keys across objects
                keys = set()
                for item in node:
                    keys.update(item.keys())

                score = len(keys) * len(node)
                candidates.append((score, node))

            for item in node:
                search(item)

        elif isinstance(node, dict):
            for value in node.values():
                search(value)

    search(obj)

    if not candidates:
        raise ValueError("No suitable dataset found.")

    # choose best scored dataset
    candidates.sort(key=lambda x: x[0], reverse=True)

    return candidates[0][1]

# ---------------------------
# Robust Recursive JSON Flattener
# ---------------------------
def flatten_json(obj, parent_key="", sep="_"):
    """
    Recursively flattens nested dictionaries and lists.

    Rules:
    - Nested dict → key_subkey
    - List of primitives → comma-separated string
    - List of dicts → indexed columns (key_0_name, key_1_name)
    - Mixed lists / arrays-of-arrays → recursively indexed (key_0_0, key_0_1)
    """
    items = {}

    if isinstance(obj, dict):
        for key, value in obj.items():
            new_key = f"{parent_key}{sep}{key}" if parent_key else key

            if isinstance(value, dict):
                items.update(flatten_json(value, new_key, sep))

            elif isinstance(value, list):
                # Empty list
                if not value:
                    items[new_key] = ""

                # List of primitives
                elif all(not isinstance(i, (dict, list)) for i in value):
                    items[new_key] = ", ".join(map(str, value))

                # Mixed or nested lists
                else:
                    for index, item in enumerate(value):
                        indexed_key = f"{new_key}{sep}{index}"
                        items.update(flatten_json(item, indexed_key, sep))

            else:
                items[new_key] = value

    # Top-level lists
    elif isinstance(obj, list):
        for index, item in enumerate(obj):
            indexed_key = f"{parent_key}{sep}{index}" if parent_key else str(index)
            items.update(flatten_json(item, indexed_key, sep))

    else:
        items[parent_key] = obj

    return items

# ---------------------------
# Normalize JSON Data (First-Seen Column Order)
# ---------------------------
def normalize_json(data):
    """
    Flatten JSON objects and align headers, preserving the first-seen order.
    The first key in the first JSON object will be the first column.
    """
    if not isinstance(data, list):
        raise ValueError("Data must be a list of objects.")

    flattened_rows = [flatten_json(item) for item in data]

    # Track headers in first-seen order
    all_keys_ordered = []
    seen_keys = set()
    for row in flattened_rows:
        for key in row.keys():
            if key not in seen_keys:
                seen_keys.add(key)
                all_keys_ordered.append(key)

    # Align all rows to include all keys
    aligned_rows = [{key: str(row.get(key, "")) for key in all_keys_ordered} for row in flattened_rows]

    return aligned_rows, all_keys_ordered

# ---------------------------
# Export to PDF via Excel
# ---------------------------
def export_to_pdf(data_rows, headers, output_path):
    workbook = Workbook()
    sheet = workbook.Worksheets[0]

    # Write header
    for col, header in enumerate(headers):
        sheet.Range[1, col + 1].Text = header

    # Write data rows
    for row_idx, row in enumerate(data_rows, start=2):
        for col_idx, header in enumerate(headers):
            sheet.Range[row_idx, col_idx + 1].Text = row[header]

    # Formatting
    workbook.ConverterSetting.SheetFitToPageRetainPaperSize = True
    workbook.ConverterSetting.SheetFitToWidth = True
    for i in range(1, sheet.Range.ColumnCount + 1):
        sheet.AutoFitColumn(i)
    sheet.PageSetup.LeftMargin = 0.3
    sheet.PageSetup.RightMargin = 0.3
    sheet.PageSetup.TopMargin = 0.5
    sheet.PageSetup.BottomMargin = 0.5
    sheet.PageSetup.IsPrintGridlines = True
    sheet.DefaultRowHeight = 18

    os.makedirs(os.path.dirname(output_path), exist_ok=True)
    sheet.SaveToPdf(output_path)
    workbook.Dispose()
    print(f"PDF saved: {output_path}")

# ===========================
# Example: Complex JSON Dataset
# ===========================

# Load JSON from file
with open(r"C:\Users\Administrator\Desktop\Products.json", "r", encoding="utf-8") as f:
    data = json.load(f)

# Option 1. Automatically detect dataset (work for most cases)
dataset = find_dataset(data)

'''
# Option 2. Manually extract dataset (work for complex unusual structures)
dataset = []
for dept in data["store"]["departments"]:
    for prod in dept["products"]:
        prod["department"] = dept["name"]
        dataset.append(prod)
'''

# Normalize (first-seen key becomes first column)
rows, headers = normalize_json(dataset)

# Export to PDF
export_to_pdf(rows, headers, "output/Products.pdf")

Заключение

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

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

Часто задаваемые вопросы

Может ли это обрабатывать любой файл JSON?

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

Как определяется порядок столбцов?

Столбцы появляются в порядке их первого появления в объектах JSON.

Можно ли объединить несколько наборов данных?

Да, вы можете объединить наборы данных перед выравниванием.

Как обрабатывать отсутствующие поля?

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

Могу ли я настроить макет PDF?

Да, поля, линии сетки и параметры автоподбора полностью настраиваются через Spire.XLS.

Смотрите также

• JSON в CSV на Python – Полное руководство для плоских и вложенных JSON
• Преобразование JSON в/из Excel на Python – Полное руководство с примерами
• Как преобразовать CSV в JSON на Python: плоский, вложенный и NDJSON

Adicionar vídeo a uma apresentação é uma das maneiras mais eficazes de aumentar o engajamento. Esteja você criando um material de treinamento, demonstração de produto, apresentação de marketing ou material educacional, o vídeo pode tornar seus slides mais dinâmicos e persuasivos.

Este guia completo explica métodos confiáveis para inserir vídeo em apresentações do PowerPoint. Você aprenderá abordagens manuais para arquivos locais, vídeos online, arquivos vinculados e soluções programáticas de alta precisão. Se você precisa inserir vídeo no PowerPoint, incorporar vídeo na apresentação do PowerPoint ou automatizar todo o processo para processamento em lote, este artigo fornece o conhecimento prático e as informações técnicas de que você precisa.

1. Por que Adicionar Vídeo a Apresentações do PowerPoint

Antes de explorar os métodos de inserção, é importante entender por que a integração de vídeo é importante e quais desafios você pode encontrar.

1.1 Benefícios do Vídeo em Apresentações

O conteúdo em vídeo oferece várias vantagens:

• Maior engajamento – Conteúdo visual e auditivo captura a atenção de forma mais eficaz do que slides estáticos
• Demonstrações complexas – Mostre processos, produtos ou procedimentos difíceis de explicar em texto
• Conexão emocional – O vídeo pode criar um impacto emocional mais forte do que apenas imagens
• Acabamento profissional – Conteúdo de vídeo de alta qualidade eleva a qualidade da apresentação

1.2 Desafios Comuns

No entanto, a inserção de vídeo apresenta vários desafios técnicos:

• Preocupações com o tamanho do arquivo – Vídeos incorporados podem aumentar drasticamente o tamanho do arquivo PPT
• Compatibilidade de formato – Nem todos os formatos de vídeo funcionam em diferentes versões do PowerPoint
• Problemas de reprodução – Problemas de codec podem impedir que os vídeos sejam reproduzidos corretamente
• Portabilidade – Vídeos vinculados podem quebrar ao compartilhar apresentações

Entender esses desafios ajuda você a selecionar o método de inserção correto para seu caso de uso específico.

2. Visão Geral dos Métodos Confiáveis

Este guia aborda quatro maneiras práticas de inserir vídeo em apresentações do PowerPoint:

1. Inserir arquivo de vídeo local – método mais comum, funciona offline
2. Incorporar vídeo online – mantém o tamanho do arquivo pequeno, requer internet
3. Vincular a arquivo de vídeo externo – equilibra tamanho e controle
4. Inserção programática – automação e processamento em lote

Dica: A maioria dos métodos manuais insere vídeos em slides individuais. Se você precisar inserir vídeos em várias apresentações ou automatizar o processo, a abordagem programática é a mais eficiente.

O método mais flexível é usar a automação com Python, que permite processamento em lote, geração no lado do servidor e integração com fluxos de trabalho de negócios.

3. Método 1: Inserir Vídeo do Seu Computador (Arquivo Local)

A maneira mais simples de inserir vídeo em um slide do PowerPoint é adicionando um arquivo de vídeo local armazenado em seu computador.

Instruções Passo a Passo

Dica: Certifique-se de que seu arquivo de vídeo esteja em um formato compatível antes de começar. MP4 com codificação H.264 funciona melhor.

1. Abra sua apresentação do PowerPoint - Inicie o PowerPoint e abra a apresentação onde deseja adicionar o vídeo.

2. Navegue até o slide de destino - Vá para o slide específico onde o vídeo deve aparecer.

3. Clique na guia Inserir - Localizada na faixa de opções do menu superior.

4. Selecione Vídeo - No grupo Mídia, clique no botão Vídeo.

5. Escolha Este Dispositivo - Selecione "Este Dispositivo" no menu suspenso.

6. Selecione e insira - Navegue até o seu arquivo de vídeo, selecione-o e clique em Inserir.

   

O vídeo aparecerá no slide como um objeto de mídia. Você pode:

• Redimensionar arrastando os cantos
• Reposicionar clicando e arrastando
• Girar usando a alça de rotação

Esta é a maneira mais direta de inserir vídeo em slides do PowerPoint e funciona totalmente offline.

Formatos de Vídeo Suportados

O PowerPoint suporta vários formatos de vídeo, incluindo:

• MP4 (recomendado para compatibilidade)
• MOV
• M4V
• WEBM

Para obter melhores resultados, use MP4 codificado com vídeo H.264 e áudio AAC.

Você pode encontrar a lista completa de formatos de mídia suportados no guia oficial da Microsoft sobre formatos de vídeo e áudio suportados no PowerPoint.

Ajustando as Configurações de Reprodução

Após inserir o vídeo, você pode personalizar as opções de reprodução:

• Iniciar Automaticamente ou Ao Clicar
• Reproduzir em Tela Cheia
• Repetir até Parar
• Cortar Vídeo
• Aparecimento Gradual / Desaparecimento Gradual

Essas opções estão disponíveis na guia Reprodução assim que o vídeo é selecionado.

Vantagens e Desvantagens da Inserção de Vídeo Local

Vantagens

• Fácil de usar
• Funciona offline
• Controle total da reprodução

Desvantagens

• Aumenta o tamanho do arquivo PPT
• Pode causar problemas de compartilhamento se o arquivo ficar muito grande

A inserção local é melhor para apresentações que precisam ser portáteis e funcionar offline.

Nota: Vídeos incorporados são suportados em apresentações PPTX modernas. Se você estiver trabalhando com um arquivo PPT mais antigo, considere convertê-lo para o formato PPTX primeiro. Consulte nosso guia sobre como converter PPT para PPTX.

4. Método 2: Incorporar Vídeo em Apresentação do PowerPoint (Vídeo Online)

Outra abordagem popular é incorporar vídeo na apresentação do PowerPoint diretamente de uma fonte online, como o YouTube.

Este método mantém o tamanho do seu arquivo pequeno porque o vídeo é transmitido em vez de armazenado dentro da apresentação.

Como Incorporar um Vídeo do YouTube

1. Vá para o slide onde você quer o vídeo.

2. Clique em Inserir → Vídeo → Vídeo Online.

   

3. Cole a URL do vídeo ou o código de incorporação.

4. Clique em Inserir.

   

O PowerPoint criará um quadro de vídeo incorporado no slide.

Quando Usar a Incorporação

A incorporação é ideal quando:

• Você quer reduzir o tamanho do arquivo PPT
• O vídeo está hospedado publicamente online
• Você precisa de conteúdo atualizado com frequência

Limitações de Vídeos Incorporados

No entanto, existem algumas considerações importantes:

• Requer uma conexão com a internet durante a apresentação
• Pode não funcionar atrás de firewalls corporativos
• O vídeo pode se tornar indisponível se for removido online
• Plataformas de vídeo podem exigir login antes da reprodução

Se a confiabilidade for crítica, a inserção local pode ser mais segura.

5. Método 3: Como Anexar um Vídeo no PPT (Vincular em Vez de Incorporar)

Alguns usuários perguntam como anexar vídeo no PPT em vez de incorporá-lo totalmente.

Este método vincula a um arquivo de vídeo externo em vez de armazená-lo dentro da apresentação.

Incorporar vs. Anexar: Qual é a Diferença?

Como Vincular um Arquivo de Vídeo

1. Vá para Inserir → Vídeo → Este Dispositivo.

2. Selecione o arquivo de vídeo.

3. Clique na seta suspensa ao lado de Inserir.

4. Escolha Vincular ao Arquivo em vez de Inserir.

   

Agora o PPT fará referência ao vídeo externamente.

Quando Vincular Faz Sentido

• Arquivos de vídeo muito grandes
• Ambientes de armazenamento em rede compartilhada
• Gerenciamento centralizado de mídia

Tenha cuidado ao compartilhar a apresentação — você deve enviar o arquivo de vídeo junto.

Se você também está adicionando visualizações de dados aos seus slides, pode querer aprender como inserir um gráfico no PowerPoint.

6. Problemas Comuns ao Inserir Vídeo no PowerPoint

Mesmo quando você sabe como adicionar vídeo a uma apresentação do PowerPoint, problemas ainda podem ocorrer.

Aqui estão alguns problemas comuns e suas soluções:

6.1 Vídeo Não Reproduzindo

Muitas vezes causado por codecs não suportados.

Solução: Converta o vídeo para MP4 (H.264 + AAC).

6.2 Arquivo Muito Grande

Incorporar vídeos de alta resolução pode aumentar drasticamente o tamanho do PPT.

Solução: Comprima a mídia usando Arquivo → Informações → Comprimir Mídia.

6.3 Problemas de Compatibilidade (Mac vs. Windows)

Alguns formatos se comportam de maneira diferente entre sistemas.

Solução: Use MP4 para máxima compatibilidade.

6.4 Atraso Durante a Reprodução

Vídeos grandes ou hardware lento podem causar travamentos.

Solução: Otimize a resolução do vídeo ou use um arquivo vinculado.

7. Método 4: Inserir Vídeo no PowerPoint Usando Python (Solução Automatizada)

Para desenvolvedores e empresas, o Python oferece uma maneira poderosa de automatizar a criação de PowerPoint e a inserção de vídeos.

Usando o Spire.Presentation for Python, você pode inserir vídeos em slides sem a necessidade do Microsoft Office.

Por que Usar Python para Automação do PowerPoint?

• Processamento em lote de apresentações
• Integração com sistemas de backend
• Geração de documentos no lado do servidor
• Sem interação manual com a interface do usuário
• Fluxos de trabalho repetíveis

Instale a Biblioteca

pip install Spire.Presentation

Exemplo Rápido: Inserir Vídeo no PowerPoint com Python

Se você precisa apenas de um exemplo mínimo, o código a seguir insere um vídeo no primeiro slide de uma nova apresentação do PowerPoint.

from spire.presentation import *

# Create presentation
presentation = Presentation()

# Add video to first slide
slide = presentation.Slides[0]

video_rect = RectangleF.FromLTRB(100, 100, 500, 400)
slide.Shapes.AppendVideoMedia("demo_video.mp4", video_rect)

# Save presentation
presentation.SaveToFile("video_demo.pptx", FileFormat.Pptx2019)
presentation.Dispose()

Este exemplo mínimo mostra como criar uma nova apresentação do PowerPoint e insere um vídeo no primeiro slide na posição especificada com código Python.

### Exemplo Avançado: Inserir ou Vincular Vídeo no PowerPoint Usando Python

Abaixo está um exemplo aprimorado com tratamento de erros e opções adicionais:

from spire.presentation import *
import os
from pathlib import Path


def insert_video_to_powerpoint(video_path, output_path, slide_index=0, position=(100, 100), size=(400, 300),
                               poster_image_path=None, embed_video=True):
    """
    Inserir um vídeo em uma apresentação do PowerPoint programaticamente

    Args:
        video_path: Caminho para o arquivo de vídeo (MP4, MOV, WMV, AVI)
        output_path: Caminho do arquivo de saída do PowerPoint (.pptx)
        slide_index: Número do slide (base 0) onde o vídeo deve ser inserido
        position: Tupla de coordenadas (x, y) para o posicionamento do vídeo
        size: Tupla (largura, altura) para as dimensões do vídeo
        poster_image_path: Caminho opcional para a imagem de pôster/miniatura do vídeo
        embed_video: Valor booleano indicando se deve incorporar o vídeo (True)
                     ou vincular ao arquivo de vídeo (False)
    """
    try:
        # Validar arquivo de entrada
        if not os.path.exists(video_path):
            raise FileNotFoundError(f"Arquivo de vídeo não encontrado: {video_path}")

        # Verificar extensão do arquivo
        valid_extensions = {'.mp4', '.mov', '.wmv', '.avi'}
        file_ext = Path(video_path).suffix.lower()
        if file_ext not in valid_extensions:
            print(f"Aviso: {file_ext} pode não ser totalmente suportado. MP4 é recomendado.")

        # Criar objeto de apresentação
        presentation = Presentation()

        # Garantir que temos slides suficientes
        while presentation.Slides.Count <= slide_index:
            presentation.Slides.Append()

        # Obter slide de destino
        slide = presentation.Slides[slide_index]

        # Criar retângulo para posição e tamanho do vídeo
        video_rect = RectangleF.FromLTRB(
            position[0],
            position[1],
            position[0] + size[0],
            position[1] + size[1]
        )

        # Inserir vídeo com base no modo de incorporação
        if embed_video:
            # Incorporar o vídeo na apresentação
            video = slide.Shapes.AppendVideoMedia(video_path, video_rect)
        else:
            # Inserir o vídeo como um link (referência de arquivo externo)
            video = slide.Shapes.AppendVideoMediaLink(video_path, video_rect, False)

        # Definir imagem de pôster se fornecida
        if poster_image_path and os.path.exists(poster_image_path):
            video.PictureFill.Picture.Url = poster_image_path

        # Salvar a apresentação
        presentation.SaveToFile(output_path, FileFormat.Pptx2019)
        print(f"Criado com sucesso: {output_path}")
        print(f"   - Vídeo inserido no slide {slide_index + 1}")
        print(f"   - Modo: {'Incorporado' if embed_video else 'Vinculado'}")
        print(f"   - Posição: {position}")
        print(f"   - Tamanho: {size}")

        return True

    except Exception as e:
        print(f"Erro ao inserir vídeo: {e}")
        return False

    finally:
        # Limpar recursos
        if 'presentation' in locals():
            presentation.Dispose()


# Exemplos de uso
if __name__ == "__main__":

    # Exemplo 1: Uso básico (incorporar vídeo)
    insert_video_to_powerpoint(
        video_path="presentation_video.mp4",
        output_path="presentation_with_video.pptx"
    )

    # Exemplo 2: Inserir vídeo vinculado
    insert_video_to_powerpoint(
        video_path="demo_video.mp4",
        output_path="linked_video_slide.pptx",
        embed_video=False
    )

    # Exemplo 3: Posição e tamanho personalizados
    insert_video_to_powerpoint(
        video_path="demo_video.mp4",
        output_path="custom_video_slide.pptx",
        slide_index=2,  # Terceiro slide
        position=(150, 100),
        size=(500, 300)
    )

    # Exemplo 4: Com imagem de pôster
    if os.path.exists("video_thumbnail.png"):
        insert_video_to_powerpoint(
            video_path="demo_video.mp4",
            output_path="video_with_poster.pptx",
            poster_image_path="video_thumbnail.png"
        )

    # Exemplo 5: Processamento em lote de vários vídeos
    videos = [
        ("intro.mp4", 0, (100, 100)),
        ("tutorial.mp4", 1, (100, 100)),
        ("conclusion.mp4", 2, (100, 100))
    ]

    for video_file, slide_num, pos in videos:
        if os.path.exists(video_file):
            insert_video_to_powerpoint(
                video_path=video_file,
                output_path=f"batch_output_slide{slide_num}.pptx",
                slide_index=slide_num,
                position=pos
            )

Abaixo está uma prévia do arquivo PowerPoint gerado 'video_with_poster.pptx' com a inserção de vídeo:

O que Este Código Faz

Este exemplo demonstra como inserir programaticamente um vídeo em uma apresentação do PowerPoint usando Python. O script inclui vários recursos práticos que o tornam adequado para cenários de automação do mundo real.

A função realiza as seguintes operações:

• Cria uma apresentação do PowerPoint se uma não existir.
• Adiciona slides automaticamente quando o índice de slide especificado não existe.
• Insere um vídeo em um slide específico usando parâmetros de posição e tamanho personalizáveis.
• Suporta dois modos de inserção:
  • Vídeo incorporado – armazena o vídeo dentro do arquivo PPT.
  • Vídeo vinculado – referencia o vídeo como um arquivo externo para manter a apresentação menor.
• Opcionalmente, define uma imagem de pôster que aparece antes do início da reprodução do vídeo.
• Inclui tratamento de erros para evitar falhas quando os arquivos estão ausentes.
• Salva a apresentação gerada como um arquivo PPTX.

Os exemplos fornecidos demonstram vários cenários comuns:

• Inserção básica de vídeo
• Vincular um vídeo em vez de incorporá-lo
• Personalizando a posição e o tamanho do vídeo
• Adicionando uma miniatura de imagem de pôster
• Inserindo em lote vários vídeos em slides

Vantagens de Usar o Spire.Presentation

• Sem dependência do Microsoft Office
• Funciona em ambientes de servidor
• Suporta elementos multimídia
• Adequado para automação empresarial

Para equipes que geram um grande número de apresentações, essa abordagem oferece uma escalabilidade muito maior do que os métodos manuais.

Se você precisar gerenciar ainda mais arquivos de mídia usando Python, também pode aprender como inserir ou extrair vídeo e áudio em apresentações do PowerPoint.

8. Comparação de Precisão de Todos os Métodos

9. Melhores Práticas para Inserção de Vídeo de Alta Qualidade

Para garantir os melhores resultados, siga estas melhores práticas:

Preparação do Vídeo

• Use o formato MP4 com vídeo H.264 e áudio AAC
• Otimize a resolução do vídeo (1080p ou inferior para apresentações)
• Comprima vídeos grandes antes de incorporar
• Teste a reprodução nos dispositivos de destino

Gerenciamento de Arquivos

• Mantenha os vídeos na mesma pasta da sua apresentação
• Use nomes de arquivo descritivos
• Mantenha cópias de backup dos arquivos de vídeo originais
• Considere o armazenamento em nuvem para vídeos vinculados

Recomendações Técnicas

• Use a inserção programática para fluxos de trabalho em lote
• Teste em sistemas Windows e Mac
• Valide a reprodução do vídeo antes das apresentações
• Considere o acesso à internet do público para vídeos incorporados

10. Perguntas Frequentes

1. Como insiro um vídeo no PowerPoint sem aumentar o tamanho do arquivo?

Sim. Você pode incorporar um vídeo online ou vincular a um arquivo local em vez de incorporá-lo. A vinculação mantém o arquivo PPT menor, mas requer acesso ao arquivo externo.

2. Como insiro um vídeo em um slide específico?

Simplesmente navegue até o slide de destino antes de usar Inserir → Vídeo. Em cenários de automação, você pode especificar o índice do slide programaticamente.

3. Qual é o melhor formato de vídeo para o PowerPoint?

MP4 com vídeo H.264 e áudio AAC é o formato mais compatível entre os sistemas Windows e Mac.

4. Por que meu vídeo não está sendo reproduzido no PowerPoint?

As razões comuns incluem codecs não suportados, arquivos corrompidos ou problemas de incorporação. Converter o vídeo para MP4 geralmente resolve o problema.

5. Posso inserir vídeos automaticamente no PowerPoint?

Sim. Usando bibliotecas Python como o Spire.Presentation, você pode inserir vídeos programaticamente em slides do PowerPoint, tornando-o ideal para processamento em lote e automação de backend.

11. Conclusão

Agora você sabe como inserir vídeo no PowerPoint usando várias abordagens:

• Inserir um arquivo de vídeo local
• Incorporar vídeo na apresentação do PowerPoint de fontes online
• Anexar um arquivo de vídeo vinculado
• Automatizar a inserção de vídeo usando Python

Para usuários individuais que criam apresentações ocasionais, as ferramentas integradas do PowerPoint são mais do que suficientes.

No entanto, para desenvolvedores, empresas e fluxos de trabalho empresariais que exigem geração de documentos escalável, a automação oferece uma solução muito mais eficiente e flexível.

A escolha do método certo depende inteiramente do seu caso de uso — simplicidade para edição manual ou escalabilidade para produção automatizada.

Para explorar todas as capacidades do Spire.Presentation for Python sem limitações, você pode solicitar uma licença temporária gratuita.

Veja Também

• Substituir Vídeos e Áudio em Apresentações do PowerPoint Usando Python
• Como Gerenciar Objetos OLE em Apresentações do PowerPoint Usando Python
• Como Comprimir Imagens em Apresentações do PowerPoint
• Como Converter Apresentações do PowerPoint para PDF

프레젠테이션에 비디오를 추가하는 것은 참여도를 높이는 가장 효과적인 방법 중 하나입니다. 교육 자료, 제품 데모, 마케팅 홍보 자료 또는 교육 자료를 만들 때 비디오를 사용하면 슬라이드를 더욱 역동적이고 설득력 있게 만들 수 있습니다.

이 전체 가이드에서는 PowerPoint 프레젠테이션에 비디오를 삽입하는 신뢰할 수 있는 방법을 설명합니다. 로컬 파일, 온라인 비디오, 연결된 파일에 대한 수동 접근 방식과 매우 정확한 프로그래밍 방식 솔루션을 배우게 됩니다. PowerPoint에 비디오를 삽입하거나, PowerPoint 프레젠테이션에 비디오를 포함하거나, 일괄 처리를 위해 전체 프로세스를 자동화해야 하는 경우 이 문서에서 필요한 실용적인 지식과 기술적 통찰력을 얻을 수 있습니다.

1. PowerPoint 프레젠테이션에 비디오를 추가해야 하는 이유

삽입 방법을 살펴보기 전에 비디오 통합이 왜 중요하며 어떤 문제에 직면할 수 있는지 이해하는 것이 중요합니다.

1.1 프레젠테이션에서 비디오의 이점

비디오 콘텐츠는 여러 가지 이점을 제공합니다.

• 참여도 증가 – 시청각 콘텐츠는 정적인 슬라이드보다 더 효과적으로 주의를 사로잡습니다.
• 복잡한 시연 – 텍스트로 설명하기 어려운 프로세스, 제품 또는 절차를 보여줍니다.
• 정서적 연결 – 비디오는 이미지 단독보다 더 강한 정서적 영향을 줄 수 있습니다.
• 전문적인 완성도 – 고품질 비디오 콘텐츠는 프레젠테이션 품질을 높입니다.

1.2 일반적인 과제

그러나 비디오를 삽입하는 데에는 몇 가지 기술적인 문제가 있습니다.

• 파일 크기 문제 – 포함된 비디오는 PPT 파일 크기를 크게 늘릴 수 있습니다.
• 형식 호환성 – 모든 비디오 형식이 다른 PowerPoint 버전에서 작동하는 것은 아닙니다.
• 재생 문제 – 코덱 문제로 인해 비디오가 올바르게 재생되지 않을 수 있습니다.
• 이식성 – 프레젠테이션을 공유할 때 연결된 비디오가 깨질 수 있습니다.

이러한 과제를 이해하면 특정 사용 사례에 적합한 삽입 방법을 선택하는 데 도움이 됩니다.

2. 신뢰할 수 있는 방법 개요

이 가이드에서는 PowerPoint 프레젠테이션에 비디오를 삽입하는 네 가지 실용적인 방법을 다룹니다.

1. 로컬 비디오 파일 삽입 – 가장 일반적인 방법, 오프라인에서 작동
2. 온라인 비디오 포함 – 파일 크기를 작게 유지, 인터넷 필요
3. 외부 비디오 파일에 링크 – 크기와 제어의 균형
4. 프로그래밍 방식 삽입 – 자동화 및 일괄 처리

팁: 대부분의 수동 방법은 개별 슬라이드에 비디오를 삽입합니다. 여러 프레젠테이션에 비디오를 삽입하거나 프로세스를 자동화해야 하는 경우 프로그래밍 방식이 가장 효율적입니다.

가장 유연한 방법은 Python 자동화를 사용하는 것입니다. 이를 통해 일괄 처리, 서버 측 생성 및 비즈니스 워크플로와의 통합이 가능합니다.

3. 방법 1: 컴퓨터에서 비디오 삽입 (로컬 파일)

PowerPoint 슬라이드에 비디오를 삽입하는 가장 간단한 방법은 컴퓨터에 저장된 로컬 비디오 파일을 추가하는 것입니다.

단계별 지침

팁: 시작하기 전에 비디오 파일이 지원되는 형식인지 확인하십시오. H.264 인코딩이 적용된 MP4가 가장 잘 작동합니다.

1. PowerPoint 프레젠테이션 열기 - PowerPoint를 시작하고 비디오를 추가할 프레젠테이션을 엽니다.

2. 대상 슬라이드로 이동 - 비디오가 나타나야 할 특정 슬라이드로 이동합니다.

3. 삽입 탭 클릭 - 상단 메뉴 리본에 있습니다.

4. 비디오 선택 - 미디어 그룹에서 비디오 버튼을 클릭합니다.

5. 이 장치 선택 - 드롭다운 메뉴에서 "이 장치"를 선택합니다.

6. 선택 및 삽입 - 비디오 파일을 찾아 선택하고 삽입을 클릭합니다.

   

비디오가 슬라이드에 미디어 개체로 나타납니다. 다음을 수행할 수 있습니다.

• 모서리를 드래그하여 크기 조정
• 클릭하고 드래그하여 위치 변경
• 회전 핸들을 사용하여 회전

이것은 PowerPoint 슬라이드에 비디오를 삽입하는 가장 간단한 방법이며 완전히 오프라인으로 작동합니다.

지원되는 비디오 형식

PowerPoint는 다음을 포함한 여러 비디오 형식을 지원합니다.

• MP4 (호환성을 위해 권장)
• MOV
• M4V
• WEBM

최상의 결과를 얻으려면 H.264 비디오 및 AAC 오디오로 인코딩된 MP4를 사용하십시오.

지원되는 미디어 형식의 전체 목록은 PowerPoint에서 지원되는 비디오 및 오디오 파일 형식에 대한 공식 Microsoft 가이드에서 찾을 수 있습니다.

재생 설정 조정

비디오를 삽입한 후 재생 옵션을 사용자 지정할 수 있습니다.

• 자동 시작 또는 클릭 시
• 전체 화면 재생
• 중지할 때까지 반복
• 비디오 자르기
• 페이드 인 / 페이드 아웃

이러한 옵션은 비디오를 선택하면 재생 탭에서 사용할 수 있습니다.

로컬 비디오 삽입의 장단점

장점

• 사용하기 쉬움
• 오프라인에서 작동
• 전체 재생 제어

단점

• PPT 파일 크기 증가
• 파일이 너무 커지면 공유 문제가 발생할 수 있음

로컬 삽입은 휴대 가능하고 오프라인에서 작동해야 하는 프레젠테이션에 가장 적합합니다.

참고: 포함된 비디오는 최신 PPTX 프레젠테이션에서 지원됩니다. 이전 PPT 파일로 작업하는 경우 먼저 PPTX 형식으로 변환하는 것을 고려하십시오. PPT를 PPTX로 변환하는 방법에 대한 가이드를 참조하십시오.

4. 방법 2: PowerPoint 프레젠테이션에 비디오 포함 (온라인 비디오)

또 다른 인기 있는 접근 방식은 YouTube와 같은 온라인 소스에서 직접 PowerPoint 프레젠테이션에 비디오를 포함하는 것입니다.

이 방법은 비디오가 프레젠테이션 내부에 저장되는 대신 스트리밍되기 때문에 파일 크기를 작게 유지합니다.

YouTube 비디오를 포함하는 방법

1. 비디오를 원하는 슬라이드로 이동합니다.

2. 삽입 → 비디오 → 온라인 비디오를 클릭합니다.

   

3. 비디오 URL 또는 포함 코드를 붙여넣습니다.

4. 삽입을 클릭합니다.

   

PowerPoint는 슬라이드에 포함된 비디오 프레임을 만듭니다.

포함 기능을 사용해야 하는 경우

포함 기능은 다음과 같은 경우에 이상적입니다.

• PPT 파일 크기를 줄이고 싶을 때
• 비디오가 온라인에 공개적으로 호스팅될 때
• 자주 업데이트되는 콘텐츠가 필요할 때

포함된 비디오의 제한 사항

그러나 몇 가지 중요한 고려 사항이 있습니다.

• 프레젠테이션 중에 인터넷 연결이 필요합니다.
• 회사 방화벽 뒤에서는 작동하지 않을 수 있습니다.
• 온라인에서 제거되면 비디오를 사용할 수 없게 될 수 있습니다.
• 비디오 플랫폼은 재생 전에 로그인이 필요할 수 있습니다.

안정성이 중요한 경우 로컬 삽입이 더 안전할 수 있습니다.

5. 방법 3: PPT에 비디오 첨부하는 방법 (포함 대신 링크)

일부 사용자는 비디오를 완전히 포함하는 대신 PPT에 비디오를 첨부하는 방법을 묻습니다.

이 방법은 프레젠테이션 내부에 저장하는 대신 외부 비디오 파일에 연결합니다.

포함 대 첨부: 차이점은 무엇입니까?

비디오 파일을 연결하는 방법

1. 삽입 → 비디오 → 이 장치로 이동합니다.

2. 비디오 파일을 선택합니다.

3. 삽입 옆에 있는 드롭다운 화살표를 클릭합니다.

4. 삽입 대신 파일에 연결을 선택합니다.

   

이제 PPT는 외부에서 비디오를 참조합니다.

연결이 합리적인 경우

• 매우 큰 비디오 파일
• 공유 네트워크 스토리지 환경
• 중앙 집중식 미디어 관리

프레젠테이션을 공유할 때 주의하십시오 — 비디오 파일을 함께 보내야 합니다.

슬라이드에 데이터 시각화를 추가하는 경우 PowerPoint에 차트를 삽입하는 방법을 배우고 싶을 수 있습니다.

6. PowerPoint에 비디오를 삽입할 때 발생하는 일반적인 문제

PowerPoint 프레젠테이션에 비디오를 추가하는 방법을 알고 있더라도 문제가 발생할 수 있습니다.

다음은 몇 가지 일반적인 문제와 해결 방법입니다.

6.1 비디오가 재생되지 않음

지원되지 않는 코덱으로 인해 종종 발생합니다.

해결책: 비디오를 MP4(H.264 + AAC)로 변환합니다.

6.2 파일이 너무 큼

고해상도 비디오를 포함하면 PPT 크기가 크게 늘어날 수 있습니다.

해결책: 파일 → 정보 → 미디어 압축을 사용하여 미디어를 압축합니다.

6.3 호환성 문제 (Mac 대 Windows)

일부 형식은 시스템마다 다르게 작동합니다.

해결책: 최대 호환성을 위해 MP4를 사용합니다.

6.4 재생 중 지연

큰 비디오나 느린 하드웨어로 인해 끊김 현상이 발생할 수 있습니다.

해결책: 비디오 해상도를 최적화하거나 연결된 파일을 사용합니다.

7. 방법 4: Python을 사용하여 PowerPoint에 비디오 삽입 (자동화된 솔루션)

개발자와 기업을 위해 Python은 PowerPoint 생성 및 비디오 삽입을 자동화하는 강력한 방법을 제공합니다.

Spire.Presentation for Python을 사용하면 Microsoft Office 없이 슬라이드에 비디오를 삽입할 수 있습니다.

PowerPoint 자동화에 Python을 사용하는 이유

• 프레젠테이션 일괄 처리
• 백엔드 시스템과의 통합
• 서버 측 문서 생성
• 수동 UI 상호 작용 없음
• 반복 가능한 워크플로

라이브러리 설치

pip install Spire.Presentation

빠른 예제: Python으로 PowerPoint에 비디오 삽입

최소한의 예제만 필요한 경우 다음 코드는 새 PowerPoint 프레젠테이션의 첫 번째 슬라이드에 비디오를 삽입합니다.

from spire.presentation import *

# 프레젠테이션 만들기
presentation = Presentation()

# 첫 번째 슬라이드에 비디오 추가
slide = presentation.Slides[0]

video_rect = RectangleF.FromLTRB(100, 100, 500, 400)
slide.Shapes.AppendVideoMedia("demo_video.mp4", video_rect)

# 프레젠테이션 저장
presentation.SaveToFile("video_demo.pptx", FileFormat.Pptx2019)
presentation.Dispose()

이 최소한의 예제는 새 PowerPoint 프레젠테이션을 만들고 Python 코드를 사용하여 지정된 위치의 첫 번째 슬라이드에 비디오를 삽입하는 방법을 보여줍니다.

### 고급 예제: Python을 사용하여 PowerPoint에 비디오 삽입 또는 연결

다음은 오류 처리 및 추가 옵션이 포함된 향상된 예제입니다.

from spire.presentation import *
import os
from pathlib import Path


def insert_video_to_powerpoint(video_path, output_path, slide_index=0, position=(100, 100), size=(400, 300),
                               poster_image_path=None, embed_video=True):
    """
    프로그래밍 방식으로 PowerPoint 프레젠테이션에 비디오 삽입

    Args:
        video_path: 비디오 파일 경로 (MP4, MOV, WMV, AVI)
        output_path: 출력 PowerPoint 파일 경로 (.pptx)
        slide_index: 비디오를 삽입해야 하는 슬라이드 번호 (0부터 시작)
        position: 비디오 배치를 위한 튜플 (x, y) 좌표
        size: 비디오 크기를 위한 튜플 (너비, 높이)
        poster_image_path: 비디오의 포스터/썸네일 이미지에 대한 선택적 경로
        embed_video: 비디오를 포함할지(True) 또는 비디오 파일에 연결할지(False)를 나타내는 부울 값
    """
    try:
        # 입력 파일 유효성 검사
        if not os.path.exists(video_path):
            raise FileNotFoundError(f"비디오 파일을 찾을 수 없음: {video_path}")

        # 파일 확장자 확인
        valid_extensions = {'.mp4', '.mov', '.wmv', '.avi'}
        file_ext = Path(video_path).suffix.lower()
        if file_ext not in valid_extensions:
            print(f"경고: {file_ext}는 완전히 지원되지 않을 수 있습니다. MP4를 권장합니다.")

        # 프레젠테이션 개체 만들기
        presentation = Presentation()

        # 슬라이드가 충분한지 확인
        while presentation.Slides.Count <= slide_index:
            presentation.Slides.Append()

        # 대상 슬라이드 가져오기
        slide = presentation.Slides[slide_index]

        # 비디오 위치 및 크기에 대한 사각형 만들기
        video_rect = RectangleF.FromLTRB(
            position[0],
            position[1],
            position[0] + size[0],
            position[1] + size[1]
        )

        # 포함 모드에 따라 비디오 삽입
        if embed_video:
            # 프레젠테이션에 비디오 포함
            video = slide.Shapes.AppendVideoMedia(video_path, video_rect)
        else:
            # 비디오를 링크로 삽입 (외부 파일 참조)
            video = slide.Shapes.AppendVideoMediaLink(video_path, video_rect, False)

        # 제공된 경우 포스터 이미지 설정
        if poster_image_path and os.path.exists(poster_image_path):
            video.PictureFill.Picture.Url = poster_image_path

        # 프레젠테이션 저장
        presentation.SaveToFile(output_path, FileFormat.Pptx2019)
        print(f"성공적으로 생성됨: {output_path}")
        print(f"   - 슬라이드 {slide_index + 1}에 비디오 삽입됨")
        print(f"   - 모드: {'포함됨' if embed_video else '연결됨'}")
        print(f"   - 위치: {position}")
        print(f"   - 크기: {size}")

        return True

    except Exception as e:
        print(f"비디오 삽입 오류: {e}")
        return False

    finally:
        # 리소스 정리
        if 'presentation' in locals():
            presentation.Dispose()


# 사용 예
if __name__ == "__main__":

    # 예 1: 기본 사용법 (비디오 포함)
    insert_video_to_powerpoint(
        video_path="presentation_video.mp4",
        output_path="presentation_with_video.pptx"
    )

    # 예 2: 연결된 비디오 삽입
    insert_video_to_powerpoint(
        video_path="demo_video.mp4",
        output_path="linked_video_slide.pptx",
        embed_video=False
    )

    # 예 3: 사용자 지정 위치 및 크기
    insert_video_to_powerpoint(
        video_path="demo_video.mp4",
        output_path="custom_video_slide.pptx",
        slide_index=2,  # 세 번째 슬라이드
        position=(150, 100),
        size=(500, 300)
    )

    # 예 4: 포스터 이미지 포함
    if os.path.exists("video_thumbnail.png"):
        insert_video_to_powerpoint(
            video_path="demo_video.mp4",
            output_path="video_with_poster.pptx",
            poster_image_path="video_thumbnail.png"
        )

    # 예 5: 여러 비디오 일괄 처리
    videos = [
        ("intro.mp4", 0, (100, 100)),
        ("tutorial.mp4", 1, (100, 100)),
        ("conclusion.mp4", 2, (100, 100))
    ]

    for video_file, slide_num, pos in videos:
        if os.path.exists(video_file):
            insert_video_to_powerpoint(
                video_path=video_file,
                output_path=f"batch_output_slide{slide_num}.pptx",
                slide_index=slide_num,
                position=pos
            )

다음은 비디오가 삽입된 생성된 PowerPoint 파일 'video_with_poster.pptx'의 미리보기입니다.

이 코드의 기능

이 예제는 Python을 사용하여 프로그래밍 방식으로 PowerPoint 프레젠테이션에 비디오를 삽입하는 방법을 보여줍니다. 이 스크립트에는 실제 자동화 시나리오에 적합한 몇 가지 실용적인 기능이 포함되어 있습니다.

이 함수는 다음 작업을 수행합니다.

• 아직 없는 경우 PowerPoint 프레젠테이션을 만듭니다.
• 지정된 슬라이드 인덱스가 존재하지 않을 때 자동으로 슬라이드를 추가합니다.
• 사용자 지정 가능한 위치 및 크기 매개변수를 사용하여 특정 슬라이드에 비디오를 삽입합니다.
• 두 가지 삽입 모드를 지원합니다:
  • 포함된 비디오 – PPT 파일 내부에 비디오를 저장합니다.
  • 연결된 비디오 – 프레젠테이션을 더 작게 유지하기 위해 비디오를 외부 파일로 참조합니다.
• 비디오 재생이 시작되기 전에 나타나는 포스터 이미지를 선택적으로 설정합니다.
• 파일이 누락되었을 때 실패를 방지하기 위해 오류 처리를 포함합니다.
• 생성된 프레젠테이션을 PPTX 파일로 저장합니다.

제공된 예제는 몇 가지 일반적인 시나리오를 보여줍니다.

• 기본 비디오 삽입
• 비디오를 포함하는 대신 연결
• 비디오 위치 및 크기 사용자 지정
• 포스터 이미지 썸네일 추가
• 여러 슬라이드에 걸쳐 여러 비디오 일괄 삽입

Spire.Presentation 사용의 이점

• Microsoft Office에 대한 종속성 없음
• 서버 환경에서 작동
• 멀티미디어 요소 지원
• 엔터프라이즈 자동화에 적합

많은 수의 프레젠테이션을 생성하는 팀의 경우 이 접근 방식은 수동 방법보다 훨씬 뛰어난 확장성을 제공합니다.

Python을 사용하여 미디어 파일을 추가로 관리해야 하는 경우 PowerPoint 프레젠테이션에서 비디오 및 오디오를 삽입하거나 추출하는 방법도 배울 수 있습니다.

8. 모든 방법의 정확도 비교

9. 고품질 비디오 삽입을 위한 모범 사례

최상의 결과를 보장하려면 다음 모범 사례를 따르십시오.

비디오 준비

• H.264 비디오 및 AAC 오디오가 포함된 MP4 형식 사용
• 비디오 해상도 최적화 (프레젠테이션의 경우 1080p 이하)
• 포함하기 전에 대용량 비디오 압축
• 대상 장치에서 재생 테스트

파일 관리

• 비디오를 프레젠테이션과 동일한 폴더에 보관
• 설명적인 파일 이름 사용
• 원본 비디오 파일의 백업 사본 유지
• 연결된 비디오에 대한 클라우드 스토리지 고려

기술 권장 사항

• 일괄 워크플로에 프로그래밍 방식 삽입 사용
• Windows 및 Mac 시스템 모두에서 테스트
• 프레젠테이션 전에 비디오 재생 확인
• 포함된 비디오에 대한 청중의 인터넷 액세스 고려

10. 자주 묻는 질문

1. 파일 크기를 늘리지 않고 PowerPoint에 비디오를 삽입하려면 어떻게 해야 합니까?

예. 온라인 비디오를 포함하거나 로컬 파일에 연결하여 포함하는 대신 사용할 수 있습니다. 연결하면 PPT 파일이 더 작아지지만 외부 파일에 액세스해야 합니다.

2. 특정 슬라이드에 비디오를 삽입하려면 어떻게 해야 합니까?

삽입 → 비디오를 사용하기 전에 대상 슬라이드로 이동하기만 하면 됩니다. 자동화 시나리오에서는 프로그래밍 방식으로 슬라이드 인덱스를 지정할 수 있습니다.

3. PowerPoint에 가장 적합한 비디오 형식은 무엇입니까?

H.264 비디오 및 AAC 오디오가 포함된 MP4는 Windows 및 Mac 시스템에서 가장 호환되는 형식입니다.

4. PowerPoint에서 비디오가 재생되지 않는 이유는 무엇입니까?

일반적인 원인으로는 지원되지 않는 코덱, 손상된 파일 또는 포함 문제가 있습니다. 비디오를 MP4로 변환하면 일반적으로 문제가 해결됩니다.

5. PowerPoint에 비디오를 자동으로 삽입할 수 있습니까?

예. Spire.Presentation과 같은 Python 라이브러리를 사용하면 프로그래밍 방식으로 PowerPoint 슬라이드에 비디오를 삽입할 수 있으므로 일괄 처리 및 백엔드 자동화에 이상적입니다.

11. 결론

이제 여러 가지 방법을 사용하여 PowerPoint에 비디오를 삽입하는 방법을 알게 되었습니다.

• 로컬 비디오 파일 삽입
• 온라인 소스에서 PowerPoint 프레젠테이션에 비디오 포함
• 연결된 비디오 파일 첨부
• Python을 사용하여 비디오 삽입 자동화

가끔 프레젠테이션을 만드는 개인 사용자의 경우 PowerPoint의 기본 제공 도구만으로도 충분합니다.

그러나 확장 가능한 문서 생성이 필요한 개발자, 기업 및 엔터프라이즈 워크플로의 경우 자동화는 훨씬 더 효율적이고 유연한 솔루션을 제공합니다.

올바른 방법을 선택하는 것은 전적으로 사용 사례에 따라 다릅니다. 수동 편집의 단순성 또는 자동화된 생산의 확장성입니다.

제한 없이 Spire.Presentation for Python의 전체 기능을 탐색하려면 무료 임시 라이선스를 신청할 수 있습니다.

참고 항목

• Python을 사용하여 PowerPoint 프레젠테이션의 비디오 및 오디오 교체
• Python을 사용하여 PowerPoint 프레젠테이션에서 OLE 개체를 관리하는 방법
• PowerPoint 프레젠테이션에서 이미지 압축 방법
• PowerPoint 프레젠테이션을 PDF로 변환하는 방법