Convertire le presentazioni PowerPoint in HTML con Python

Panoramica

Aspose.Slides per Python via .NET può salvare le presentazioni PowerPoint come HTML senza Microsoft PowerPoint. La conversione di base consiste in un unico caricamento di Presentazione e una chiamata a save con SaveFormat. Utilizza HtmlOptions quando è necessario controllare il layout esportato, i caratteri, le immagini, le note, i commenti, l’output SVG o le risorse collegate.

Questa guida si concentra su scenari pratici di esportazione HTML:

  • Esportare un’intera presentazione o diapositive selezionate.
  • Generare HTML a layout fisso, responsive o basato su SVG.
  • Includere note del relatore e commenti.
  • Controllare la qualità delle immagini e i dati delle immagini ritagliate.
  • Incorporare i caratteri o salvare i file dei caratteri separatamente.
  • Scegliere come le risorse esterne e i file multimediali vengano scritti e referenziati.

Per impostazione predefinita, l’esportazione HTML produce un documento HTML autonomo in cui la maggior parte delle risorse è incorporata. Questo è comodo per condividere un unico file, ma può aumentare le dimensioni dell’output. Per la pubblicazione web, considerare risorse esterne, DPI immagine più bassi e incorporare solo i caratteri non disponibili in modo affidabile nell’ambiente di destinazione.

Convertire una presentazione in HTML

Per esportare una presentazione in HTML, caricala con Presentazione e salvala con SaveFormat.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    presentation.save("presentation.html", slides.export.SaveFormat.HTML)

Questo esempio scrive un file HTML. L’istruzione with elimina l’oggetto presentazione e rilascia i gestori di file e le risorse di rendering dopo l’esportazione.

Utilizzare HtmlOptions

HtmlOptions è la classe di configurazione principale per l’esportazione HTML. Le impostazioni comuni includono:

  • slides_layout_options: aggiunge note, commenti, dispense o altre informazioni di layout.
  • html_formatter: modifica la struttura del documento HTML o delega la formattazione a un controller.
  • slide_image_format: cambia il modo in cui le diapositive sono rappresentate, ad esempio come SVG.
  • pictures_compression: controlla DPI dell’immagine e dimensione dell’output.
  • delete_pictures_cropped_areas: conserva o rimuove i dati delle immagini ritagliate.
  • svg_responsive_layout: fa sì che il contenuto SVG esportato si adatti al contenitore.
  • show_hidden_slides: include le diapositive nascoste quando richiesto.

Le sezioni seguenti mostrano le opzioni più comuni separatamente, così da poter combinare solo quelle necessarie al tuo flusso di lavoro.

Convertire diapositive selezionate in HTML

Il sovraccarico save che accetta numeri di diapositiva utilizza posizioni basate su 1. Il ciclo sottostante salva ogni diapositiva in un file HTML separato.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    slide_count = len(presentation.slides)

    for slide_index in range(slide_count):
        slide_number = slide_index + 1
        slide_numbers = [slide_number]
        html_file_name = "slide-{}.html".format(slide_number)

        presentation.save(html_file_name, slide_numbers, slides.export.SaveFormat.HTML)

Usa questo modello quando un sito web o un’applicazione necessita di una pagina HTML per diapositiva. Se ogni diapositiva deve avere lo stesso layout, crea un’istanza di HtmlOptions e passala a ogni chiamata save.

Creare HTML responsive

ResponsiveHtmlController fornisce output HTML responsive tramite HtmlFormatter. Usalo quando la pagina esportata deve adattarsi meglio alla larghezza del browser.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    controller = slides.export.ResponsiveHtmlController()
    formatter = slides.export.HtmlFormatter.create_custom_formatter(controller)

    html_options = slides.export.HtmlOptions()
    html_options.html_formatter = formatter

    presentation.save("presentation-responsive.html", slides.export.SaveFormat.HTML, html_options)

Per un layout responsive basato su SVG, imposta svg_responsive_layout su HtmlOptions. Questo è utile quando il contenuto della diapositiva viene esportato come markup SVG scalabile.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    html_options = slides.export.HtmlOptions()
    html_options.svg_responsive_layout = True

    presentation.save("presentation-svg-responsive.html", slides.export.SaveFormat.HTML, html_options)

Includere note del relatore e commenti

Usa NotesCommentsLayoutingOptions tramite html_options.slides_layout_options per includere note del relatore o commenti. Note e commenti sono nascosti per impostazione predefinita a meno che non vengano scelte le loro posizioni.

Supponiamo che la presentazione di origine contenga note del relatore:

Diapositiva con note del relatore in PowerPoint

Il codice seguente esporta il contenuto della diapositiva con le note del relatore sotto la diapositiva.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    layout_options = slides.export.NotesCommentsLayoutingOptions()
    layout_options.notes_position = slides.export.NotesPositions.BOTTOM_FULL

    html_options = slides.export.HtmlOptions()
    html_options.slides_layout_options = layout_options

    presentation.save("presentation-with-notes.html", slides.export.SaveFormat.HTML, html_options)

L’HTML esportato include l’area delle note:

Output HTML con diapositiva e note del relatore

Per esportare i commenti, imposta comments_position, ad esempio su CommentsPositions.RIGHT o CommentsPositions.BOTTOM. Se ti servono solo i commenti, ometti notes_position. Se ti servono sia note sia commenti, imposta entrambe le proprietà.

Controllare la qualità dell’immagine e le aree ritagliate

L’esportazione HTML può comprimere le immagini delle diapositive per ridurre le dimensioni dell’output. Imposta pictures_compression a un valore di PicturesCompression quando hai bisogno di una qualità d’immagine più alta.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    html_options = slides.export.HtmlOptions()
    html_options.pictures_compression = slides.export.PicturesCompression.DPI150

    presentation.save("presentation-dpi-150.html", slides.export.SaveFormat.HTML, html_options)

Per impostazione predefinita, le aree ritagliate delle immagini possono essere rimosse dall’output esportato. Conserva i dati ritagliati solo quando gli utenti devono poter recuperare o ispezionare quelle parti nascoste dell’immagine. Mantenerli può aumentare la dimensione dell’HTML.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    html_options = slides.export.HtmlOptions()
    html_options.delete_pictures_cropped_areas = False

    presentation.save("presentation-with-cropped-areas.html", slides.export.SaveFormat.HTML, html_options)

Aggiungere CSS

Per una stilizzazione semplice, passa una stringa CSS a HtmlFormatter. Questo modifica il documento HTML circostante mentre Aspose.Slides continua a renderizzare il contenuto della diapositiva.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    css_rules = "body { margin: 0; background: #f7f7f7; } .slide { margin: 24px auto; }"
    formatter = slides.export.HtmlFormatter.create_document_formatter(css_rules, True)

    html_options = slides.export.HtmlOptions()
    html_options.html_formatter = formatter

    presentation.save("presentation-styled.html", slides.export.SaveFormat.HTML, html_options)

Per un’intestazione di documento personalizzata, un file CSS collegato o markup personalizzato intorno a diapositive e forme, utilizza un controller di formattazione personalizzato e passalo a HtmlFormatter con create_custom_formatter.

Incorporare i caratteri

Se l’ambiente di destinazione potrebbe non avere i caratteri della presentazione installati, incorpora i caratteri nell’HTML con EmbedAllFontsHtmlController. L’incorporamento migliora la fedeltà visiva ma aumenta le dimensioni dell’output.

import aspose.slides as slides

with slides.Presentation("presentation.pptx") as presentation:
    font_names_to_exclude = ["Arial"]
    font_controller = slides.export.EmbedAllFontsHtmlController(font_names_to_exclude)
    formatter = slides.export.HtmlFormatter.create_custom_formatter(font_controller)

    html_options = slides.export.HtmlOptions()
    html_options.html_formatter = formatter

    presentation.save("presentation-embedded-fonts.html", slides.export.SaveFormat.HTML, html_options)

Escludi un carattere solo quando sei certo che i browser o i sistemi di destinazione lo forniscano già. Per caratteri di brand o meno comuni, l’incorporamento è solitamente più sicuro.

Collegare file di caratteri invece di incorporarli

Per ridurre la dimensione del file HTML, puoi scrivere i dati dei caratteri in file WOFF separati e aggiungere regole @font-face all’HTML. Questo richiede un controller che personalizzi come i dati dei caratteri vengono scritti durante l’esportazione. In Python via .NET, implementa quel controller in un piccolo assembly .NET di supporto, caricalo in Python e passa l’oggetto di supporto a HtmlFormatter con create_custom_formatter.

Quando esternalizzi i caratteri, scegli due percorsi in modo deliberato:

  • La directory di output del file system dove verranno scritti i file WOFF generati.
  • Il percorso URL che apparirà nel documento HTML e che il browser utilizzerà per caricare quei file di caratteri.

Mantieni il file HTML e i file dei caratteri generati insieme fino a quando i percorsi di distribuzione non siano definitivi. Se i file vengono distribuiti in un’altra posizione, fai corrispondere il prefisso URL al percorso URL distribuito.

Salvare le risorse esternamente

HTML autonomo è facile da spostare, ma le risorse Base64 incorporate possono rendere il file grande. Se la tua applicazione necessita di immagini, caratteri, audio o video esterni, utilizza un controller personalizzato di collegamento/incorporamento e passalo al costruttore di HtmlOptions.

Quando esternalizzi le risorse, scegli due percorsi in modo deliberato:

  • Il percorso di output del file system, dove la tua applicazione scrive le immagini, i caratteri, l’audio o il video generati.
  • Il percorso URL, che è ciò che il browser usa dal documento HTML per caricare quei file.

Per una discussione completa sul collegamento delle immagini, vedi Esportare presentazioni in HTML con immagini collegate esternamente.

Esportare file multimediali

VideoPlayerHtmlController esporta file video e audio e genera HTML che può riprodurli in un browser. Il suo costruttore accetta:

  • path: la directory dove verranno scritti i file multimediali generati.
  • file_name: il nome del file HTML in fase di generazione.
  • base_uri: il prefisso URI assoluto usato nei collegamenti HTML ai file multimediali.

Se il file HTML è html-output/presentation.html e i file multimediali sono salvati in html-output/media, path dovrebbe puntare alla directory multimediale sul disco, mentre base_uri dovrebbe puntare alla stessa directory dal punto di vista del browser. Per l’anteprima locale, puoi costruire un URI file:/// dalla directory multimediale. Per un’applicazione distribuita, utilizza l’URL assoluto della directory multimediale pubblicata.

import os
from pathlib import Path

import aspose.slides as slides

output_directory = os.path.join(os.getcwd(), "html-output")
media_directory = os.path.join(output_directory, "media")
os.makedirs(output_directory, exist_ok=True)
os.makedirs(media_directory, exist_ok=True)

html_file_name = "presentation.html"
media_base_uri = Path(media_directory).as_uri() + "/"

with slides.Presentation() as presentation:
    with open("intro.mp4", "rb") as video_stream:
        video = presentation.videos.add_video(
            video_stream,
            slides.LoadingStreamBehavior.READ_STREAM_AND_RELEASE)

    slide = presentation.slides[0]
    slide.shapes.add_video_frame(20, 20, 480, 270, video)

    controller = slides.export.VideoPlayerHtmlController(
        media_directory,
        html_file_name,
        media_base_uri)

    formatter = slides.export.HtmlFormatter.create_custom_formatter(controller)
    svg_options = slides.export.SVGOptions(controller)
    slide_image_format = slides.export.SlideImageFormat.svg(svg_options)

    html_options = slides.export.HtmlOptions(controller)
    html_options.html_formatter = formatter
    html_options.slide_image_format = slide_image_format

    html_file_path = os.path.join(output_directory, html_file_name)
    presentation.save(html_file_path, slides.export.SaveFormat.HTML, html_options)

