Automação com Selenium e Python: Guia | Python Brasil

Introdução

Selenium é a ferramenta mais popular para automatizar navegadores web com Python. Com ele, você pode simular ações de um usuário real: clicar em botões, preencher formulários, navegar entre páginas e extrair dados de sites que dependem de JavaScript para carregar conteúdo.

Neste guia, vamos instalar o Selenium, aprender a interagir com páginas web e criar automações úteis para o dia a dia.

Casos de uso

O Selenium é usado para:

Testes automatizados: testar aplicações web simulando interações do usuário
Web scraping de sites dinâmicos: coletar dados de páginas que usam JavaScript
Automação de tarefas repetitivas: preencher formulários, gerar relatórios, baixar arquivos
Monitoramento: verificar se um site está funcionando corretamente

Instalação

pip install selenium

O Selenium 4 gerencia os drivers automaticamente via Selenium Manager, então não é mais necessário baixar o ChromeDriver manualmente como nas versões anteriores.

Para garantir que o Chrome está instalado:

# Verificar no Linux
google-chrome --version

# Verificar no macOS
/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --version

Primeiro script de automação

Crie automacao.py:

from selenium import webdriver
from selenium.webdriver.common.by import By

# Iniciar o navegador
driver = webdriver.Chrome()

# Acessar um site
driver.get("https://www.python.org")

# Extrair informacoes
titulo = driver.title
print(f"Titulo da pagina: {titulo}")

# Encontrar um elemento
barra_busca = driver.find_element(By.ID, "id-search-field")
barra_busca.send_keys("tutorial")
barra_busca.submit()

# Aguardar e extrair resultados
resultados = driver.find_elements(By.CSS_SELECTOR, "ul.list-recent-events li")
for resultado in resultados:
    print(resultado.text)

# Fechar o navegador
driver.quit()

Execute:

python automacao.py

O Chrome abrirá automaticamente, fará a busca e exibirá os resultados no terminal.

Modo headless (sem interface)

Para rodar sem abrir o navegador (útil em servidores e CI/CD):

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

opcoes = Options()
opcoes.add_argument("--headless=new")
opcoes.add_argument("--no-sandbox")
opcoes.add_argument("--disable-dev-shm-usage")

driver = webdriver.Chrome(options=opcoes)
driver.get("https://www.python.org")
print(driver.title)
driver.quit()

Encontrando elementos

O Selenium oferece vários métodos para localizar elementos na página:

from selenium.webdriver.common.by import By

# Por ID
elemento = driver.find_element(By.ID, "meu-id")

# Por nome
campo = driver.find_element(By.NAME, "email")

# Por classe CSS
botao = driver.find_element(By.CLASS_NAME, "btn-enviar")

# Por seletor CSS
item = driver.find_element(By.CSS_SELECTOR, "div.container > p.destaque")

# Por XPath
titulo = driver.find_element(By.XPATH, "//h1[@class='titulo']")

# Por texto do link
link = driver.find_element(By.LINK_TEXT, "Saiba mais")

# Por texto parcial do link
link = driver.find_element(By.PARTIAL_LINK_TEXT, "Saiba")

# Encontrar multiplos elementos
itens = driver.find_elements(By.CSS_SELECTOR, "li.item")

Interagindo com elementos

from selenium.webdriver.common.keys import Keys

# Clicar
botao = driver.find_element(By.ID, "enviar")
botao.click()

# Digitar texto
campo = driver.find_element(By.NAME, "usuario")
campo.clear()  # Limpar o campo primeiro
campo.send_keys("meu_usuario")

# Teclas especiais
campo.send_keys(Keys.ENTER)
campo.send_keys(Keys.TAB)
campo.send_keys(Keys.CONTROL, "a")  # Ctrl+A (selecionar tudo)

# Selecionar opcoes em dropdown
from selenium.webdriver.support.ui import Select

dropdown = Select(driver.find_element(By.ID, "estado"))
dropdown.select_by_visible_text("Sao Paulo")
dropdown.select_by_value("SP")
dropdown.select_by_index(0)

# Checkbox e radio buttons
checkbox = driver.find_element(By.ID, "aceito-termos")
if not checkbox.is_selected():
    checkbox.click()

Waits: esperando elementos carregarem

Sites modernos carregam conteúdo dinamicamente. Usar time.sleep() é ineficiente. O Selenium oferece waits inteligentes:

Explicit Waits (recomendado)

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Esperar ate 10 segundos pelo elemento aparecer
wait = WebDriverWait(driver, 10)
elemento = wait.until(
    EC.presence_of_element_located((By.ID, "resultado"))
)

# Esperar elemento ficar clicavel
botao = wait.until(
    EC.element_to_be_clickable((By.CSS_SELECTOR, "button.enviar"))
)
botao.click()

# Esperar texto aparecer
wait.until(
    EC.text_to_be_present_in_element((By.ID, "status"), "Concluido")
)

# Esperar elemento desaparecer (loading spinner)
wait.until(
    EC.invisibility_of_element_located((By.CLASS_NAME, "loading"))
)

Implicit Waits

Define um tempo de espera padrão para todos os find_element:

driver.implicitly_wait(10)  # Espera ate 10 segundos

Exemplo prático: preenchendo formulário

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


def preencher_formulario():
    driver = webdriver.Chrome()
    wait = WebDriverWait(driver, 10)

    try:
        driver.get("https://exemplo.com/cadastro")

        # Preencher campos
        wait.until(EC.presence_of_element_located((By.NAME, "nome")))
        driver.find_element(By.NAME, "nome").send_keys("Maria Silva")
        driver.find_element(By.NAME, "email").send_keys("maria@email.com")
        driver.find_element(By.NAME, "telefone").send_keys("11999998888")

        # Selecionar estado
        from selenium.webdriver.support.ui import Select
        estado = Select(driver.find_element(By.NAME, "estado"))
        estado.select_by_visible_text("Sao Paulo")

        # Aceitar termos
        termos = driver.find_element(By.ID, "aceito-termos")
        if not termos.is_selected():
            termos.click()

        # Enviar formulario
        driver.find_element(By.CSS_SELECTOR, "button[type='submit']").click()

        # Verificar sucesso
        mensagem = wait.until(
            EC.presence_of_element_located((By.CLASS_NAME, "sucesso"))
        )
        print(f"Resultado: {mensagem.text}")

    finally:
        driver.quit()


preencher_formulario()

Capturando screenshots

# Screenshot da pagina inteira
driver.save_screenshot("pagina_completa.png")

# Screenshot de um elemento especifico
elemento = driver.find_element(By.ID, "grafico")
elemento.screenshot("grafico.png")

Executando JavaScript

# Scroll ate o final da pagina
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

# Scroll ate um elemento
elemento = driver.find_element(By.ID, "rodape")
driver.execute_script("arguments[0].scrollIntoView();", elemento)

# Alterar valor de um campo oculto
driver.execute_script("document.getElementById('campo-oculto').value = 'valor';")

Gerenciando múltiplas abas e janelas

# Abrir nova aba
driver.execute_script("window.open('https://exemplo.com', '_blank');")

# Trocar para a nova aba
driver.switch_to.window(driver.window_handles[1])

# Voltar para a aba original
driver.switch_to.window(driver.window_handles[0])

# Fechar aba atual
driver.close()

Alternativas ao Selenium

Playwright: mais moderno, suporte nativo a async e múltiplos navegadores
Scrapy: framework completo para web scraping em escala
Pyppeteer: port do Puppeteer para Python

Boas práticas

Use waits explícitos em vez de time.sleep()
Sempre use driver.quit() em um bloco finally para fechar o navegador
Prefira seletores CSS a XPath quando possível (mais legíveis e rápidos)
Use modo headless em ambientes de CI/CD
Respeite os termos de uso dos sites que você automatiza
Adicione delays razoáveis entre ações para não sobrecarregar servidores

Conclusão

Selenium é uma ferramenta versátil para automação de navegadores com Python. Seja para testes automatizados, web scraping de sites dinâmicos ou automação de tarefas repetitivas, o Selenium oferece controle total sobre o navegador. Com waits inteligentes e boas práticas, você pode criar automações robustas que funcionam de forma confiável em diferentes cenários.