Documentation – Travailler avec PDF Facades

Python-Net: Classe PdfFileEditor

Fri, 22 May 2026 00:00:00 +0000

Travailler avec des documents PDF comprend diverses fonctions. La gestion des pages d’un fichier PDF est une partie importante de cette tâche. ‘aspose.pdf.facades’ fournit le PdfFileEditor classe à cet effet.

La classe PdfFileEditor contient les méthodes qui permettent de manipuler des pages individuelles ; cette classe ne modifie ni ne manipule le contenu d’une page. Vous pouvez insérer une nouvelle page, supprimer une page existante, scinder les pages, ou spécifier l’imposition des pages à l’aide de PdfFileEditor.

Ce que vous pouvez faire avec PdfFileEditor

Les fonctionnalités offertes par cette classe peuvent être regroupées en workflows de modification de pages, d’imposition PDF et de division de documents. Ces articles montrent comment réarranger les pages, combiner plusieurs PDF, préparer des fichiers pour l’impression et extraire des sections de documents existants sans modifier manuellement le fichier source.

Tutoriels PdfFileEditor

Python-Net: Classe PdfContentEditor

Fri, 22 May 2026 00:00:00 +0000

Le PdfContentEditor La classe dans Aspose.PDF Facades est conçue pour les tâches de modification au niveau du contenu dans des documents PDF existants. Elle fournit une API simplifiée pour mettre à jour les éléments interactifs, remplacer du texte, travailler avec les pièces jointes et les liens, et ajuster le comportement du document dans les applications Python via .NET.

Ce que vous pouvez faire avec PdfContentEditor

Utilisez cette section pour explorer les principales zones de l’édition de contenu PDF prises en charge par le PdfContentEditor façade:

Python-Net: Classe PdfAnnotationEditor

Fri, 22 May 2026 00:00:00 +0000

Le PdfAnnotationEditor La classe dans Aspose.PDF Facades est destinée à travailler avec les annotations PDF et le balisage basé sur les commentaires sans modifier manuellement la structure de bas niveau d’un document. Elle fournit un moyen simplifié de gérer les flux de travail d’annotation en Python via .NET lorsque vous devez inspecter ou mettre à jour des fichiers PDF existants.

À quoi sert PdfAnnotationEditor

Utilisez cette façade lorsque votre flux de travail PDF implique des annotations, des commentaires de révision ou d’autres éléments de balisage qui doivent être gérés de manière programmatique. À mesure que cette section s’étend, elle devrait servir de page d’accueil aux tutoriels liés aux annotations construits autour du PdfAnnotationEditor classe.

Python-Net: Classe PdfFileSignature

Fri, 22 May 2026 00:00:00 +0000

Préparer les assistants de signature numérique PDF

Avant d’appliquer une signature numérique à un PDF, il est recommandé de mettre en place un groupe de fonctions d’assistance réutilisables. Ces fonctions encapsulent les tâches courantes — comme l’initialisation du gestionnaire de signature, la définition du placement visuel de la signature et la configuration de la signature basée sur un certificat — afin que la logique principale de signature reste claire, cohérente et facile à maintenir.

Ce que cette configuration réalise

Cette couche d’assistance prépare tout ce qui est nécessaire pour un flux de travail de signature fluide :

Initialise un objet PdfFileSignature et le lie à un document
Définit où la signature apparaîtra sur la page
Charge et applique un certificat de signature
Crée un objet de signature PKCS#7 réutilisable avec des métadonnées
Personnalise l’apparence visuelle de la signature

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as apd


DEFAULT_CERTIFICATE_PASSWORD = "Aspose2021"
DEFAULT_SIGNATURE_NAME = "Signature1"


def create_pdf_file_signature(infile):
    pdf_signature = pdf_facades.PdfFileSignature()
    pdf_signature.bind_pdf(infile)
    return pdf_signature


def create_signature_rectangle():
    return apd.Rectangle(10, 10, 200, 60)


