Word DOC/DOCX에서 이미지를 추출하는 것은 학생, 마케터, 디자이너 및 사무직 종사자에게 가장 일반적인 일상 작업 중 하나입니다. 프레젠테이션에서 사진을 재사용하거나, Photoshop에서 편집하거나, 소셜 미디어에서 시각 자료를 공유하거나, 미디어 라이브러리를 구성하려는 경우 Word 문서에서 이미지를 추출하는 방법을 효율적으로 알면 반복적인 작업 시간을 절약할 수 있습니다.

이 단계별 가이드에서는 Word에서 사진을 추출하는 5가지 신뢰할 수 있고 무료이며 쉬운 방법을 보여줍니다. 단일 이미지 추출, 일괄 처리, 온라인 도구 및 전문 소프트웨어를 다룹니다.

• Word에서 이미지를 추출하는 이유는 무엇입니까?
• 방법 1: 마우스 오른쪽 버튼을 클릭하여 다른 이름으로 그림 저장
• 방법 2: 웹 페이지로 저장
• 방법 3: ZIP 파일 트릭
• 방법 4: 무료 온라인 Word 이미지 추출기
• 방법 5: 무료 프로그래밍 솔루션
• 모든 방법의 빠른 비교
• Word에서 이미지 추출에 대한 FAQ

Word에서 이미지를 추출하는 이유는 무엇입니까?

사용 사례를 이해하면 올바른 추출 방법을 선택하는 데 도움이 됩니다.

• 콘텐츠 용도 변경: 내부 문서 시각 자료를 블로그 그래픽, 소셜 미디어 게시물 또는 프레젠테이션 슬라이드로 변환
• 백업: 진화하는 문서 버전과 별도로 원본 이미지 품질 보존
• 편집: 반복적인 Word 저장으로 인한 압축 아티팩트 없이 특수 소프트웨어에서 사진 편집
• 파일 크기 축소: 이메일 또는 클라우드 저장을 위해 큰 포함 그래픽을 제거하여 문서 크기 축소

방법 1: 마우스 오른쪽 버튼을 클릭하여 다른 이름으로 그림 저장

적합 대상: 1-3개의 이미지를 빠르게 추출해야 하는 Microsoft Word 사용자.

"다른 이름으로 그림 저장"은 한두 개의 이미지만 필요할 때 Word에서 사진을 추출하는 가장 직관적인 방법입니다. 기술적인 지식이 필요 없으며 몇 초 만에 작동합니다.

단계별 지침:

• Microsoft Word에서 Word 문서를 엽니다.
• 저장하려는 이미지를 마우스 오른쪽 버튼으로 클릭합니다.
• 상황에 맞는 메뉴에서 다른 이름으로 그림 저장을 선택합니다.

• 대화 상자에서:
  • 대상 폴더 선택
  • 파일 이름 바꾸기(선택 사항이지만 권장됨)
  • 선호하는 형식 선택(투명도는 PNG, 사진은 JPG, 간단한 그래픽은 GIF)
  • 저장을 클릭합니다.

✔ 장점: 무료, 내장, 원클릭 작동, Microsoft Word의 기본 기능

✘ 단점: 일괄 추출 시 매우 느림(한 번에 하나의 이미지만)

Word 문서가 일반적이지만 PDF에서 이미지를 추출해야 할 수도 있습니다. 무료 도구 및 고급 방법을 포함한 PDF 이미지 추출에 대한 전체 가이드를 확인하십시오.

방법 2: 웹 페이지로 저장

적합 대상: 일괄 이미지 저장을 위해 Word의 기본 기능을 선호하는 사용자.

Microsoft Word에는 강력한 숨겨진 기능이 포함되어 있습니다. 웹 페이지로 저장하면 모든 포함된 이미지가 전용 폴더로 자동 내보내집니다. 이것은 Word doc 또는 docx 파일에서 이미지를 추출하는 가장 오래되고 신뢰할 수 있는 방법 중 하나입니다.

전체 연습:

• Word 문서를 엽니다.
• 파일 → 다른 이름으로 저장을 클릭하고 장치에 저장 위치를 선택합니다.
• "파일 형식" 드롭다운에서 *웹 페이지 (*.htm; *.html)*를 선택합니다.
  • 참고: "단일 파일 웹 페이지"를 선택하지 마십시오. – 모든 것을 하나의 파일로 패키지합니다.

• 저장을 클릭하면 선택한 폴더에 두 개의 항목이 생성됩니다.
  • HTML 웹 페이지 파일.
  • [문서이름]_files라는 이름의 폴더(예: Report_files).
• 해당 폴더를 열어 추출된 모든 이미지(PNG/JPG와 같은 원본 형식)에 액세스합니다.

✔ 장점: 기본 Word 도구, 모든 이미지를 즉시 일괄 추출, 좋은 품질 유지

✘ 단점: 추가 HTML 파일 생성, 문서에서 시각 자료를 재사용할 경우 중복 이미지 생성

방법 3: ZIP 파일 트릭

적합 대상: DOCX 파일에서 모든 고해상도 이미지를 대량으로 추출해야 하는 사용자 - 소프트웨어 필요 없음.

여기 잘 알려지지 않은 사실이 있습니다. 최신 Word 문서(.docx)는 실제로 압축된 ZIP 아카이브입니다. 즉, Microsoft Word를 열지 않고도 docx 파일에서 이미지를 추출할 수 있습니다.

이것이 작동하는 이유:

Microsoft Office 2007부터 Word는 Open XML 형식을 사용했습니다. .docx 파일은 기본적으로 XML 파일과 모든 포함된 이미지를 포함하는 전용 /word/media/ 폴더가 있는 컨테이너입니다.

자세한 단계:

• DOCX 파일을 찾아 복사본을 만듭니다(원본 보호).
• 파일을 마우스 오른쪽 버튼으로 클릭하고 이름 바꾸기를 선택합니다.
• 파일 확장자를 .docx에서 .zip으로 변경합니다(예: report.docx → report.zip).
• Enter 키를 눌러 확장자 변경을 확인합니다.
• 경고가 나타나면 예를 클릭합니다.
• 폴더처럼 두 번 클릭하여 엽니다(Windows 탐색기 또는 Mac Finder).
• 폴더 경로로 이동: word → media.
• 원하는 폴더에 모든 이미지를 복사합니다.

✔ 장점: 100% 무료, 일괄 추출, 원본 고해상도 보존

✘ 단점: DOCX 파일에서만 작동합니다.

빠른 팁: 레거시 .doc 파일에서 이미지를 대량으로 추출하려면 방법 2(웹 페이지로 저장)를 사용하거나 이 방법을 적용하기 전에 먼저 DOC를 DOCX로 변환하십시오.

방법 4: 무료 온라인 Word 이미지 추출기

적합 대상: 소프트웨어를 설치하고 싶지 않거나 빠른 크로스 플랫폼 솔루션(Windows, Mac, 모바일에서 작동)이 필요한 사용자.

ExtractAssets 또는 Groupdocs와 같은 전용 온라인 도구는 DOC 및 DOCX 파일을 모두 처리하여 모든 이미지를 추출하고 다운로드 가능한 ZIP 파일로 제공합니다. 기술적인 단계가 필요 없습니다.

온라인에서 Word 이미지 추출 단계:

• 도구 웹사이트(예: ExtractAssets Word 이미지 추출기)로 이동합니다.
• Word 문서를 업로드합니다.
• 이미지 추출을 클릭합니다.
• 이미지를 ZIP 파일로 다운로드합니다.

✔ 장점: 설치 불필요, 크로스 플랫폼, DOC 및 DOCX 파일에서 작동

✘ 단점: 인터넷 필요, 무료 사용자를 위한 파일 크기 제한

경고: 민감하거나 기밀인 문서를 온라인 도구에 업로드할 때는 주의하십시오. 개인 파일의 경우 오프라인 방법을 사용하십시오.

방법 5: 무료 프로그래밍 솔루션

적합 대상: 이미지를 일괄 추출하거나 자동화된 워크플로에 통합해야 하는 빈번한 사용자.

기업 및 개발자를 위해 .NET용 Free Spire.Doc은 출력 형식을 완전히 제어하면서 C#에서 프로그래밍 방식으로 Word에서 이미지를 추출할 수 있는 강력한 라이브러리입니다.

Word 이미지 추출을 위한 C# 코드:

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

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load a Word document
            Document document = new Document("input.docx");
            int index = 0;

            // Traverses each section in the document
            foreach (Section section in document.Sections)
            {
                // Traverses each paragraph in the current section
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Traverses each document object in the current paragraph
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Checks if the current document object is an image
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Saves the extracted image as a PNG file
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

이 코드는 Word 문서를 로드하고 계층적 방식(문서 → 섹션 → 단락 → DocumentObject)으로 탐색하여 이미지 유형 개체만 필터링한 다음 별도의 PNG 파일로 저장합니다.

주요 기술 기능:

• 형식 지원: DOC, DOCX, DOT, DOTX, DOCM, RTF 등
• 출력 형식: 추출된 이미지를 PNG, JPG, BMP, EMF, GIF, TIFF로 저장
• 일괄 처리: 단일 스크립트로 수천 개의 문서 처리
• 선택적 추출: 특정 섹션, 단락에서 이미지 추출

✔ 장점: 전체 일괄 자동화, 광범위한 파일 형식 지원, 엔터프라이즈급 안정성

✘ 단점: 기본 코딩 지식 필요, 무료 버전에는 특정 제한이 있음

이미지는 Word 문서의 유일한 귀중한 콘텐츠가 아닙니다. 다른 프로젝트에서 재사용하기 위해 텍스트, 표 및 서식을 추출하는 방법을 알아보십시오.

모든 방법의 빠른 비교

이 표를 사용하여 사용 사례에 맞는 올바른 방법을 즉시 선택하십시오.

Word에서 이미지 추출에 대한 FAQ

Q1: 암호로 보호된 Word 문서에서 이미지를 추출할 수 있습니까?

A: 먼저 문서의 잠금을 해제한 다음 위의 방법을 사용해야 합니다.

Q2: Word에서 고해상도 이미지를 얻으려면 어떻게 해야 합니까?

A: .docx의 경우 ZIP 트릭을 사용하십시오. .doc 파일의 경우 웹 페이지로 저장 방법이 일반적으로 마우스 오른쪽 버튼으로 저장하는 것보다 더 나은 품질을 유지합니다.

Q3: Word에서 어떤 이미지 형식을 추출할 수 있습니까?

A: Word는 다음을 포함한 다양한 형식의 포함된 이미지를 지원합니다.

• JPEG/JPG (사진)
• PNG (투명도가 있는 그래픽)
• GIF (애니메이션, 간단한 그래픽)
• BMP (비트맵 이미지)
• TIFF (고해상도 이미지)
• EMF/WMF (벡터 그래픽)
• SVG (확장 가능한 벡터 그래픽 – 최신 Word 버전)

Q4: 여러 Word 문서에서 한 번에 이미지를 추출할 수 있습니까?

A: 예, Spire.Doc과 같은 전문 도구를 사용하여 스크립트로 전체 폴더를 처리할 수 있습니다. 일부 온라인 도구는 여러 Word 문서의 일괄 처리도 제공합니다.

마지막 말

이제 Word 문서에서 이미지를 추출하는 5가지 무료이고 효과적인 방법이 있으며, 각 방법은 다양한 요구 사항과 기술 수준에 적합합니다. 빠른 단일 이미지의 경우 마우스 오른쪽 버튼으로 저장을 사용하십시오. 일괄 추출의 경우 ZIP 트릭이 가장 좋은 무료 선택입니다. 온라인 도구는 이동 중에 작동하며 Spire.Doc과 같은 전문 소프트웨어는 많이 사용하는 경우 고품질의 자동화된 결과를 제공합니다.

더 이상 스크린샷을 찍거나 이미지를 다시 만드는 데 시간을 낭비하지 마십시오. 대신 이러한 방법을 사용하여 몇 초 만에 Word에서 깨끗하고 고품질의 이미지를 얻으십시오.

참고 항목

• Word 문서 병합 방법: 서식 보존 또는 통합
• 텍스트를 PDF로 쉽게 변환: 4가지 빠르고 전문적인 방법
• Word를 PNG로 변환: 실제로 사용할 수 있는 3가지 실용적인 방법
• C#/VB.NET: Word에서 텍스트 및 이미지 추출
• Java: Word에서 텍스트 및 이미지 추출

L'estrazione di immagini da Word DOC/DOCX è una delle attività quotidiane più comuni per studenti, operatori di marketing, designer e impiegati. Che tu voglia riutilizzare le immagini in una presentazione, modificarle in Photoshop, condividere elementi visivi sui social media o organizzare una libreria multimediale, sapere come estrarre immagini da un documento Word in modo efficiente ti fa risparmiare ore di lavoro ripetitivo.

In questa guida passo-passo, ti mostreremo 5 modi affidabili, gratuiti e facili per estrarre immagini da Word. Tratteremo l'estrazione di singole immagini, l'elaborazione in batch, gli strumenti online e il software professionale.

• Perché estrarre immagini da Word?
• Metodo 1: Salva immagine con nome tramite clic destro
• Metodo 2: Salva come pagina Web
• Metodo 3: Il trucco del file ZIP
• Metodo 4: Estrattori di immagini da Word online gratuiti
• Metodo 5: Soluzioni di programmazione gratuite
• Confronto rapido di tutti i metodi
• Domande frequenti sull'estrazione di immagini da Word

Perché estrarre immagini da Word?

Comprendere i casi d'uso ti aiuta a scegliere il metodo di estrazione giusto:

• Riutilizzo dei contenuti: Trasforma gli elementi visivi dei documenti interni in grafica per blog, post sui social media o diapositive di presentazioni
• Backup: Conserva la qualità dell'immagine originale separatamente dalle versioni in evoluzione del documento
• Modifica: Modifica le foto in software specializzati senza gli artefatti di compressione derivanti da salvataggi ripetuti in Word
• Riduzione delle dimensioni del file: Riduci le dimensioni del documento rimuovendo le grafiche incorporate di grandi dimensioni per l'invio tramite e-mail o l'archiviazione nel cloud

Metodo 1: Salva immagine con nome tramite clic destro

Ideale per: Utenti che si trovano già in Microsoft Word e che devono estrarre rapidamente 1–3 immagini.

"Salva come immagine" è il metodo più intuitivo per estrarre immagini da Word quando hai bisogno solo di una o due immagini. Non richiede conoscenze tecniche e funziona in pochi secondi.

Istruzioni passo-passo:

• Apri il tuo documento Word in Microsoft Word.
• Fai clic con il pulsante destro del mouse sull'immagine che desideri salvare.
• Dal menu contestuale, seleziona Salva come immagine.

• Nella finestra di dialogo:
  • Scegli una cartella di destinazione
  • Rinomina il file (facoltativo ma consigliato)
  • Seleziona il tuo formato preferito (PNG per la trasparenza, JPG for le foto, GIF per la grafica semplice)
  • Fai clic su Salva.

✔ Pro: Gratuito, integrato, operazione con 1 clic, funzionalità nativa di Microsoft Word

✘ Contro: Estremamente lento per l'estrazione in batch (solo un'immagine alla volta)

