[Pode Copiar e Colar] Redimensionamento de Imagens em Massa com Python! Um Guia de Pillow para Criadores Web

Olá! Esta é uma série de artigos onde eu, que não sabia nada de programação até alguns meses atrás, explico tudo da perspectiva de um iniciante, com base na minha experiência de criar sites com a ajuda da IA.

Quando se gere um site, uma tarefa que surge quase sempre é o "redimensionamento de imagens". Miniaturas para publicações de blog, imagens de produtos, trabalhos para o portfólio... redimensionar um grande número de imagens uma a uma, sinceramente, é de desanimar, não é? Eu também já passei por isso.

Mas não se preocupe. Com o Python, pode automatizar essa tarefa aborrecida em apenas alguns segundos! Neste artigo, vou explicar cuidadosamente como criar uma "ferramenta de redimensionamento de imagens em massa" que até os iniciantes em programação podem usar imediatamente, apenas copiando e colando, partilhando também os pontos onde tive dificuldades. Quero muito que sinta aquela emoção de "Funcionou!".

O nosso objetivo: Vamos automatizar o aborrecido redimensionamento de imagens!

Ao ler este artigo até ao fim, será capaz de criar um script em Python que faz o seguinte:

• Pega em todas as imagens de uma pasta especificada
• Mantém a proporção da imagem para que não fique distorcida
• Redimensiona em massa para uma largura especificada
• E guarda automaticamente noutra pasta

Por exemplo, poderá converter instantaneamente dezenas de fotos acumuladas numa pasta em imagens com uma largura de 800px para o seu blog. Acabou-se o ter de abrir o software de edição de imagem vezes sem conta!

Adeus ao trabalho manual! Uma imagem do processamento em massa com Python.

Preparação: Instalar o Pillow e configurar as pastas de trabalho

Antes de lançarmos o feitiço mágico, vamos começar pela preparação. Não é difícil, por isso, não se preocupe!

1. O que é o Pillow? E como se instala?

A estrela principal que vamos usar hoje é uma biblioteca chamada "Pillow". Uma biblioteca é como uma "caixa de ferramentas" cheia de funções úteis. O Pillow é, por assim dizer, a "caixa de ferramentas mestre para o processamento de imagens" em Python.

O Pillow é uma biblioteca extremamente fiável, usada por muitos programadores em todo o mundo. Tem uma vasta documentação no seu site oficial, pelo que pode usá-la com toda a confiança. (Referência: Documentação Oficial do Pillow)

A instalação é tão simples como executar a seguinte linha na sua Linha de Comandos (Windows) ou no Terminal (Mac).

pip install Pillow

2. Prepare as suas pastas de trabalho

A seguir, vamos preparar uma pasta para o nosso trabalho. Isto é muito importante! Para que as coisas não fiquem desorganizadas, vamos separar a pasta para as imagens originais da pasta onde serão guardadas as imagens redimensionadas.

Primeiro, crie uma pasta chamada "resize_tool" num local à sua escolha, como o ambiente de trabalho. Depois, crie estes três itens dentro dela:

1. Pasta input_images: É aqui que vai colocar as imagens originais que quer redimensionar.
2. Pasta output_images: É aqui que as imagens redimensionadas serão guardadas.
3. resize.py: Este é o ficheiro de código Python que vamos escrever.

A estrutura ficará assim:

resize_tool/
├── input_images/
│   ├── photo1.jpg
│   ├── photo2.png
│   └── ... (coloque aqui as imagens que quer redimensionar)
│
├── output_images/
│   └── (estará vazia no início)
│
└── resize.py (vamos criar este ficheiro)

E a preparação está feita! Vá em frente e coloque algumas das suas imagens na pasta `input_images`.

Parte prática: Vamos escrever o código Python!

Finalmente, chegou a hora de programar! Abra o ficheiro `resize.py` no seu editor de texto e vamos escrevê-lo juntos. Vou decompor e explicar cada parte do processo, por isso, acompanhe-me sem pressa.

Passo 1: Preparar as ferramentas necessárias (módulos)

Primeiro, no início do nosso programa, precisamos de declarar "vamos usar estas ferramentas". Vamos chamar o nosso mestre do processamento de imagens, "Pillow", e o nosso especialista em lidar com pastas e ficheiros, "os".

import os
from PIL import Image

from PIL import Image significa "Da biblioteca Pillow (PIL), queremos usar especificamente a funcionalidade para lidar com Imagens". Pense nisto como um encantamento padrão.

Passo 2: Indicar a localização das pastas

A seguir, precisamos de dizer ao programa onde se encontram a "pasta de entrada" e a "pasta de saída" que acabámos de criar.

# Especificar os caminhos das pastas de entrada e saída
input_dir = 'input_images'
output_dir = 'output_images'

Com isto, o programa agora entende que deve ler as imagens de `input_images` e escrever os resultados em `output_images`.

Passo 3: Tentar redimensionar uma única imagem (O processo básico)

Tentar fazer tudo de uma vez pode ser confuso, por isso, primeiro vamos ver o fluxo do processo para redimensionar "uma única imagem". Isto será a base para tudo o resto.

1. Abrir a imagem (`Image.open`)
2. Redimensioná-la para o novo tamanho (`.resize`)
3. Guardá-la com um novo nome (`.save`)

Em código, ficaria algo assim. (※ Ainda não vamos executar este código).

# (Isto é apenas um exemplo conceitual)
# 1. Abrir a imagem
img = Image.open('input_images/photo1.jpg')

# 2. Redimensionar para 800px de largura (a altura é arbitrária por agora)
resized_img = img.resize((800, 600))

# 3. Guardá-la com outro nome
resized_img.save('output_images/resized_photo1.jpg')

Passo 4: Processar sequencialmente todas as imagens da pasta de entrada

Assim que entender o básico, é hora do prato principal. Vamos fazer com que o Python retire os ficheiros da pasta `input_images` um a um e lhes aplique o processo de redimensionamento em sequência. Este tipo de "processamento em ciclo" (loop) é a especialidade da programação.

Usando `os.listdir(input_dir)` obtém-se uma lista com os nomes dos ficheiros dentro da pasta especificada. Vamos usar isto para repetir o processo até não restarem ficheiros.

# Percorrer todos os ficheiros no diretório de entrada
for filename in os.listdir(input_dir):
    # O processo de redimensionamento para cada ficheiro virá aqui
    print(f"A processar {filename}...")

A sintaxe for ... in ...: serve para criar um ciclo. Ela pega na lista de nomes de ficheiros obtida de `os.listdir(input_dir)`, coloca-os um a um numa variável chamada `filename` e executa o bloco de código que está dentro.

[Crucial] A armadilha em que caí e como a resolver

Pode parecer que estamos a progredir sem problemas, mas é aqui que reside uma armadilha comum para iniciantes. E eu caí nela em cheio!

Problema: O script tenta processar ficheiros que não são imagens e dá erro!

Se estiver a usar um Mac, ele gera automaticamente ficheiros ocultos como `.DS_Store`. Também pode acontecer ter colocado os seus próprios ficheiros de texto para notas na pasta. O código anterior tenta processar "todos" os ficheiros na pasta, por isso, vai gerar um erro quando tentar abrir um ficheiro que não é uma imagem.

Solução: Processar apenas ficheiros de imagem (como .jpg, .png, etc.)

Vamos adicionar uma condição para verificar o final do nome do ficheiro (a extensão) e apenas realizar a operação de redimensionamento se for um formato de imagem. Isto irá prevenir erros de forma fiável.

for filename in os.listdir(input_dir):
    # Verificar se a extensão do ficheiro é .jpg, .jpeg, .png ou .gif
    if filename.lower().endswith(('.jpg', '.jpeg', '.png', '.gif')):
        # Se a lógica de redimensionamento estiver aqui, apenas os ficheiros de imagem serão alvo!
        print(f"A processar o ficheiro de imagem: {filename}")
    else:
        # Se não for um ficheiro de imagem, ignorá-lo
        print(f"A ignorar o ficheiro não-imagem: {filename}")
        continue # Passar para a próxima iteração do ciclo

A chave é converter o nome do ficheiro para minúsculas com .lower() antes de verificar o final com .endswith(). Isto permite-lhe lidar com extensões em maiúsculas, como `FOTO.JPG`.

Dica Avançada 1: Redimensione com elegância, mantendo a proporção

Ok, já dominamos o básico do redimensionamento, mas se apenas especificar um tamanho, a imagem ficará esticada vertical ou horizontalmente e com um aspeto distorcido. Para manter a qualidade do seu site, preservar a proporção é essencial!

O cálculo é simples. Só precisamos de calcular a proporção da imagem original e, em seguida, calcular automaticamente a nova altura com base na nova largura.

1. Decidir a largura alvo (ex: 800px)
2. Obter as dimensões originais da imagem (largura e altura)
3. Calcular a proporção com altura_original / largura_original
4. Determinar a nova altura com nova_altura = largura_alvo * proporcao

Traduzido para código, fica assim:

# (Este código vai para dentro do ciclo)

# Abrir a imagem original
img = Image.open(os.path.join(input_dir, filename))
width, height = img.size # Obter a largura e altura originais

# Especificar a nova largura
new_width = 800
# Calcular a nova altura mantendo a proporção
new_height = int(new_width * height / width)

# Executar o redimensionamento!
resized_img = img.resize((new_width, new_height))

Usar os.path.join() é uma forma segura de combinar corretamente o nome da pasta e do ficheiro para qualquer sistema operativo. Além disso, como o resultado do cálculo pode ser um decimal, convertemo-lo para um número inteiro com `int()`.

Dica Avançada 2: Para criadores web! Vamos adicionar uma marca d'água

Às vezes, queremos adicionar uma "marca d'água" (watermark) para evitar que o nosso trabalho ou as imagens do nosso blog sejam usadas sem permissão. Com o Pillow, até isso é fácil. Vamos adicionar um aviso de direitos de autor ou outro texto à imagem redimensionada.

Para isso, vamos usar a funcionalidade de desenho do Pillow, o `ImageDraw`.

# (Isto é processado após o redimensionamento)
from PIL import ImageDraw, ImageFont

# ... após o processo de redimensionamento ...

# Criar um objeto de desenho
draw = ImageDraw.Draw(resized_img)

# Especificar texto e fonte
text = "© Seu Nome"
# Pode especificar uma fonte instalada no seu PC. Se não for encontrada, é usada uma fonte padrão.
try:
    font = ImageFont.truetype("arial.ttf", 24)
except IOError:
    font = ImageFont.load_default()

# Calcular a posição para desenhar o texto (canto inferior direito)
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)

# Desenhar o texto
draw.text(position, text, font=font, fill=(255, 255, 255, 128)) # Branco semitransparente

# Guardar a imagem depois disto

Pode parecer um pouco complexo, mas o fluxo é simplesmente "mudar para o modo de desenho", "decidir o texto e a posição" e "escrevê-lo". O último `128` em `fill=(255, 255, 255, 128)` representa a opacidade, que pode ajustar entre 0 (totalmente transparente) e 255 (totalmente opaco).

[Dica de IA] Como pedir a uma IA para escrever este código?

IAs como o ChatGPT e o Gemini têm sido indispensáveis na minha jornada de programação. Se lhes der as instruções certas (prompts), elas podem gerar código como este num instante.

Por exemplo, tente pedir assim:

Por favor, crie um script em Python para redimensionar imagens em massa usando a biblioteca Pillow. # Requisitos - Ler imagens de uma pasta chamada `input_images`. - Processar apenas ficheiros com as extensões `.jpg`, `.jpeg` e `.png`. - Redimensionar todas as imagens para uma largura de 800px, mantendo a proporção. - Guardar as imagens redimensionadas numa pasta chamada `output_images` com os seus nomes de ficheiro originais. - Por favor, mostre uma mensagem na consola a indicar qual o ficheiro que está a ser processado.

A chave é transmitir o que quer fazer de forma concreta e clara, numa lista. A IA é uma excelente assistente, por isso, quanto mais precisas forem as suas instruções, mais preciso será o código que ela irá devolver.

