引言：为什么选择Pillow进行图像格式转换
在数字图像处理领域，JPG和PNG是两种最常见的图像格式。JPG采用有损压缩，适合照片类图像，但在多次编辑和保存后会损失质量；PNG采用无损压缩，支持透明通道，适合图标、截图和需要保留清晰度的图像。将JPG转换为PNG可以避免后续处理中的质量损失，同时获得透明背景等优势。
Pillow（PIL Fork）是Python中最流行的图像处理库，它基于Python Imaging Library (PIL) 的现代化分支，提供了强大而简洁的API来处理各种图像格式。相比其他工具，Pillow具有以下优势：
跨平台
：支持Windows、macOS、Linux等操作系统
功能丰富
：支持图像打开、保存、转换、滤镜、缩放、裁剪等操作
易于集成
：可以轻松嵌入到Web应用、自动化脚本或数据处理流程中
格式支持广泛
：支持JPG、PNG、GIF、BMP、TIFF等数十种格式
一、环境准备与安装
1.1 安装Python环境
首先确保你的系统已安装Python 3.6或更高版本。可以通过终端或命令提示符运行以下命令检查：
python –version
# 或
python3 –version
如果未安装，请从
Python官网
下载并安装。
1.2 安装Pillow库
使用pip包管理器安装Pillow：
# 基础安装
pip install Pillow
# 如果你使用的是Python 3，可能需要使用
pip3 install Pillow
# 在某些系统上可能需要管理员权限
sudo pip3 install Pillow
# 如果你使用虚拟环境（推荐），先激活虚拟环境
source venv/bin/activate # Linux/macOS
# venv\Scripts\activate # Windows
pip install Pillow
1.3 验证安装
创建一个简单的Python脚本来验证Pillow是否正确安装：
from PIL import Image
# 打印Pillow版本
print(f”Pillow版本: {Image.__version__}”)
# 创建一个简单的测试图像
img = Image.new(‘RGB’, (100, 100), color=’red’)
img.save(‘test.png’)
print(“Pillow安装验证成功！”)
运行此脚本，如果成功生成
test.png
文件，说明Pillow已正确安装。
二、JPG转PNG的核心代码实现
2.1 基础转换代码
最简单的JPG到PNG转换只需要几行代码：
from PIL import Image
def convert_jpg_to_png(input_path, output_path):
“””
将JPG图像转换为PNG格式
参数:
input_path: 输入的JPG文件路径
output_path: 输出的PNG文件路径
“””
try:
# 打开JPG图像
image = Image.open(input_path)
# 转换并保存为PNG
image.save(output_path, ‘PNG’)
print(f”成功转换: {input_path} -> {output_path}”)
except FileNotFoundError:
print(f”错误: 文件未找到 – {input_path}”)
except Exception as e:
print(f”转换失败: {str(e)}”)
# 使用示例
convert_jpg_to_png(‘input.jpg’, ‘output.png’)
2.2 完整功能实现（包含错误处理和日志）
下面是一个更健壮的实现，包含详细的错误处理和日志记录：
from PIL import Image
import os
import logging
from pathlib import Path
# 配置日志
logging.basicConfig(
level=logging.INFO,
format=’%(asctime)s – %(levelname)s – %(message)s’
)
class JPGToPNGConverter:
“””JPG到PNG转换器类”””
def __init__(self, input_dir, output_dir):
self.input_dir = Path(input_dir)
self.output_dir = Path(output_dir)
# 创建输出目录
self.output_dir.mkdir(parents=True, exist_ok=True)
# 支持的输入格式
self.supported_formats = {‘.jpg’, ‘.jpeg’, ‘.JPG’, ‘.JPEG’}
def validate_image(self, image_path):
“””验证图像文件是否有效”””
try:
with Image.open(image_path) as img:
# 检查图像是否能被加载
img.verify()
return True
except Exception as e:
logging.error(f”图像验证失败 {image_path}: {str(e)}”)
return False
def convert_single_file(self, input_file, output_file=None):
“””转换单个文件”””
input_path = self.input_dir / input_file
# 确定输出路径
if output_file is None:
output_name = input_path.stem + ‘.png’
output_path = self.output_dir / output_name
else:
output_path = self.output_dir / output_file
# 验证输入文件
if not input_path.exists():
logging.error(f”文件不存在: {input_path}”)
return False
if not self.validate_image(input_path):
return False
try:
# 打开图像
with Image.open(input_path) as img:
# 确保图像模式正确（RGB或RGBA）
if img.mode not in [‘RGB’, ‘RGBA’]:
img = img.convert(‘RGB’)
# 保存为PNG
img.save(output_path, ‘PNG’, optimize=True)
# 验证输出文件
if output_path.exists():
original_size = input_path.stat().st_size
new_size = output_path.stat().st_size
logging.info(
f”转换成功: {input_file} -> {output_path.name} ”
f”(原始: {original_size} bytes, 新文件: {new_size} bytes)”
)
return True
else:
logging.error(f”输出文件未创建: {output_path}”)
return False
except Exception as e:
logging.error(f”转换失败 {input_file}: {str(e)}”)
return False
def convert_batch(self, pattern=”*”):
“””批量转换目录中的所有JPG文件”””
converted = 0
failed = 0
for ext in self.supported_formats:
for input_file in self.input_dir.glob(f”{pattern}{ext}”):
if self.convert_single_file(input_file):
converted += 1
else:
failed += 1
logging.info(f”批量转换完成: 成功 {converted}, 失败 {failed}”)
return converted, failed
# 使用示例
if __name__ == “__main__”:
converter = JPGToPNGConverter(
input_dir=”path/to/jpg/folder”,
output_dir=”path/to/png/folder”
)
# 转换单个文件
converter.convert_single_file(“photo.jpg”)
# 批量转换
converter.convert_batch()
2.3 高级转换选项
Pillow提供了多种优化选项，可以控制转换过程：
from PIL import Image
import os
def advanced_convert(input_path, output_path, **options):
“””
高级转换函数，支持多种选项
参数:
input_path: 输入文件路径
output_path: 输出文件路径
options: 转换选项
– optimize: 是否优化文件大小（默认True）
– quality: PNG压缩级别（0-9，0=无压缩，9=最大压缩）
– dpi: 设置DPI（默认保留原DPI）
– keep_exif: 是否保留EXIF信息（默认False，PNG不支持EXIF）
– background: 背景颜色（用于透明图像填充）
“””
# 设置默认选项
defaults = {
‘optimize’: True,
‘quality’: 9, # PNG压缩级别
‘keep_exif’: False,
‘background’: None
}
defaults.update(options)
try:
with Image.open(input_path) as img:
# 处理透明通道
if img.mode in [‘P’, ‘PA’]:
# 调色板图像
if img.mode == ‘P’:
# 转换为RGBA以支持透明
img = img.convert(‘RGBA’)
else:
# PA模式已包含透明
pass
elif img.mode == ‘L’:
# 灰度图像
img = img.convert(‘L’)
elif img.mode == ‘RGB’:
# 标准RGB
pass
elif img.mode == ‘RGBA’:
# 已有透明通道
pass
else:
# 其他模式转换为RGB
img = img.convert(‘RGB’)
# 准备保存参数
save_params = {
‘format’: ‘PNG’,
‘optimize’: defaults[‘optimize’]
}
# PNG压缩级别（0-9）
if 0 <= defaults['quality'] <= 9:
save_params['compress_level'] = defaults['quality']
# 处理背景颜色（用于填充透明区域）
if defaults['background'] and img.mode == 'RGBA':
# 创建背景图像
bg = Image.new('RGBA', img.size, defaults['background'])
# 合成
bg.paste(img, mask=img.split()[-1])
img = bg
# 保存图像
img.save(output_path, **save_params)
# 显示转换信息
original_size = os.path.getsize(input_path)
new_size = os.path.getsize(output_path)
print(f"转换完成: {input_path} -> {output_path}”)
print(f”文件大小: {original_size} -> {new_size} bytes”)
print(f”压缩率: {(1 – new_size/original_size)*100:.2f}%”)
return True
except Exception as e:
print(f”转换失败: {str(e)}”)
return False
# 使用示例
advanced_convert(
‘photo.jpg’,
‘photo_optimized.png’,
optimize=True,
quality=9,
background=(255, 255, 255) # 白色背景
)
三、避坑指南：常见问题与解决方案
3.1 问题1：内存不足（MemoryError）
症状
：处理大尺寸图像时程序崩溃，提示内存不足。
原因
：JPG图像在内存中解压后体积巨大。例如，一张4000×3000像素的JPG（5MB）解压后可能占用36MB内存（4000*3000*3字节）。
解决方案
：
from PIL import Image
import gc
def convert_large_image(input_path, output_path, chunk_size=2048):
“””
分块处理大图像，避免内存溢出
“””
try:
# 打开图像但不立即加载全部数据
with Image.open(input_path) as img:
# 获取图像信息
width, height = img.size
mode = img.mode
# 如果图像太大，分块处理
if width * height > chunk_size * chunk_size:
logging.info(f”大图像检测: {width}x{height}，使用分块处理”)
# 创建目标图像
if mode in [‘RGBA’, ‘LA’]:
target = Image.new(mode, (width, height), (0, 0, 0, 0))
else:
target = Image.new(mode, (width, height))
# 分块复制
block_size = 1024 # 每次处理1024×1024块
for y in range(0, height, block_size):
for x in range(0, width, block_size):
# 计算当前块的边界
x_end = min(x + block_size, width)
y_end = min(y + block_size, height)
# 提取块
box = (x, y, x_end, y_end)
block = img.crop(box)
# 粘贴到目标
target.paste(block, box)
# 显式删除块，释放内存
del block
gc.collect()
# 保存目标图像
target.save(output_path, ‘PNG’, optimize=True)
del target
else:
# 小图像直接处理
img.save(output_path, ‘PNG’, optimize=True)
return True
except MemoryError:
logging.error(“内存不足，建议使用更小的图像或增加系统内存”)
return False
except Exception as e:
logging.error(f”处理失败: {str(e)}”)
return False
# 使用示例
convert_large_image(‘large_photo.jpg’, ‘large_photo.png’)
3.2 问题2：颜色空间不匹配
症状
：转换后颜色失真、偏色或出现奇怪的色调。
原因
：JPG可能使用CMYK、YCbCr等颜色空间，而PNG通常使用RGB。Pillow在转换时可能无法正确处理颜色空间转换。
解决方案
：
from PIL import Image, ImageCms
def convert_with_color_management(input_path, output_path, target_profile=’sRGB’):
“””
使用色彩管理系统进行精确的颜色空间转换
“””
try:
with Image.open(input_path) as img:
# 检查当前颜色空间
print(f”原始模式: {img.mode}”)
# 如果是CMYK，需要特殊处理
if img.mode == ‘CMYK’:
# 方法1：使用Pillow内置转换（简单但可能不精确）
img_rgb = img.convert(‘RGB’)
# 方法2：使用ICC配置文件进行精确转换（推荐）
# 需要安装littlecms（通常Pillow已包含）
# 获取CMYK配置文件（假设图像嵌入了ICC配置）
if ‘icc_profile’ in img.info:
icc_profile = img.info[‘icc_profile’]
# 加载CMYK和sRGB配置文件
# 注意：需要实际的ICC配置文件路径
# cmyk_profile = ImageCms.getOpenProfile(‘USWebCoatedSWOP.icc’)
# srgb_profile = ImageCms.getOpenProfile(‘sRGB.icm’)
# 执行色彩转换
# img_rgb = ImageCms.profileToProfile(img, cmyk_profile, srgb_profile)
pass
img = img_rgb
# 处理其他非RGB模式
elif img.mode not in [‘RGB’, ‘RGBA’, ‘L’, ‘LA’]:
img = img.convert(‘RGB’)
# 保存
img.save(output_path, ‘PNG’, optimize=True)
print(f”颜色空间转换完成: {img.mode}”)
return True
except Exception as e:
print(f”颜色转换失败: {str(e)}”)
return False
# 简化版本：处理常见颜色问题
def safe_color_convert(input_path, output_path):
“””安全的颜色转换”””
with Image.open(input_path) as img:
# 统一转换为RGB或RGBA
if img.mode == ‘RGBA’:
# 已经是RGBA，直接保存
pass
elif img.mode == ‘RGB’:
# 标准RGB
pass
elif img.mode == ‘L’:
# 灰度
pass
elif img.mode == ‘P’:
# 调色板图像，转换为RGBA
img = img.convert(‘RGBA’)
elif img.mode == ‘CMYK’:
# CMYK转换为RGB
img = img.convert(‘RGB’)
else:
# 其他未知模式
img = img.convert(‘RGB’)
img.save(output_path, ‘PNG’, optimize=True)
return True
3.3 问题3：透明通道处理错误
症状
：PNG本应透明的部分变为黑色或白色，或透明效果异常。
原因
：JPG不支持透明，但某些JPG可能包含alpha通道（罕见）。转换时需要正确处理透明信息。
解决方案
：
from PIL import Image
def handle_transparency(input_path, output_path, background_color=(255, 255, 255)):
“””
正确处理透明通道
参数:
input_path: 输入文件
output_path: 输出文件
background_color: 背景颜色，用于填充透明区域
“””
with Image.open(input_path) as img:
# 检查是否有透明通道
has_alpha = img.mode in [‘RGBA’, ‘LA’, ‘PA’]
if has_alpha:
# 有透明通道，保留它
if img.mode == ‘PA’:
# 调色板+透明
img = img.convert(‘RGBA’)
elif img.mode == ‘LA’:
# 灰度+透明
img = img.convert(‘RGBA’)
# 保存为PNG以保留透明
img.save(output_path, ‘PNG’, optimize=True)
print(“保留透明通道”)
else:
# 无透明通道，但可能需要添加透明背景
# 或者填充背景色
# 如果需要透明背景
# 首先转换为RGBA
img_rgba = img.convert(‘RGBA’)
# 创建透明背景
# 但通常JPG转PNG不需要透明背景，除非特殊需求
# 更常见的场景：确保背景不透明
# 直接保存为PNG（无透明）
img.save(output_path, ‘PNG’, optimize=True)
print(“无透明通道，直接转换”)
return True
def add_transparency_mask(input_path, output_path, mask_threshold=128):
“””
为JPG图像添加透明蒙版（基于颜色阈值）
例如：将白色背景变为透明
“””
with Image.open(input_path) as img:
# 转换为RGBA
img = img.convert(‘RGBA’)
# 获取数据
data = img.getdata()
# 创建新数据
new_data = []
for item in data:
# 如果颜色接近白色（或指定阈值），设为透明
if all(c > mask_threshold for c in item[:3]):
new_data.append((255, 255, 255, 0)) # 透明
else:
new_data.append(item) # 保持原样
# 应用新数据
img.putdata(new_data)
# 保存
img.save(output_path, ‘PNG’, optimize=True)
print(“添加透明蒙版完成”)
return True
3.4 问题4：EXIF和元数据丢失
症状
：转换后照片的拍摄时间、相机型号等EXIF信息丢失。
原因
：PNG格式不支持EXIF数据（这是JPG的特性），但可以保留其他元数据。
解决方案
：
from PIL import Image
from PIL.ExifTags import TAGS
import json
def extract_and_preserve_metadata(input_path, output_path, metadata_file=None):
“””
提取并尝试保留元数据
注意：PNG不支持EXIF，但可以将元数据保存为JSON或PNG文本块
“””
metadata = {}
# 打开图像
with Image.open(input_path) as img:
# 提取EXIF信息
if hasattr(img, ‘_getexif’):
exifdata = img._getexif()
if exifdata:
for tag_id, value in exifdata.items():
tag = TAGS.get(tag_id, tag_id)
metadata[tag] = str(value)
# 提取ICC配置文件
if ‘icc_profile’ in img.info:
metadata[‘icc_profile’] = ‘present’ # 只记录存在，不保存二进制数据
# 提取其他信息
metadata[‘format’] = img.format
metadata[‘size’] = img.size
metadata[‘mode’] = img.mode
# 保存PNG（不包含EXIF）
img.save(output_path, ‘PNG’, optimize=True)
# 将元数据保存为单独的JSON文件
if metadata and metadata_file:
with open(metadata_file, ‘w’, encoding=’utf-8′) as f:
json.dump(metadata, f, indent=2, ensure_ascii=False)
print(f”元数据已保存到: {metadata_file}”)
# 如果需要在PNG中嵌入文本元数据（PNG支持文本块）
if metadata:
with Image.open(output_path) as img:
# PNG支持添加文本信息
img.info[‘comment’] = json.dumps(metadata, ensure_ascii=False)
img.save(output_path, ‘PNG’, optimize=True)
return metadata
def restore_metadata(png_path, metadata_file, output_path):
“””
从JSON文件恢复元数据到PNG（作为文本块）
“””
# 读取元数据
with open(metadata_file, ‘r’, encoding=’utf-8′) as f:
metadata = json.load(f)
# 打开PNG并添加元数据
with Image.open(png_path) as img:
# 添加文本块
for key, value in metadata.items():
# PNG文本块限制为79字符
if len(str(value)) > 79:
img.info[key] = str(value)[:79]
else:
img.info[key] = str(value)
# 重新保存
img.save(output_path, ‘PNG’, optimize=True)
print(f”元数据已恢复到: {output_path}”)
return True
3.5 问题5：批量转换时的性能问题
症状
：批量转换大量文件时速度慢，或内存占用持续增长。
原因
：没有正确释放资源，或没有使用优化策略。
解决方案
：
from PIL import Image
import os
import gc
from pathlib import Path
import time
class OptimizedBatchConverter:
“””优化的批量转换器”””
def __init__(self, input_dir, output_dir, max_memory_mb=500):
self.input_dir = Path(input_dir)
self.output_dir = Path(output_dir)
self.max_memory_mb = max_memory_mb
self.output_dir.mkdir(parents=True, exist_ok=True)
# 统计信息
self.stats = {
‘total’: 0,
‘success’: 0,
‘failed’: 0,
‘total_time’: 0,
‘total_size_in’: 0,
‘total_size_out’: 0
}
def get_memory_usage(self):
“””获取当前内存使用（近似）”””
import psutil
process = psutil.Process()
return process.memory_info().rss / 1024 / 1024 # MB
def convert_with_memory_check(self, input_file):
“””带内存检查的转换”””
input_path = self.input_dir / input_file
output_name = input_path.stem + ‘.png’
output_path = self.output_dir / output_name
# 检查内存
if self.get_memory_usage() > self.max_memory_mb:
logging.warning(“内存使用过高，强制垃圾回收”)
gc.collect()
start_time = time.time()
try:
# 使用上下文管理器确保资源释放
with Image.open(input_path) as img:
# 检查图像尺寸
width, height = img.size
pixels = width * height
# 超大图像使用分块处理
if pixels > 50_000_000: # 5000万像素
logging.info(f”超大图像: {input_file} ({width}x{height})”)
result = self._convert_large_image(img, output_path)
else:
# 普通图像
img.save(output_path, ‘PNG’, optimize=True)
result = True
# 显式删除引用
del img
# 强制垃圾回收
gc.collect()
end_time = time.time()
duration = end_time – start_time
# 更新统计
self.stats[‘total’] += 1
if result:
self.stats[‘success’] += 1
self.stats[‘total_time’] += duration
self.stats[‘total_size_in’] += input_path.stat().st_size
self.stats[‘total_size_out’] += output_path.stat().st_size
logging.info(
f”[{self.stats[‘success’]}] {input_file} -> {output_name} ”
f”({duration:.2f}s)”
)
else:
self.stats[‘failed’] += 1
return result
except Exception as e:
logging.error(f”转换失败 {input_file}: {str(e)}”)
self.stats[‘failed’] += 1
return False
def _convert_large_image(self, img, output_path):
“””分块转换超大图像”””
width, height = img.size
block_size = 2048
# 创建目标图像
target = Image.new(img.mode, (width, height))
# 分块处理
for y in range(0, height, block_size):
for x in range(0, width, block_size):
x_end = min(x + block_size, width)
y_end = min(y + block_size, height)
box = (x, y, x_end, y_end)
block = img.crop(box)
target.paste(block, box)
del block
gc.collect()
target.save(output_path, ‘PNG’, optimize=True)
del target
return True
def convert_all(self):
“””转换所有JPG文件”””
logging.info(f”开始批量转换: {self.input_dir} -> {self.output_dir}”)
# 获取所有JPG文件
jpg_files = []
for ext in [‘.jpg’, ‘.jpeg’, ‘.JPG’, ‘.JPEG’]:
jpg_files.extend(self.input_dir.glob(f”*{ext}”))
if not jpg_files:
logging.warning(“未找到JPG文件”)
return
logging.info(f”找到 {len(jpg_files)} 个文件”)
# 转换
for jpg_file in jpg_files:
self.convert_with_memory_check(jpg_file.name)
# 打印总结
self.print_summary()
def print_summary(self):
“””打印转换总结”””
print(“\n” + “=”*50)
print(“转换总结”)
print(“=”*50)
print(f”总文件数: {self.stats[‘total’]}”)
print(f”成功: {self.stats[‘success’]}”)
print(f”失败: {self.stats[‘failed’]}”)
if self.stats[‘success’] > 0:
avg_time = self.stats[‘total_time’] / self.stats[‘success’]
print(f”平均耗时: {avg_time:.2f}秒”)
total_in = self.stats[‘total_size_in’]
total_out = self.stats[‘total_size_out’]
if total_in > 0:
ratio = (1 – total_out/total_in) * 100
print(f”总压缩率: {ratio:.2f}%”)
print(f”空间节省: {total_in – total_out} bytes”)
print(“=”*50)
# 使用示例
converter = OptimizedBatchConverter(
input_dir=”path/to/jpg”,
output_dir=”path/to/png”,
max_memory_mb=400 # 内存超过400MB时触发GC
)
converter.convert_all()
3.6 问题6：文件权限和路径问题
症状
：PermissionError、文件锁定、路径不存在等错误。
解决方案
：
from pathlib import Path
import os
import shutil
def safe_file_operation(input_path, output_path):
“””
安全的文件操作，处理权限和路径问题
“””
input_path = Path(input_path)
output_path = Path(output_path)
# 检查输入文件是否存在
if not input_path.exists():
raise FileNotFoundError(f”输入文件不存在: {input_path}”)
# 检查输入文件是否可读
if not os.access(input_path, os.R_OK):
raise PermissionError(f”无读取权限: {input_path}”)
# 确保输出目录存在
output_path.parent.mkdir(parents=True, exist_ok=True)
# 检查输出目录是否可写
if not os.access(output_path.parent, os.W_OK):
raise PermissionError(f”无写入权限: {output_path.parent}”)
# 检查输出文件是否已存在
if output_path.exists():
logging.warning(f”输出文件已存在，将覆盖: {output_path}”)
# 可以选择备份或跳过
# backup_path = output_path.with_suffix(‘.bak’)
# shutil.copy2(output_path, backup_path)
# 执行转换
try:
with Image.open(input_path) as img:
img.save(output_path, ‘PNG’, optimize=True)
return True
except Exception as e:
# 如果转换失败，删除可能创建的不完整文件
if output_path.exists():
output_path.unlink()
raise e
def convert_with_retry(input_path, output_path, max_retries=3):
“””
带重试机制的转换
“””
for attempt in range(max_retries):
try:
return safe_file_operation(input_path, output_path)
except Exception as e:
if attempt == max_retries – 1:
raise e
logging.warning(f”尝试 {attempt + 1} 失败: {str(e)}，重试中…”)
time.sleep(1) # 等待1秒后重试
四、完整项目示例
4.1 命令行工具
#!/usr/bin/env python3
“””
JPG to PNG Converter CLI Tool
使用: python jpg2png.py input.jpg output.png
python jpg2png.py input_folder output_folder
“””
import argparse
import sys
from pathlib import Path
from PIL import Image
import logging
# 配置日志
logging.basicConfig(level=logging.INFO, format=’%(message)s’)
class JPG2PNGConverter:
def __init__(self, verbose=False):
self.verbose = verbose
if verbose:
logging.getLogger().setLevel(logging.DEBUG)
def convert(self, input_path, output_path):
input_path = Path(input_path)
output_path = Path(output_path)
# 判断是文件还是目录
if input_path.is_file():
return self._convert_file(input_path, output_path)
elif input_path.is_dir():
return self._convert_directory(input_path, output_path)
else:
logging.error(f”无效的输入路径: {input_path}”)
return False
def _convert_file(self, input_file, output_file):
if output_file.suffix.lower() != ‘.png’:
output_file = output_file.with_suffix(‘.png’)
try:
with Image.open(input_file) as img:
# 处理颜色模式
if img.mode not in [‘RGB’, ‘RGBA’, ‘L’, ‘LA’]:
img = img.convert(‘RGB’)
# 保存
img.save(output_file, ‘PNG’, optimize=True)
# 输出信息
original_size = input_file.stat().st_size
new_size = output_file.stat().st_size
ratio = (1 – new_size/original_size) * 100 if original_size > 0 else 0
logging.info(
f”✓ {input_file.name} -> {output_file.name} ”
f”({original_size} → {new_size} bytes, {ratio:.1f}% saved)”
)
return True
except Exception as e:
logging.error(f”✗ {input_file.name}: {str(e)}”)
return False
def _convert_directory(self, input_dir, output_dir):
output_dir.mkdir(parents=True, exist_ok=True)
# 支持的扩展名
extensions = {‘.jpg’, ‘.jpeg’, ‘.JPG’, ‘.JPEG’}
files = [f for ext in extensions for f in input_dir.glob(f’*{ext}’)]
if not files:
logging.warning(f”目录 {input_dir} 中没有找到JPG文件”)
return False
logging.info(f”找到 {len(files)} 个JPG文件，开始转换…”)
success = 0
for file in files:
if self._convert_file(file, output_dir / file.with_suffix(‘.png’).name):
success += 1
logging.info(f”\n转换完成: {success}/{len(files)} 成功”)
return success > 0
def main():
parser = argparse.ArgumentParser(
description=’将JPG图像转换为PNG格式’,
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog=”’
示例:
python jpg2png.py photo.jpg output.png
python jpg2png.py images/ converted/ -v
python jpg2png.py input_folder output_folder –verbose
”’
)
parser.add_argument(‘input’, help=’输入文件或目录路径’)
parser.add_argument(‘output’, help=’输出文件或目录路径’)
parser.add_argument(‘-v’, ‘–verbose’, action=’store_true’, help=’详细输出’)
args = parser.parse_args()
converter = JPG2PNGConverter(verbose=args.verbose)
try:
success = converter.convert(args.input, args.output)
sys.exit(0 if success else 1)
except KeyboardInterrupt:
logging.info(“\n操作被用户取消”)
sys.exit(1)
except Exception as e:
logging.error(f”程序错误: {str(e)}”)
sys.exit(1)
if __name__ == ‘__main__’:
main()
4.2 GUI版本（使用Tkinter）
import tkinter as tk
from tkinter import filedialog, messagebox, ttk
from PIL import Image
import threading
import queue
import os
class JPG2PNGGUI:
def __init__(self, root):
self.root = root
self.root.title(“JPG to PNG Converter”)
self.root.geometry(“500×400″)
self.input_path = tk.StringVar()
self.output_path = tk.StringVar()
self.status_queue = queue.Queue()
self.setup_ui()
self.check_queue()
def setup_ui(self):
# 主框架
main_frame = ttk.Frame(self.root, padding=”10″)
main_frame.grid(row=0, column=0, sticky=(tk.W, tk.E, tk.N, tk.S))
# 输入选择
ttk.Label(main_frame, text=”输入文件/目录:”).grid(row=0, column=0, sticky=tk.W, pady=5)
input_entry = ttk.Entry(main_frame, textvariable=self.input_path, width=40)
input_entry.grid(row=1, column=0, sticky=(tk.W, tk.E), pady=5)
ttk.Button(main_frame, text=”浏览”, command=self.browse_input).grid(row=1, column=1, padx=5)
# 输出选择
ttk.Label(main_frame, text=”输出目录:”).grid(row=2, column=0, sticky=tk.W, pady=5)
output_entry = ttk.Entry(main_frame, textvariable=self.output_path, width=40)
output_entry.grid(row=3, column=0, sticky=(tk.W, tk.E), pady=5)
ttk.Button(main_frame, text=”浏览”, command=self.browse_output).grid(row=3, column=1, padx=5)
# 进度条
self.progress = ttk.Progressbar(main_frame, mode=’indeterminate’)
self.progress.grid(row=4, column=0, columnspan=2, sticky=(tk.W, tk.E), pady=10)
# 按钮
btn_frame = ttk.Frame(main_frame)
btn_frame.grid(row=5, column=0, columnspan=2, pady=10)
ttk.Button(btn_frame, text=”开始转换”, command=self.start_conversion).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text=”清空”, command=self.clear).pack(side=tk.LEFT, padx=5)
ttk.Button(btn_frame, text=”退出”, command=self.root.quit).pack(side=tk.LEFT, padx=5)
# 状态文本
self.status_text = tk.Text(main_frame, height=10, width=50, state=tk.DISABLED)
self.status_text.grid(row=6, column=0, columnspan=2, sticky=(tk.W, tk.E, tk.N, tk.S))
# 配置网格权重
self.root.columnconfigure(0, weight=1)
self.root.rowconfigure(0, weight=1)
main_frame.columnconfigure(0, weight=1)
main_frame.rowconfigure(6, weight=1)
def browse_input(self):
path = filedialog.askopenfilename(
title=”选择JPG文件”,
filetypes=[(“JPG files”, “*.jpg *.jpeg”), (“All files”, “*.*”)]
)
if path:
self.input_path.set(path)
# 自动设置输出路径
if not self.output_path.get():
output_dir = os.path.dirname(path)
self.output_path.set(output_dir)
def browse_output(self):
path = filedialog.askdirectory(title=”选择输出目录”)
if path:
self.output_path.set(path)
def start_conversion(self):
input_path = self.input_path.get()
output_path = self.output_path.get()
if not input_path or not output_path:
messagebox.showerror(“错误”, “请选择输入和输出路径”)
return
if not os.path.exists(input_path):
messagebox.showerror(“错误”, “输入路径不存在”)
return
# 禁用按钮
self.progress.start(10)
# 在新线程中运行转换
thread = threading.Thread(target=self.run_conversion, args=(input_path, output_path))
thread.daemon = True
thread.start()
def run_conversion(self, input_path, output_path):
try:
converter = JPG2PNGConverter(verbose=True)
success = converter.convert(input_path, output_path)
if success:
self.status_queue.put((“success”, “转换完成！”))
else:
self.status_queue.put((“error”, “转换失败，请检查日志”))
except Exception as e:
self.status_queue.put((“error”, f”错误: {str(e)}”))
finally:
self.status_queue.put((“done”, None))
def check_queue(self):
try:
while True:
msg_type, msg = self.status_queue.get_nowait()
if msg_type == “done”:
self.progress.stop()
self.progress[‘value’] = 0
else:
self.update_status(msg, msg_type == “error”)
except queue.Empty:
pass
self.root.after(100, self.check_queue)
def update_status(self, message, is_error=False):
self.status_text.config(state=tk.NORMAL)
self.status_text.insert(tk.END, message + “\n”)
self.status_text.see(tk.END)
self.status_text.config(state=tk.DISABLED)
if is_error:
messagebox.showerror(“错误”, message)
def clear(self):
self.input_path.set(“”)
self.output_path.set(“”)
self.status_text.config(state=tk.NORMAL)
self.status_text.delete(1.0, tk.END)
self.status_text.config(state=tk.DISABLED)
if __name__ == “__main__”:
root = tk.Tk()
app = JPG2PNGGUI(root)
root.mainloop()
五、性能优化技巧
5.1 使用多进程加速批量转换
from multiprocessing import Pool, cpu_count
import os
from pathlib import Path
def convert_single_file_parallel(args):
“””并行转换单个文件”””
input_file, output_dir = args
try:
with Image.open(input_file) as img:
output_file = Path(output_dir) / (Path(input_file).stem + ‘.png’)
img.save(output_file, ‘PNG’, optimize=True)
return (True, input_file)
except Exception as e:
return (False, input_file, str(e))
def batch_convert_parallel(input_dir, output_dir, num_processes=None):
“””使用多进程并行转换”””
if num_processes is None:
num_processes = cpu_count()
input_dir = Path(input_dir)
output_dir = Path(output_dir)
output_dir.mkdir(parents=True, exist_ok=True)
# 获取所有JPG文件
jpg_files = []
for ext in [‘.jpg’, ‘.jpeg’, ‘.JPG’, ‘.JPEG’]:
jpg_files.extend(input_dir.glob(f’*{ext}’))
# 准备参数列表
args_list = [(str(f), str(output_dir)) for f in jpg_files]
# 并行处理
with Pool(num_processes) as pool:
results = pool.map(convert_single_file_parallel, args_list)
# 统计结果
success = sum(1 for r in results if r[0])
failed = len(results) – success
print(f”并行转换完成: 成功 {success}, 失败 {failed}”)
return success, failed
# 使用示例
# batch_convert_parallel(‘input/’, ‘output/’, num_processes=4)
5.2 使用内存映射处理超大文件
import mmap
from PIL import Image
import io
def convert_with_mmap(input_path, output_path):
“””
使用内存映射处理超大JPG文件
适用于无法一次性加载到内存的超大文件
“””
try:
# 打开文件并创建内存映射
with open(input_path, ‘rb’) as f:
# 创建内存映射
mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
# 使用BytesIO包装内存映射
file_like = io.BytesIO(mm)
# 打开图像
img = Image.open(file_like)
# 保存
img.save(output_path, ‘PNG’, optimize=True)
# 清理
mm.close()
return True
except Exception as e:
print(f”内存映射转换失败: {str(e)}”)
return False
六、测试与验证
6.1 验证转换质量
from PIL import Image, ImageChops
import numpy as np
def verify_conversion(input_path, output_path, max_diff=1):
“””
验证转换质量：比较JPG和PNG的像素差异
注意：由于JPG是有损压缩，会有微小差异
“””
try:
with Image.open(input_path) as jpg, Image.open(output_path) as png:
# 确保尺寸相同
if jpg.size != png.size:
print(f”尺寸不匹配: {jpg.size} vs {png.size}”)
return False
# 转换为相同模式
if jpg.mode != png.mode:
if jpg.mode == ‘CMYK’:
jpg = jpg.convert(‘RGB’)
else:
jpg = jpg.convert(png.mode)
# 计算差异
diff = ImageChops.difference(jpg, png)
# 统计差异像素
diff_array = np.array(diff)
diff_pixels = np.sum(diff_array > 0)
total_pixels = diff_array.size
# 计算平均差异
avg_diff = np.mean(diff_array)
print(f”差异像素: {diff_pixels}/{total_pixels} ({diff_pixels/total_pixels*100:.4f}%)”)
print(f”平均差异: {avg_diff:.4f}”)
# 判断是否可接受
if diff_pixels / total_pixels < 0.01: # 少于1%的像素有差异
print("✓ 转换质量良好")
return True
else:
print("⚠ 转换质量可能有问题")
return False
except Exception as e:
print(f"验证失败: {str(e)}")
return False
# 使用示例
# verify_conversion('input.jpg', 'output.png')
6.2 性能基准测试
import time
import statistics
def benchmark_conversion(input_path, num_runs=5):
"""测试转换性能"""
times = []
for i in range(num_runs):
output_path = f"benchmark_output_{i}.png"
start = time.time()
with Image.open(input_path) as img:
img.save(output_path, 'PNG', optimize=True)
end = time.time()
times.append(end - start)
# 清理
if os.path.exists(output_path):
os.remove(output_path)
print(f"基准测试 ({num_runs} 次运行):")
print(f" 平均时间: {statistics.mean(times):.4f} 秒")
print(f" 中位数: {statistics.median(times):.4f} 秒")
print(f" 标准差: {statistics.stdev(times):.4f} 秒")
print(f" 最快: {min(times):.4f} 秒")
print(f" 最慢: {max(times):.4f} 秒")
七、总结与最佳实践
7.1 核心要点回顾
始终使用上下文管理器
：
with Image.open() as img:
确保资源正确释放
正确处理颜色模式
：统一转换为RGB/RGBA/LA等标准模式
使用optimize参数
：
save(..., optimize=True)
减小文件大小
内存管理
：大文件使用分块处理，及时垃圾回收
错误处理
：捕获并记录所有异常，提供有意义的错误信息
7.2 推荐的工作流程
def recommended_workflow(input_path, output_path):
"""
推荐的转换工作流程
"""
# 1. 验证输入
if not os.path.exists(input_path):
raise FileNotFoundError(f"文件不存在: {input_path}")
# 2. 打开并验证图像
with Image.open(input_path) as img:
# 3. 处理颜色模式
if img.mode not in ['RGB', 'RGBA', 'L', 'LA']:
img = img.convert('RGB')
# 4. 检查图像尺寸
width, height = img.size
if width * height > 100_000_000: # 超过1亿像素
logging.warning(“超大图像，可能需要大量内存”)
# 5. 保存为PNG
img.save(output_path, ‘PNG’, optimize=True, compress_level=9)
# 6. 验证输出
if not os.path.exists(output_path):
raise RuntimeError(“输出文件未创建”)
# 7. 记录统计信息
original_size = os.path.getsize(input_path)
new_size = os.path.getsize(output_path)
ratio = (1 – new_size/original_size) * 100
logging.info(f”转换成功: {original_size} → {new_size} bytes ({ratio:.1f}% saved)”)
return True
7.3 常见陷阱总结
问题
解决方案
内存不足
使用分块处理或内存映射
颜色失真
显式转换颜色模式（CMYK→RGB）
透明通道错误
正确处理RGBA模式，避免误操作
元数据丢失
单独保存元数据为JSON
批量转换慢
使用多进程并行处理
文件权限问题
检查并处理权限异常
大文件处理
使用optimize和compress_level优化
7.4 性能优化清单
[ ] 使用
optimize=True
减小文件大小
[ ] 设置
compress_level=9
最大压缩（牺牲速度）
[ ] 批量转换时使用多进程
[ ] 大文件使用分块处理
[ ] 及时调用
gc.collect()
释放内存
[ ] 使用
with
语句确保资源释放
[ ] 避免不必要的图像模式转换
通过遵循这些指南和最佳实践，你可以高效、可靠地使用Pillow将JPG图像转换为PNG格式，同时避免常见问题和陷阱。记住，高质量的转换不仅仅是格式改变，还需要考虑颜色管理、内存使用、性能优化和错误处理等多个方面。