在Python桌面应用开发中，图片显示是最常见也是最容易踩坑的功能之一。你是否遇到过这样的问题：使用Tkinter显示图片时，只支持有限的格式？想要显示JPG、PNG等常见格式却总是报错？或者图片尺寸过大导致界面布局混乱？

本文将深入解析Python Tkinter中的两种主要图片显示方案：原生PhotoImage和PIL图片处理，通过实战案例帮你彻底解决图片显示的各种问题，让你的Python上位机开发更加得心应手。

🔍 问题分析：Tkinter图片显示的核心痛点

📋 PhotoImage的局限性

Tkinter原生的PhotoImage组件存在以下限制：

• 格式支持有限：仅支持GIF和PPM/PGM格式
• 功能单一：无法进行图片缩放、旋转等操作
• 兼容性差：对现代图片格式支持不足

🎯 实际开发需求

在实际Python开发项目中，我们通常需要：

• 显示JPG、PNG、BMP等主流格式
• 动态调整图片尺寸适应界面
• 对图片进行基本的处理操作

💡 解决方案：双管齐下的技术路线

🚀 方案一：原生PhotoImage（基础应用）

适用于简单的GIF动图显示和基础图片需求。

🔥 方案二：PIL + ImageTk（推荐方案）

通过Pillow库扩展Tkinter的图片处理能力，实现全格式支持。

🛠️ 代码实战

📦 环境准备

Python
# 安装必要的库
pip install pillow

# 导入模块
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os

🎨 方案一：PhotoImage基础应用

Python
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os


class PhotoImageDemo:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("PhotoImage 图片显示")
        self.root.geometry("600x400")

        # 创建显示区域
        self.setup_ui()

    def setup_ui(self):
        """设置用户界面"""
        # 标题
        title_label = tk.Label(
            self.root,
            text="📸 PhotoImage 图片显示示例",
            font=("Arial", 16, "bold")
        )
        title_label.pack(pady=10)

        # 按钮框架
        button_frame = tk.Frame(self.root)
        button_frame.pack(pady=10)

        # 加载GIF按钮
        load_gif_btn = tk.Button(
            button_frame,
            text="加载GIF图片",
            command=self.load_gif_image,
            bg="#4CAF50",
            fg="white",
            font=("Arial", 12)
        )
        load_gif_btn.pack(side=tk.LEFT, padx=5)

        # 图片显示标签
        self.image_label = tk.Label(
            self.root,
            text="请选择GIF图片进行显示",
            bg="#f0f0f0",
            width=50,
            height=15
        )
        self.image_label.pack(pady=20, expand=True, fill=tk.BOTH)

    def load_gif_image(self):
        """加载并显示GIF图片"""
        try:
            # 选择文件
            file_path = filedialog.askopenfilename(
                title="选择GIF图片",
                filetypes=[("GIF files", "*.gif"), ("All files", "*.*")]
            )

            if file_path:
                # 创建PhotoImage对象
                photo = tk.PhotoImage(file=file_path)

                # 显示图片
                self.image_label.configure(image=photo, text="")
                self.image_label.image = photo  # 保持引用，防止垃圾回收

                print(f"✅ 成功加载图片：{os.path.basename(file_path)}")

        except Exception as e:
            messagebox.showerror("错误", f"加载图片失败：{str(e)}")
            print(f"❌ 图片加载失败：{e}")

    def run(self):
        """启动应用"""
        self.root.mainloop()


# 使用示例
if __name__ == "__main__":
    app = PhotoImageDemo()
    app.run()

🔥 方案二：PIL + ImageTk全能方案

Python
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os

class AdvancedImageViewer:
    def __init__(self):
        self.root = tk.Tk()
        self.root.title("🖼️ 高级图片查看器")
        self.root.geometry("800x600")
        
        # 图片相关属性
        self.current_image = None
        self.photo_image = None
        self.scale_factor = 1.0
        
        self.setup_ui()
        
    def setup_ui(self):
        """设置完整的用户界面"""
        # 创建主框架
        main_frame = tk.Frame(self.root)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)
        
        # 工具栏
        self.create_toolbar(main_frame)
        
        # 图片显示区域
        self.create_image_display(main_frame)
        
        # 状态栏
        self.create_status_bar()
        
    def create_toolbar(self, parent):
        """创建工具栏"""
        toolbar = tk.Frame(parent, bg="#2c3e50", height=60)
        toolbar.pack(fill=tk.X, pady=(0, 10))
        toolbar.pack_propagate(False)
        
        # 按钮样式
        btn_style = {
            "font": ("Arial", 10, "bold"),
            "bg": "#3498db",
            "fg": "white",
            "relief": "flat",
            "padx": 15,
            "pady": 5
        }
        
        # 打开图片按钮
        open_btn = tk.Button(
            toolbar,
            text="📁 打开图片",
            command=self.load_image,
            **btn_style
        )
        open_btn.pack(side=tk.LEFT, padx=5, pady=10)
        
        # 缩放按钮组
        scale_frame = tk.Frame(toolbar, bg="#2c3e50")
        scale_frame.pack(side=tk.LEFT, padx=20, pady=10)
        
        tk.Button(
            scale_frame,
            text="🔍+ 放大",
            command=lambda: self.scale_image(1.2),
            **btn_style
        ).pack(side=tk.LEFT, padx=2)
        
        tk.Button(
            scale_frame,
            text="🔍- 缩小", 
            command=lambda: self.scale_image(0.8),
            **btn_style
        ).pack(side=tk.LEFT, padx=2)
        
        tk.Button(
            scale_frame,
            text="↻ 重置",
            command=self.reset_image,
            **btn_style
        ).pack(side=tk.LEFT, padx=2)
        
    def create_image_display(self, parent):
        """创建图片显示区域"""
        # 创建滚动框架
        canvas_frame = tk.Frame(parent, bg="#ecf0f1", relief=tk.SUNKEN, bd=2)
        canvas_frame.pack(fill=tk.BOTH, expand=True)
        
        # 创建Canvas和滚动条
        self.canvas = tk.Canvas(canvas_frame, bg="white")
        v_scrollbar = tk.Scrollbar(canvas_frame, orient=tk.VERTICAL, command=self.canvas.yview)
        h_scrollbar = tk.Scrollbar(canvas_frame, orient=tk.HORIZONTAL, command=self.canvas.xview)
        
        self.canvas.configure(yscrollcommand=v_scrollbar.set, xscrollcommand=h_scrollbar.set)
        
        # 布局滚动条和Canvas
        v_scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
        h_scrollbar.pack(side=tk.BOTTOM, fill=tk.X)
        self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
        
        # 图片标签
        self.image_label = tk.Label(self.canvas, bg="white")
        self.canvas_window = self.canvas.create_window(0, 0, anchor=tk.NW, window=self.image_label)
        
        # 绑定Canvas调整事件
        self.canvas.bind("<Configure>", self.on_canvas_configure)
        
    def create_status_bar(self):
        """创建状态栏"""
        self.status_var = tk.StringVar()
        self.status_var.set("就绪 - 请选择图片文件")
        
        status_bar = tk.Label(
            self.root,
            textvariable=self.status_var,
            relief=tk.SUNKEN,
            anchor=tk.W,
            bg="#34495e",
            fg="white",
            font=("Arial", 9)
        )
        status_bar.pack(side=tk.BOTTOM, fill=tk.X)
        
    def load_image(self):
        """加载图片文件"""
        file_types = [
            ("图片文件", "*.jpg *.jpeg *.png *.bmp *.gif *.tiff"),
            ("JPEG files", "*.jpg *.jpeg"),
            ("PNG files", "*.png"),
            ("BMP files", "*.bmp"),
            ("GIF files", "*.gif"),
            ("所有文件", "*.*")
        ]
        
        file_path = filedialog.askopenfilename(
            title="选择图片文件",
            filetypes=file_types
        )
        
        if file_path:
            try:
                # 使用PIL加载图片
                self.current_image = Image.open(file_path)
                self.scale_factor = 1.0
                
                # 显示图片
                self.display_image()
                
                # 更新状态栏
                width, height = self.current_image.size
                file_name = os.path.basename(file_path)
                self.status_var.set(
                    f"✅ 已加载：{file_name} | 尺寸：{width}×{height} | 格式：{self.current_image.format}"
                )
                
            except Exception as e:
                messagebox.showerror("错误", f"无法加载图片：{str(e)}")
                self.status_var.set(f"❌ 加载失败：{str(e)}")
                
    def display_image(self):
        """显示当前图片"""
        if self.current_image:
            # 计算显示尺寸
            display_image = self.current_image.copy()
            
            if self.scale_factor != 1.0:
                new_width = int(self.current_image.width * self.scale_factor)
                new_height = int(self.current_image.height * self.scale_factor)
                display_image = display_image.resize((new_width, new_height), Image.Resampling.LANCZOS)
            
            # 转换为Tkinter可用格式
            self.photo_image = ImageTk.PhotoImage(display_image)
            
            # 更新标签
            self.image_label.configure(image=self.photo_image)
            self.image_label.image = self.photo_image  # 保持引用
            
            # 更新Canvas滚动区域
            self.canvas.configure(scrollregion=self.canvas.bbox("all"))
            
    def scale_image(self, factor):
        """缩放图片"""
        if self.current_image:
            self.scale_factor *= factor
            # 限制缩放范围
            self.scale_factor = max(0.1, min(5.0, self.scale_factor))
            
            self.display_image()
            
            # 更新状态栏
            current_status = self.status_var.get()
            if "缩放" in current_status:
                base_status = current_status.split(" | 缩放")[0]
            else:
                base_status = current_status
            
            self.status_var.set(f"{base_status} | 缩放：{self.scale_factor:.1f}x")
            
    def reset_image(self):
        """重置图片到原始大小"""
        if self.current_image:
            self.scale_factor = 1.0
            self.display_image()
            
            # 更新状态栏
            current_status = self.status_var.get()
            if "缩放" in current_status:
                base_status = current_status.split(" | 缩放")[0]
                self.status_var.set(base_status)
                
    def on_canvas_configure(self, event):
        """Canvas尺寸变化时的处理"""
        # 更新Canvas窗口大小
        canvas_width = event.width
        canvas_height = event.height
        
        if self.image_label.winfo_reqwidth() < canvas_width:
            self.canvas.itemconfig(self.canvas_window, width=canvas_width)
            
    def run(self):
        """启动应用程序"""
        self.root.mainloop()

# 使用示例
if __name__ == "__main__":
    app = AdvancedImageViewer()
    app.run()

🎯 实用工具函数

Python
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os


class ImageUtils:
    """图片处理工具类"""

    @staticmethod
    def resize_image_to_fit(image, max_width, max_height):
        """
        按比例缩放图片以适应指定尺寸

        Args:
            image: PIL Image对象
            max_width: 最大宽度
            max_height: 最大高度

        Returns:
            缩放后的PIL Image对象
        """
        # 获取原始尺寸
        orig_width, orig_height = image.size

        # 计算缩放比例
        width_ratio = max_width / orig_width
        height_ratio = max_height / orig_height
        scale_ratio = min(width_ratio, height_ratio, 1.0)  # 不放大

        # 计算新尺寸
        new_width = int(orig_width * scale_ratio)
        new_height = int(orig_height * scale_ratio)

        # 返回缩放后的图片
        return image.resize((new_width, new_height), Image.Resampling.LANCZOS)

    @staticmethod
    def create_thumbnail(image_path, size=(100, 100)):
        """
        创建缩略图

        Args:
            image_path: 图片路径
            size: 缩略图尺寸元组 (width, height)

        Returns:
            PIL Image对象
        """
        try:
            with Image.open(image_path) as img:
                # 创建缩略图（保持比例）
                img.thumbnail(size, Image.Resampling.LANCZOS)
                return img.copy()
        except Exception as e:
            print(f"创建缩略图失败：{e}")
            return None

    @staticmethod
    def get_image_info(image_path):
        """
        获取图片信息

        Args:
            image_path: 图片路径

        Returns:
            包含图片信息的字典
        """
        try:
            with Image.open(image_path) as img:
                return {
                    'format': img.format,
                    'mode': img.mode,
                    'size': img.size,
                    'width': img.width,
                    'height': img.height,
                    'file_size': os.path.getsize(image_path)
                }
        except Exception as e:
            return {'error': str(e)}


# 使用示例
def demo_utils():
    """演示工具函数的使用"""

    # 假设有一个图片文件
    image_path = "D:\圆形微信头像-s.png"  # 替换为实际路径

    if os.path.exists(image_path):
        # 获取图片信息
        info = ImageUtils.get_image_info(image_path)
        print("📊 图片信息：", info)

        # 创建缩略图
        thumbnail = ImageUtils.create_thumbnail(image_path, (150, 150))
        if thumbnail:
            print("✅ 缩略图创建成功")

        # 按比例缩放
        original = Image.open(image_path)
        resized = ImageUtils.resize_image_to_fit(original, 400, 300)
        print(f"🔄 缩放结果：{original.size} -> {resized.size}")

if __name__ == "__main__":
    try:
        # 执行演示
        demo_utils()
        print("\n🎉 程序执行完成！")
    except Exception as e:
        print(f"❌ 程序执行出错：{e}")

💎 进阶技巧：动态图片轮播

Python
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageTk
import os


class ImageUtils:
    """图片处理工具类"""

    @staticmethod
    def resize_image_to_fit(image, max_width, max_height):
        """
        按比例缩放图片以适应指定尺寸

        Args:
            image: PIL Image对象
            max_width: 最大宽度
            max_height: 最大高度

        Returns:
            缩放后的PIL Image对象
        """
        # 获取原始尺寸
        orig_width, orig_height = image.size

        # 计算缩放比例
        width_ratio = max_width / orig_width
        height_ratio = max_height / orig_height
        scale_ratio = min(width_ratio, height_ratio, 1.0)  # 不放大

        # 计算新尺寸
        new_width = int(orig_width * scale_ratio)
        new_height = int(orig_height * scale_ratio)

        # 返回缩放后的图片
        return image.resize((new_width, new_height), Image.Resampling.LANCZOS)


def safe_image_display(image_path, label_widget, default_size=(300, 200)):
    """
    安全的图片显示函数

    Args:
        image_path: 图片路径
        label_widget: Tkinter Label组件
        default_size: 默认显示尺寸
    """
    try:
        # 检查文件是否存在
        if not os.path.exists(image_path):
            raise FileNotFoundError(f"图片文件不存在：{image_path}")

        # 检查文件大小（避免加载过大文件）
        file_size = os.path.getsize(image_path)
        if file_size > 50 * 1024 * 1024:  # 50MB限制
            raise ValueError(f"图片文件过大：{file_size / 1024 / 1024:.1f}MB")

        # 加载并显示图片
        image = Image.open(image_path)

        # 调整尺寸
        display_image = ImageUtils.resize_image_to_fit(
            image, default_size[0], default_size[1]
        )

        # 转换并显示
        photo = ImageTk.PhotoImage(display_image)
        label_widget.configure(image=photo, text="")
        label_widget.image = photo  # 保持引用

        print(
            f"✅ 显示图片：{os.path.basename(image_path)} ({image.size[0]}x{image.size[1]} -> {display_image.size[0]}x{display_image.size[1]})")
        return True

    except Exception as e:
        # 显示错误信息
        error_text = f"无法显示图片\n{os.path.basename(image_path)}\n{str(e)}"
        label_widget.configure(image="", text=error_text, fg="red")
        print(f"❌ 图片显示失败：{e}")
        return False