def configure_signature_certificate(
    pdf_signature, certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    pdf_signature.set_certificate(certificate_path, certificate_password)


def create_pkcs7_signature(
    certificate_path, certificate_password=DEFAULT_CERTIFICATE_PASSWORD
):
    signature = ap.forms.PKCS7(certificate_path, certificate_password)
    signature.reason = "Document approval"
    signature.contact_info = "qa@example.com"
    signature.location = "New York, USA"
    signature.authority = "Aspose.PDF Example"
    return signature


def create_custom_signature_appearance():
    appearance = ap.forms.SignatureCustomAppearance()
    appearance.font_family_name = "Arial"
    appearance.font_size = 10
    appearance.show_contact_info = True
    appearance.show_location = True
    appearance.show_reason = True
    return appearance

Python-Net: Classe FormEditor

Fri, 22 May 2026 00:00:00 +0000

Le FormEditor La classe dans Aspose.PDF Facades est conçue pour créer et mettre à jour des champs de formulaire PDF interactifs. Elle vous aide à construire des structures de formulaire, à ajuster les propriétés des champs, à modifier les paramètres d’apparence et à ajouter un comportement interactif tel que des scripts et des actions de soumission dans les applications Python.

Tâches courantes du FormEditor

Utilisez les tutoriels suivants pour travailler avec les principales capacités de FormEditor façade:

Python-Net: Classe PdfFileInfo

Fri, 22 May 2026 00:00:00 +0000

Le PdfFileInfo La classe dans Aspose.PDF Facades offre un accès aux informations PDF au niveau du document et de la page sans nécessiter d’analyse bas niveau. Elle est utile lorsque vous devez inspecter les métadonnées, récupérer les propriétés du document, vérifier les privilèges ou examiner les dimensions et les décalages des pages dans des flux de travail automatisés.

Ce que vous pouvez faire avec PdfFileInfo

Utilisez les articles de cette section pour explorer les principales capacités d’inspection de fichiers de PdfFileInfo façade:

Python-Net: Classe PdfFileSecurity

Fri, 22 May 2026 00:00:00 +0000

Le PdfFileSecurity La classe dans Aspose.PDF Facades est utilisée pour protéger les documents PDF et contrôler la façon dont les utilisateurs peuvent interagir avec eux. Elle prend en charge les flux de travail de sécurité courants tels que le chiffrement basé sur un mot de passe, le déchiffrement, la rotation des mots de passe et la gestion des autorisations pour l’impression, la copie et la modification.

Ce que vous pouvez faire avec PdfFileSecurity

Utilisez les articles de cette section pour explorer les principales tâches de sécurité PDF prises en charge par le PdfFileSecurity façade:

Python-Net: Classe PdfViewer

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fournit le PdfViewer façade pour travailler avec la visualisation de PDF et les scénarios de décodage de pages. Un cas d’utilisation courant consiste à convertir des pages PDF en objets image qui peuvent ensuite être enregistrés sur le disque.

Créer un assistant PdfViewer réutilisable

Avant de décoder les pages ou de lire les propriétés liées au visualiseur, créez un petit assistant qui initialise et renvoie un PdfViewer instance. Cela rend les exemples ci-dessous autonomes et clarifie comment l’objet viewer est créé avant d’être lié à un document PDF.

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades


def _create_viewer() -> pdf_facades.PdfViewer:
    """Create a PdfViewer configured for decoding examples."""
    viewer = pdf_facades.PdfViewer()
    viewer.coordinate_type = ap.PageCoordinateType.MEDIA_BOX
    viewer.resolution = 150
    viewer.scale_factor = 1.0
    viewer.show_hidden_areas = False
    return viewer

Décoder toutes les pages du PDF

Utiliser decode_all_pages() lorsque vous souhaitez convertir chaque page du PDF en une image distincte. Les images de page renvoyées peuvent ensuite être enregistrées une par une dans un répertoire de sortie.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades

from config import initialize_data_dir, set_license


def decode_all_pages(infile: str, output_dir: str) -> None:
    """Decode all pages of a PDF document into image files."""
    viewer = _create_viewer()
    try:
        viewer.open_pdf_file(infile)
        decoded_pages = viewer.decode_all_pages()

        for index, page_image in enumerate(decoded_pages, start=1):
            image_path = path.join(output_dir, f"decode_all_pages_{index}.png")
            page_image.save(image_path)
    finally:
        viewer.close_pdf_file()

Décoder une page PDF spécifique

Utiliser decode_page() Lorsque vous avez besoin d’une seule page du document. Cela est utile lors de la génération d’aperçus, de miniatures ou d’exportations spécifiques à une page.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades

from config import initialize_data_dir, set_license


def decode_specific_page(infile: str, outfile: str, page_number: int = 1) -> None:
    """Decode a specific PDF page into an image file."""
    viewer = _create_viewer()
    try:
        viewer.bind_pdf(infile)
        page_image = viewer.decode_page(page_number)
        page_image.save(outfile)

    finally:
        viewer.close()

Inspecter les métadonnées PDF

Le inspect_pdf_metadata La fonction montre comment ouvrir un document PDF et récupérer les métadonnées de base liées au visualiseur en utilisant Aspose.PDF. Elle se concentre sur l’extraction d’informations qui décrivent comment le document est interprété et affiché plutôt que son contenu.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades

from config import initialize_data_dir, set_license


def inspect_pdf_metadata(infile: str) -> None:
    """Open a PDF and print page-count related viewer metadata."""
    viewer = _create_viewer()
    try:
        viewer.open_pdf_file(infile)
        print(f"Page count: {viewer.page_count}")
        print(f"Coordinate type: {viewer.coordinate_type}")
        print(f"Resolution: {viewer.resolution}")
    finally:
        viewer.close_pdf_file()

Python-Net: Classe Form

Fri, 22 May 2026 00:00:00 +0000

Python-Net: Classe Stamp

Fri, 22 May 2026 00:00:00 +0000

Aspose.PDF pour Python via .NET fournit le Stamp classe pour placer du contenu visuel réutilisable sur les pages PDF. Un tampon peut être basé sur du texte, une image, ou même une page d’un autre PDF, et il peut être positionné, pivoté, stylisé et limité à des pages spécifiques.

Cet article montre plusieurs flux de travail d’estampillage courants :

Créer des ressources texte réutilisables pour les tampons basés sur du texte.
Ajouter des tampons d’image et de page PDF.
Ajouter des tampons de texte stylisés.
Limiter un tampon aux pages sélectionnées.
Configurer un tampon d’image d’arrière-plan.

L’exemple utilise deux fonctions d’assistance : l’une crée du texte formaté pour les tampons basés sur du texte, et l’autre crée un TextState objet utilisé pour mettre en forme les tampons de texte.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def _create_text_logo(text: str) -> pdf_facades.FormattedText:
    """Create formatted text for text stamp examples."""
    return pdf_facades.FormattedText(
        text,
        drawing.Color.blue,
        drawing.Color.light_gray,
        pdf_facades.FontStyle.HELVETICA_BOLD,
        pdf_facades.EncodingType.WINANSI,
        True,
        14,
    )


def _create_text_state() -> ap.text.TextState:
    """Create a text state used to style text stamps."""
    text_state = ap.text.TextState()
    text_state.foreground_color = ap.Color.dark_blue
    text_state.font_size = 16
    text_state.font_style = ap.text.FontStyles.BOLD
    return text_state

Ajouter un tampon d’image

Utiliser bind_image() lorsque le tampon doit afficher une image telle qu’un logo, un badge ou une icône. Après avoir lié l’image, vous pouvez définir l’ID du tampon et l’origine avant de l’ajouter au document.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def add_image_stamp(infile: str, image_file: str, outfile: str) -> None:
    """Add an image stamp to the PDF."""
    pdf_stamper = pdf_facades.PdfFileStamp()
    try:
        pdf_stamper.bind_pdf(infile)

        stamp = pdf_facades.Stamp()
        stamp.bind_image(image_file)
        stamp.stamp_id = 1
        stamp.set_origin(36, 520)

        pdf_stamper.add_stamp(stamp)
        pdf_stamper.save(outfile)
    finally:
        pdf_stamper.close()

Ajouter une page PDF en tant que tampon

Utiliser bind_pdf() lorsque vous souhaitez utiliser une page d’un autre fichier PDF comme contenu du tampon. Ceci est utile pour les superpositions telles que les approbations, les modèles ou les éléments visuels préconstruits stockés dans un document séparé.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def add_pdf_page_as_stamp(infile: str, stamp_pdf: str, outfile: str) -> None:
    """Add the first page of another PDF as a stamp."""
    pdf_stamper = pdf_facades.PdfFileStamp()
    try:
        pdf_stamper.bind_pdf(infile)

        stamp = pdf_facades.Stamp()
        stamp.bind_pdf(stamp_pdf, 1)
        stamp.page_number = 1
        stamp.set_origin(36, 250)

        pdf_stamper.add_stamp(stamp)
        pdf_stamper.save(outfile)
    finally:
        pdf_stamper.close()

Ajouter un tampon de texte avec un état de texte

Utiliser bind_logo() avec bind_text_state() lorsque vous souhaitez créer un tampon texte avec une mise en forme de police personnalisée. Cette approche est utile pour les marques d’approbation, les étiquettes et les annotations spécifiques aux flux de travail.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def add_text_stamp_with_text_state(infile: str, outfile: str) -> None:
    """Add a text stamp and style it with a TextState object."""
    pdf_stamper = pdf_facades.PdfFileStamp()
    try:
        pdf_stamper.bind_pdf(infile)

        stamp = pdf_facades.Stamp()
        stamp.bind_logo(_create_text_logo("Approved by signing workflow"))
        stamp.bind_text_state(_create_text_state())
        stamp.set_origin(36, 700)
        stamp.rotation = 15.0

        pdf_stamper.add_stamp(stamp)
        pdf_stamper.save(outfile)
    finally:
        pdf_stamper.close()

Ajouter un tampon aux pages spécifiques

Si le tampon ne doit pas apparaître sur chaque page, attribuez les numéros de pages cibles à pages propriété. Cet exemple ajoute un ImageStamp uniquement à la première page.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def add_stamp_to_specific_pages(infile: str, image_file: str, outfile: str) -> None:
    """Add an image stamp only to the selected pages."""
    pdf_stamper = pdf_facades.PdfFileStamp()
    try:
        pdf_stamper.bind_pdf(infile)

        stamp = pdf_facades.Stamp()
        stamp.bind_image(image_file)
        stamp.pages = [1]
        stamp.set_origin(400, 40)
        stamp.set_image_size(120, 60)

        pdf_stamper.add_stamp(stamp)
        pdf_stamper.save(outfile)
    finally:
        pdf_stamper.close()

Ajouter un tampon d’image d’arrière-plan

Utilisez un tampon d’arrière-plan lorsque l’image doit apparaître derrière le contenu de la page. Vous pouvez également contrôler l’opacité du tampon, la rotation, la qualité, la taille et la position pour créer des effets de type filigrane.

import sys
from os import path

import aspose.pdf as ap
import aspose.pdf.facades as pdf_facades
import aspose.pydrawing as drawing

from config import initialize_data_dir, set_license


def add_background_image_stamp(infile: str, image_file: str, outfile: str) -> None:
    """Add a rotated background image stamp with opacity and quality settings."""
    pdf_stamper = pdf_facades.PdfFileStamp()
    try:
        pdf_stamper.bind_pdf(infile)

        stamp = pdf_facades.Stamp()
        stamp.bind_image(image_file)
        stamp.is_background = True
        stamp.opacity = 0.35
        stamp.quality = 90
        stamp.rotation = 45.0
        stamp.set_image_size(160, 80)
        stamp.set_origin(200, 300)

        pdf_stamper.add_stamp(stamp)
        pdf_stamper.save(outfile)
    finally:
        pdf_stamper.close()

Sujets liés aux façades

Python-Net: Classe PdfFileStamp

Fri, 22 May 2026 00:00:00 +0000

Le PdfFileStamp La classe dans Aspose.PDF Facades est conçue pour ajouter du contenu visuel répété aux pages PDF. Elle est utile lorsque vous devez appliquer des en-têtes, pieds de page, numéros de page ou tampons sur l’ensemble d’un document sans éditer manuellement chaque page.

Ce que vous pouvez faire avec PdfFileStamp

Utilisez les articles de cette section pour explorer les principales tâches d’estampillage prises en charge par le PdfFileStamp façade: