基于Python自制一个图片批量处理工具实现格式统一和大小压缩

pip install pillow

pillow>=9.0.0

import os
import sys
from pil import image
import time
from io import bytesio
import tkinter as tk
from tkinter import filedialog, ttk, messagebox
import threading
import queue

# 打包命令：pyinstaller --noconsole --onefile --icon=icon.ico --name="图片批量处理工具" image_processor.py
class imageprocessor:
    def __init__(self):
        self.window = tk.tk()
        self.window.title("图片批量处理工具")
        # 设置窗口大小和位置（居中显示）
        window_width = 800
        window_height = 600
        screen_width = self.window.winfo_screenwidth()
        screen_height = self.window.winfo_screenheight()
        x = (screen_width - window_width) // 2
        y = (screen_height - window_height) // 2
        self.window.geometry(f"{window_width}x{window_height}+{x}+{y}")
        self.window.resizable(false, false)
        
        # 界面样式配置（现代简洁风格）
        self.style = ttk.style()
        self.style.theme_use('clam')
        self.style.configure("tbutton", padding=10, font=('微软雅黑', 10))
        self.style.configure("tlabel", font=('微软雅黑', 10))
        self.style.configure("header.tlabel", font=('微软雅黑', 16, 'bold'))
        self.style.configure("info.tlabel", font=('微软雅黑', 9))
        self.style.configure("custom.tbutton", padding=10, font=('微软雅黑', 10, 'bold'))
        
        # 线程通信队列（避免界面卡顿）
        self.message_queue = queue.queue()
        
        self.create_widgets()
        self.update_messages()
    
    def create_widgets(self):
        # 主框架（统一内边距，布局更整洁）
        main_frame = ttk.frame(self.window, padding="20")
        main_frame.pack(fill=tk.both, expand=true)
        
        # 标题区域
        title_frame = ttk.frame(main_frame)
        title_frame.pack(fill=tk.x, pady=(0, 20))
        title_label = ttk.label(title_frame, text="图片批量处理工具", style="header.tlabel")
        title_label.pack(side=tk.left)
        
        # 功能说明区域
        features_frame = ttk.labelframe(main_frame, text="功能说明", padding="10")
        features_frame.pack(fill=tk.x, pady=(0, 20))
        features_text = """本工具提供以下功能：
• 将图片转换为正方形（短边两侧填充白色）
• 统一转换为jpg格式，保证最佳图片质量
• 智能控制图片大小在3mb以下
• 自动创建输出文件夹，原图保持不变"""
        features_label = ttk.label(features_frame, text=features_text, justify=tk.left)
        features_label.pack(pady=5)
        
        # 文件夹选择区域
        folder_frame = ttk.labelframe(main_frame, text="选择文件夹", padding="10")
        folder_frame.pack(fill=tk.x, pady=(0, 20))
        self.folder_path = tk.stringvar()
        folder_entry = ttk.entry(folder_frame, textvariable=self.folder_path, width=70)
        folder_entry.pack(side=tk.left, padx=(0, 10), fill=tk.x, expand=true)
        folder_button = ttk.button(folder_frame, text="浏览...", command=self.select_folder, style="custom.tbutton")
        folder_button.pack(side=tk.left)
        
        # 操作按钮区域
        control_frame = ttk.frame(main_frame)
        control_frame.pack(fill=tk.x, pady=(0, 10))
        self.process_button = ttk.button(control_frame, text="开始处理", 
                                       command=self.start_processing, 
                                       style="custom.tbutton")
        self.process_button.pack(pady=10)
        
        # 进度显示区域
        progress_frame = ttk.labelframe(main_frame, text="处理进度", padding="10")
        progress_frame.pack(fill=tk.x, pady=(0, 20))
        self.progress_var = tk.doublevar()
        self.progress_bar = ttk.progressbar(progress_frame, 
                                          variable=self.progress_var, 
                                          maximum=100,
                                          length=300)
        self.progress_bar.pack(fill=tk.x, pady=(5, 10))
        self.progress_label = ttk.label(progress_frame, text="等待开始...", style="info.tlabel")
        self.progress_label.pack()
        
        # 处理详情日志区域
        log_frame = ttk.labelframe(main_frame, text="处理详情", padding="10")
        log_frame.pack(fill=tk.both, expand=true)
        text_frame = ttk.frame(log_frame)
        text_frame.pack(fill=tk.both, expand=true)
        self.log_text = tk.text(text_frame, height=10, width=70, 
                               font=('微软雅黑', 9),
                               wrap=tk.word)
        self.log_text.pack(side=tk.left, fill=tk.both, expand=true)
        scrollbar = ttk.scrollbar(text_frame, orient=tk.vertical, 
                                command=self.log_text.yview)
        scrollbar.pack(side=tk.right, fill=tk.y)
        self.log_text.configure(yscrollcommand=scrollbar.set)
        
        # 状态栏
        self.status_label = ttk.label(main_frame, text="就绪", style="info.tlabel")
        self.status_label.pack(pady=(10, 0))
    
    def select_folder(self):
        # 选择文件夹并更新路径
        folder_path = filedialog.askdirectory(title="选择包含图片的文件夹")
        if folder_path:
            self.folder_path.set(folder_path)
            self.log_message(f"已选择文件夹: {folder_path}")
            self.status_label.config(text="已选择文件夹，可以开始处理")
    
    def log_message(self, message):
        # 日志信息入队（线程安全）
        self.message_queue.put(message)
    
    def update_messages(self):
        # 实时更新日志显示
        try:
            while true:
                message = self.message_queue.get_nowait()
                self.log_text.insert(tk.end, message + "\n")
                self.log_text.see(tk.end)
                self.log_text.update()
        except queue.empty:
            pass
        self.window.after(100, self.update_messages)
    
    def start_processing(self):
        # 预处理校验（避免无效操作）
        folder_path = self.folder_path.get()
        if not folder_path:
            messagebox.showerror("错误", "请先选择要处理的文件夹！")
            return
        if not os.path.exists(folder_path):
            messagebox.showerror("错误", "选择的文件夹不存在！")
            return
        
        # 禁用按钮防止重复点击
        self.process_button.state(['disabled'])
        self.status_label.config(text="正在处理中...")
        self.progress_label.config(text="正在准备处理...")
        
        # 开启子线程处理图片（避免界面冻结）
        thread = threading.thread(target=self.process_images_thread, args=(folder_path,))
        thread.daemon = true
        thread.start()
    
    def process_images_thread(self, input_folder):
        try:
            # 支持的图片格式（覆盖主流格式）
            supported_formats = ['.png', '.jpeg', '.jpg', '.bmp', '.gif', '.webp']
            
            # 创建输出文件夹（原文件夹名+“调整”）
            dir_name = os.path.basename(input_folder)
            output_dir_name = dir_name + "调整"
            parent_dir = os.path.dirname(input_folder)
            output_dir = os.path.join(parent_dir, output_dir_name)
            try:
                os.makedirs(output_dir, exist_ok=true)
            except exception as e:
                self.log_message(f"创建输出文件夹失败：{str(e)}")
                messagebox.showerror("错误", f"创建输出文件夹失败：{str(e)}")
                return
            
            # 筛选图片文件
            image_files = [f for f in os.listdir(input_folder) 
                         if any(f.lower().endswith(fmt) for fmt in supported_formats)]
            if not image_files:
                self.log_message("没有找到支持的图片文件！")
                messagebox.showinfo("提示", "文件夹中没有找到支持的图片文件！")
                return
            
            # 初始化统计参数
            total_files = len(image_files)
            processed_files = 0
            success_count = 0
            error_count = 0
            size_reduced_count = 0
            total_size_saved = 0
            
            # 日志初始化
            self.log_message(f"\n开始处理图片...")
            self.log_message(f"输入目录: {input_folder}")
            self.log_message(f"输出目录: {output_dir}\n")
            self.log_message(f"共发现 {total_files} 个图片文件\n")
            
            # 批量处理图片
            for filename in image_files:
                file_path = os.path.join(input_folder, filename)
                try:
                    # 更新进度
                    processed_files += 1
                    progress = (processed_files / total_files) * 100
                    self.progress_var.set(progress)
                    self.progress_label.config(
                        text=f"正在处理: {filename} ({processed_files}/{total_files})"
                    )
                    
                    # 打开图片并处理
                    with image.open(file_path) as img:
                        # 保留exif信息（避免图片方向异常）
                        exif = img.info.get('exif')
                        
                        # 处理透明背景（png转jpg时填充白色）
                        if img.mode in ('rgba', 'p'):
                            background = image.new('rgb', img.size, 'white')
                            if img.mode == 'p':
                                img = img.convert('rgba')
                            background.paste(img, mask=img.split()[3] if img.mode == 'rgba' else none)
                            img = background
                        
                        # 转为正方形
                        square_img = self.convert_to_square(img)
                        if square_img is none:
                            continue
                        
                        # 生成输出路径
                        new_filename = os.path.splitext(filename)[0] + '.jpg'
                        new_path = os.path.join(output_dir, new_filename)
                        
                        # 计算大小变化
                        original_size = os.path.getsize(file_path) / (1024 * 1024)
                        
                        # 优化图片大小（控制在3mb内）
                        quality = self.optimize_image_size(square_img)
                        
                        # 保存图片
                        save_args = {'format': 'jpeg', 'quality': quality}
                        if exif:
                            save_args['exif'] = exif
                        square_img.save(new_path, **save_args)
                        
                        # 更新统计信息
                        new_size = os.path.getsize(new_path) / (1024 * 1024)
                        success_count += 1
                        if new_size < original_size:
                            size_reduced_count += 1
                            size_reduction = original_size - new_size
                            total_size_saved += size_reduction
                            self.log_message(f"✓ 已处理: {filename} -> {new_filename}")
                            self.log_message(
                                f"  大小: {original_size:.1f}mb → {new_size:.1f}mb "
                                f"(节省 {size_reduction:.1f}mb)"
                            )
                        else:
                            self.log_message(f"✓ 已处理: {filename} -> {new_filename}")
                            self.log_message(f"  大小: {new_size:.1f}mb")
                
                except exception as e:
                    error_count += 1
                    self.log_message(f"✗ 处理 {filename} 时出错: {str(e)}")
            
            # 输出处理总结
            summary = f"""\n处理完成！
----------------------------------------
成功处理：{success_count} 个文件
处理失败：{error_count} 个文件
文件大小优化：{size_reduced_count} 个文件
总共节省空间：{total_size_saved:.1f}mb
输出文件夹：{output_dir}
----------------------------------------"""
            self.log_message(summary)
            
            # 弹窗提示结果
            if success_count > 0:
                messagebox.showinfo("完成", 
                    f"图片处理完成！\n成功：{success_count} 个\n失败：{error_count} 个")
            else:
                messagebox.showwarning("警告", "没有成功处理任何文件！")
        
        except exception as e:
            self.log_message(f"处理过程出错：{str(e)}")
            messagebox.showerror("错误", f"处理过程出错：{str(e)}")
        
        finally:
            # 恢复界面状态
            self.process_button.state(['!disabled'])
            self.progress_var.set(0)
            self.progress_label.config(text="处理完成")
            self.status_label.config(text="就绪")
    
    def convert_to_square(self, image):
        """将图片转为正方形，最大尺寸限制800x800（避免过大）"""
        try:
            width, height = image.size
            max_size = max(width, height)
            
            # 缩放过大图片
            if max_size > 800:
                scale = 800 / max_size
                new_width = int(width * scale)
                new_height = int(height * scale)
                image = image.resize((new_width, new_height), image.lanczos)  # 高质量缩放
                width, height = image.size
                max_size = max(width, height)
            
            # 创建白色正方形背景
            square_img = image.new('rgb', (max_size, max_size), 'white')
            
            # 居中粘贴原图
            paste_x = (max_size - width) // 2 if height > width else 0
            paste_y = (max_size - height) // 2 if width > height else 0
            square_img.paste(image, (paste_x, paste_y))
            return square_img
        except exception as e:
            self.log_message(f"转换图片时出错：{str(e)}")
            return none
    
    def get_file_size(self, img, quality):
        """计算指定质量下的图片大小（字节）"""
        buffer = bytesio()
        img.save(buffer, format='jpeg', quality=quality)
        size = buffer.tell()
        buffer.close()
        return size
    
    def optimize_image_size(self, img, max_size_mb=2.9):
        """二分查找最优质量，确保图片<3mb（留0.1mb冗余）"""
        max_size_bytes = int(max_size_mb * 1024 * 1024)
        quality = 95
        current_size = self.get_file_size(img, quality)
        
        # 原图已达标，直接返回高质量
        if current_size <= max_size_bytes:
            return quality
        
        # 二分查找最优质量
        min_quality = 5
        max_quality = 95
        best_quality = max_quality
        while min_quality <= max_quality:
            quality = (min_quality + max_quality) // 2
            current_size = self.get_file_size(img, quality)
            if current_size > max_size_bytes:
                max_quality = quality - 1
            else:
                best_quality = quality
                min_quality = quality + 1
        
        # 最终校验（确保不超标）
        final_size = self.get_file_size(img, best_quality)
        while final_size > max_size_bytes and best_quality > 5:
            best_quality -= 1
            final_size = self.get_file_size(img, best_quality)
        
        return best_quality
    
    def run(self):
        # 启动gui
        self.window.mainloop()

def main():
    app = imageprocessor()
    app.run()

if __name__ == '__main__':
    main()