Usa directory di output uniche per ogni lavoro di esportazione, specialmente nelle applicazioni server. Percorsi di output condivisi possono far sì che i file di conversioni diverse si sovrascrivano.

Prestazioni e gestione delle risorse

La conversione HTML è un’operazione di rendering, quindi tempo di elaborazione e utilizzo della memoria dipendono dal numero di diapositive, risoluzione delle immagini, caratteri, effetti, grafici e media incorporati. Valori DPI più alti per pictures_compression, caratteri incorporati, output SVG e aree immagine ritagliate conservate possono migliorare la fedeltà ma solitamente aumentano le dimensioni dell’output.

Per la conversione batch:

  • Elimina tempestivamente ogni istanza di Presentazione.
  • Usa directory di output separate per lavori separati.
  • Evita di incorporare i caratteri comuni a meno che la fedeltà non lo richieda.
  • Riduci DPI delle immagini quando l’HTML è destinato a anteprime o miniature.
  • Mantieni la presentazione di origine, l’HTML generato e le risorse esterne insieme fino a quando i percorsi di distribuzione non siano definitivi.

FAQ

I collegamenti ipertestuali vengono conservati nell’output HTML?

Sì. I collegamenti ipertestuali della presentazione vengono esportati in HTML e rimangono cliccabili quando l’URL di destinazione è valido.

Posso convertire presentazioni in HTML in parallelo?

Sì, ma non condividere un’istanza di Presentazione tra thread. Elabora file diversi con istanze di presentazione separate, flussi separati e directory di output separate. Vedi le linee guida sul multithreading per i dettagli.

Un oggetto Presentazione è thread‑safe?

No. Un’unica istanza di Presentazione deve essere caricata, modificata, salvata ed eliminata su un solo thread. Per lavoro parallelo, crea un’istanza indipendente per thread o processo.

Perché il file HTML generato è grande?

L’esportazione predefinita può incorporare risorse direttamente nell’HTML. Caratteri incorporati, immagini ad alta DPI, media, contenuto SVG e aree immagine ritagliate conservate aumentano anche le dimensioni. Usa risorse esterne, escludi i caratteri comuni dall’incorporamento e riduci pictures_compression quando un output più piccolo è più importante della massima fedeltà.

Perché una dimensione di carattere PowerPoint come 24 pt appare come 17.999819 pt nell’HTML?

Ciò può accadere perché PowerPoint e HTML usano modelli DPI diversi. PowerPoint memorizza le dimensioni del testo in punti tipografici basati su 72 DPI, mentre il layout HTML si basa su pixel CSS in un modello a 96 DPI. Quando Aspose.Slides esporta una presentazione in HTML, la dimensione del carattere è tradotta tra questi sistemi e la conversione può introdurre piccole differenze di arrotondamento.

Questi valori non indicano un reale cambiamento visivo della dimensione del carattere. Sono solo un effetto collaterale matematico della conversione delle metriche del testo tra PowerPoint e HTML.

Come dovrei scegliere base_uri per l’esportazione dei media?

Scegli base_uri dal punto di vista del browser e passalo come URI assoluto. Per l’anteprima locale, puoi derivarlo dalla directory di output con Path(media_directory).as_uri() + "/". Per la distribuzione, usa l’URL assoluto della directory multimediale pubblicata. Il path del file system e il base_uri del browser non devono essere la stessa stringa, ma devono descrivere la stessa posizione della risorsa.

Posso includere diapositive nascoste?

Sì. Imposta show_hidden_slides = True su HtmlOptions quando le diapositive nascoste devono essere esportate.

Converti PPTX in PPT con Python Converti PPT e PPTX in PDF con Python | Opzioni Avanzate