Documentation – Trabalhando com PDF Facades

Python-Net: Classe PdfFileEditor

Mon, 18 May 2026 00:00:00 +0000

Trabalhar com documentos PDF inclui várias funções. Gerenciar as páginas de um arquivo PDF é uma parte importante deste trabalho. ‘aspose.pdf.facades’ fornece o PdfFileEditor classe para este propósito.

A classe PdfFileEditor contém os métodos que ajudam a manipular páginas individuais; esta classe não edita nem manipula o conteúdo de uma página. Você pode inserir uma nova página, excluir uma página existente, dividir as páginas ou especificar a imposição das páginas usando PdfFileEditor.

O que você pode fazer com PdfFileEditor

Os recursos fornecidos por esta classe podem ser agrupados em fluxos de trabalho de edição de páginas, imposição de PDF e divisão de documentos. Estes artigos mostram como reorganizar páginas, combinar vários PDFs, preparar arquivos para impressão e extrair seções de documentos existentes sem editar manualmente o arquivo de origem.

Tutoriais do PdfFileEditor

Python-Net: Classe PdfContentEditor

Mon, 18 May 2026 00:00:00 +0000

O PdfContentEditor A classe em Aspose.PDF Facades foi projetada para tarefas de edição em nível de conteúdo em documentos PDF existentes. Ela fornece uma API simplificada para atualizar elementos interativos, substituir texto, trabalhar com anexos e links, e ajustar o comportamento do documento em aplicações Python via .NET.

O que você pode fazer com PdfContentEditor

Use esta seção para explorar as principais áreas de edição de conteúdo PDF suportadas por PdfContentEditor fachada:

Python-Net: Classe PdfAnnotationEditor

Mon, 18 May 2026 00:00:00 +0000

O PdfAnnotationEditor A classe em Aspose.PDF Facades destina‑se a trabalhar com anotações de PDF e marcações baseadas em comentários sem editar manualmente a estrutura de baixo nível de um documento. Ela fornece uma maneira simplificada de lidar com fluxos de trabalho de anotação em Python via .NET quando você precisa inspecionar ou atualizar arquivos PDF existentes.

Para que o PdfAnnotationEditor é usado

Use esta fachada quando seu fluxo de trabalho PDF envolve anotações, comentários de revisão ou outros elementos de marcação que precisam ser gerenciados programaticamente. À medida que esta seção se expande, ela deve servir como a página inicial para tutoriais relacionados a anotações construídos em torno do PdfAnnotationEditor classe.

Python-Net: Classe PdfFileSignature

Mon, 18 May 2026 00:00:00 +0000

Preparando Auxiliares de Assinatura Digital PDF

Antes de aplicar uma assinatura digital a um PDF, é uma prática recomendada configurar um grupo de funções auxiliares reutilizáveis. Essas funções encapsulam tarefas comuns — como inicializar o manipulador de assinatura, definir a posição visual da assinatura e configurar a assinatura baseada em certificado — para que a lógica principal de assinatura permaneça limpa, consistente e fácil de manter.

O que esta configuração alcança

Esta camada auxiliar prepara tudo o que é necessário para um fluxo de assinatura tranquilo:

Inicializa um objeto PdfFileSignature e o vincula a um documento
Define onde a assinatura aparecerá na página
Carrega e aplica um certificado de assinatura
Cria um objeto de assinatura PKCS#7 reutilizável com metadados
Personaliza a aparência visual da assinatura

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

Mon, 18 May 2026 00:00:00 +0000

O FormEditor A classe em Aspose.PDF Facades foi projetada para criar e atualizar campos de formulário PDF interativos. Ela ajuda a construir estruturas de formulário, ajustar as propriedades dos campos, alterar as configurações de aparência e anexar comportamentos interativos, como scripts e ações de envio, em aplicações Python.

Tarefas comuns do FormEditor

Use os seguintes tutoriais para trabalhar com as principais capacidades de FormEditor fachada:

Python-Net: Classe PdfFileInfo

Mon, 18 May 2026 00:00:00 +0000

O PdfFileInfo A classe em Aspose.PDF Facades fornece acesso às informações PDF em nível de documento e de página sem exigir análise de baixo nível. É útil quando você precisa inspecionar metadados, recuperar propriedades do documento, verificar privilégios ou examinar dimensões e deslocamentos de página em fluxos de trabalho automatizados.

O que você pode fazer com PdfFileInfo

Use os artigos nesta seção para explorar os principais recursos de inspeção de arquivos do PdfFileInfo fachada:

Python-Net: Classe PdfFileSecurity

Mon, 18 May 2026 00:00:00 +0000

O PdfFileSecurity A classe em Aspose.PDF Facades é usada para proteger documentos PDF e controlar como os usuários podem interagir com eles. Ela suporta fluxos de trabalho de segurança comuns, como criptografia baseada em senha, descriptografia, rotação de senha e gerenciamento de permissões para impressão, cópia e edição.

O que você pode fazer com PdfFileSecurity

Use os artigos nesta seção para explorar as principais tarefas de segurança de PDF suportadas por PdfFileSecurity fachada:

Python-Net: Classe PdfViewer

Mon, 18 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fornece o PdfViewer fachada para trabalhar com visualização de PDF e cenários de decodificação de página. Um caso de uso comum é converter páginas de PDF em objetos de imagem que podem então ser salvos no disco.

Crie um auxiliar PdfViewer reutilizável

Antes de decodificar páginas ou ler propriedades relacionadas ao visualizador, crie um pequeno auxiliar que inicializa e retorna um PdfViewer instância. Isso mantém os exemplos abaixo autossuficientes e deixa claro como o objeto visualizador é criado antes de ser associado a um documento 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

Decodificar todas as páginas PDF

usar decode_all_pages() quando você deseja converter cada página do PDF em uma imagem separada. As imagens das páginas retornadas podem então ser salvas uma a uma em um diretório de saída.

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()

Decodificar uma página PDF específica

usar decode_page() quando você precisa de apenas uma página do documento. Isso é útil ao gerar pré-visualizações, miniaturas ou exportações específicas de página.

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()

Inspecionar Metadados do PDF

O inspect_pdf_metadata A função demonstra como abrir um documento PDF e recuperar metadados básicos relacionados ao visualizador usando o Aspose.PDF. Ela se concentra em extrair informações que descrevem como o documento é interpretado e exibido, em vez de seu conteúdo.

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

Mon, 18 May 2026 00:00:00 +0000

Python-Net: Classe Stamp

Mon, 18 May 2026 00:00:00 +0000

Aspose.PDF for Python via .NET fornece o Stamp classe para colocar conteúdo visual reutilizável em páginas PDF. Uma marca pode ser baseada em texto, uma imagem ou até mesmo uma página de outro PDF, e pode ser posicionada, girada, estilizada e limitada a páginas específicas.

Este artigo demonstra vários fluxos de trabalho comuns de carimbo:

Criar recursos de texto reutilizáveis para carimbos baseados em texto.
Adicionar carimbos de imagem e de página PDF.
Adicionar carimbos de texto estilizados.
Limite um carimbo a páginas selecionadas.
Configure um carimbo de imagem de fundo.

O exemplo usa duas funções auxiliares: uma cria texto formatado para carimbos baseados em texto, e a outra cria um TextState objeto usado para estilizar carimbos de texto.

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

Adicionar um carimbo de imagem

Usar bind_image() quando o carimbo deve exibir uma imagem, como um logotipo, emblema ou ícone. Depois de vincular a imagem, você pode definir o ID do carimbo e a origem antes de adicioná-lo ao documento.

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()

Adicionar uma página PDF como carimbo

Usar bind_pdf() quando você deseja usar uma página de outro arquivo PDF como o conteúdo do selo. Isso é útil para sobreposições, como aprovações, modelos ou elementos visuais pré-construídos armazenados em um documento separado.

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()

Adicionar um carimbo de texto com estado de texto

Usar bind_logo() junto com bind_text_state() quando você deseja criar um selo baseado em texto com estilo de fonte personalizado. Esta abordagem é útil para marcas de aprovação, rótulos e anotações específicas de fluxo de trabalho.

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()

Adicionar um carimbo a páginas específicas

Se o carimbo não deve aparecer em todas as páginas, atribua os números das páginas de destino a pages propriedade. Este exemplo adiciona um carimbo de imagem apenas na primeira página.

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()

Adicionar um carimbo de imagem de fundo

Use um carimbo de fundo quando a imagem deve aparecer atrás do conteúdo da página. Você também pode controlar a opacidade, rotação, qualidade, tamanho e posição do carimbo para criar efeitos no estilo de marca d’água.

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()

Tópicos Relacionados a Facades

Python-Net: Classe PdfFileStamp

Mon, 18 May 2026 00:00:00 +0000

O PdfFileStamp A classe em Aspose.PDF Facades foi projetada para adicionar conteúdo visual repetido às páginas PDF. É útil quando você precisa aplicar cabeçalhos, rodapés, números de página ou carimbos em todo o documento sem editar manualmente cada página.

O que você pode fazer com PdfFileStamp

Use os artigos nesta seção para explorar as principais tarefas de marcação suportadas por PdfFileStamp fachada: