import os
import sys
import argparse
from PIL import Image
import shutil
from datetime import datetime

class BatchImageCompressor:
    def __init__(self, input_dir, output_dir=None, quality=85, resize_ratio=1.0):
        self.input_dir = input_dir
        self.output_dir = output_dir or input_dir
        self.quality = quality
        self.resize_ratio = resize_ratio
        self.supported_formats = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff', '.webp')
        self.compression_log = []
        
    def check_directories(self):
        """檢查輸入和輸出目錄"""
        if not os.path.exists(self.input_dir):
            raise FileNotFoundError(f"輸入目錄 '{self.input_dir}' 不存在")
        
        if not os.path.exists(self.output_dir):
            try:
                os.makedirs(self.output_dir)
                print(f"創(chuàng)建輸出目錄: {self.output_dir}")
            except Exception as e:
                raise OSError(f"無法創(chuàng)建輸出目錄 '{self.output_dir}': {e}")
                
    def is_supported_image(self, filename):
        """檢查文件是否為支持的圖片格式"""
        return filename.lower().endswith(self.supported_formats)
        
    def get_image_files(self):
        """獲取目錄中的所有圖片文件"""
        try:
            files = os.listdir(self.input_dir)
            image_files = [f for f in files if self.is_supported_image(f)]
            return sorted(image_files)
        except Exception as e:
            print(f"讀取目錄時(shí)出錯(cuò): {e}")
            return []
            
    def get_file_size(self, filepath):
        """獲取文件大?。∕B）"""
        size_bytes = os.path.getsize(filepath)
        return size_bytes / (1024 * 1024)
        
    def compress_image(self, filename):
        """壓縮單個(gè)圖片文件"""
        input_path = os.path.join(self.input_dir, filename)
        output_path = os.path.join(self.output_dir, filename)
        
        try:
            # 獲取原始文件大小
            original_size = self.get_file_size(input_path)
            
            # 打開圖片
            with Image.open(input_path) as img:
                # 如果需要調(diào)整尺寸
                if self.resize_ratio < 1.0:
                    width, height = img.size
                    new_width = int(width * self.resize_ratio)
                    new_height = int(height * self.resize_ratio)
                    img = img.resize((new_width, new_height), Image.LANCZOS)
                
                # 處理RGBA模式的圖片（如PNG）
                if img.mode in ('RGBA', 'LA', 'P'):
                    # 轉(zhuǎn)換為RGB模式以支持JPEG格式
                    if filename.lower().endswith(('.jpg', '.jpeg')):
                        background = Image.new('RGB', img.size, (255, 255, 255))
                        background.paste(img, mask=img.split()[-1] if img.mode == 'RGBA' else None)
                        img = background
                
                # 保存壓縮后的圖片
                if filename.lower().endswith(('.jpg', '.jpeg')):
                    img.save(output_path, 'JPEG', quality=self.quality, optimize=True)
                elif filename.lower().endswith('.png'):
                    img.save(output_path, 'PNG', optimize=True)
                else:
                    img.save(output_path, optimize=True)
                    
            # 獲取壓縮后文件大小
            compressed_size = self.get_file_size(output_path)
            compression_ratio = (1 - compressed_size / original_size) * 100
            
            return {
                'filename': filename,
                'original_size': original_size,
                'compressed_size': compressed_size,
                'compression_ratio': compression_ratio,
                'status': 'success'
            }
            
        except Exception as e:
            return {
                'filename': filename,
                'error': str(e),
                'status': 'failed'
            }
            
    def process_images(self, backup_original=False):
        """批量處理圖片"""
        try:
            self.check_directories()
            image_files = self.get_image_files()
            
            if not image_files:
                print("未找到支持的圖片文件")
                return
                
            print(f"找到 {len(image_files)} 個(gè)圖片文件")
            print(f"壓縮質(zhì)量: {self.quality}%")
            if self.resize_ratio < 1.0:
                print(f"尺寸調(diào)整比例: {self.resize_ratio}")
                
            # 如果需要備份且輸入輸出目錄相同，則創(chuàng)建備份目錄
            if backup_original and self.input_dir == self.output_dir:
                backup_dir = self.input_dir + "_backup"
                if not os.path.exists(backup_dir):
                    os.makedirs(backup_dir)
                print(f"原始文件將備份到: {backup_dir}")
                
            processed_count = 0
            failed_count = 0
            
            for i, filename in enumerate(image_files, 1):
                print(f"\r處理進(jìn)度: {i}/{len(image_files)} ({i/len(image_files)*100:.1f}%)", end='')
                
                # 如果需要備份，先復(fù)制原始文件
                if backup_original and self.input_dir == self.output_dir:
                    backup_path = os.path.join(self.input_dir + "_backup", filename)
                    if not os.path.exists(backup_path):
                        shutil.copy2(os.path.join(self.input_dir, filename), backup_path)
                
                result = self.compress_image(filename)
                
                if result['status'] == 'success':
                    self.compression_log.append(result)
                    processed_count += 1
                    print(f"\n{filename}: {result['original_size']:.2f}MB -> {result['compressed_size']:.2f}MB "
                          f"(壓縮率: {result['compression_ratio']:.1f}%)")
                else:
                    failed_count += 1
                    print(f"\n{filename}: 處理失敗 - {result['error']}")
                    
            print(f"\n\n處理完成!")
            print(f"成功處理: {processed_count}")
            print(f"處理失敗: {failed_count}")
            
            if processed_count > 0:
                total_original = sum(item['original_size'] for item in self.compression_log)
                total_compressed = sum(item['compressed_size'] for item in self.compression_log)
                avg_compression = (1 - total_compressed / total_original) * 100
                print(f"總壓縮率: {avg_compression:.1f}%")
                print(f"節(jié)省空間: {total_original - total_compressed:.2f}MB")
                
        except KeyboardInterrupt:
            print("\n\n用戶中斷操作")
        except Exception as e:
            print(f"\n處理過程中發(fā)生錯(cuò)誤: {e}")
            
    def save_log(self, log_file="compression_log.txt"):
        """保存壓縮日志"""
        try:
            log_path = os.path.join(self.output_dir, log_file)
            with open(log_path, "w", encoding="utf-8") as f:
                f.write("批量圖片壓縮操作日志\n")
                f.write("=" * 50 + "\n")
                f.write(f"操作時(shí)間: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
                f.write(f"輸入目錄: {self.input_dir}\n")
                f.write(f"輸出目錄: {self.output_dir}\n")
                f.write(f"壓縮質(zhì)量: {self.quality}%\n")
                f.write(f"尺寸調(diào)整比例: {self.resize_ratio}\n\n")
                
                if self.compression_log:
                    f.write("壓縮詳情:\n")
                    f.write("-" * 50 + "\n")
                    for item in self.compression_log:
                        f.write(f"{item['filename']}:\n")
                        f.write(f"  原始大小: {item['original_size']:.2f}MB\n")
                        f.write(f"  壓縮后大小: {item['compressed_size']:.2f}MB\n")
                        f.write(f"  壓縮率: {item['compression_ratio']:.1f}%\n\n")
                        
            print(f"操作日志已保存到: {log_file}")
        except Exception as e:
            print(f"保存日志時(shí)出錯(cuò): {e}")

def main():
    parser = argparse.ArgumentParser(description="批量圖片壓縮工具")
    parser.add_argument("input_dir", help="輸入目錄路徑")
    parser.add_argument("-o", "--output_dir", help="輸出目錄路徑（默認(rèn)與輸入目錄相同）")
    parser.add_argument("-q", "--quality", type=int, default=85, 
                       help="壓縮質(zhì)量 (1-100, 默認(rèn): 85)")
    parser.add_argument("-r", "--resize", type=float, default=1.0, 
                       help="尺寸調(diào)整比例 (0.1-1.0, 默認(rèn): 1.0)")
    parser.add_argument("-b", "--backup", action="store_true", 
                       help="備份原始文件")
    
    args = parser.parse_args()
    
    # 驗(yàn)證參數(shù)
    if not 1 <= args.quality <= 100:
        print("錯(cuò)誤: 壓縮質(zhì)量必須在1-100之間")
        sys.exit(1)
        
    if not 0.1 <= args.resize <= 1.0:
        print("錯(cuò)誤: 尺寸調(diào)整比例必須在0.1-1.0之間")
        sys.exit(1)
    
    try:
        compressor = BatchImageCompressor(
            input_dir=args.input_dir,
            output_dir=args.output_dir,
            quality=args.quality,
            resize_ratio=args.resize
        )
        
        compressor.process_images(backup_original=args.backup)
        compressor.save_log()
        
    except Exception as e:
        print(f"程序執(zhí)行出錯(cuò): {e}")
        sys.exit(1)

if __name__ == "__main__":
    main()

pip install Pillow

# 基本用法，使用默認(rèn)壓縮質(zhì)量
python image_compressor.py /path/to/images

# 指定壓縮質(zhì)量
python image_compressor.py /path/to/images -q 70

# 指定輸出目錄
python image_compressor.py /path/to/images -o /path/to/compressed

# 調(diào)整圖片尺寸（縮小到原來的80%）
python image_compressor.py /path/to/images -r 0.8

# 備份原始文件
python image_compressor.py /path/to/images -b

python image_compressor.py ./images -q 70 -r 0.9