Dividir archivos PDF en Python

Dividir páginas PDF puede ser una característica útil para quienes desean dividir un archivo grande en páginas separadas o grupos de páginas.

Utilice este flujo de trabajo cuando necesite dividir archivos PDF grandes en archivos de una sola página o en conjuntos de documentos más pequeños para distribución, revisión o procesamiento posterior.

Ejemplo en vivo

Divisor de Aspose.PDF es una aplicación web gratuita en línea que le permite investigar cómo funciona la funcionalidad de división de presentaciones.

Este tema muestra cómo dividir páginas PDF en archivos PDF individuales en sus aplicaciones Python. Para dividir páginas PDF en archivos PDF de una sola página usando Python, se pueden seguir los siguientes pasos:

Recorrer las páginas del documento PDF a través de la Documento del objeto ColecciónDePáginas colección
Para cada iteración, crea un nuevo objeto Document y agrega el individual Página objeto en el documento vacío
Guardar el nuevo PDF usando save() método

Dividir PDF en varios archivos o pdfs separados en Python

El siguiente fragmento de código Python le muestra cómo dividir las páginas PDF en archivos PDF individuales.

import sys
import aspose.pdf as ap
from os import path


def split_documents(infile, outdir):
    document = ap.Document(infile)
    for page_num in range(1, len(document.pages) + 1):
        with ap.Document() as new_document:
            new_document.pages.add(document.pages[page_num])
            new_document.save(path.join(outdir, f"Page_{page_num}.pdf"))

Dividir un PDF en dos partes iguales

Cargue el documento PDF.
Determinar el número total de páginas.
Calcule el punto medio.
Crea el primer documento de salida.
Eliminar las páginas de la segunda mitad del primer documento.
Guarda la primera parte.
Cree el segundo documento de salida.
Eliminar las páginas de la primera mitad del segundo documento.
Guardar la segunda parte.

import sys
import aspose.pdf as ap
from os import path


def split_documents_into_two_parts(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)
    mid_point = total_pages // 2

    # First part
    with ap.Document(infile) as first_document:
        first_part_range = range(mid_point + 1, total_pages + 1)
        first_document.pages.delete(first_part_range)
        first_document.save(path.join(outdir, "Part_1.pdf"))

    # Second part
    with ap.Document(infile) as second_document:
        second_part_range = range(1, mid_point + 1)
        second_document.pages.delete(second_part_range)
        second_document.save(path.join(outdir, "Part_2.pdf"))

Dividir un PDF en varios archivos cada N páginas

Divida un documento PDF en varios archivos más pequeños basándose en un número fijo de páginas usando Aspose.PDF for Python via .NET.

Cargue el documento PDF.
Determinar el número total de páginas.
Definir páginas por parte.
Itera a través del documento en fragmentos.
Calcule el rango de páginas para cada parte.
Crea un nuevo documento para cada parte.
Copiar páginas al nuevo documento.
Guarda el documento dividido.
Repita hasta que se procesen todas las páginas.

import sys
import aspose.pdf as ap
from os import path


def split_documents_every_n_pages(infile, outdir, pages_per_part=3):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    part_index = 1
    for start_page in range(1, total_pages + 1, pages_per_part):
        end_page = min(start_page + pages_per_part - 1, total_pages)

        with ap.Document() as part_document:
            for page_num in range(start_page, end_page + 1):
                part_document.pages.add(document.pages[page_num])
            part_document.save(
                path.join(outdir, f"Every_{pages_per_part}_Part_{part_index}.pdf")
            )

        part_index += 1

Dividir un PDF por rangos de página personalizados

Dividir un documento PDF en varios archivos basados en rangos de páginas personalizados usando Aspose.PDF for Python.

Cargue el documento PDF.
Determinar el número total de páginas.
Crea una lista de tuplas que representen rangos (start_page, end_page).
Iterar a través de los rangos definidos.
Validar la página de inicio.
Ajusta la página final.
Validar el rango efectivo.
Cree un nuevo documento para cada rango.
Copiar páginas al nuevo documento.
Guarde cada documento dividido.

import sys
import aspose.pdf as ap
from os import path


def split_documents_by_page_ranges(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)
    # Define ranges as (start_page, end_page). Use None to indicate last page.
    ranges = [(1, 3), (4, 6), (7, None)]

    for index, (start_page, end_page) in enumerate(ranges, start=1):
        if start_page > total_pages:
            continue

        effective_end = total_pages if end_page is None else min(end_page, total_pages)
        if start_page > effective_end:
            continue

        with ap.Document() as range_document:
            for page_num in range(start_page, effective_end + 1):
                range_document.pages.add(document.pages[page_num])
            range_document.save(
                path.join(outdir, f"Range_{index}_{start_page}_to_{effective_end}.pdf")
            )

Dividir un PDF en Primera página y Páginas restantes

Separe la primera página de un documento PDF del resto de las páginas usando Aspose.PDF for Python.

Cargue el documento PDF.
Determinar el número total de páginas.
Verifique si el documento está vacío.
Crea un documento para la primera página.
Agregar la primera página.
Guardar el documento de la primera página.
Verifique si hay páginas adicionales.
Crea un documento para las páginas restantes.
Copiar páginas restantes.
Guarda el documento de páginas restantes.

import sys
import aspose.pdf as ap
from os import path


def split_documents_first_page_and_rest(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    if total_pages == 0:
        return

    with ap.Document() as first_page_document:
        first_page_document.pages.add(document.pages[1])
        first_page_document.save(path.join(outdir, "First_Page.pdf"))

    if total_pages == 1:
        return

    with ap.Document() as remaining_pages_document:
        for page_num in range(2, total_pages + 1):
            remaining_pages_document.pages.add(document.pages[page_num])
        remaining_pages_document.save(path.join(outdir, "Remaining_Pages.pdf"))

Dividir un PDF en la última página y las páginas anteriores

Extraiga la última página de un documento PDF y sepárela de las páginas restantes usando Aspose.PDF for Python.

Cargue el documento PDF.
Determinar el número total de páginas.
Verifique si el documento está vacío.
Crea un documento para la última página.
Agregar la última página.
Guarda el documento de la última página.
Verificar documentos de una sola página.
Elimina la última página del documento original.
Guarda las páginas restantes.

import sys
import aspose.pdf as ap
from os import path


def split_documents_last_page_and_rest(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    if total_pages == 0:
        return

    with ap.Document() as last_page_document:
        last_page_document.pages.add(document.pages[total_pages])
        last_page_document.save(path.join(outdir, "Last_Page.pdf"))

    if total_pages == 1:
        return

    document.pages.delete(total_pages)  # Remove last page from original document
    document.save(path.join(outdir, "Previous_Pages.pdf"))

Dividir un PDF en tres partes

Divida un documento PDF en tres partes separadas usando Aspose.PDF for Python.

Cargue el documento PDF.
Determinar el número total de páginas.
Verifique si el documento está vacío.
Calcular el tamaño de la pieza.
Iterar a través de tres partes.
Determine el rango de páginas para cada parte.
Validar el rango de páginas.
Crea un nuevo documento para cada parte.
Copiar páginas en el documento de la parte.
Guarda cada parte.

import sys
import aspose.pdf as ap
from os import path


def split_documents_into_three_parts(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    if total_pages == 0:
        return

    part_size = max(1, (total_pages + 2) // 3)

    for part_index in range(3):
        start_page = part_index * part_size + 1
        end_page = min((part_index + 1) * part_size, total_pages)

        if start_page > total_pages:
            break

        with ap.Document() as part_document:
            for page_num in range(start_page, end_page + 1):
                part_document.pages.add(document.pages[page_num])
            part_document.save(path.join(outdir, f"Three_Parts_{part_index + 1}.pdf"))

Divisor de páginas PDF personalizado

Divida un documento PDF en varios archivos basándose en grupos de páginas definidos de forma personalizada usando Aspose.PDF for Python.

import sys
import aspose.pdf as ap
from os import path


def split_documents_custom_page_groups(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)
    groups = [
        [1, 2, 5],
        [3, 4, 6, 7],
    ]

    for group_index, group in enumerate(groups, start=1):
        valid_pages = [page_num for page_num in group if 1 <= page_num <= total_pages]
        if not valid_pages:
            continue

        with ap.Document() as group_document:
            for page_num in valid_pages:
                group_document.pages.add(document.pages[page_num])
            group_document.save(path.join(outdir, f"Custom_Group_{group_index}.pdf"))

Dividir PDF en páginas individuales con nombres de archivo estables

Divida un documento PDF en páginas individuales y guárdelas con nombres de archivo estables utilizando Aspose.PDF for Python.

import sys
import aspose.pdf as ap
from os import path


def split_documents_with_stable_filenames(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    for page_num in range(1, total_pages + 1):
        with ap.Document() as new_document:
            new_document.pages.add(document.pages[page_num])
            new_document.save(path.join(outdir, f"Page_{page_num:03d}.pdf"))

Dividir PDF en páginas impares y pares

Divida un documento PDF en dos archivos separados que contengan, respectivamente, las páginas impares y pares, usando Aspose.PDF for Python via .NET.

import sys
import aspose.pdf as ap
from os import path


def split_documents_odd_even_pages(infile, outdir):
    document = ap.Document(infile)
    total_pages = len(document.pages)

    # Odd pages document
    with ap.Document(infile) as document:
        with ap.Document() as odd_document:
            for page_num in range(1, total_pages + 1, 2):
                odd_document.pages.add(document.pages[page_num])
            odd_document.save(path.join(outdir, "Odd_Pages.pdf"))

        with ap.Document() as even_document:
            for page_num in range(2, total_pages + 1, 2):
                even_document.pages.add(document.pages[page_num])
            even_document.save(path.join(outdir, "Even_Pages.pdf"))

Temas de documentos relacionados

Combinar archivos PDF en Python