class ImageSlideshow:
    """图片轮播组件"""

    def __init__(self, parent, images_folder, display_size=(800, 600)):  # 🔥 增大默认尺寸
        self.parent = parent
        self.display_size = display_size
        self.current_index = 0
        self.is_playing = False
        self.slide_interval = 3000  # 3秒切换
        self.after_id = None  # 用于取消定时器

        # 加载图片列表
        self.load_images_from_folder(images_folder)

        # 设置UI
        self.setup_slideshow_ui()

    def load_images_from_folder(self, folder_path):
        """从文件夹加载所有图片"""
        self.image_paths = []
        supported_formats = ('.jpg', '.jpeg', '.png', '.bmp', '.gif', '.tiff', '.webp')

        try:
            if not os.path.exists(folder_path):
                print(f"❌ 文件夹不存在：{folder_path}")
                return

            files = os.listdir(folder_path)
            for filename in files:
                if filename.lower().endswith(supported_formats):
                    full_path = os.path.join(folder_path, filename)
                    self.image_paths.append(full_path)

            # 按文件名排序
            self.image_paths.sort()
            print(f"✅ 加载了 {len(self.image_paths)} 张图片")

            if len(self.image_paths) == 0:
                print(f"⚠️ 文件夹中没有找到支持的图片格式：{supported_formats}")

        except Exception as e:
            print(f"❌ 加载图片文件夹失败：{e}")
            self.image_paths = []

    def setup_slideshow_ui(self):
        """设置轮播界面"""
        # 主框架
        main_frame = tk.Frame(self.parent, bg="#f0f0f0")
        main_frame.pack(fill=tk.BOTH, expand=True, padx=15, pady=15)

        # 标题
        title_label = tk.Label(
            main_frame,
            text="🖼️ 大屏图片轮播查看器",
            font=("Arial", 18, "bold"),
            bg="#f0f0f0",
            fg="#2c3e50"
        )
        title_label.pack(pady=(0, 15))

        # 🔥 图片显示区域 - 大幅增加尺寸
        image_frame = tk.Frame(main_frame, relief=tk.RIDGE, bd=3, bg="#34495e")
        image_frame.pack(pady=15, padx=10, fill=tk.BOTH, expand=True)

        # 创建内部框架来居中显示图片
        inner_frame = tk.Frame(image_frame, bg="white")
        inner_frame.pack(fill=tk.BOTH, expand=True, padx=5, pady=5)

        self.image_label = tk.Label(
            inner_frame,
            bg="white",
            text="🖼️ 大屏显示区域\n\n没有找到图片文件\n请点击下方'选择文件夹'按钮\n选择包含图片的文件夹",
            font=("Arial", 14),
            fg="#7f8c8d",
            justify=tk.CENTER
        )
        self.image_label.pack(fill=tk.BOTH, expand=True, padx=20, pady=20)

        # 控制按钮框架
        control_frame = tk.Frame(main_frame, bg="#f0f0f0")
        control_frame.pack(pady=20)

        # 🔥 按钮样式
        btn_style = {
            "font": ("Arial", 12, "bold"),
            "padx": 20,
            "pady": 10,
            "relief": "raised",
            "bd": 3,
            "cursor": "hand2"
        }

        # 控制按钮
        prev_btn = tk.Button(
            control_frame,
            text="⏮️ 上一张",
            command=self.previous_image,
            bg="#e74c3c",
            fg="white",
            activebackground="#c0392b",
            **btn_style
        )
        prev_btn.pack(side=tk.LEFT, padx=8)

        self.play_btn = tk.Button(
            control_frame,
            text="▶️ 播放",
            command=self.toggle_slideshow,
            bg="#27ae60",
            fg="white",
            activebackground="#229954",
            **btn_style
        )
        self.play_btn.pack(side=tk.LEFT, padx=8)

        next_btn = tk.Button(
            control_frame,
            text="⏭️ 下一张",
            command=self.next_image,
            bg="#3498db",
            fg="white",
            activebackground="#2980b9",
            **btn_style
        )
        next_btn.pack(side=tk.LEFT, padx=8)

        # 选择文件夹按钮
        folder_btn = tk.Button(
            control_frame,
            text="📁 选择文件夹",
            command=self.select_folder,
            bg="#9b59b6",
            fg="white",
            activebackground="#8e44ad",
            **btn_style
        )
        folder_btn.pack(side=tk.LEFT, padx=20)

        # 🔥 全屏按钮
        fullscreen_btn = tk.Button(
            control_frame,
            text="🖥️ 全屏",
            command=self.toggle_fullscreen,
            bg="#34495e",
            fg="white",
            activebackground="#2c3e50",
            **btn_style
        )
        fullscreen_btn.pack(side=tk.LEFT, padx=8)

        # 状态信息
        self.status_label = tk.Label(
            main_frame,
            text="就绪 - 图片将以最大 {}x{} 尺寸显示".format(self.display_size[0], self.display_size[1]),
            font=("Arial", 11),
            bg="#f0f0f0",
            fg="#34495e"
        )
        self.status_label.pack(pady=(15, 0))

        # 显示第一张图片
        if self.image_paths:
            self.show_current_image()
            self.update_status()

    def select_folder(self):
        """选择图片文件夹"""
        folder_path = filedialog.askdirectory(title="选择包含图片的文件夹")
        if folder_path:
            # 停止当前播放
            if self.is_playing:
                self.toggle_slideshow()

            # 重新加载图片
            self.current_index = 0
            self.load_images_from_folder(folder_path)

            if self.image_paths:
                self.show_current_image()
            else:
                self.image_label.configure(
                    image="",
                    text="🔍 选择的文件夹中没有找到图片文件\n\n📋 支持格式：\nJPG, PNG, BMP, GIF, TIFF, WEBP\n\n💡 提示：请选择包含图片文件的文件夹",
                    font=("Arial", 12),
                    fg="#e74c3c"
                )

            self.update_status()

    def show_current_image(self):
        """显示当前索引的图片"""
        if self.image_paths and 0 <= self.current_index < len(self.image_paths):
            success = safe_image_display(
                self.image_paths[self.current_index],
                self.image_label,
                self.display_size
            )
            self.update_status()
            return success
        return False

    def next_image(self):
        """切换到下一张图片"""
        if self.image_paths:
            self.current_index = (self.current_index + 1) % len(self.image_paths)
            self.show_current_image()

    def previous_image(self):
        """切换到上一张图片"""
        if self.image_paths:
            self.current_index = (self.current_index - 1) % len(self.image_paths)
            self.show_current_image()

    def toggle_slideshow(self):
        """切换自动播放状态"""
        self.is_playing = not self.is_playing

        if self.is_playing:
            self.play_btn.configure(text="⏸️ 暂停", bg="#e67e22", activebackground="#d68910")
            self.auto_slide()
        else:
            self.play_btn.configure(text="▶️ 播放", bg="#27ae60", activebackground="#229954")
            if self.after_id:
                self.parent.after_cancel(self.after_id)
                self.after_id = None

    def auto_slide(self):
        """自动轮播"""
        if self.is_playing and self.image_paths:
            self.next_image()
            self.after_id = self.parent.after(self.slide_interval, self.auto_slide)

    def toggle_fullscreen(self):
        """切换全屏模式"""
        current_state = self.parent.attributes('-fullscreen')
        self.parent.attributes('-fullscreen', not current_state)

        if not current_state:  # 进入全屏
            # 调整显示尺寸为屏幕尺寸
            screen_width = self.parent.winfo_screenwidth()
            screen_height = self.parent.winfo_screenheight()
            self.display_size = (screen_width - 100, screen_height - 200)  # 留一些边距
        else:  # 退出全屏
            # 恢复默认尺寸
            self.display_size = (800, 600)

        # 重新显示当前图片
        if self.image_paths:
            self.show_current_image()

    def update_status(self):
        """更新状态信息"""
        if self.image_paths:
            current_file = os.path.basename(self.image_paths[self.current_index])
            status_text = f"📸 图片 {self.current_index + 1} / {len(self.image_paths)} - {current_file} | 显示尺寸：{self.display_size[0]}x{self.display_size[1]}"
        else:
            status_text = "没有加载图片"

        self.status_label.configure(text=status_text)


