Python实现批量压缩图片的实用脚本分享

from PIL import Image
img = Image.open("photo.jpg")
img.thumbnail((1920, 1080))  # 保持比例缩放

img.save("compressed.jpg", quality=85, optimize=True)

import os
from PIL import Image
from pathlib import Path

def compress_image(input_path, output_path, max_size=1920, quality=85):
    """压缩单张图片"""
    try:
        with Image.open(input_path) as img:
            # 转换模式处理透明通道
            if img.mode in ("RGBA", "P"):
                img = img.convert("RGB")
            
            # 按比例缩放
            img.thumbnail((max_size, max_size), Image.LANCZOS)
            
            # 保存为JPEG格式
            output_path = output_path.with_suffix('.jpg')
            img.save(output_path, "JPEG", optimize=True, quality=quality)
            
            # 计算压缩率
            orig_size = os.path.getsize(input_path)
            new_size = os.path.getsize(output_path)
            ratio = (1 - new_size / orig_size) * 100
            print(f"✅ {Path(input_path).name}: {orig_size//1024}KB → {new_size//1024}KB (节省{ratio:.1f}%)")
            
    except Exception as e:
        print(f"❌ 压缩失败 {input_path}: {e}")

def batch_compress(input_folder, output_folder, max_size=1920, quality=85):
    """批量处理文件夹"""
    input_path = Path(input_folder)
    output_path = Path(output_folder)
    output_path.mkdir(parents=True, exist_ok=True)

    # 支持的图片格式
    supported_ext = ('.jpg', '.jpeg', '.png', '.bmp', '.tiff')
    
    # 遍历所有图片文件
    image_files = [
        f for f in input_path.rglob('*') 
        if f.suffix.lower() in supported_ext and f.is_file()
    ]

    if not image_files:
        print("⚠️ 指定文件夹中没有可处理的图片")
        return

    print(f"🔍 找到 {len(image_files)} 张图片，开始压缩...")
    for img_file in image_files:
        rel_path = img_file.relative_to(input_path)
        out_file = output_path / rel_path.with_stem(f"{rel_path.stem}_compressed")
        compress_image(img_file, out_file, max_size, quality)

    print(f"\n🎉 全部完成！压缩后图片保存在: {output_folder}")

if __name__ == "__main__":
    batch_compress("./photos", "./compressed", max_size=1200, quality=75)

from math import log
from SSIM_PIL import compare_ssim  # 需安装pyssim库

def get_ssim_at_quality(photo, quality):
    """计算指定质量下的SSIM值"""
    temp_path = "temp.jpg"
    photo.save(temp_path, format="JPEG", quality=quality, progressive=True)
    ssim_score = compare_ssim(photo, Image.open(temp_path))
    os.remove(temp_path)
    return ssim_score

def find_optimal_quality(original_photo, target_ssim=0.95):
    """二分法寻找最优质量参数"""
    low, high = 70, 95
    while high - low > 2:
        mid = (high + low) // 2
        if get_ssim_at_quality(original_photo, mid) < target_ssim:
            low = mid
        else:
            high = mid
    return high

# 使用示例
img = Image.open("photo.jpg")
optimal_quality = find_optimal_quality(img)
img.save("optimized.jpg", quality=optimal_quality)

def compress_png(input_path, output_path, palette_size=256):
    """PNG无损压缩"""
    img = Image.open(input_path)
    if img.mode == "RGB":
        # 生成最优调色板
        palleted_img = img.convert(
            'P', 
            palette=Image.ADAPTIVE, 
            colors=palette_size
        )
        palleted_img.save(
            output_path, 
            optimize=True,
            compress_level=9  # 最大压缩级别
        )

from concurrent.futures import ThreadPoolExecutor

def parallel_compress(input_folder, output_folder, max_workers=4):
    """多线程压缩"""
    image_files = [f for f in Path(input_folder).rglob('*') 
                  if f.suffix.lower() in ('.jpg', '.png') and f.is_file()]
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        for img_file in image_files:
            rel_path = img_file.relative_to(input_folder)
            out_file = Path(output_folder) / rel_path.with_stem(f"{rel_path.stem}_compressed")
            executor.submit(
                compress_image, 
                img_file, 
                out_file, 
                max_size=1200, 
                quality=75
            )

import pandas as pd
from datetime import datetime

def ecommerce_compress(input_folder, output_folder):
    """电商图片专用压缩流程"""
    results = []
    start_time = datetime.now()
    
    for img_file in Path(input_folder).rglob('*.jpg'):
        try:
            # 创建输出路径
            rel_path = img_file.relative_to(input_folder)
            out_file = Path(output_folder) / rel_path.with_stem(f"{rel_path.stem}_web")
            out_file.parent.mkdir(parents=True, exist_ok=True)
            
            # 压缩处理
            with Image.open(img_file) as img:
                # 强制正方形裁剪（需先安装opencv-python）
                # import cv2
                # img = cv2.resize(np.array(img), (800,800))
                # img = Image.fromarray(img)
                
                # 简单缩放方案
                img.thumbnail((800, 800), Image.LANCZOS)
                img.save(out_file, "JPEG", quality=80, optimize=True)
            
            # 记录结果
            results.append({
                "文件名": img_file.name,
                "原始大小(KB)": os.path.getsize(img_file)//1024,
                "压缩后(KB)": os.path.getsize(out_file)//1024,
                "状态": "成功"
            })
            
        except Exception as e:
            results.append({
                "文件名": img_file.name,
                "原始大小(KB)": "-",
                "压缩后(KB)": "-",
                "状态": f"失败: {str(e)}"
            })
    
    # 生成报告
    df = pd.DataFrame(results)
    report_path = Path(output_folder) / f"压缩报告_{datetime.now().strftime('%Y%m%d')}.csv"
    df.to_csv(report_path, index=False)
    
    print(f"\n处理完成！耗时: {(datetime.now()-start_time).seconds}秒")
    print(f"详细报告已生成: {report_path}")

# 使用示例
ecommerce_compress("./raw_images", "./web_images")

def handle_transparency(input_path, output_path):
    img = Image.open(input_path)
    if img.mode == "RGBA":
        # 创建白色背景
        background = Image.new("RGB", img.size, (255, 255, 255))
        background.paste(img, mask=img.split()[-1])
        background.save(output_path, "JPEG", quality=85)
    else:
        img.save(output_path, "JPEG", quality=85)

import piexif

def save_with_exif(img, output_path, quality=85):
    """保存图片并保留EXIF信息"""
    exif_dict = piexif.load(img.info['exif']) if 'exif' in img.info else {}
    img.save(
        output_path, 
        "JPEG", 
        quality=quality,
        exif=piexif.dump(exif_dict)
    )

from PIL import ImageSequence

def process_large_tiff(input_path, output_path):
    """分块处理超大TIFF文件"""
    with Image.open(input_path) as img:
        for i, page in enumerate(ImageSequence.Iterator(img)):
            page.thumbnail((4000, 4000))  # 先缩小尺寸
            page.save(
                f"{output_path}_page{i}.jpg",
                "JPEG",
                quality=80,
                optimize=True
            )