[Copiar y Pegar OK] ¡Redimensionamiento de Imágenes en Lote con Python! Guía de Pillow para Creadores Web

¡Hola! Esta es una serie en la que yo, alguien que no sabía absolutamente nada de programación hace solo unos meses, explico las cosas desde la perspectiva de un principiante, basándome en mi experiencia de lanzar sitios web con la ayuda de la IA.

Cuando administras un sitio web, una tarea que surge casi siempre es el "redimensionamiento de imágenes". Miniaturas para artículos de blog, imágenes de productos, piezas para tu portafolio... redimensionar una gran cantidad de imágenes una por una, sinceramente, es para desanimarse, ¿verdad? Yo también pasé por eso.

Pero no te preocupes. ¡Con Python, puedes automatizar esa tediosa tarea en solo unos segundos! En este artículo, explicaré detalladamente cómo crear una "herramienta de redimensionamiento de imágenes en lote" que incluso los principiantes en programación pueden usar de inmediato con solo copiar y pegar, compartiendo también los puntos en los que me atasqué. ¡Espero que puedas experimentar esa emoción de "¡Funciona!".

El objetivo de hoy: ¡Automaticemos el tedioso redimensionamiento de imágenes!

Si lees este artículo hasta el final, podrás crear un script de Python que haga lo siguiente:

• Toma todas las imágenes de una carpeta especificada
• Mantiene la relación de aspecto (proporción entre alto y ancho) para que no se deformen
• Las redimensiona en lote a un ancho específico
• Y las guarda automáticamente en otra carpeta

Por ejemplo, podrás convertir instantáneamente docenas de fotos acumuladas en una carpeta a imágenes con un ancho de 800px para tu blog. ¡Ya no necesitarás abrir tu software de edición de imágenes una y otra vez!

¡Adiós al trabajo manual! Una imagen del procesamiento en lote con Python.

Preparación: Instalar Pillow y organizar las carpetas de trabajo

Antes de lanzar el hechizo mágico, empecemos con la preparación. No es difícil, ¡así que no te preocupes!

1. ¿Qué es Pillow? ¿Y cómo se instala?

La protagonista que usaremos hoy es una biblioteca llamada "Pillow". Una biblioteca es como una "caja de herramientas" llena de funciones útiles. Pillow es, por así decirlo, la "caja de herramientas maestra para el procesamiento de imágenes" en Python.

Pillow es una biblioteca extremadamente confiable utilizada por muchos desarrolladores en todo el mundo. Tiene una amplia documentación en su sitio web oficial, por lo que puedes usarla con total confianza. (Referencia: Documentación Oficial de Pillow)

La instalación es tan simple como ejecutar la siguiente línea en el Símbolo del sistema (Windows) o en la Terminal (Mac).

pip install Pillow

2. Prepara tus carpetas de trabajo

A continuación, vamos a preparar una carpeta para nuestro trabajo. ¡Esto es muy importante! Para que no se arme un desorden, separemos la carpeta para las imágenes originales y la carpeta donde se guardarán las imágenes redimensionadas.

Primero, crea una carpeta llamada "resize_tool" en un lugar que te guste, como el escritorio. Luego, crea estos tres elementos dentro de ella:

1. Carpeta input_images: Aquí es donde pondrás las imágenes originales que quieres redimensionar.
2. Carpeta output_images: Aquí es donde se guardarán las imágenes redimensionadas.
3. resize.py: Este es el archivo de código Python que vamos a escribir.

La estructura se verá así:

resize_tool/
├── input_images/
│   ├── photo1.jpg
│   ├── photo2.png
│   └── ... (pon aquí las imágenes que quieres redimensionar)
│
├── output_images/
│   └── (al principio estará vacía)
│
└── resize.py (crearemos este archivo)

¡Y eso es todo para la preparación! Adelante, pon algunas de tus imágenes en la carpeta `input_images`.

Parte práctica: ¡Escribamos el código Python!

¡Finalmente llegó la hora de programar! Abre el archivo `resize.py` en tu editor de texto y escribámoslo juntos. Descompondré y explicaré cada parte del proceso, así que sígueme sin prisas.

Paso 1: Preparar las herramientas necesarias (módulos)