Sebbene i documenti Word siano comuni, potresti anche dover estrarre immagini da PDF. Consulta la nostra guida completa per estrarre immagini da PDF – che include strumenti gratuiti e metodi avanzati.

Metodo 2: Salva come pagina Web

Ideale per: Utenti che preferiscono le funzionalità native di Word per il salvataggio di immagini in batch.

Microsoft Word include una potente funzionalità nascosta: il salvataggio come pagina Web esporta automaticamente ogni immagine incorporata in una cartella dedicata. Questo è uno dei metodi più antichi e affidabili per estrarre immagini da file Word doc o docx.

Procedura completa:

• Apri il documento Word.
• Fai clic su File → Salva con nome e scegli una posizione di salvataggio sul tuo dispositivo.
• Nel menu a discesa "Salva come", seleziona *Pagina Web (.htm; *.html)**.
  • Nota: NON selezionare "Pagina Web, file unico" – questo impacchetta tutto in un unico file

• Fai clic su Salva—Word genererà due elementi nella cartella scelta:
  • Il file della pagina Web HTML.
  • Una cartella denominata [NomeDocumento]_files (ad es. Report_files).
• Apri quella cartella per accedere a tutte le immagini estratte (nei loro formati originali come PNG/JPG).

✔ Pro: Strumento nativo di Word, estrae istantaneamente tutte le immagini in batch, mantiene una buona qualità

✘ Contro: Crea file HTML aggiuntivi, genera immagini duplicate se gli elementi visivi vengono riutilizzati nel documento

Metodo 3: Il trucco del file ZIP

Ideale per: Utenti che necessitano di estrarre in blocco tutte le immagini ad alta risoluzione da file DOCX, senza bisogno di software.

Ecco un fatto poco noto: i moderni documenti di Word (.docx) sono in realtà archivi ZIP compressi. Ciò significa che puoi estrarre immagini da file docx senza mai aprire Microsoft Word.

Perché funziona:

Da Microsoft Office 2007, Word utilizza il formato Open XML. Un file .docx è essenzialmente un contenitore con file XML e una cartella dedicata /word/media/ che contiene tutte le immagini incorporate.

Passaggi dettagliati:

• Individua il tuo file DOCX e creane una copia (per proteggere l'originale).
• Fai clic con il pulsante destro del mouse sul file e seleziona Rinomina.
• Modifica l'estensione del file da .docx a .zip (ad es. report.docx → report.zip).
• Premi Invio per confermare la modifica dell'estensione.
• Fai clic su Sì se viene visualizzato un avviso.
• Fai doppio clic per aprirlo come una qualsiasi cartella (Esplora file di Windows o Finder di Mac).
• Vai al percorso della cartella: word → media.
• Copia tutte le immagini nella cartella desiderata.

✔ Pro: 100% gratuito, estrazione in batch, conserva l'alta risoluzione originale

✘ Contro: Funziona solo per i file DOCX.

Suggerimento rapido: per l'estrazione in blocco di immagini da file .doc legacy, utilizzare il Metodo 2 (Salva come pagina Web) o convertire prima DOC in DOCX prima di applicare questo metodo.

Metodo 4: Estrattori di immagini da Word online gratuiti

Ideale per: Utenti che non desiderano installare software o che necessitano di una soluzione multipiattaforma rapida (funziona su Windows, Mac, dispositivi mobili).

Strumenti online dedicati come ExtractAssets o Groupdocs gestiscono sia i file DOC che DOCX, estraendo tutte le immagini e fornendole come file ZIP scaricabile, senza richiedere passaggi tecnici.

Passaggi per estrarre immagini da Word online:

• Vai al sito web dello strumento (ad es. Estrattore di immagini da Word di ExtractAssets)
• Carica il tuo documento Word.
• Fai clic su Estrai immagini.
• Scarica le immagini come file ZIP.

✔ Pro: Nessuna installazione, multipiattaforma, funziona per file DOC e DOCX

✘ Contro: Necessita di Internet; limiti di dimensione dei file per gli utenti gratuiti

Attenzione: prestare attenzione quando si caricano documenti sensibili o riservati su strumenti online. Per i file privati, attenersi ai metodi offline.

Metodo 5: Soluzioni di programmazione gratuite

Ideale per: Utenti frequenti che necessitano di estrarre immagini in batch o di integrarle in flussi di lavoro automatizzati.

Per aziende e sviluppatori, Free Spire.Doc for .NET è una potente libreria che consente di estrarre programmaticamente immagini da Word in C# con il pieno controllo sul formato di output.

Codice C# per estrarre immagini da Word:

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

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load a Word document
            Document document = new Document("input.docx");
            int index = 0;

            // Traverses each section in the document
            foreach (Section section in document.Sections)
            {
                // Traverses each paragraph in the current section
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Traverses each document object in the current paragraph
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Checks if the current document object is an image
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Saves the extracted image as a PNG file
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

Il codice carica un documento Word e lo attraversa in modo gerarchico: Documento → Sezione → Paragrafo → OggettoDocumento, filtrando solo gli oggetti di tipo immagine e salvandoli poi come file PNG separati.

Capacità tecniche principali:

• Supporto formati: DOC, DOCX, DOT, DOTX, DOCM, RTF e altri
• Formati di output: Salva le immagini estratte come PNG, JPG, BMP, EMF, GIF, TIFF
• Elaborazione in batch: Elabora migliaia di documenti con un unico script
• Estrazione selettiva: Estrai immagini da sezioni o paragrafi specifici

✔ Pro: Automazione completa in batch, ampio supporto di formati di file, affidabilità di livello aziendale

✘ Contro: Richiede conoscenze di base di programmazione; la versione gratuita ha alcune limitazioni

Le immagini non sono l'unico contenuto di valore nei tuoi documenti Word. Scopri come estrarre testo, tabelle e formattazione per riutilizzarli in altri progetti

Confronto rapido di tutti i metodi

Usa questa tabella per scegliere immediatamente il metodo giusto per il tuo caso d'uso:

Domande frequenti sull'estrazione di immagini da Word

D1: Posso estrarre immagini da un documento Word protetto da password?

R: Devi prima sbloccare il documento, quindi utilizzare uno dei metodi sopra indicati.

D2: Come posso ottenere immagini ad alta risoluzione da Word?

R: Usa il trucco ZIP per i file .docx. Per i file .doc, il metodo Salva come pagina Web di solito conserva una qualità migliore rispetto al salvataggio con il clic destro.

D3: Quali formati di immagine posso estrarre da Word?

R: Word supporta immagini incorporate in vari formati, tra cui:

• JPEG/JPG (foto)
• PNG (grafica con trasparenza)
• GIF (animazioni, grafica semplice)
• BMP (immagini bitmap)
• TIFF (immagini ad alta risoluzione)
• EMF/WMF (grafica vettoriale)
• SVG (grafica vettoriale scalabile – versioni più recenti di Word)

D4: Posso estrarre immagini da più documenti Word contemporaneamente?

R: Sì, utilizza strumenti professionali come Spire.Doc per elaborare intere cartelle con uno script. Alcuni strumenti online offrono anche l'elaborazione in batch di più documenti Word.

Considerazioni finali

Ora hai 5 modi gratuiti ed efficaci per estrarre immagini da un documento Word, ognuno adatto a esigenze e livelli di competenza tecnica diversi. Per immagini singole veloci, usa il salvataggio con il clic destro. Per l'estrazione in batch, il trucco ZIP è la scelta gratuita migliore. Gli strumenti online funzionano ovunque, mentre software professionali come Spire.Doc offrono risultati automatizzati di alta qualità per un uso intensivo.

Niente più perdite di tempo a fare screenshot o a ricreare immagini. Usa invece questi metodi per ottenere immagini pulite e di alta qualità da Word in pochi secondi.

Vedi anche

• Come unire documenti Word: preservare o unificare la formattazione
• Convertire testo in PDF facilmente: 4 metodi rapidi e professionali
• Convertire Word in PNG: 3 modi pratici che puoi effettivamente usare
• C#/VB.NET: Estrarre testo e immagini da Word
• Java: Estrarre testo e immagini da Word

L'extraction d'images de documents Word DOC/DOCX est l'une des tâches quotidiennes les plus courantes pour les étudiants, les spécialistes du marketing, les concepteurs et les employés de bureau. Que vous souhaitiez réutiliser des images dans une présentation, les modifier dans Photoshop, partager des visuels sur les réseaux sociaux ou organiser une médiathèque, savoir comment extraire efficacement des images d'un document Word vous fait gagner des heures de travail répétitif.

Dans ce guide étape par étape, nous vous présenterons 5 façons fiables, gratuites et faciles d'extraire des images de Word. Nous couvrons l'extraction d'une seule image, le traitement par lots, les outils en ligne et les logiciels professionnels.

• Pourquoi extraire des images de Word ?
• Méthode 1 : Clic droit Enregistrer en tant qu'image
• Méthode 2 : Enregistrer en tant que page Web
• Méthode 3 : L'astuce du fichier ZIP
• Méthode 4 : Extracteurs d'images Word en ligne gratuits
• Méthode 5 : Solutions de programmation gratuites
• Comparaison rapide de toutes les méthodes
• FAQ sur l'extraction d'images de Word

Pourquoi extraire des images de Word ?

Comprendre les cas d'utilisation vous aide à choisir la bonne méthode d'extraction :

• Réutilisation du contenu : Transformez les visuels de documents internes en graphiques de blog, en publications sur les réseaux sociaux ou en diapositives de présentation
• Sauvegarde : Préservez la qualité d'image originale séparément des versions de documents en évolution
• Édition : Modifiez des photos dans un logiciel spécialisé sans les artefacts de compression dus aux enregistrements répétés dans Word
• Réduction de la taille du fichier : Réduisez la taille du document en supprimant les grands graphiques intégrés pour l'envoi par e-mail ou le stockage dans le cloud

Méthode 1 : Clic droit Enregistrer en tant qu'image

Idéal pour : Les utilisateurs déjà dans Microsoft Word qui ont besoin d'extraire rapidement 1 à 3 images.

"Enregistrer en tant qu'image" est la méthode la plus intuitive pour extraire des images de Word lorsque vous n'avez besoin que d'une ou deux images. Elle ne nécessite aucune connaissance technique et fonctionne en quelques secondes.

Instructions étape par étape :

• Ouvrez votre document Word dans Microsoft Word.
• Faites un clic droit sur l'image que vous souhaitez enregistrer.
• Dans le menu contextuel, sélectionnez Enregistrer en tant qu'image.

• Dans la boîte de dialogue :
  • Choisissez un dossier de destination
  • Renommez le fichier (facultatif mais recommandé)
  • Sélectionnez votre format préféré (PNG pour la transparence, JPG pour les photos, GIF pour les graphiques simples)
  • Cliquez sur Enregistrer.

✔ Avantages : Gratuit, intégré, opération en 1 clic, fonctionnalité native de Microsoft Word

✘ Inconvénients : Extrêmement lent pour l'extraction par lots (une seule image à la fois)

Bien que les documents Word soient courants, vous devrez peut-être également extraire des images de PDF. Consultez notre guide complet pour extraire les images PDF – y compris des outils gratuits et des méthodes avancées.

Méthode 2 : Enregistrer en tant que page Web

Idéal pour : Les utilisateurs qui préfèrent les fonctionnalités natives de Word pour l'enregistrement d'images par lots.

Microsoft Word inclut une fonctionnalité cachée puissante : l'enregistrement en tant que page Web exporte automatiquement chaque image intégrée dans un dossier dédié. C'est l'une des méthodes les plus anciennes et les plus fiables pour extraire des images de fichiers Word doc ou docx.

Procédure complète :

• Ouvrez le document Word.
• Cliquez sur Fichier → Enregistrer sous et choisissez un emplacement d'enregistrement sur votre appareil.
• Dans la liste déroulante "Type de fichier", sélectionnez *Page Web (.htm; *.html)**.
  • Remarque : Ne sélectionnez PAS "Page Web, fichier unique" – cela regroupe tout dans un seul fichier

• Cliquez sur Enregistrer—Word générera deux éléments dans le dossier que vous avez choisi :
  • Le fichier de la page Web HTML.
  • Un dossier nommé [NomDeVotreDocument]_fichiers (par ex., Rapport_fichiers).
• Ouvrez ce dossier pour accéder à toutes les images extraites (dans leurs formats d'origine comme PNG/JPG).

✔ Avantages : Outil natif de Word, extrait instantanément toutes les images par lots, conserve une bonne qualité

✘ Inconvénients : Crée des fichiers HTML supplémentaires, génère des images en double si les visuels sont réutilisés dans le document

Méthode 3 : L'astuce du fichier ZIP

Idéal pour : Les utilisateurs qui ont besoin d'extraire en masse toutes les images haute résolution des fichiers DOCX — aucun logiciel requis.

Voici un fait peu connu : les documents Word modernes (.docx) sont en fait des archives ZIP compressées. Cela signifie que vous pouvez extraire des images de fichiers docx sans jamais ouvrir Microsoft Word.

Pourquoi ça marche :

Depuis Microsoft Office 2007, Word utilise le format Open XML. Un fichier .docx est essentiellement un conteneur avec des fichiers XML et un dossier dédié /word/media/ contenant toutes les images intégrées.

Étapes détaillées :

• Localisez votre fichier DOCX et faites-en une copie (pour protéger l'original).
• Faites un clic droit sur le fichier et sélectionnez Renommer.
• Changez l'extension du fichier de .docx à .zip (par ex., rapport.docx → rapport.zip).
• Appuyez sur Entrée pour confirmer le changement d'extension.
• Cliquez sur Oui si un avertissement apparaît.
• Double-cliquez pour l'ouvrir comme n'importe quel dossier (Explorateur Windows ou Finder Mac).
• Naviguez jusqu'au chemin du dossier : word → media.
• Copiez toutes les images dans le dossier de votre choix.

✔ Avantages : 100% gratuit, extraction par lots, préserve la haute résolution d'origine

✘ Inconvénients : Ne fonctionne que pour les fichiers DOCX.

Conseil rapide : Pour l'extraction en masse d'images à partir d'anciens fichiers .doc, utilisez la méthode 2 (Enregistrer en tant que page Web), ou convertissez d'abord DOC en DOCX avant d'appliquer cette méthode.

Méthode 4 : Extracteurs d'images Word en ligne gratuits

Idéal pour : Les utilisateurs qui ne veulent pas installer de logiciel ou qui ont besoin d'une solution multiplateforme rapide (fonctionne sur Windows, Mac, mobile).

Des outils en ligne dédiés comme ExtractAssets ou Groupdocs gèrent les fichiers DOC et DOCX, extrayant toutes les images et les livrant sous forme de fichier ZIP téléchargeable — aucune étape technique requise.

Étapes pour extraire des images de Word en ligne :

• Accédez au site Web de l'outil (par ex., ExtractAssets Word Image Extractor)
• Téléchargez votre document Word.
• Cliquez sur Extraire les images.
• Téléchargez les images sous forme de fichier ZIP.

✔ Avantages : Aucune installation, multiplateforme, fonctionne pour les fichiers DOC et DOCX

✘ Inconvénients : Nécessite Internet ; limites de taille de fichier pour les utilisateurs gratuits

Avertissement : Soyez prudent lorsque vous téléchargez des documents sensibles ou confidentiels sur des outils en ligne. Pour les fichiers privés, tenez-vous-en aux méthodes hors ligne.

Méthode 5 : Solutions de programmation gratuites

Idéal pour : Les utilisateurs fréquents qui ont besoin d'extraire des images par lots ou de les intégrer dans des flux de travail automatisés.

Pour les entreprises et les développeurs, Free Spire.Doc for .NET est une bibliothèque puissante qui vous permet d'extraire par programmation des images de Word en C# avec un contrôle total sur le format de sortie.

Code C# pour extraire les images Word :

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

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load a Word document
            Document document = new Document("input.docx");
            int index = 0;

            // Traverses each section in the document
            foreach (Section section in document.Sections)
            {
                // Traverses each paragraph in the current section
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Traverses each document object in the current paragraph
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Checks if the current document object is an image
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Saves the extracted image as a PNG file
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

Le code charge un document Word et le parcourt de manière hiérarchique : Document → Section → Paragraphe → DocumentObject, en filtrant uniquement les objets de type image, puis en les enregistrant en tant que fichiers PNG distincts.

Capacités techniques clés :

• Prise en charge des formats : DOC, DOCX, DOT, DOTX, DOCM, RTF, et plus
• Formats de sortie : Enregistrez les images extraites en PNG, JPG, BMP, EMF, GIF, TIFF
• Traitement par lots : Traitez des milliers de documents avec un seul script
• Extraction sélective : Extrayez des images de sections, de paragraphes spécifiques

✔ Avantages : Automatisation complète par lots, large prise en charge des formats de fichiers, fiabilité de niveau entreprise

✘ Inconvénients : Connaissances de base en codage requises ; la version gratuite a certaines limitations

Les images ne sont pas le seul contenu de valeur dans vos documents Word. Découvrez comment extraire du texte, des tableaux, et une mise en forme pour les réutiliser dans d'autres projets

Comparaison rapide de toutes les méthodes

Utilisez ce tableau pour choisir instantanément la bonne méthode pour votre cas d'utilisation :

FAQ sur l'extraction d'images de Word

Q1 : Puis-je extraire des images d'un document Word protégé par mot de passe ?

R : Vous devez d'abord déverrouiller le document, puis utiliser l'une des méthodes ci-dessus.

Q2 : Comment puis-je obtenir des images haute résolution à partir de Word ?

R : Utilisez l'astuce ZIP pour les .docx. Pour les fichiers .doc, la méthode Enregistrer en tant que page Web préserve généralement une meilleure qualité que l'enregistrement par clic droit.

Q3 : Quels formats d'image puis-je extraire de Word ?

R : Word prend en charge les images intégrées dans divers formats, notamment :

• JPEG/JPG (photos)
• PNG (graphiques avec transparence)
• GIF (animations, graphiques simples)
• BMP (images bitmap)
• TIFF (images haute résolution)
• EMF/WMF (graphiques vectoriels)
• SVG (graphiques vectoriels adaptables – versions plus récentes de Word)

Q4 : Puis-je extraire des images de plusieurs documents Word à la fois ?

R : Oui, utilisez des outils professionnels comme Spire.Doc pour traiter des dossiers entiers avec un script. Certains outils en ligne proposent également le traitement par lots de plusieurs documents Word.

Mots de la fin

Vous disposez maintenant de 5 moyens gratuits et efficaces pour extraire des images d'un document Word, chacun adapté à des besoins et à des niveaux de compétence technique différents. Pour des images uniques rapides, utilisez l'enregistrement par clic droit. Pour l'extraction par lots, l'astuce ZIP est le meilleur choix gratuit. Les outils en ligne fonctionnent en déplacement, tandis que les logiciels professionnels comme Spire.Doc offrent des résultats automatisés de haute qualité pour une utilisation intensive.

Ne perdez plus de temps à faire des captures d'écran ou à recréer des images. Utilisez plutôt ces méthodes pour obtenir des images nettes et de haute qualité à partir de Word en quelques secondes.

Voir aussi

• Comment fusionner des documents Word : préserver ou unifier la mise en forme
• Convertir facilement du texte en PDF : 4 méthodes rapides et professionnelles
• Convertir Word en PNG : 3 façons pratiques que vous pouvez réellement utiliser
• C#/VB.NET : Extraire du texte et des images de Word
• Java : Extraire du texte et des images de Word

Extraer imágenes de documentos Word DOC/DOCX es una de las tareas diarias más comunes para estudiantes, especialistas en marketing, diseñadores y trabajadores de oficina. Ya sea que desees reutilizar imágenes en una presentación, editarlas en Photoshop, compartir visuales en redes sociales u organizar una biblioteca de medios, saber cómo extraer imágenes de un documento de Word de manera eficiente te ahorra horas de trabajo repetitivo.

En esta guía paso a paso, te mostraremos 5 formas fiables, gratuitas y fáciles de extraer imágenes de Word. Cubrimos la extracción de una sola imagen, el procesamiento por lotes, las herramientas en línea y el software profesional.

• ¿Por Qué Extraer Imágenes de Word?
• Método 1: Guardar Imagen Como con Clic Derecho
• Método 2: Guardar como Página Web
• Método 3: El Truco del Archivo ZIP
• Método 4: Extractores de Imágenes de Word en Línea Gratuitos
• Método 5: Soluciones de Programación Gratuitas
• Comparación Rápida de Todos los Métodos
• Preguntas Frecuentes Sobre la Extracción de Imágenes de Word

¿Por Qué Extraer Imágenes de Word?

Comprender los casos de uso te ayuda a elegir el método de extracción correcto:

• Reutilización de Contenido: Transforma los elementos visuales de documentos internos en gráficos para blogs, publicaciones en redes sociales o diapositivas de presentación
• Copia de Seguridad: Conserva la calidad de imagen original por separado de las versiones en evolución del documento
• Edición: Edita fotos en software especializado sin los artefactos de compresión de los guardados repetidos en Word
• Reducción del Tamaño del Archivo: Reduce el tamaño del documento eliminando gráficos incrustados grandes para el correo electrónico o el almacenamiento en la nube

Método 1: Guardar Imagen Como con Clic Derecho

Ideal para: Usuarios que ya están en Microsoft Word y necesitan extraer rápidamente de 1 a 3 imágenes.

"Guardar como imagen" es el método más intuitivo para extraer imágenes de Word cuando solo necesitas una o dos imágenes. No requiere conocimientos técnicos y funciona en segundos.

Instrucciones Paso a Paso:

• Abre tu documento de Word en Microsoft Word.
• Haz clic derecho en la imagen que deseas guardar.
• En el menú contextual, selecciona Guardar como imagen.

• En el cuadro de diálogo:
  • Elige una carpeta de destino
  • Cambia el nombre del archivo (opcional pero recomendado)
  • Selecciona tu formato preferido (PNG para transparencia, JPG para fotos, GIF para gráficos simples)
  • Haz clic en Guardar.

✔ Ventajas: Gratuito, integrado, operación de 1 clic, función nativa de Microsoft Word

✘ Desventajas: Extremadamente lento para la extracción por lotes (solo una imagen a la vez)

Aunque los documentos de Word son comunes, también es posible que necesites extraer imágenes de archivos PDF. Consulta nuestra guía completa para extraer imágenes de PDF, que incluye herramientas gratuitas y métodos avanzados.

Método 2: Guardar como Página Web

Ideal para: Usuarios que prefieren las funciones nativas de Word para guardar imágenes por lotes.

Microsoft Word incluye una potente función oculta: guardar como página web exporta automáticamente cada imagen incrustada a una carpeta dedicada. Este es uno de los métodos más antiguos y fiables para extraer imágenes de archivos Word doc o docx.

Guía Completa:

• Abre el documento de Word.
• Haz clic en Archivo → Guardar como y elige una ubicación para guardar en tu dispositivo.
• En el menú desplegable "Guardar como tipo", selecciona *Página web (.htm; *.html)**.
  • Nota: NO selecciones "Página web de un solo archivo", ya que esto empaqueta todo en un solo archivo.

• Haz clic en Guardar. Word generará dos elementos en la carpeta que elijas:
  • El archivo de la página web HTML.
  • Una carpeta llamada [NombreDeTuDocumento]_files (p. ej., Report_files).
• Abre esa carpeta para acceder a todas las imágenes extraídas (en sus formatos originales como PNG/JPG).

✔ Ventajas: Herramienta nativa de Word, extrae todas las imágenes por lotes al instante, conserva una buena calidad

✘ Desventajas: Crea archivos HTML adicionales, genera imágenes duplicadas si los elementos visuales se reutilizan en el documento

Método 3: El Truco del Archivo ZIP

Ideal para: Usuarios que necesitan extraer en masa todas las imágenes de alta resolución de archivos DOCX, sin necesidad de software.

Aquí hay un hecho poco conocido: los documentos de Word modernos (.docx) son en realidad archivos ZIP comprimidos. Esto significa que puedes extraer imágenes de archivos docx sin siquiera abrir Microsoft Word.

Por Qué Funciona Esto:

Desde Microsoft Office 2007, Word ha utilizado el formato Open XML. Un archivo .docx es esencialmente un contenedor con archivos XML y una carpeta dedicada /word/media/ que contiene todas las imágenes incrustadas.

Pasos Detallados:

• Localiza tu archivo DOCX y haz una copia (para proteger el original).
• Haz clic con el botón derecho en el archivo y selecciona Cambiar nombre.
• Cambia la extensión del archivo de .docx a .zip (p. ej., informe.docx → informe.zip).
• Presiona Enter para confirmar el cambio de extensión.
• Haz clic en Sí si aparece una advertencia.
• Haz doble clic para abrirlo como cualquier carpeta (Explorador de Windows o Finder de Mac).
• Navega a la ruta de la carpeta: word → media.
• Copia todas las imágenes a la carpeta que desees.

✔ Ventajas: 100% gratuito, extracción por lotes, conserva la alta resolución original

✘ Desventajas: Solo funciona para archivos DOCX.

Consejo Rápido: Para extraer imágenes en masa de archivos .doc antiguos, utiliza el Método 2 (Guardar como Página Web), o convierte DOC a DOCX primero antes de aplicar este método.

Método 4: Extractores de Imágenes de Word en Línea Gratuitos

Ideal para: Usuarios que no quieren instalar software o necesitan una solución rápida multiplataforma (funciona en Windows, Mac, móvil).

Herramientas en línea dedicadas como ExtractAssets o Groupdocs manejan archivos DOC y DOCX, extrayendo todas las imágenes y entregándolas como un archivo ZIP descargable, sin necesidad de pasos técnicos.

Pasos para extraer imágenes de Word en línea:

• Navega al sitio web de la herramienta (p. ej., Extractor de Imágenes de Word de ExtractAssets)
• Sube tu documento de Word.
• Haz clic en Extraer Imágenes.
• Descarga las imágenes como un archivo ZIP.

✔ Ventajas: Sin instalación, multiplataforma, funciona para archivos DOC y DOCX

✘ Desventajas: Necesita internet; límites de tamaño de archivo para usuarios gratuitos

Advertencia: Ten cuidado al subir documentos sensibles o confidenciales a herramientas en línea. Para archivos privados, utiliza los métodos sin conexión.

Método 5: Soluciones de Programación Gratuitas

Ideal para: Usuarios frecuentes que necesitan extraer imágenes por lotes o integrarlas en flujos de trabajo automatizados.

Para empresas y desarrolladores, Free Spire.Doc for .NET es una potente biblioteca que te permite extraer imágenes de Word mediante programación en C# con control total sobre el formato de salida.

Código C# para Extraer Imágenes de Word:

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

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load a Word document
            Document document = new Document("input.docx");
            int index = 0;

            // Traverses each section in the document
            foreach (Section section in document.Sections)
            {
                // Traverses each paragraph in the current section
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Traverses each document object in the current paragraph
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Checks if the current document object is an image
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Saves the extracted image as a PNG file
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

El código carga un documento de Word y lo recorre de manera jerárquica: Documento → Sección → Párrafo → DocumentObject, filtrando solo los objetos de tipo imagen y luego guardándolos como archivos PNG separados.

Capacidades Técnicas Clave:

• Soporte de Formatos: DOC, DOCX, DOT, DOTX, DOCM, RTF y más
• Formatos de Salida: Guarda las imágenes extraídas como PNG, JPG, BMP, EMF, GIF, TIFF
• Procesamiento por Lotes: Procesa miles de documentos con un solo script
• Extracción Selectiva: Extrae imágenes de secciones o párrafos específicos

✔ Ventajas: Automatización completa por lotes, amplio soporte de formatos de archivo, fiabilidad de nivel empresarial

✘ Desventajas: Se requieren conocimientos básicos de codificación; la versión gratuita tiene ciertas limitaciones

Las imágenes no son el único contenido valioso en tus documentos de Word. Descubre cómo extraer texto, tablas y formato para reutilizarlos en otros proyectos

Comparación Rápida de Todos los Métodos

Usa esta tabla para elegir al instante el método adecuado para tu caso de uso:

Preguntas Frecuentes Sobre la Extracción de Imágenes de Word

P1: ¿Puedo extraer imágenes de un documento de Word protegido con contraseña?

R: Primero debes desbloquear el documento y luego usar cualquiera de los métodos anteriores.

P2: ¿Cómo obtengo imágenes de alta resolución de Word?

R: Usa el truco del ZIP para .docx. Para archivos .doc, el método de Guardar como Página Web generalmente conserva una mejor calidad que guardar con clic derecho.

P3: ¿Qué formatos de imagen puedo extraer de Word?

R: Word admite imágenes incrustadas en varios formatos, que incluyen:

• JPEG/JPG (fotos)
• PNG (gráficos con transparencia)
• GIF (animaciones, gráficos simples)
• BMP (imágenes de mapa de bits)
• TIFF (imágenes de alta resolución)
• EMF/WMF (gráficos vectoriales)
• SVG (gráficos vectoriales escalables – versiones más recientes de Word)

P4: ¿Puedo extraer imágenes de varios documentos de Word a la vez?

R: Sí, usa herramientas profesionales como Spire.Doc para procesar carpetas enteras con un script. Algunas herramientas en línea también ofrecen procesamiento por lotes de múltiples documentos de Word.

Palabras Finales

Ahora tienes 5 formas gratuitas y efectivas de extraer imágenes de un documento de Word, cada una adaptada a diferentes necesidades y niveles de habilidad técnica. Para imágenes individuales rápidas, usa guardar con clic derecho. Para la extracción por lotes, el truco del ZIP es la mejor opción gratuita. Las herramientas en línea funcionan sobre la marcha, mientras que el software profesional como Spire.Doc ofrece resultados automatizados de alta calidad para un uso intensivo.

No más perder tiempo haciendo capturas de pantalla o recreando imágenes. En su lugar, utiliza estos métodos para obtener imágenes limpias y de alta calidad de Word en segundos.

Ver También

• Cómo Combinar Documentos de Word: Preservar o Unificar el Formato
• Convertir Texto a PDF Fácilmente: 4 Métodos Rápidos y Profesionales
• Convertir Word a PNG: 3 Formas Prácticas que Realmente Puedes Usar
• C#/VB.NET: Extraer Texto e Imágenes de Word
• Java: Extraer Texto e Imágenes de Word

Das Extrahieren von Bildern aus Word DOC/DOCX ist eine der häufigsten täglichen Aufgaben für Studenten, Vermarkter, Designer und Büroangestellte. Ob Sie Bilder in einer Präsentation wiederverwenden, sie in Photoshop bearbeiten, visuelle Inhalte in sozialen Medien teilen oder eine Medienbibliothek organisieren möchten – zu wissen, wie man Bilder effizient aus einem Word-Dokument extrahiert, spart Ihnen Stunden repetitiver Arbeit.

In dieser Schritt-für-Schritt-Anleitung zeigen wir Ihnen 5 zuverlässige, kostenlose und einfache Möglichkeiten, Bilder aus Word zu extrahieren. Wir behandeln die Extraktion einzelner Bilder, die Stapelverarbeitung, Online-Tools und professionelle Software.

• Warum Bilder aus Word extrahieren?
• Methode 1: Rechtsklick „Als Bild speichern“
• Methode 2: Als Webseite speichern
• Methode 3: Der ZIP-Datei-Trick
• Methode 4: Kostenlose Online-Word-Bildextraktoren
• Methode 5: Kostenlose Programmierlösungen
• Schneller Vergleich aller Methoden
• FAQs zum Extrahieren von Bildern aus Word

Warum Bilder aus Word extrahieren?

Das Verständnis der Anwendungsfälle hilft Ihnen, die richtige Extraktionsmethode zu wählen:

• Inhalte wiederverwenden: Wandeln Sie interne Dokumentenvisualisierungen in Blog-Grafiken, Social-Media-Beiträge oder Präsentationsfolien um
• Sicherung: Bewahren Sie die ursprüngliche Bildqualität getrennt von sich entwickelnden Dokumentversionen
• Bearbeitung: Bearbeiten Sie Fotos in spezialisierter Software ohne die Kompressionsartefakte wiederholter Word-Speicherungen
• Dateigrößenreduzierung: Reduzieren Sie die Dokumentgröße, indem Sie große eingebettete Grafiken für den E-Mail- oder Cloud-Speicher entfernen

Methode 1: Rechtsklick „Als Bild speichern“

Am besten für: Benutzer, die bereits in Microsoft Word arbeiten und schnell 1–3 Bilder extrahieren müssen.

„Als Bild speichern“ ist die intuitivste Methode, um Bilder aus Word zu extrahieren, wenn Sie nur ein oder zwei Bilder benötigen. Es erfordert keine technischen Kenntnisse und funktioniert in Sekunden.

Schritt-für-Schritt-Anleitung:

• Öffnen Sie Ihr Word-Dokument in Microsoft Word.
• Klicken Sie mit der rechten Maustaste auf das Bild, das Sie speichern möchten.
• Wählen Sie im Kontextmenü Als Bild speichern.

• Im Dialogfeld:
  • Wählen Sie einen Zielordner
  • Benennen Sie die Datei um (optional, aber empfohlen)
  • Wählen Sie Ihr bevorzugtes Format (PNG für Transparenz, JPG für Fotos, GIF für einfache Grafiken)
  • Klicken Sie auf Speichern.

✔ Vorteile: Kostenlos, integriert, 1-Klick-Bedienung, native Funktion von Microsoft Word

✘ Nachteile: Extrem langsam bei der Stapel-Extraktion (nur ein Bild auf einmal)

Obwohl Word-Dokumente üblich sind, müssen Sie möglicherweise auch Bilder aus PDFs extrahieren. Sehen Sie sich unsere vollständige Anleitung zum Extrahieren von PDF-Bildern an – einschließlich kostenloser Tools und fortgeschrittener Methoden.

Methode 2: Als Webseite speichern

Am besten für: Benutzer, die die nativen Funktionen von Word für das Speichern von Bildern im Stapel bevorzugen.

Microsoft Word enthält eine leistungsstarke versteckte Funktion: Das Speichern als Webseite exportiert automatisch jedes eingebettete Bild in einen eigenen Ordner. Dies ist eine der ältesten und zuverlässigsten Methoden, um Bilder aus Word-Doc- oder Docx-Dateien zu extrahieren.

Vollständige Anleitung:

• Öffnen Sie das Word-Dokument.
• Klicken Sie auf Datei → Speichern unter und wählen Sie einen Speicherort auf Ihrem Gerät.
• Im „Dateityp“-Dropdown-Menü wählen Sie *Webseite (*.htm; *.html)**.
  • Hinweis: Wählen Sie NICHT „Einzelne Webseite“ – dies packt alles in eine einzige Datei

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

namespace ExtractImage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Load a Word document
            Document document = new Document("input.docx");
            int index = 0;

            // Traverses each section in the document
            foreach (Section section in document.Sections)
            {
                // Traverses each paragraph in the current section
                foreach (Paragraph paragraph in section.Paragraphs)
                {
                    // Traverses each document object in the current paragraph
                    foreach (DocumentObject docObject in paragraph.ChildObjects)
                    {
                        // Checks if the current document object is an image
                        if (docObject.DocumentObjectType == DocumentObjectType.Picture)
                        {
                            DocPicture picture = docObject as DocPicture;
                            // Saves the extracted image as a PNG file
                            picture.Image.Save(string.Format("image_{0}.png", index), System.Drawing.Imaging.ImageFormat.Png);
                            index++;
                        }
                    }
                }
            }
        }
    }
}

Извлечение изображений из 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