Elysia Tools
Navigation
Python
Web Image Processing Python Samples
Web Python image processing examples using PIL/Pillow including reading, saving, resizing, and format conversion
Samples
Entries inside this sample collection
CodepythonSimple
Image Read & Save
Read and save image files in various formats (JPG, PNG, GIF, BMP) with PIL/Pillow and get image metadata
Difficulty
3/10
Estimated time
20 min
Tags
python, web, image, processing
Prerequisites
Basic Python, PIL/Pillow library
python
# Web Python Image Read & Save Examples
# Reading, saving, and getting image information using PIL/Pillow
# 1. Basic Image Operations
from PIL import Image
from typing import Optional, Tuple, List
import os
def open_image(filepath: str) -> Optional[Image.Image]:
"""
Open image file
Args:
filepath: Path to image file
Returns:
PIL Image object or None if error
"""
try:
return Image.open(filepath)
except FileNotFoundError:
return None
except Exception as e:
print(f"Error opening image: {e}")
return None
def save_image(image: Image.Image, filepath: str, format: Optional[str] = None, **kwargs) -> bool:
"""
Save image to file
Args:
image: PIL Image object
filepath: Output file path
format: Image format (auto-detected from extension if None)
**kwargs: Additional save parameters (quality, optimize, etc.)
Returns:
True if successful
"""
try:
# Create directory if not exists
os.makedirs(os.path.dirname(filepath) or '.', exist_ok=True)
image.save(filepath, format=format, **kwargs)
return True
except Exception as e:
print(f"Error saving image: {e}")
return False
def save_as_jpg(image: Image.Image, filepath: str, quality: int = 95) -> bool:
"""
Save as JPEG format
Args:
image: PIL Image object
filepath: Output file path
quality: JPEG quality (1-100)
Returns:
True if successful
"""
return save_image(image, filepath, quality=quality)
def save_as_png(image: Image.Image, filepath: str, optimize: bool = True) -> bool:
"""
Save as PNG format
Args:
image: PIL Image object
filepath: Output file path
optimize: Enable PNG optimization
Returns:
True if successful
"""
return save_image(image, filepath, optimize=optimize)
def save_as_gif(image: Image.Image, filepath: str) -> bool:
"""
Save as GIF format
Args:
image: PIL Image object
filepath: Output file path
Returns:
True if successful
"""
return save_image(image, filepath)
def save_as_bmp(image: Image.Image, filepath: str) -> bool:
"""
Save as BMP format
Args:
image: PIL Image object
filepath: Output file path
Returns:
True if successful
"""
return save_image(image, filepath)
# 2. Image Information
def get_image_size(image: Image.Image) -> Tuple[int, int]:
"""
Get image dimensions
Args:
image: PIL Image object
Returns:
(width, height) tuple
"""
return image.size
def get_image_width(image: Image.Image) -> int:
"""Get image width"""
return image.width
def get_image_height(image: Image.Image) -> int:
"""Get image height"""
return image.height
def get_image_format(image: Image.Image) -> Optional[str]:
"""Get image format (JPEG, PNG, etc.)"""
return image.format
def get_image_mode(image: Image.Image) -> str:
"""
Get image mode (RGB, RGBA, L, CMYK, etc.)
Returns:
Mode string
"""
return image.mode
def get_image_info(image: Image.Image) -> dict:
"""
Get comprehensive image information
Args:
image: PIL Image object
Returns:
Dictionary with image metadata
"""
return {
'format': image.format,
'mode': image.mode,
'size': image.size,
'width': image.width,
'height': image.height,
'has_transparency': image.mode in ('RGBA', 'LA', 'PA') or 'transparency' in image.info
}
def print_image_info(image: Image.Image) -> None:
"""Print image information"""
info = get_image_info(image)
print("Image Information:")
for key, value in info.items():
print(f" {key}: {value}")
# 3. Image Mode Conversion
def convert_to_rgb(image: Image.Image) -> Image.Image:
"""
Convert image to RGB mode
Args:
image: PIL Image object
Returns:
RGB Image
"""
return image.convert('RGB')
def convert_to_rgba(image: Image.Image) -> Image.Image:
"""
Convert image to RGBA mode
Args:
image: PIL Image object
Returns:
RGBA Image
"""
return image.convert('RGBA')
def convert_to_grayscale(image: Image.Image) -> Image.Image:
"""
Convert image to grayscale
Args:
image: PIL Image object
Returns:
Grayscale Image
"""
return image.convert('L')
def convert_mode(image: Image.Image, mode: str) -> Image.Image:
"""
Convert image to specified mode
Args:
image: PIL Image object
mode: Target mode ('RGB', 'RGBA', 'L', 'CMYK', etc.)
Returns:
Converted Image
"""
return image.convert(mode)
# 4. Batch Processing
def batch_convert_format(input_files: List[str], output_dir: str, output_format: str) -> List[str]:
"""
Convert multiple images to specified format
Args:
input_files: List of input file paths
output_dir: Output directory
output_format: Target format ('jpg', 'png', etc.)
Returns:
List of output file paths
"""
os.makedirs(output_dir, exist_ok=True)
output_files = []
for filepath in input_files:
try:
image = open_image(filepath)
if image:
basename = os.path.splitext(os.path.basename(filepath))[0]
output_path = os.path.join(output_dir, f"{basename}.{output_format}")
save_image(image, output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error processing {filepath}: {e}")
return output_files
def batch_resize_save(input_files: List[str], output_dir: str, size: Tuple[int, int]) -> List[str]:
"""
Resize multiple images and save
Args:
input_files: List of input file paths
output_dir: Output directory
size: Target size (width, height)
Returns:
List of output file paths
"""
from PIL import Image
os.makedirs(output_dir, exist_ok=True)
output_files = []
for filepath in input_files:
try:
image = open_image(filepath)
if image:
resized = image.resize(size)
basename = os.path.basename(filepath)
output_path = os.path.join(output_dir, basename)
save_image(resized, output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error processing {filepath}: {e}")
return output_files
# 5. Image Creation
def create_new_image(mode: str, size: Tuple[int, int], color: str = 'white') -> Image.Image:
"""
Create new image
Args:
mode: Image mode ('RGB', 'RGBA', 'L', etc.)
size: Image size (width, height)
color: Background color
Returns:
New PIL Image
"""
return Image.new(mode, size, color)
def create_rgb_image(width: int, height: int, color: str = 'white') -> Image.Image:
"""
Create new RGB image
Args:
width: Image width
height: Image height
color: Background color
Returns:
New RGB Image
"""
return Image.new('RGB', (width, height), color)
def create_rgba_image(width: int, height: int, color: Tuple[int, int, int, int] = (255, 255, 255, 255)) -> Image.Image:
"""
Create new RGBA image
Args:
width: Image width
height: Image height
color: Background color (R, G, B, A)
Returns:
New RGBA Image
"""
return Image.new('RGBA', (width, height), color)
# 6. Image Operations
def rotate_image(image: Image.Image, angle: float, expand: bool = False) -> Image.Image:
"""
Rotate image
Args:
image: PIL Image object
angle: Rotation angle in degrees
expand: Expand image to fit rotated content
Returns:
Rotated Image
"""
return image.rotate(angle, expand=expand)
def flip_horizontal(image: Image.Image) -> Image.Image:
"""
Flip image horizontally
Args:
image: PIL Image object
Returns:
Flipped Image
"""
return image.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
def flip_vertical(image: Image.Image) -> Image.Image:
"""
Flip image vertically
Args:
image: PIL Image object
Returns:
Flipped Image
"""
return image.transpose(Image.Transpose.FLIP_TOP_BOTTOM)
def crop_image(image: Image.Image, box: Tuple[int, int, int, int]) -> Image.Image:
"""
Crop image
Args:
image: PIL Image object
box: Crop box (left, top, right, bottom)
Returns:
Cropped Image
"""
return image.crop(box)
# 7. Thumbnail Generation
def create_thumbnail(image: Image.Image, size: Tuple[int, int]) -> Image.Image:
"""
Create thumbnail maintaining aspect ratio
Args:
image: PIL Image object
size: Maximum size (width, height)
Returns:
Thumbnail Image
"""
thumbnail = image.copy()
thumbnail.thumbnail(size)
return thumbnail
# 8. Image Validation
def is_valid_image(filepath: str) -> bool:
"""
Check if file is valid image
Args:
filepath: Path to file
Returns:
True if valid image
"""
try:
with Image.open(filepath) as img:
img.verify()
return True
except:
return False
def get_supported_formats() -> List[str]:
"""
Get list of supported image formats
Returns:
List of format extensions
"""
return Image.register_extensions.keys()
# Usage Examples
def demonstrate_image_read_save():
print("=== Web Python Image Read & Save Examples ===\n")
# Note: These examples demonstrate the API calls
# In real usage, you would provide actual image file paths
# 1. Open and save image
print("--- 1. Open and Save Image ---")
print("# Open an image")
print("image = open_image('input.jpg')")
print("\n# Save as different formats")
print("save_as_jpg(image, 'output.jpg', quality=95)")
print("save_as_png(image, 'output.png', optimize=True)")
print("save_as_gif(image, 'output.gif')")
print("save_as_bmp(image, 'output.bmp')")
# 2. Get image information
print("\n--- 2. Image Information ---")
print("# Get image metadata")
print("width = get_image_width(image)")
print("height = get_image_height(image)")
print("mode = get_image_mode(image)")
print("format = get_image_format(image)")
print("\n# Get all info at once")
print("info = get_image_info(image)")
print("print_image_info(image)")
# 3. Mode conversion
print("\n--- 3. Mode Conversion ---")
print("# Convert to different modes")
print("rgb_image = convert_to_rgb(image)")
print("rgba_image = convert_to_rgba(image)")
print("gray_image = convert_to_grayscale(image)")
print("cmyk_image = convert_mode(image, 'CMYK')")
# 4. Create new images
print("\n--- 4. Create New Images ---")
print("# Create new RGB image")
print("new_image = create_rgb_image(800, 600, color='white')")
print("\n# Create new RGBA image with transparency")
print("new_rgba = create_rgba_image(800, 600, color=(255, 0, 0, 128))")
# 5. Transformations
print("\n--- 5. Image Transformations ---")
print("# Rotate image")
print("rotated = rotate_image(image, angle=45, expand=True)")
print("\n# Flip image")
print("flipped_h = flip_horizontal(image)")
print("flipped_v = flip_vertical(image)")
print("\n# Crop image")
print("cropped = crop_image(image, (100, 100, 500, 500))")
# 6. Thumbnail
print("\n--- 6. Thumbnail Generation ---")
print("# Create thumbnail")
print("thumbnail = create_thumbnail(image, (150, 150))")
print("save_as_jpg(thumbnail, 'thumbnail.jpg')")
# 7. Batch processing
print("\n--- 7. Batch Processing ---")
print("# Convert multiple images to PNG")
print("input_files = ['photo1.jpg', 'photo2.jpg', 'photo3.jpg']")
print("outputs = batch_convert_format(input_files, 'output_dir/', 'png')")
print("\n# Resize multiple images")
print("outputs = batch_resize_save(input_files, 'resized/', (800, 600))")
# 8. Validation
print("\n--- 8. Image Validation ---")
print("# Check if file is valid image")
print("if is_valid_image('photo.jpg'):")
print(" print('Valid image')")
print("\n# Get supported formats")
print("formats = get_supported_formats()")
print("print(f'Supported formats: {formats}')")
# 9. Complete workflow example
print("\n--- 9. Complete Workflow Example ---")
print(workflow_example)
print("\n=== All Image Read & Save Examples Completed ===")
# Example workflow
workflow_example = '''
# Complete image processing workflow
from PIL import Image
def process_image(input_path: str, output_path: str) -> bool:
"""Process image: open, convert, resize, save"""
# Open image
image = open_image(input_path)
if not image:
print(f"Failed to open {input_path}")
return False
# Print info
print_image_info(image)
# Convert to RGB if necessary
if image.mode != 'RGB':
image = convert_to_rgb(image)
# Resize to maximum 1920x1080
thumbnail = create_thumbnail(image, (1920, 1080))
# Save with quality 85
success = save_as_jpg(thumbnail, output_path, quality=85)
return success
# Usage
process_image('input.jpg', 'output.jpg')
'''
# Export functions
# export { open_image, save_image }
# export { save_as_jpg, save_as_png, save_as_gif, save_as_bmp }
# export { get_image_size, get_image_width, get_image_height }
# export { get_image_format, get_image_mode, get_image_info, print_image_info }
# export { convert_to_rgb, convert_to_rgba, convert_to_grayscale, convert_mode }
# export { batch_convert_format, batch_resize_save }
# export { create_new_image, create_rgb_image, create_rgba_image }
# export { rotate_image, flip_horizontal, flip_vertical, crop_image }
# export { create_thumbnail }
# export { is_valid_image, get_supported_formats }
# export { demonstrate_image_read_save }
CodepythonIntermediate
Image Resize
Resize images with aspect ratio preservation, fixed dimensions, thumbnail generation, and quality control
Difficulty
5/10
Estimated time
25 min
Tags
python, web, image, processing, resize
Prerequisites
Intermediate Python, PIL/Pillow library
python
# Web Python Image Resize Examples
# Resizing images with various methods and options
# 1. Basic Resizing
from PIL import Image
from typing import Tuple, Optional
import os
def resize_image(image: Image.Image, size: Tuple[int, int], resample: Image.Resampling = Image.Resampling.LANCZOS) -> Image.Image:
"""
Resize image to exact dimensions
Args:
image: PIL Image object
size: Target size (width, height)
resample: Resampling filter
Returns:
Resized Image
"""
return image.resize(size, resample)
def resize_width(image: Image.Image, width: int) -> Image.Image:
"""
Resize image to specific width (maintains aspect ratio)
Args:
image: PIL Image object
width: Target width
Returns:
Resized Image
"""
aspect_ratio = image.height / image.width
new_height = int(width * aspect_ratio)
return image.resize((width, new_height), Image.Resampling.LANCZOS)
def resize_height(image: Image.Image, height: int) -> Image.Image:
"""
Resize image to specific height (maintains aspect ratio)
Args:
image: PIL Image object
height: Target height
Returns:
Resized Image
"""
aspect_ratio = image.width / image.height
new_width = int(height * aspect_ratio)
return image.resize((new_width, height), Image.Resampling.LANCZOS)
# 2. Aspect Ratio Preservation
def resize_fit_in_box(image: Image.Image, max_size: Tuple[int, int]) -> Image.Image:
"""
Resize image to fit within box (maintains aspect ratio)
Args:
image: PIL Image object
max_size: Maximum dimensions (max_width, max_height)
Returns:
Resized Image
"""
max_width, max_height = max_size
# Calculate scaling factor
width_ratio = max_width / image.width
height_ratio = max_height / image.height
scale = min(width_ratio, height_ratio)
# Only resize if image is larger
if scale >= 1:
return image.copy()
new_width = int(image.width * scale)
new_height = int(image.height * scale)
return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
def resize_fill_box(image: Image.Image, size: Tuple[int, int], background_color: str = 'white') -> Image.Image:
"""
Resize and crop to fill box (maintains aspect ratio)
Args:
image: PIL Image object
size: Target size (width, height)
background_color: Background color for letterboxing
Returns:
Resized and cropped Image
"""
target_width, target_height = size
# Calculate scaling
width_ratio = target_width / image.width
height_ratio = target_height / image.height
scale = max(width_ratio, height_ratio)
new_width = int(image.width * scale)
new_height = int(image.height * scale)
# Resize
resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
# Create output image
if image.mode == 'RGBA':
output = Image.new('RGBA', size, background_color)
else:
output = Image.new('RGB', size, background_color)
# Calculate position to center
x = (target_width - new_width) // 2
y = (target_height - new_height) // 2
# Paste resized image
output.paste(resized, (x, y))
return output
def resize_cover_box(image: Image.Image, size: Tuple[int, int]) -> Image.Image:
"""
Resize and crop to cover box completely (maintains aspect ratio)
Args:
image: PIL Image object
size: Target size (width, height)
Returns:
Resized and cropped Image
"""
target_width, target_height = size
# Calculate scaling
width_ratio = target_width / image.width
height_ratio = target_height / image.height
scale = max(width_ratio, height_ratio)
new_width = int(image.width * scale)
new_height = int(image.height * scale)
# Resize
resized = image.resize((new_width, new_height), Image.Resampling.LANCZOS)
# Calculate crop box
left = (new_width - target_width) // 2
top = (new_height - target_height) // 2
right = left + target_width
bottom = top + target_height
return resized.crop((left, top, right, bottom))
# 3. Percentage Resizing
def resize_by_percentage(image: Image.Image, percentage: float) -> Image.Image:
"""
Resize image by percentage
Args:
image: PIL Image object
percentage: Scale percentage (e.g., 0.5 for 50%)
Returns:
Resized Image
"""
new_width = int(image.width * percentage)
new_height = int(image.height * percentage)
return image.resize((new_width, new_height), Image.Resampling.LANCZOS)
def resize_half(image: Image.Image) -> Image.Image:
"""Resize image to 50%"""
return resize_by_percentage(image, 0.5)
def resize_double(image: Image.Image) -> Image.Image:
"""Resize image to 200%"""
return resize_by_percentage(image, 2.0)
# 4. Thumbnail Generation
def create_thumbnail(image: Image.Image, size: Tuple[int, int], resample: Image.Resampling = Image.Resampling.LANCZOS) -> Image.Image:
"""
Create thumbnail maintaining aspect ratio
Args:
image: PIL Image object
size: Maximum size (width, height)
resample: Resampling filter
Returns:
Thumbnail Image
"""
thumbnail = image.copy()
thumbnail.thumbnail(size, resample)
return thumbnail
def create_thumbnail_fit(image: Image.Image, max_width: int, max_height: int) -> Image.Image:
"""
Create thumbnail that fits within dimensions
Args:
image: PIL Image object
max_width: Maximum width
max_height: Maximum height
Returns:
Thumbnail Image
"""
return create_thumbnail(image, (max_width, max_height))
# 5. Quality Control
def resize_with_quality(image: Image.Image, size: Tuple[int, int], quality: str = 'high') -> Image.Image:
"""
Resize with specified quality
Args:
image: PIL Image object
size: Target size
quality: 'low', 'medium', 'high', 'highest'
Returns:
Resized Image
"""
filters = {
'low': Image.Resampling.NEAREST,
'medium': Image.Resampling.BILINEAR,
'high': Image.Resampling.BICUBIC,
'highest': Image.Resampling.LANCZOS
}
resample = filters.get(quality, Image.Resampling.LANCZOS)
return image.resize(size, resample)
# 6. Batch Resizing
def batch_resize_images(input_files: list, output_dir: str, size: Tuple[int, int], maintain_aspect: bool = True) -> list:
"""
Resize multiple images
Args:
input_files: List of input file paths
output_dir: Output directory
size: Target size
maintain_aspect: Maintain aspect ratio
Returns:
List of output file paths
"""
os.makedirs(output_dir, exist_ok=True)
output_files = []
for filepath in input_files:
try:
image = Image.open(filepath)
if maintain_aspect:
resized = resize_fit_in_box(image, size)
else:
resized = resize_image(image, size)
basename = os.path.basename(filepath)
output_path = os.path.join(output_dir, basename)
resized.save(output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error processing {filepath}: {e}")
return output_files
def batch_create_thumbnails(input_files: list, output_dir: str, size: Tuple[int, int] = (150, 150)) -> list:
"""
Create thumbnails for multiple images
Args:
input_files: List of input file paths
output_dir: Output directory
size: Thumbnail size
Returns:
List of output file paths
"""
os.makedirs(output_dir, exist_ok=True)
output_files = []
for filepath in input_files:
try:
image = Image.open(filepath)
thumbnail = create_thumbnail(image, size)
basename = os.path.basename(filepath)
name, ext = os.path.splitext(basename)
output_path = os.path.join(output_dir, f"{name}_thumb{ext}")
thumbnail.save(output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error processing {filepath}: {e}")
return output_files
# 7. Smart Resizing
def resize_for_web(image: Image.Image, max_dimension: int = 1920) -> Image.Image:
"""
Resize image for web use
Args:
image: PIL Image object
max_dimension: Maximum width or height
Returns:
Resized Image
"""
if max(image.width, image.height) > max_dimension:
return resize_fit_in_box(image, (max_dimension, max_dimension))
return image.copy()
def resize_for_thumbnail(image: Image.Image, max_dimension: int = 150) -> Image.Image:
"""
Create optimized thumbnail
Args:
image: PIL Image object
max_dimension: Maximum width or height
Returns:
Thumbnail Image
"""
return create_thumbnail(image, (max_dimension, max_dimension))
def resize_for_social_media(image: Image.Image, platform: str) -> Image.Image:
"""
Resize for social media platforms
Args:
image: PIL Image object
platform: Platform name ('instagram', 'twitter', 'facebook', 'linkedin')
Returns:
Resized Image
"""
sizes = {
'instagram': (1080, 1080),
'twitter': (1200, 675),
'facebook': (1200, 630),
'linkedin': (1200, 627)
}
size = sizes.get(platform.lower(), (1200, 630))
return resize_cover_box(image, size)
# 8. Advanced Resizing
def resize_with_padding(image: Image.Image, size: Tuple[int, int], padding_color: str = 'white') -> Image.Image:
"""
Resize and add padding to fit exact size
Args:
image: PIL Image object
size: Target size
padding_color: Color of padding
Returns:
Resized Image with padding
"""
resized = resize_fit_in_box(image, size)
if resized.mode == 'RGBA':
output = Image.new('RGBA', size, padding_color)
else:
output = Image.new('RGB', size, padding_color)
# Center the resized image
x = (size[0] - resized.width) // 2
y = (size[1] - resized.height) // 2
output.paste(resized, (x, y))
return output
def resize_step_down(image: Image.Image, size: Tuple[int, int], steps: int = 3) -> Image.Image:
"""
Resize in multiple steps for better quality
Args:
image: PIL Image object
size: Target size
steps: Number of resize steps
Returns:
Resized Image
"""
current = image.copy()
for i in range(steps):
factor = (steps - i) / steps
intermediate_width = int(size[0] / factor)
intermediate_height = int(size[1] / factor)
current = current.resize((intermediate_width, intermediate_height), Image.Resampling.LANCZOS)
return current.resize(size, Image.Resampling.LANCZOS)
# Usage Examples
def demonstrate_image_resize():
print("=== Web Python Image Resize Examples ===\n")
# API usage demonstrations
print("--- 1. Basic Resizing ---")
print("# Resize to exact dimensions")
print("resized = resize_image(image, (800, 600))")
print("\n# Resize by width")
print("resized = resize_width(image, 800)")
print("\n# Resize by height")
print("resized = resize_height(image, 600)")
print("\n--- 2. Aspect Ratio Preservation ---")
print("# Fit within box")
print("resized = resize_fit_in_box(image, (800, 600))")
print("\n# Fill box with background")
print("resized = resize_fill_box(image, (800, 600), 'white')")
print("\n# Cover box (crop to fit)")
print("resized = resize_cover_box(image, (800, 600))")
print("\n--- 3. Percentage Resizing ---")
print("# Resize by percentage")
print("resized = resize_by_percentage(image, 0.5) # 50%")
print("resized_half = resize_half(image)")
print("resized_double = resize_double(image)")
print("\n--- 4. Thumbnails ---")
print("# Create thumbnail")
print("thumbnail = create_thumbnail(image, (150, 150))")
print("thumbnail_fit = create_thumbnail_fit(image, 150, 150)")
print("\n--- 5. Quality Control ---")
print("# Resize with quality")
print("resized = resize_with_quality(image, (800, 600), quality='high')")
print("# Quality options: 'low', 'medium', 'high', 'highest'")
print("\n--- 6. Batch Processing ---")
print("# Resize multiple images")
print("files = ['photo1.jpg', 'photo2.jpg']")
print("outputs = batch_resize_images(files, 'output/', (800, 600))")
print("\n# Create thumbnails")
print("thumbnails = batch_create_thumbnails(files, 'thumbs/', (150, 150))")
print("\n--- 7. Smart Resizing ---")
print("# Resize for web")
print("web_image = resize_for_web(image, max_dimension=1920)")
print("\n# Thumbnail for web")
print("thumb = resize_for_thumbnail(image, max_dimension=150)")
print("\n# Social media sizes")
print("instagram_img = resize_for_social_media(image, 'instagram')")
print("twitter_img = resize_for_social_media(image, 'twitter')")
print("\n--- 8. Advanced Resizing ---")
print("# Resize with padding")
print("resized = resize_with_padding(image, (800, 600), 'white')")
print("\n# Multi-step resize for quality")
print("resized = resize_step_down(image, (400, 300), steps=3)")
print("\n--- 9. Complete Workflow ---")
print(complete_workflow)
print("\n=== All Image Resize Examples Completed ===")
# Complete workflow example
complete_workflow = '''
# Complete image resizing workflow
from PIL import Image
def process_images_for_web(input_dir: str, output_dir: str):
"""Process images for web deployment"""
# Create output directories
web_dir = os.path.join(output_dir, 'web')
thumb_dir = os.path.join(output_dir, 'thumbnails')
os.makedirs(web_dir, exist_ok=True)
os.makedirs(thumb_dir, exist_ok=True)
# Process each image
for filename in os.listdir(input_dir):
if filename.lower().endswith(('.jpg', '.jpeg', '.png')):
input_path = os.path.join(input_dir, filename)
# Open image
image = Image.open(input_path)
# Create web version (max 1920px)
web_image = resize_for_web(image, 1920)
web_path = os.path.join(web_dir, filename)
web_image.save(web_path, quality=85, optimize=True)
# Create thumbnail (150x150)
thumbnail = create_thumbnail(image, (150, 150))
name, ext = os.path.splitext(filename)
thumb_path = os.path.join(thumb_dir, f"{name}_thumb{ext}")
thumbnail.save(thumb_path, quality=80, optimize=True)
print(f"Processed: {filename}")
# Usage
process_images_for_web('input_images/', 'output_images/')
'''
# Export functions
# export { resize_image, resize_width, resize_height }
# export { resize_fit_in_box, resize_fill_box, resize_cover_box }
# export { resize_by_percentage, resize_half, resize_double }
# export { create_thumbnail, create_thumbnail_fit }
# export { resize_with_quality }
# export { batch_resize_images, batch_create_thumbnails }
# export { resize_for_web, resize_for_thumbnail, resize_for_social_media }
# export { resize_with_padding, resize_step_down }
# export { demonstrate_image_resize }
CodepythonIntermediate
Image Format Convert
Convert between image formats (JPG, PNG, GIF, BMP) with color space conversion, quality control, and transparency handling
Difficulty
5/10
Estimated time
30 min
Tags
python, web, image, processing, convert
Prerequisites
Intermediate Python, PIL/Pillow library
python
# Web Python Image Format Conversion Examples
# Convert between image formats with color space and quality control
# 1. Basic Format Conversion
from PIL import Image
from typing import Optional, Tuple
import os
def convert_to_jpg(image: Image.Image, output_path: str, quality: int = 95) -> bool:
"""
Convert image to JPEG format
Args:
image: PIL Image object
output_path: Output file path
quality: JPEG quality (1-100)
Returns:
True if successful
"""
# Convert to RGB if necessary (JPEG doesn't support transparency)
if image.mode in ('RGBA', 'LA', 'PA'):
# Create white background
background = Image.new('RGB', image.size, (255, 255, 255))
if image.mode == 'RGBA':
background.paste(image, mask=image.split()[3]) # Use alpha channel as mask
else:
background.paste(image)
image = background
elif image.mode != 'RGB':
image = image.convert('RGB')
image.save(output_path, 'JPEG', quality=quality, optimize=True)
return True
def convert_to_png(image: Image.Image, output_path: str, optimize: bool = True) -> bool:
"""
Convert image to PNG format
Args:
image: PIL Image object
output_path: Output file path
optimize: Enable PNG optimization
Returns:
True if successful
"""
# PNG supports all modes, but convert RGBA if needed
if image.mode == 'RGB':
# No transparency needed
pass
elif image.mode not in ('RGBA', 'LA', 'PA'):
# Ensure mode is supported
image = image.convert(image.mode if image.mode in ('RGB', 'RGBA') else 'RGB')
image.save(output_path, 'PNG', optimize=optimize)
return True
def convert_to_gif(image: Image.Image, output_path: str) -> bool:
"""
Convert image to GIF format
Args:
image: PIL Image object
output_path: Output file path
Returns:
True if successful
"""
# GIF supports palette mode
if image.mode not in ('P', 'L'):
image = image.convert('P')
image.save(output_path, 'GIF')
return True
def convert_to_bmp(image: Image.Image, output_path: str) -> bool:
"""
Convert image to BMP format
Args:
image: PIL Image object
output_path: Output file path
Returns:
True if successful
"""
# BMP doesn't support alpha, convert to RGB
if image.mode == 'RGBA':
background = Image.new('RGB', image.size, (255, 255, 255))
background.paste(image, mask=image.split()[3])
image = background
elif image.mode != 'RGB':
image = image.convert('RGB')
image.save(output_path, 'BMP')
return True
def convert_to_webp(image: Image.Image, output_path: str, quality: int = 80, lossless: bool = False) -> bool:
"""
Convert image to WebP format
Args:
image: PIL Image object
output_path: Output file path
quality: WebP quality (0-100)
lossless: Use lossless compression
Returns:
True if successful
"""
image.save(output_path, 'WEBP', quality=quality, lossless=lossless)
return True
def convert_to_tiff(image: Image.Image, output_path: str) -> bool:
"""
Convert image to TIFF format
Args:
image: PIL Image object
output_path: Output file path
Returns:
True if successful
"""
image.save(output_path, 'TIFF')
return True
# 2. Color Space Conversion
def convert_to_rgb(image: Image.Image) -> Image.Image:
"""
Convert image to RGB color space
Args:
image: PIL Image object
Returns:
RGB Image
"""
return image.convert('RGB')
def convert_to_rgba(image: Image.Image, background_color: Tuple[int, int, int] = (255, 255, 255)) -> Image.Image:
"""
Convert image to RGBA with transparency
Args:
image: PIL Image object
background_color: Background color for non-transparent images
Returns:
RGBA Image
"""
if image.mode == 'RGB':
# Add alpha channel (fully opaque)
return image.convert('RGBA')
elif image.mode == 'RGBA':
return image
else:
# Convert via RGBA
return image.convert('RGBA')
def convert_to_grayscale(image: Image.Image) -> Image.Image:
"""
Convert image to grayscale
Args:
image: PIL Image object
Returns:
Grayscale Image
"""
return image.convert('L')
def convert_to_cmyk(image: Image.Image) -> Image.Image:
"""
Convert image to CMYK color space
Args:
image: PIL Image object
Returns:
CMYK Image
"""
return image.convert('CMYK')
def convert_mode(image: Image.Image, mode: str) -> Image.Image:
"""
Convert image to specified mode
Args:
image: PIL Image object
mode: Target mode ('RGB', 'RGBA', 'L', 'CMYK', 'P')
Returns:
Converted Image
"""
return image.convert(mode)
# 3. Quality Control
def convert_jpg_with_quality(image: Image.Image, output_path: str, quality: int = 95) -> bool:
"""
Convert to JPEG with specified quality
Args:
image: PIL Image object
output_path: Output file path
quality: Quality level (1-100)
Returns:
True if successful
"""
return convert_to_jpg(image, output_path, quality=quality)
def convert_png_compression(image: Image.Image, output_path: str, compress_level: int = 9) -> bool:
"""
Convert to PNG with compression
Args:
image: PIL Image object
output_path: Output file path
compress_level: Compression level (0-9, 9 = max compression)
Returns:
True if successful
"""
if image.mode != 'RGB' and image.mode != 'RGBA':
image = image.convert('RGB')
image.save(output_path, 'PNG', compress_level=compress_level)
return True
def convert_webp_with_settings(image: Image.Image, output_path: str, quality: int = 80, method: int = 6) -> bool:
"""
Convert to WebP with advanced settings
Args:
image: PIL Image object
output_path: Output file path
quality: Quality (0-100)
method: Compression method (0=fast, 6=best)
Returns:
True if successful
"""
image.save(output_path, 'WEBP', quality=quality, method=method)
return True
# 4. Transparency Handling
def preserve_transparency(image: Image.Image, output_format: str) -> Optional[Image.Image]:
"""
Prepare image for format conversion while preserving transparency
Args:
image: PIL Image object
output_format: Target format ('jpg', 'png', 'webp')
Returns:
Prepared Image or None
"""
if output_format.lower() == 'jpg':
# JPEG doesn't support transparency, composite with white background
if image.mode == 'RGBA':
background = Image.new('RGB', image.size, (255, 255, 255))
background.paste(image, mask=image.split()[3])
return background
return image.convert('RGB')
elif output_format.lower() in ('png', 'webp'):
# These formats support transparency
if image.mode != 'RGBA':
return image.convert('RGBA')
return image
else:
return image
def remove_transparency(image: Image.Image, background_color: Tuple[int, int, int] = (255, 255, 255)) -> Image.Image:
"""
Remove transparency from image
Args:
image: PIL Image object
background_color: Background color
Returns:
Image without transparency
"""
if image.mode == 'RGBA':
background = Image.new('RGB', image.size, background_color)
background.paste(image, mask=image.split()[3])
return background
return image.convert('RGB')
def add_transparency(image: Image.Image, alpha: int = 128) -> Image.Image:
"""
Add transparency to image
Args:
image: PIL Image object
alpha: Alpha channel value (0-255)
Returns:
RGBA Image with transparency
"""
if image.mode != 'RGBA':
image = image.convert('RGBA')
# Split channels and modify alpha
r, g, b, a = image.split()
a = a.point(lambda p: p * alpha // 255)
# Merge back
return Image.merge('RGBA', (r, g, b, a))
# 5. Batch Conversion
def batch_convert_format(input_files: list, output_dir: str, output_format: str, **kwargs) -> list:
"""
Convert multiple images to specified format
Args:
input_files: List of input file paths
output_dir: Output directory
output_format: Target format ('jpg', 'png', 'gif', 'bmp', 'webp')
**kwargs: Additional format-specific options
Returns:
List of output file paths
"""
os.makedirs(output_dir, exist_ok=True)
output_files = []
converters = {
'jpg': convert_to_jpg,
'jpeg': convert_to_jpg,
'png': convert_to_png,
'gif': convert_to_gif,
'bmp': convert_to_bmp,
'webp': convert_to_webp,
'tiff': convert_to_tiff
}
converter = converters.get(output_format.lower())
if not converter:
raise ValueError(f"Unsupported format: {output_format}")
for filepath in input_files:
try:
image = Image.open(filepath)
# Determine output path
basename = os.path.basename(filepath)
name = os.path.splitext(basename)[0]
output_path = os.path.join(output_dir, f"{name}.{output_format}")
# Convert
if output_format.lower() in ('jpg', 'jpeg'):
converter(image, output_path, quality=kwargs.get('quality', 95))
elif output_format.lower() == 'webp':
converter(image, output_path, quality=kwargs.get('quality', 80))
else:
converter(image, output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error converting {filepath}: {e}")
return output_files
def batch_convert_with_color_space(input_files: list, output_dir: str, output_format: str, color_mode: str = 'RGB') -> list:
"""
Convert images with color space transformation
Args:
input_files: List of input file paths
output_dir: Output directory
output_format: Target format
color_mode: Target color mode ('RGB', 'RGBA', 'L', 'CMYK')
Returns:
List of output file paths
"""
os.makedirs(output_dir, exist_ok=True)
output_files = []
for filepath in input_files:
try:
image = Image.open(filepath)
# Convert color space
image = convert_mode(image, color_mode)
# Save in target format
basename = os.path.basename(filepath)
name = os.path.splitext(basename)[0]
output_path = os.path.join(output_dir, f"{name}.{output_format}")
image.save(output_path)
output_files.append(output_path)
except Exception as e:
print(f"Error converting {filepath}: {e}")
return output_files
# 6. Optimization
def optimize_image_size(image: Image.Image, output_path: str, max_size_kb: int, format: str = 'jpg') -> bool:
"""
Convert with size constraint
Args:
image: PIL Image object
output_path: Output file path
max_size_kb: Maximum file size in KB
format: Output format
Returns:
True if successful
"""
quality = 95
min_quality = 10
while quality >= min_quality:
from io import BytesIO
# Save to memory
buffer = BytesIO()
if format.lower() == 'jpg':
image.save(buffer, format='JPEG', quality=quality, optimize=True)
elif format.lower() == 'png':
image.save(buffer, format='PNG', optimize=True)
elif format.lower() == 'webp':
image.save(buffer, format='WEBP', quality=quality)
# Check size
size_kb = len(buffer.getvalue()) / 1024
if size_kb <= max_size_kb:
# Save to file
with open(output_path, 'wb') as f:
f.write(buffer.getvalue())
return True
# Reduce quality
quality -= 5
return False
# 7. Special Conversions
def convert_to_black_white(image: Image.Image) -> Image.Image:
"""
Convert to black and white (1-bit)
Args:
image: PIL Image object
Returns:
Black and white Image
"""
return image.convert('1')
def convert_to_palette(image: Image.Image, colors: int = 256) -> Image.Image:
"""
Convert to palette mode
Args:
image: PIL Image object
colors: Number of colors
Returns:
Palette Image
"""
return image.convert('P', palette=Image.Palette.ADAPTIVE, colors=colors)
def convert_with_icc_profile(image: Image.Image, output_path: str, icc_profile_path: str) -> bool:
"""
Convert with ICC color profile
Args:
image: PIL Image object
output_path: Output file path
icc_profile_path: Path to ICC profile
Returns:
True if successful
"""
try:
image.save(output_path, icc_profile=icc_profile_path)
return True
except:
return False
# Usage Examples
def demonstrate_image_format_convert():
print("=== Web Python Image Format Conversion Examples ===\n")
print("--- 1. Basic Format Conversion ---")
print("# Convert to JPEG")
print("convert_to_jpg(image, 'output.jpg', quality=95)")
print("\n# Convert to PNG")
print("convert_to_png(image, 'output.png', optimize=True)")
print("\n# Convert to WebP")
print("convert_to_webp(image, 'output.webp', quality=80)")
print("\n# Convert to GIF")
print("convert_to_gif(image, 'output.gif')")
print("\n--- 2. Color Space Conversion ---")
print("# Convert color spaces")
print("rgb_img = convert_to_rgb(image)")
print("rgba_img = convert_to_rgba(image)")
print("gray_img = convert_to_grayscale(image)")
print("cmyk_img = convert_to_cmyk(image)")
print("\n--- 3. Quality Control ---")
print("# JPEG with quality")
print("convert_jpg_with_quality(image, 'output.jpg', quality=85)")
print("\n# PNG with compression")
print("convert_png_compression(image, 'output.png', compress_level=9)")
print("\n# WebP with settings")
print("convert_webp_with_settings(image, 'output.webp', quality=80, method=6)")
print("\n--- 4. Transparency Handling ---")
print("# Preserve transparency for PNG/WebP")
print("prepared = preserve_transparency(image, 'png')")
print("\n# Remove transparency for JPEG")
print("no_alpha = remove_transparency(image, (255, 255, 255))")
print("\n# Add transparency")
print("with_alpha = add_transparency(image, alpha=128)")
print("\n--- 5. Batch Conversion ---")
print("# Convert all to JPEG")
print("files = ['photo1.png', 'photo2.png']")
print("outputs = batch_convert_format(files, 'output/', 'jpg', quality=85)")
print("\n# Convert with color space")
print("outputs = batch_convert_with_color_space(files, 'output/', 'jpg', 'RGB')")
print("\n--- 6. Optimization ---")
print("# Optimize for size constraint")
print("optimize_image_size(image, 'output.jpg', max_size_kb=500)")
print("\n--- 7. Special Conversions ---")
print("# Black and white")
print("bw = convert_to_black_white(image)")
print("\n# Palette mode")
print("palette = convert_to_palette(image, colors=256)")
print("\n--- 8. Complete Workflow ---")
print(complete_workflow)
print("\n=== All Image Format Conversion Examples Completed ===")
# Complete workflow
complete_workflow = '''
# Complete image conversion workflow
from PIL import Image
def convert_for_web(input_path: str, output_dir: str):
"""Convert image for web with multiple formats"""
# Open image
image = Image.open(input_path)
# Create output directory
os.makedirs(output_dir, exist_ok=True)
# Get base name
basename = os.path.splitext(os.path.basename(input_path))[0]
# 1. High-quality JPEG for general use
convert_to_jpg(image, os.path.join(output_dir, f'{basename}.jpg'), quality=95)
# 2. PNG with transparency if needed
if image.mode == 'RGBA':
convert_to_png(image, os.path.join(output_dir, f'{basename}.png'))
# 3. WebP for modern browsers
convert_to_webp(image, os.path.join(output_dir, f'{basename}.webp'), quality=85)
# 4. Optimized JPEG (smaller file)
optimize_image_size(image, os.path.join(output_dir, f'{basename}_small.jpg'), max_size_kb=200)
print(f"Converted: {basename}")
# Usage
convert_for_web('input.png', 'web_output/')
'''
# Export functions
# export { convert_to_jpg, convert_to_png, convert_to_gif, convert_to_bmp }
# export { convert_to_webp, convert_to_tiff }
# export { convert_to_rgb, convert_to_rgba, convert_to_grayscale, convert_to_cmyk, convert_mode }
# export { convert_jpg_with_quality, convert_png_compression, convert_webp_with_settings }
# export { preserve_transparency, remove_transparency, add_transparency }
# export { batch_convert_format, batch_convert_with_color_space }
# export { optimize_image_size }
# export { convert_to_black_white, convert_to_palette, convert_with_icc_profile }
# export { demonstrate_image_format_convert }
Tools
Tools frequently paired with this sample
Related