Juntando tudo: O script completo e pronto a executar para redimensionar imagens em massa

A espera acabou! Aqui está a versão final do script Python que combina todos os elementos que discutimos. Copie e cole isto no `resize.py`, coloque algumas imagens na sua pasta `input_images` e execute-o.

Para o executar, navegue até à pasta `resize_tool` na sua linha de comandos ou terminal e simplesmente escreva `python resize.py`.

import os
from PIL import Image

def resize_images_in_folder(input_dir, output_dir, new_width=800):
    """
    Função para redimensionar em massa as imagens numa pasta especificada,
    mantendo a proporção.
    
    :param input_dir: Caminho para a pasta de entrada
    :param output_dir: Caminho para a pasta de saída
    :param new_width: A largura alvo das imagens redimensionadas em píxeis
    """
    # Criar a pasta de saída se não existir
    if not os.path.exists(output_dir):
        os.makedirs(output_dir)
        print(f"Pasta criada: '{output_dir}'")

    # Lista de extensões de imagem suportadas
    supported_formats = ('.jpg', '.jpeg', '.png', '.gif', '.bmp', '.tiff')

    # Obter todos os ficheiros do diretório de entrada
    filenames = os.listdir(input_dir)
    
    if not filenames:
        print(f"A pasta de entrada '{input_dir}' está vazia.")
        return

    print(f"A iniciar o processamento... Número de ficheiros a verificar: {len(filenames)}")

    # Processar cada ficheiro
    for filename in filenames:
        # Verificar se o formato do ficheiro é suportado
        if not filename.lower().endswith(supported_formats):
            print(f"--- A ignorar: {filename} (tipo de ficheiro não suportado)")
            continue

        try:
            # Criar caminhos completos de entrada e saída
            input_path = os.path.join(input_dir, filename)
            output_path = os.path.join(output_dir, filename)

            # Abrir a imagem
            with Image.open(input_path) as img:
                # Obter a largura e altura originais da imagem
                width, height = img.size
                
                # Calcular a nova altura mantendo a proporção
                aspect_ratio = height / width
                new_height = int(new_width * aspect_ratio)

                # Redimensionar a imagem
                resized_img = img.resize((new_width, new_height))
                
                # Guardar a imagem (mantendo a transparência para PNGs)
                if filename.lower().endswith('.png'):
                    resized_img.save(output_path, 'PNG')
                else:
                    # Para JPEGs, pode especificar a qualidade (o padrão é 75)
                    # Converter para RGB para evitar erros ao guardar JPEGs
                    resized_img.convert('RGB').save(output_path, 'JPEG', quality=90)

                print(f"✓ Sucesso: {filename} redimensionada para {new_width}x{new_height}.")

        except Exception as e:
            print(f"× Erro: Ocorreu um problema ao processar {filename} - {e}")

    print("Todo o processamento foi concluído.")

# --- É aqui que a execução do programa começa ---
if __name__ == "__main__":
    # Especificar os caminhos das pastas de entrada e saída
    INPUT_FOLDER = 'input_images'
    OUTPUT_FOLDER = 'output_images'
    
    # Especificar a largura alvo para o redimensionamento
    TARGET_WIDTH = 800

    # Executar a função
    resize_images_in_folder(INPUT_FOLDER, OUTPUT_FOLDER, TARGET_WIDTH)

Abra a pasta `output_images`. Se vir uma fila inteira de imagens redimensionadas, foi um grande sucesso!

Para terminar: A programação é a magia que resolve o que é "aborrecido"

Desta vez, usámos o Python e o Pillow para criar uma ferramenta que automatiza a tarefa aborrecida de redimensionar imagens. A programação pode parecer difícil, mas quando se tem um objetivo como "resolver um problema aborrecido que me rodeia", de repente torna-se divertido e uma habilidade muito prática.

Ficaria muito feliz se este artigo o levasse à sua própria experiência de sucesso de "Consegui!" e se tornasse o seu primeiro passo no mundo da programação. Por favor, experimente diferentes configurações e modifique-o para o transformar na sua própria ferramenta pessoal!