def create_slideshow_demo():
    """创建轮播演示窗口"""
    root = tk.Tk()
    root.title("🎬 Python 大屏图片轮播")

    # 🔥 增大窗口尺寸
    window_width = 1200
    window_height = 900
    root.geometry(f"{window_width}x{window_height}")
    root.configure(bg="#f0f0f0")

    # 设置最小窗口尺寸
    root.minsize(800, 600)

    # 设置窗口居中
    root.update_idletasks()
    x = (root.winfo_screenwidth() // 2) - (window_width // 2)
    y = (root.winfo_screenheight() // 2) - (window_height // 2)
    root.geometry(f"{window_width}x{window_height}+{x}+{y}")

    # 绑定ESC键退出全屏
    def exit_fullscreen(event):
        root.attributes('-fullscreen', False)

    root.bind('<Escape>', exit_fullscreen)

    try:
        # 🔥 创建轮播组件，使用更大的显示尺寸
        current_dir = os.path.dirname(os.path.abspath(__file__))
        slideshow = ImageSlideshow(root, current_dir, (1000, 650))  # 大尺寸显示

        # 添加退出处理
        def on_closing():
            if slideshow.is_playing:
                slideshow.toggle_slideshow()
            root.destroy()

        root.protocol("WM_DELETE_WINDOW", on_closing)

    except Exception as e:
        messagebox.showerror("错误", f"初始化失败：{str(e)}")
        return

    print("🚀 图片轮播器已启动")
    print("💡 提示：")
    print("   - 点击'选择文件夹'来加载图片")
    print("   - 使用'全屏'按钮进入全屏模式")
    print("   - 按ESC键退出全屏")
    print("   - 支持的格式：JPG, PNG, BMP, GIF, TIFF, WEBP")

    root.mainloop()


if __name__ == "__main__":
    create_slideshow_demo()

📚 总结与延伸学习

🎯 核心要点回顾

本文深入讲解了Python Tkinter图片显示的完整解决方案：

1. PhotoImage适用场景：简单的GIF显示和基础需求，无需额外依赖
2. PIL+ImageTk推荐方案：支持全格式、功能强大，是Python开发的首选
3. 实战技巧集成：缓存优化、错误处理、批量操作等生产级特性

🚀 进阶方向建议

• 图像处理算法：学习OpenCV与PIL的结合使用
• 上位机开发：将图片显示集成到工业控制界面
• 性能优化：探索多线程图片加载和内存管理技巧

通过本文的学习，你已经掌握了Python Tkinter图片显示的核心技能。这些技术不仅适用于桌面应用开发，也是构建专业上位机软件的重要基础。继续实践和优化，让你的Python开发技能更上一层楼！

💡 提示：将以上代码保存为.py文件即可直接运行测试。记得安装pillow库：**pip install pillow