Primero, al inicio de nuestro programa, necesitamos declarar "vamos a usar estas herramientas". Invoquemos a nuestro maestro del procesamiento de imágenes, "Pillow", y a nuestro experto en el manejo de carpetas y archivos, "os".

import os
from PIL import Image

from PIL import Image significa "De la biblioteca Pillow (PIL), queremos usar específicamente la funcionalidad para manejar Imágenes". Piensa en ello como un conjuro estándar.

Paso 2: Indicar la ubicación de las carpetas

A continuación, necesitamos decirle al programa dónde se encuentran la "carpeta de entrada" y la "carpeta de salida" que acabamos de crear.

# Especificar las rutas de las carpetas de entrada y salida
input_dir = 'input_images'
output_dir = 'output_images'

Con esto, el programa ahora entiende que debe leer imágenes de `input_images` y escribir los resultados en `output_images`.

Paso 3: Intentar redimensionar una sola imagen (El proceso básico)

Intentar hacerlo todo de golpe puede ser confuso, así que primero veamos el flujo del proceso para redimensionar "una sola imagen". Esto será la base de todo lo demás.

1. Abrir la imagen (`Image.open`)
2. Redimensionarla al nuevo tamaño (`.resize`)
3. Guardarla con un nuevo nombre (`.save`)

En código, se vería algo así. (※ Aún no ejecutaremos este código).

# (Esto es solo un ejemplo conceptual)
# 1. Abrir la imagen
img = Image.open('input_images/photo1.jpg')

# 2. Redimensionar a 800px de ancho (la altura es arbitraria por ahora)
resized_img = img.resize((800, 600))

# 3. Guardarla con otro nombre
resized_img.save('output_images/resized_photo1.jpg')

Paso 4: Procesar secuencialmente todas las imágenes de la carpeta de entrada

Una vez que entiendes lo básico, es hora del plato fuerte. Hagamos que Python tome los archivos de la carpeta `input_images` uno por uno y les aplique el proceso de redimensionamiento en secuencia. Este tipo de "procesamiento en bucle" es la especialidad de la programación.

Usando `os.listdir(input_dir)` obtienes una lista con los nombres de los archivos dentro de la carpeta especificada. Usaremos esto para repetir el proceso hasta que no queden archivos.

# Recorrer todos los archivos en el directorio de entrada
for filename in os.listdir(input_dir):
    # Aquí irá el proceso de redimensionamiento para cada archivo
    print(f"Procesando {filename}...")

La sintaxis for ... in ...: sirve para crear un bucle. Toma la lista de nombres de archivo obtenida de `os.listdir(input_dir)`, los va poniendo uno por uno en una variable llamada `filename` y ejecuta el bloque de código que hay dentro.

[¡Muy importante!] El error en el que caí y su solución

Puede parecer que avanzamos sin problemas, pero justo aquí hay una trampa en la que los principiantes suelen caer. ¡Y yo caí de lleno!

Problema: ¡El script intenta procesar archivos que no son imágenes y da error!

Si usas Mac, se generan automáticamente archivos ocultos como `.DS_Store`. También podrías poner tus propios archivos de texto para notas en la carpeta. El código anterior intenta procesar "todos" los archivos de la carpeta, por lo que dará un error cuando intente abrir un archivo que no es una imagen.

Solución: Procesar únicamente archivos de imagen (como .jpg, .png, etc.)

Añadiremos una condición para comprobar el final del nombre del archivo (la extensión) y solo realizar la operación de redimensionamiento si es un formato de imagen. Esto evitará errores de forma fiable.

for filename in os.listdir(input_dir):
    # Comprobar si la extensión del archivo es .jpg, .jpeg, .png o .gif
    if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
        # ¡Si la lógica de redimensionamiento está aquí, solo se procesarán los archivos de imagen!
        print(f"Procesando archivo de imagen: {filename}")
    else:
        # Si no es un archivo de imagen, omitirlo
        print(f"Omitiendo archivo no-imagen: {filename}")
        continue # Pasar a la siguiente iteración del bucle

La clave es convertir el nombre del archivo a minúsculas con .lower() antes de comprobar el final con .endswith(). Esto permite manejar extensiones en mayúsculas, como `FOTO.JPG`.

