Comment extraire du texte, des liens et des images de fichiers PDF à l'aide de Python

Manipulation de fichiers PDF avec Python : Extraction de texte, liens et images

Le langage Python, réputé pour sa polyvalence, conduit fréquemment ses développeurs à interagir avec divers types de fichiers. Le format PDF, largement répandu, se présente comme un support privilégié pour le stockage d’informations. L’extraction de données à partir de ces documents devient alors une nécessité dans de nombreux contextes de programmation.

Les fichiers PDF, au-delà du simple texte, peuvent intégrer des images et des hyperliens. Le défi réside dans la complexité de l’accès à ces informations, contrairement aux structures de données classiques comme les listes ou les dictionnaires. Pourtant, grâce à des bibliothèques spécialisées, l’extraction de données à partir de PDF devient une tâche tout à fait réalisable.

Dans cet article, nous allons explorer des bibliothèques Python dédiées à la manipulation de fichiers PDF, en mettant l’accent sur l’extraction de texte, de liens et d’images. Pour ce faire, assurez-vous de télécharger le fichier PDF exemple et de le placer dans le même répertoire que votre script Python.

Extraction de texte avec PyPDF2

La bibliothèque PyPDF2, solution open-source et gratuite, se révèle particulièrement efficace pour l’extraction de texte à partir de fichiers PDF. Bien qu’elle propose des fonctionnalités comme la fusion, le recadrage et la transformation de pages PDF, sa capacité à extraire le texte reste un atout majeur.

Installation de PyPDF2

L’installation de PyPDF2 se fait via pip, le gestionnaire de packages de Python.

Vérification de pip : Commencez par vérifier si pip est déjà installé en exécutant la commande suivante :
```
pip --version
```
Si aucune version n’est affichée, pip n’est pas installé.
Installation de pip : Téléchargez le script d’installation via ce lien. Enregistrez le fichier sous le nom « get-pip.py ».
Ouvrez ensuite un terminal, naviguez jusqu’au répertoire où vous avez enregistré le script et exécutez :
```
sudo python3 get-pip.py
```
Vérification de l’installation de pip : Confirmez l’installation avec :
```
pip --version
```
Une version devrait maintenant être affichée.

Une fois pip correctement installé, procédez à l’installation de PyPDF2.

Installation de PyPDF2 et utilisation

Installation de PyPDF2 : Exécutez la commande suivante dans votre terminal :
```
pip install PyPDF2
```
Importation : Dans votre script Python, importez la classe PdfReader :
```
from PyPDF2 import PdfReader
```
Ouverture du fichier PDF : Créez une instance de PdfReader en spécifiant le chemin de votre fichier PDF :
```
reader = PdfReader('games.pdf')
```
Cette instance permet d’accéder au contenu du fichier PDF.
Nombre de pages : Vérifiez le nombre total de pages du document :
```
print(len(reader.pages))
```
Ce code affiche le nombre de pages de votre document.
Accès à une page spécifique : Récupérez la première page du document (l’indexation commençant à 0) :
```
page1 = reader.pages[0]
```
Extraction du texte : Extrayez le texte de la page sélectionnée :
```
textPage1 = page1.extract_text()
```
Le texte extrait est stocké dans la variable textPage1.
Affichage du texte : Finalement, affichez le texte extrait :
```
print(textPage1)
```

Voici le code complet pour extraire et afficher le texte de la première page :

    from PyPDF2 import PdfReader
    
    reader = PdfReader('games.pdf')
    
    print(len(reader.pages))
    
    page1 = reader.pages[0]
    
    textPage1 = page1.extract_text()
    
    print(textPage1)

Extraction de liens avec PyMuPDF

PyMuPDF, une autre bibliothèque Python, est capable d’extraire, d’analyser et de manipuler les données des documents, y compris les fichiers PDF. Cette bibliothèque nécessite Python 3.8 ou une version ultérieure.

Installation et utilisation de PyMuPDF

Installation : Installez PyMuPDF via pip :
```
pip install PyMuPDF
```
Importation : Importez la bibliothèque dans votre script :
```
import fitz
```
Ouverture du fichier PDF : Accédez à votre fichier PDF :
```
doc = fitz.open("games.pdf")
```
Nombre de pages : Affichez le nombre de pages du PDF:
```
print(doc.page_count)
```
Chargement d’une page : Chargez la page dont vous souhaitez extraire les liens (ici, la première page, index 0) :
```
page = doc.load_page(0)
```
Extraction des liens : Extrayez les liens de la page :
```
links = page.get_links()
```
Affichage des liens : Affichez la liste des liens :
```
print(links)
```
Les liens sont stockés dans une liste de dictionnaires, où chaque dictionnaire représente un lien. La clé « uri » contient l’URL réelle.

Affichage des URLs : Parcourez la liste des liens et affichez les URL :

        for obj in links:
          print(obj["uri"])

Le code complet pour extraire et afficher les liens de la première page :

    import fitz

    doc = fitz.open("games.pdf")
    
    print(doc.page_count)
    
    page = doc.load_page(0)
    
    links = page.get_links()
    
    for obj in links:
      print(obj["uri"])

Pour une meilleure réutilisation, on peut créer des fonctions :

    import fitz

    def extract_link(path_to_pdf):
      links = []
      doc = fitz.open(path_to_pdf)

      for page_num in range(doc.page_count):
        page = doc.load_page(page_num)
        page_links = page.get_links()
        links.extend(page_links)
      return links
    
    def print_all_links(links):
      for link in links:
        print(link["uri"])
    
    all_links = extract_link("games.pdf")
    
    print_all_links(all_links)

Extraction d’images avec PyMuPDF et PIL

PyMuPDF, combiné à la bibliothèque PIL (Python Imaging Library), permet également d’extraire des images depuis un fichier PDF. La bibliothèque ‘io’ facilite la gestion des données binaires.

Installation et utilisation

Importation : Importez les bibliothèques nécessaires :

    import fitz
    from io import BytesIO
    from PIL import Image

Ouverture du fichier PDF : Ouvrez le document PDF :
```
doc = fitz.open("games.pdf")
```
Chargement d’une page : Chargez la page contenant les images :
```
page = doc.load_page(0)
```
Obtention des références d’images : Récupérez la liste des références d’images :
```
    image_xref = page.get_images()
    print(image_xref)
            
```
Chaque image a un numéro de référence croisée (xref). Cette fonction retourne une liste de tuples avec des informations sur chaque image. Le premier élément du tuple est la référence xréf.

Extraction de la valeur xref : Récupérez la valeur xréf :

        xref_value = image_xref[0][0]
        print(xref_value)

Extraction de l’image : Extrayez l’image en utilisant sa référence :
```
img_dictionary = doc.extract_image(xref_value)
```
Cette fonction retourne un dictionnaire contenant les métadonnées de l’image et ses données binaires.

Récupération de l’extension : Vérifiez l’extension du fichier :

       img_extension = img_dictionary["ext"]
       print(img_extension)

Récupération des données binaires : Accédez aux données binaires de l’image :
```
img_binary = img_dictionary["image"]
```
Création d’un objet BytesIO : Créez un objet BytesIO à partir des données binaires :
```
image_io = BytesIO(img_binary)
```
Cet objet permet de traiter les données d’image comme un fichier.
Ouverture de l’image avec PIL : Ouvrez l’image en utilisant la bibliothèque PIL :
```
image = Image.open(image_io)
```
Définition du chemin de sortie : Définissez le chemin et le nom du fichier de sortie :
```
output_path = "image_1.png"
```
Enregistrement de l’image et fermeture de l’objet BytesIO : Enregistrez l’image sur le disque :
```
       image.save(output_path)
       image_io.close()
            
```

Voici le code complet pour l’extraction d’une image:

    import fitz
    from io import BytesIO
    from PIL import Image
    
    doc = fitz.open("games.pdf")
    page = doc.load_page(0)
    
    image_xref = page.get_images()
    
    xref_value = image_xref[0][0]
    
    img_dictionary = doc.extract_image(xref_value)
    
    img_extension = img_dictionary["ext"]
    
    img_binary = img_dictionary["image"]
    
    image_io = BytesIO(img_binary)
    
    image = Image.open(image_io)
    
    output_path = "image_1.png"
    
    image.save(output_path)
    
    image_io.close()

Conclusion

L’extraction de données depuis des fichiers PDF avec Python s’avère accessible grâce à des bibliothèques puissantes comme PyPDF2 et PyMuPDF. L’adaptation de ces exemples pour créer des fonctions réutilisables, comme démontré pour l’extraction de liens, permet une manipulation flexible et efficace des documents PDF. N’hésitez pas à explorer davantage ces bibliothèques pour maîtriser la manipulation de fichiers PDF avec Python.

Pour ceux qui cherchent des solutions plus élaborées, l’exploration des API dédiées à la gestion de documents PDF peut s’avérer très pertinente.

0 Partages