Comment traiter des images par lots à l'aide de Python

Comment traiter par lots des images à l'aide de Python

Introduction :
À l'ère actuelle des médias sociaux et de la culture numérique, les images sont devenues un élément indispensable de la vie quotidienne des gens. Cependant, nous devons parfois effectuer les mêmes opérations sur un grand nombre d’images, comme le redimensionnement, le recadrage, la rotation, etc. Le traitement manuel de ces images est très long et fastidieux. Par conséquent, l’utilisation de Python pour traiter les images par lots améliorera considérablement l’efficacité. Cet article explique comment utiliser la bibliothèque Pillow de Python pour traiter des images par lots et fournit des exemples de code correspondants.

Étape 1 : Installer la bibliothèque Pillow
Avant de commencer, nous devons d'abord installer la bibliothèque Pillow. Entrez la commande suivante sur la ligne de commande pour terminer l'installation :

pip install pillow

Étape 2 : Importer les bibliothèques et modules requis
Avant d'écrire du code Python, nous devons importer les bibliothèques et modules requis. Ajoutez les lignes suivantes dans le code :

from PIL import Image
import os

Étape 3 : Définir les chemins des dossiers d'entrée et de sortie
Avant le traitement par lots, nous devons définir les chemins des dossiers d'entrée et de sortie. L'exemple suivant suppose que le chemin de notre dossier d'entrée est « input_folder » et que notre chemin de dossier de sortie est « output_folder ». Vous pouvez modifier ces chemins selon vos besoins.

input_folder = 'path/to/input_folder'
output_folder = 'path/to/output_folder'

Étape 4 : Écrire une fonction de traitement d'image
Avant d'écrire la boucle principale, nous écrivons d'abord une fonction pour traiter les images. L'exemple suivant montre comment redimensionner une image et l'enregistrer dans le dossier de sortie :

def process_image(input_path, output_path, width, height):
    image = Image.open(input_path)
    resized_image = image.resize((width, height))
    resized_image.save(output_path)

Dans cette fonction, nous ouvrons d'abord l'image d'entrée en utilisant Image.open() et la redimensionnons en appelant resize () pour redimensionner l'image. Enfin, nous utilisons la méthode save() pour enregistrer l'image traitée dans le chemin de sortie spécifié. Image.open()打开输入图片，并通过调用resize()方法调整图片大小。最后，我们使用save()方法将处理后的图片保存到指定的输出路径。

可以根据自己的需求在这个函数中添加其它图片处理操作，例如裁剪、旋转等。

第五步：遍历输入文件夹并进行批量处理
现在我们可以编写主循环来遍历输入文件夹中的所有图片，并对每张图片进行批量处理。以下示例展示了如何遍历输入文件夹并调用上述的图片处理函数：

for filename in os.listdir(input_folder):
    if filename.endswith('.jpg') or filename.endswith('.png'):
        input_path = os.path.join(input_folder, filename)
        output_path = os.path.join(output_folder, filename)
        process_image(input_path, output_path, 800, 600)

在这个示例中，我们使用os.listdir()函数获取输入文件夹中的所有文件名，并通过os.path.join()函数将文件名与文件夹路径拼接成完整的文件路径。

然后，我们使用endswith()方法来检查文件名的后缀是否为".jpg"或".png"，以便仅处理这些图片文件。

最后，我们调用上述process_image()

Vous pouvez ajouter d'autres opérations de traitement d'image à cette fonction selon vos propres besoins, comme le recadrage, la rotation, etc.

Étape 5 : Parcourez le dossier d'entrée et le traitement par lots

Nous pouvons maintenant écrire la boucle principale pour parcourir toutes les images du dossier d'entrée et traiter par lots chaque image. L'exemple suivant montre comment parcourir le dossier d'entrée et appeler la fonction de traitement d'image ci-dessus :

rrreee

Dans cet exemple, nous utilisons la fonction os.listdir() pour obtenir tous les noms de fichiers dans le dossier d'entrée et utilisez la fonction os.path.join() pour concaténer le nom du fichier et le chemin du dossier en un chemin de fichier complet.

Ensuite, nous utilisons la méthode endswith() pour vérifier si le suffixe du nom de fichier est ".jpg" ou ".png" afin que seuls ces fichiers image puissent être traités.

• Enfin, nous appelons la fonction process_image() ci-dessus, en passant le chemin d'entrée, le chemin de sortie et la taille d'image requise comme paramètres. Dans cet exemple, nous définissons la taille de l'image sur 800 x 600 pixels.
• Résumé :
En utilisant la bibliothèque Python's Pillow, nous pouvons facilement traiter des images par lots. Cet article présente un exemple d'utilisation de la bibliothèque Pillow pour redimensionner une image et fournit un exemple de code complet. Vous pouvez étendre ces codes pour ajouter d'autres opérations de traitement d'image selon vos besoins. Commencez à utiliser Python pour traiter des images par lots et améliorer l'efficacité du travail !

🎜Ce qui précède est une introduction à la façon d'utiliser Python pour traiter des images par lots. Que ce soit dans un projet personnel ou une application commerciale, ces conseils vous permettront d'économiser du temps et de l'énergie. J'espère que cet article pourra vous aider. 🎜🎜Références : 🎜🎜🎜Python Software Foundation (s.d.). Python Imaging Library (PIL). https://pillow.readthedocs.io/en/stable/handbook/index.html🎜🎜

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!