Consejo avanzado ①: Redimensiona con elegancia manteniendo la relación de aspecto

Bueno, ya dominamos lo básico del redimensionamiento, pero si simplemente especificas un tamaño, la imagen se estirará vertical u horizontalmente y se verá deformada. Para mantener la calidad de tu sitio web, ¡conservar la relación de aspecto es fundamental!

El cálculo es sencillo. Solo necesitamos calcular la relación de aspecto de la imagen original y luego computar automáticamente la nueva altura basándonos en el nuevo ancho.

1. Decidir el ancho objetivo (ej: 800px)
2. Obtener las dimensiones originales de la imagen (ancho y alto)
3. Calcular la relación de aspecto con alto_original / ancho_original
4. Determinar la nueva altura con nuevo_alto = ancho_objetivo * relacion_de_aspecto

Traducido a código, se ve así:

# (Este código va dentro del bucle)

# Abrir la imagen original
img = Image.open(os.path.join(input_dir, filename))
width, height = img.size # Obtener el ancho y alto originales

# Especificar el nuevo ancho
new_width = 800
# Calcular la nueva altura manteniendo la relación de aspecto
new_height = int(new_width * height / width)

# ¡Ejecutar el redimensionamiento!
resized_img = img.resize((new_width, new_height))

Usar os.path.join() es una forma segura de combinar correctamente el nombre de la carpeta y el del archivo para cualquier sistema operativo. Además, como el resultado del cálculo podría ser un decimal, lo convertimos a un entero con `int()`.

Consejo avanzado ②: ¡Para creadores web! Añadamos una marca de agua

A veces quieres añadir una "marca de agua" (watermark) para evitar que tu trabajo o las imágenes de tu blog se usen sin permiso. Con Pillow, hasta eso es fácil. Añadamos un aviso de copyright u otro texto a la imagen redimensionada.

Para esto, usaremos la funcionalidad de dibujo de Pillow, `ImageDraw`.

# (Esto se procesa después de redimensionar)
from PIL import ImageDraw, ImageFont

# ... después del proceso de redimensionamiento ...

# Crear un objeto de dibujo
draw = ImageDraw.Draw(resized_img)

# Especificar texto y fuente
text = "© Tu Nombre"
# Puedes especificar una fuente instalada en tu PC. Si no se encuentra, se usa una por defecto.
try:
    font = ImageFont.truetype("arial.ttf", 24)
except IOError:
    font = ImageFont.load_default()

# Calcular la posición para dibujar el texto (abajo a la derecha)
text_width, text_height = draw.textbbox((0, 0), text, font=font)[2:4]
position = (resized_img.width - text_width - 10, resized_img.height - text_height - 10)

# Dibujar el texto
draw.text(position, text, font=font, fill=(255, 255, 255, 128)) # Blanco semitransparente

# Guardar la imagen después de esto

Puede parecer un poco complejo, pero el flujo es simplemente "activar modo de dibujo", "decidir el texto y la posición" y "escribirlo". El último `128` en `fill=(255, 255, 255, 128)` representa la opacidad, que puedes ajustar entre 0 (totalmente transparente) y 255 (totalmente opaco).

[Truco de IA] ¿Cómo pedirle a una IA que escriba este código?

Las IAs como ChatGPT y Gemini han sido indispensables en mi viaje de aprendizaje de la programación. Si les das las instrucciones correctas (prompts), pueden generar código como este en un instante.

Por ejemplo, intenta pedirlo así:

Por favor, crea un script en Python para redimensionar imágenes en lote usando la biblioteca Pillow. # Requisitos - Lee imágenes de una carpeta llamada `input_images`. - Procesa solo archivos con extensiones `.jpg`, `.jpeg` y `.png`. - Redimensiona todas las imágenes a un ancho de 800px manteniendo la relación de aspecto. - Guarda las imágenes redimensionadas en una carpeta llamada `output_images` con sus nombres de archivo originales. - Por favor, muestra un mensaje en la consola que indique qué archivo se está procesando.

La clave es transmitir lo que quieres hacer de forma concreta y clara en una lista. La IA es una asistente excelente, así que cuanto más precisas sean tus instrucciones, más preciso será el código que te devuelva.

El gran final: El script completo y funcional para redimensionar imágenes en lote

¡La espera ha terminado! Aquí está la versión final del script de Python que combina todos los elementos que hemos discutido. Cópialo y pégalo en `resize.py`, pon algunas imágenes en tu carpeta `input_images` y ejecútalo.

Para ejecutarlo, navega a la carpeta `resize_tool` en tu símbolo del sistema o terminal y simplemente escribe `python resize.py`.

import os
from PIL import Image

def resize_images_in_folder(input_dir, output_dir, new_width=800):
    """
    Función para redimensionar en lote las imágenes de una carpeta especificada,
    manteniendo la relación de aspecto.
    
    :param input_dir: Ruta a la carpeta de entrada
    :param output_dir: Ruta a la carpeta de salida
    :param new_width: El ancho objetivo de las imágenes redimensionadas en píxeles
    """
    # Crear la carpeta de salida si no existe
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
        print(f"Carpeta creada: '{output_dir}'")

    # Lista de extensiones de imagen compatibles
    supported_formats = ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff')

    # Obtener todos los archivos del directorio de entrada
    filenames = os.listdir(input_dir)
    
    if not filenames:
        print(f"La carpeta de entrada '{input_dir}' está vacía.")
        return

    print(f"Iniciando proceso... Número de archivos a comprobar: {len(filenames)}")

    # Procesar cada archivo
    for filename in filenames:
        # Comprobar si el formato del archivo es compatible
        if not filename.lower().endswith(supported_formats):
            print(f"--- Omitiendo: {filename} (tipo de archivo no compatible)")
            continue

        try:
            # Crear rutas completas de entrada и salida
            input_path = os.path.join(input_dir, filename)
            output_path = os.path.join(output_dir, filename)

            # Abrir la imagen
            with Image.open(input_path) as img:
                # Obtener ancho y alto originales de la imagen
                width, height = img.size
                
                # Calcular la nueva altura manteniendo la relación de aspecto
                aspect_ratio = height / width
                new_height = int(new_width * aspect_ratio)

                # Redimensionar la imagen
                resized_img = img.resize((new_width, new_height))
                
                # Guardar la imagen (manteniendo la transparencia para PNGs)
                if filename.lower().endswith('.png'):
                    resized_img.save(output_path, 'PNG')
                else:
                    # Para JPEGs, puedes especificar la calidad (por defecto es 75)
                    # Convertir a RGB para evitar errores al guardar JPEGs
                    resized_img.convert('RGB').save(output_path, 'JPEG', quality=90)

                print(f"✓ Éxito: Se redimensionó {filename} a {new_width}x{new_height}")

        except Exception as e:
            print(f"× Error: Ocurrió un problema al procesar {filename} - {e}")

    print("Todo el procesamiento ha finalizado.")

# --- Aquí es donde comienza la ejecución del programa ---
if __name__ == "__main__":
    # Especificar las rutas de las carpetas de entrada y salida
    INPUT_FOLDER = 'input_images'
    OUTPUT_FOLDER = 'output_images'
    
    # Especificar el ancho objetivo para el redimensionamiento
    TARGET_WIDTH = 800

    # Ejecutar la función
    resize_images_in_folder(INPUT_FOLDER, OUTPUT_FOLDER, TARGET_WIDTH)

Abre la carpeta `output_images`. Si ves una fila entera de imágenes redimensionadas, ¡ha sido un gran éxito!

Para terminar: La programación es la magia que resuelve lo "tedioso"

Esta vez, usamos Python y Pillow para crear una herramienta que automatiza la aburrida tarea de redimensionar imágenes. La programación puede sonar difícil, pero cuando tienes un objetivo como "resolver un problema tedioso que me rodea", de repente se convierte en algo divertido y en una habilidad muy práctica.

Me sentiría muy feliz si este artículo te lleva a tu propia experiencia de éxito de "¡Lo logré!" y se convierte en tu primer paso en el mundo de la programación. ¡Por favor, experimenta con diferentes configuraciones y modifícalo para convertirlo en tu propia herramienta personal!