Você sabe usar o Selenium com Python? Aprenda a utilizar essa poderosa biblioteca para web scraping e automatize qualquer tarefa na internet!
Caso prefira esse conteúdo no formato de vídeo-aula, assista ao vídeo abaixo ou acesse o nosso canal do YouTube!
Para receber por e-mail o(s) arquivo(s) utilizados na aula, preencha:
Não vamos te encaminhar nenhum tipo de SPAM! A Hashtag Treinamentos é uma empresa preocupada com a proteção de seus dados e realiza o tratamento de acordo com a Lei Geral de Proteção de Dados (Lei n. 13.709/18). Qualquer dúvida, nos contate.
O que você vai ver hoje?
Selenium com Python – Automatize Qualquer Tarefa na Web
O Selenium é uma ferramenta de automação para navegadores web que permite controlar ações no navegador com Python. Ele é amplamente usado para testes de software, web scraping de dados e automação de tarefas online.
Nesta aula, vou te mostrar em detalhes as funcionalidades dessa biblioteca essencial e como podemos utilizar o Selenium com Python para que você crie suas próprias automações na web.
Veremos desde a instalação e configuração até a automação de ações complexas no navegador, com exemplos práticos e um passo a passo para que você aprenda tudo o que precisa para começar a usar essa biblioteca.
O que é o Selenium?
O Selenium é uma importante biblioteca do Python capaz de criar automações para navegadores, permitindo que você controle e interaja com sites de forma programada e eficiente.
As principais funcionalidades e usos do Selenium com Python incluem:
- Automação de Testes: O Selenium é usado para criar testes automatizados que simulam as ações dos usuários no site. Com ele, é possível verificar se os elementos da página estão funcionando corretamente em diferentes navegadores e ambientes.
- Raspagem de Dados: Para extrair informações de sites que não oferecem APIs, o Selenium pode simular ações humanas, permitindo a coleta de dados em sites dinâmicos.
- Execução de Ações no Navegador: Ele permite que você simule cliques, preencha formulários, role páginas, navegue entre abas e realize outras ações. Isso é útil para automatizar tarefas repetitivas na internet.
Um ponto muito interessante do Selenium é que ele permite realizar essas ações e tarefas enquanto você continua utilizando o computador para outras atividades.
Lembre-se sempre de consultar a documentação oficial do Selenium para entender melhor todos os comandos e funcionalidades disponíveis.
Ao trabalhar com Selenium, é importante que você tenha pelo menos um conhecimento básico sobre HTML e CSS. Recomendo que você veja a nossa aula: Aprenda HTML e CSS Rapidamente.
O Papel do WebDriver
O Selenium se conecta a um navegador (como Chrome, Firefox, etc.) por meio de um componente chamado WebDriver. O WebDriver é responsável por controlar o navegador e responder aos comandos do código Python.
Nas versões mais recentes, o Selenium já gerencia automaticamente o WebDriver necessário para o navegador escolhido, simplificando a configuração e o uso.
Navegadores Recomendados
Os navegadores mais recomendados para usar com o Selenium são o Google Chrome e o Firefox, devido à sua maior compatibilidade com essa ferramenta.
Como instalar o Selenium?
Para instalar o Selenium, basta rodar o comando pip install selenium no terminal do seu editor de código.
Feito isso, a biblioteca estará disponível para uso.
Começando uma Automação – Abrindo o Navegador com Selenium
Para começar a criar uma automação básica com Selenium, primeiro precisamos abrir o navegador. Vamos importar o webdriver a partir da biblioteca selenium e utilizá-lo para inicializar o Chrome através do comando webdriver.Chrome().
Cada navegador terá seu método específico para ser aberto. Por exemplo, o Firefox pode ser inicializado com o comando webdriver.Firefox().
from selenium import webdriver # abrir o navegador navegador = webdriver.Chrome()
Observe que este código apenas abre o navegador sem acessar nenhum site específico.
Caso você esteja utilizando o Jupyter Notebook, ou a extensão dele no VS Code para trabalhar com um arquivo .ipynb, verá o navegador aberto como na imagem acima.
Se estiver trabalhando com um arquivo Python .py, você verá apenas a janela do navegador abrindo rapidamente e sendo encerrada.
Para evitar que o navegador feche imediatamente após a abertura, podemos usar a biblioteca time e o comando time.sleep() para visualizar o processo.
from selenium import webdriver import time # abrir o navegador navegador = webdriver.Chrome() time.sleep(10)
Repare que no seu navegador, será exibida a mensagem: O Chrome está sendo controlado por um software de teste automatizado.
Caso esteja trabalhando em um editor de código online, ele pode não ter navegadores instalados. Nesses ambientes, pode ser necessário utilizar uma máquina virtual ou outra ferramenta específica para rodar o Selenium.
Acessando um Site e Maximizando o Navegador
Após abrir o navegador, uma das primeiras ações que vamos automatizar é acessar algum site. Para esta aula, utilizaremos o próprio site da Hashtag.
Para acessar um site com Selenium, utilizamos o método get(), passando como argumento o endereço desejado. Além disso, podemos usar o método maximize_window() para maximizar a janela do navegador, deixando-a em tela cheia.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
time.sleep(10)
Você notará que o Selenium aguarda o carregamento completo da página antes de executar a próxima ação, como a de colocar o site em tela cheia.
Algumas informações em sites e páginas da internet são carregadas de forma dinâmica. Nesses casos, será necessário fornecer um comando específico para que o Selenium aguarde antes de tentar interagir com esses elementos.
Identificando e Interagindo com Elementos Web
Toda página da internet é estruturada a partir de elementos HTML. Esses elementos são os componentes de uma página web e podem ser identificados pelo ID, classe, texto ou outras características.
Para visualizar essas informações, abra a página que deseja interagir usando o Selenium, clique com o botão direito do mouse e selecione Inspecionar.
Isso abrirá a janela com as ferramentas do programado/desenvolvedor.
No Chrome, por exemplo, você também pode acessar clicando nos três pontos no canto superior direito do navegador, indo em Mais ferramentas e selecionando Ferramentas do programador. Ou pode simplesmente utilizar o atalho Ctrl + Shift + I.
Você pode personalizar onde essa janela ficará na tela, clicando nos três pontos no canto superior direito da janela do desenvolvedor.
Ao abrir essa ferramenta, verá a opção Select an element in the page to inspect it, localizada no canto superior esquerdo da janela (ícone com um quadrado pontilhado e uma seta).
Essa ferramenta permite selecionar um elemento na página e verificar suas propriedades dentro da janela de desenvolvedor. Basta clicar sobre o elemento desejado, que ele será destacado no código HTML da página.
Por exemplo, vamos clicar no botão “Quero Aprender” presente na página da Hashtag.
Repare que esse botão é estruturado por uma tag <a>, que possui atributos específicos como href, target e class. É por meio dessas informações que podemos identificar e selecionar um elemento dentro de uma página usando o Selenium.
Para que o Selenium encontre um elemento, utilizamos o método find_element ou find_elements.
A diferença entre eles é que o primeiro encontra apenas uma correspondência na página, enquanto o segundo retorna uma lista com todas as correspondências.
O find_element precisa de duas informações para localizar o elemento: o tipo de atributo que estamos utilizando e o valor associado a ele.
Nesse caso, vamos localizar o botão a partir da classe dele, usando o atributo class name e o valor atribuído, “botao-verde”.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
time.sleep(10)Dessa forma, estamos salvando uma referência ao botão na variável botao_verde. A partir disso, podemos interagir com o elemento, como clicá-lo, obter seu texto ou aplicar outros métodos do Selenium.
Por exemplo, para clicar no botão, usamos o método click().
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
# clicar em um elemento
botao_verde.click()
time.sleep(10)
Além de CLASS_NAME, podemos utilizar outros seletores disponíveis no find_element(), como ID, XPATH, LINK_TEXT, entre outros. Você pode conferir todos os tipos de seletores na documentação oficial.
Os seletores mais comuns e utilizados são ID, CLASS_NAME e XPATH. Nesta aula, vamos focar no uso de ID e CLASS_NAME.
Encontrando Vários Elementos
Como vimos no exemplo anterior, utilizando o método find_element() e o método click(), conseguimos localizar e clicar no botão “Quero aprender”.
O problema dessa abordagem é que, em alguns casos, a mesma classe pode estar atribuída a mais de um elemento na página.
Nesse cenário, o find_element() selecionará apenas a primeira ocorrência dessa classe, o que pode não ser ideal para a sua automação.
Para resolver isso, você pode tentar encontrar um identificador único daquele elemento, como um ID, ou utilizar o método find_elements(), que retornará uma lista com todos os elementos encontrados na página que correspondem ao seletor especificado.
Essa lista pode conter zero ou mais elementos, dependendo da presença deles na página.
Como exemplo, vamos criar uma automação para clicar no botão “Assinatura” na barra de navegação do site da Hashtag.
Esse botão possui o class name header__titulo. No entanto, os demais botões dentro da barra de navegação também possuem essa mesma classe. Portanto, precisaremos buscar todos os elementos na página que tenham a classe header__titulo.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# encontrar varios elementos
lista_botoes = navegador.find_elements("class name", "header__titulo")
time.sleep(10)Com os elementos encontrados e armazenados na lista_botoes, podemos percorrer essa lista com um loop for. Para cada elemento presente na lista, verificaremos se o texto contém a palavra “Assinatura”.
Para verificar o texto de um elemento, basta acessarmos o atributo text correspondente.
Quando o botão com a palavra “Assinatura” for localizado, utilizaremos o método click() do Selenium e encerraremos o loop com um comando break para parar a busca.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# encontrar varios elementos
lista_botoes = navegador.find_elements("class name", "header__titulo")
for botao in lista_botoes:
if "Assinatura" in botao.text:
botao.click()
break
time.sleep(10)Ao executar esse código, nossa automação abrirá a página da Hashtag, localizará todos os elementos que possuem a classe header__titulo e clicará naquele que contém o texto “Assinatura”.
Automatizando Navegação Entre Abas
Muitas vezes, as automações precisam alternar entre várias abas do navegador durante a execução, e o Selenium oferece uma maneira prática de fazer isso utilizando o método switch_to.window.
Vamos usar o código do exemplo anterior, que clicava no botão “Quero Aprender”. Quando esse código é executado, o navegador fica com duas abas abertas.
O Selenium mantém o controle das abas abertas no navegador por meio do atributo window_handles. Esse atributo retorna uma lista de identificadores de todas as janelas ou abas abertas na sessão atual do navegador automatizado.
Podemos armazenar essa lista em uma variável e utilizar o método switch_to.window() para alternar entre as abas. Para isso, basta passar como argumento a variável que armazena o atributo window_handles e o índice da aba que desejamos acessar.
A primeira janela ou aba aberta corresponderá ao índice [0], e a última ao índice [-1], ou ao índice correspondente, dependendo de quantas abas existirem.
Vamos aplicar esse método para selecionar a segunda aba aberta após o clique no botão “Quero Aprender” e, dentro dela, acessar a página do Curso de Python Impressionador.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
# clicar em um elemento
botao_verde.click()
# selecionar uma aba
abas = navegador.window_handles
navegador.switch_to.window(abas[1])
# navegar para um site diferente
navegador.get("https://www.hashtagtreinamentos.com/curso-python")
time.sleep(10)Ao executar esse código, o Selenium irá abrir a página inicial, clicar no botão “Quero Aprender”, alternar para a segunda aba aberta, e então navegar até a página do Curso de Python Impressionador.
Preenchendo um Formulário com o Selenium
Agora, vamos aprender a preencher um formulário com o Selenium, localizando os campos, preenchendo as informações necessárias e enviando o formulário no final.
Neste exemplo, utilizaremos o formulário disponível na página do Curso Completo de Python Impressionador da Hashtag.
Esse formulário possui três campos: Primeiro Nome, E-mail e WhatsApp. O primeiro passo será encontrar esses campos utilizando o método find_element().
Para localizar cada campo individualmente, podemos usar um identificador único, como o ID do campo.
Com os elementos localizados, usaremos o método send_keys() do Selenium para preencher os campos com as informações necessárias.
O send_keys() simula a entrada de texto nos campos, permitindo que o Selenium preencha as informações como se estivéssemos digitando no teclado.
Após preencher todos os campos, vamos enviar o formulário clicando no botão “Quero acessar as informações do curso”.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
# clicar em um elemento
botao_verde.click()
# selecionar uma aba
abas = navegador.window_handles
navegador.switch_to.window(abas[1])
# navegar para um site diferente
navegador.get("https://www.hashtagtreinamentos.com/curso-python")
# escrever em um campo/formulario
navegador.find_element("id", "firstname").send_keys("Lira")
navegador.find_element("id", "email").send_keys("[email protected]")
navegador.find_element("id", "phone").send_keys("2199999999")
navegador.find_element("id", "_form_2475_submit").click()
time.sleep(10)Ao executar esse código, o Selenium irá abrir o navegador, acessar a página da Hashtag, clicar no botão “Quero Aprender”, alternar para a aba do Curso de Python e preencher o formulário com as informações fornecidas.
No entanto, se você tentar executar o código, pode perceber que o botão “Quero acessar as informações do curso” não será clicado corretamente, e um erro aparecerá no terminal.
Esse erro ocorre porque o Selenium não conseguiu clicar no botão, o que geralmente acontece quando o elemento não está visível na tela.
No Selenium, é importante que o elemento com o qual você deseja interagir esteja visível na tela do navegador.
Executando Comandos JavaScript com Selenium – Scroll na Tela
Para solucionar o problema de visibilidade do botão, podemos utilizar o método execute_script do Selenium, que permite executar comandos JavaScript diretamente no navegador.
Utilizando o comando scrollIntoView, podemos rolar a página até um elemento específico, garantindo que ele esteja visível. É possível, ainda, centralizar o elemento na tela usando o parâmetro block: ‘center’.
Para identificar o elemento desejado, utilizamos o argumento especial arguments[0], que se refere ao primeiro parâmetro passado para o método execute_script(). Nesse caso, será o elemento botao_quero_clicar.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
# clicar em um elemento
botao_verde.click()
# selecionar uma aba
abas = navegador.window_handles
navegador.switch_to.window(abas[1])
# navegar para um site diferente
navegador.get("https://www.hashtagtreinamentos.com/curso-python")
# escrever em um campo/formulario
navegador.find_element("id", "firstname").send_keys("Lira")
navegador.find_element("id", "email").send_keys("[email protected]")
navegador.find_element("id", "phone").send_keys("2199999999")
botao_quero_clicar = navegador.find_element("id", "_form_2475_submit")
# dar scroll (colocar um elemento na tela)
navegador.execute_script("arguments[0].scrollIntoView({block: 'center'})",
botao_quero_clicar)
time.sleep(10)Esse código exibe o botão na tela, mas se tentarmos clicar logo em seguida, ainda receberemos um erro. Isso ocorre porque o Selenium tenta clicar antes que o JavaScript tenha completado a rolagem.
Para evitar esse problema, é necessário esperar até que o botão esteja clicável.
Manipulando Sites Dinâmicos – Aguardando um Elemento Carregar
Além do nosso exemplo, em que precisamos aguardar o scroll para que o elemento fique visível, muitos sites carregam conteúdo de forma dinâmica. Em ambos os casos, é necessário esperar até que o elemento seja carregado antes de interagir com ele.
Podemos fazer isso de duas formas. A primeira seria configurar uma espera manual utilizando a biblioteca time, adicionando um time.sleep() antes de executar o clique no elemento.
No entanto, o Selenium oferece uma abordagem mais completa e eficaz: a classe WebDriverWait e o método expected_conditions. Vamos importar e aplicar essas duas funcionalidades ao nosso código.
Com elas, podemos configurar o Selenium para aguardar até que um elemento específico esteja disponível para interação.
A classe WebDriverWait é responsável por definir a espera personalizada para o navegador, enquanto o método expected_conditions determina o critério dessa espera.
Vamos começar criando uma instância da classe WebDriverWait, chamada espera, atribuindo a ela a instância atual do navegador e o tempo limite em segundos.
Por exemplo, ao definirmos 10 segundos, o Selenium aguardará esse tempo até que a condição seja atendida. Se o elemento não estiver pronto dentro desse prazo, o Selenium gerará uma exceção de tempo esgotado.
Para definir o critério de espera, usaremos expected_conditions com o alias EC. Vamos aplicar a espera até que o elemento botao_quero_clicar esteja clicável (element_to_be_clickable).
O comando until continuará verificando a condição em intervalos curtos até que o elemento esteja clicável ou que o tempo limite seja alcançado.
from selenium import webdriver
import time
# abrir o navegador
navegador = webdriver.Chrome()
# acessar um site
navegador.get("https://www.hashtagtreinamentos.com/")
# colocar o navegador em tela cheia
navegador.maximize_window()
# selecionar um elemento na tela
botao_verde = navegador.find_element("class name", "botao-verde")
# clicar em um elemento
botao_verde.click()
# selecionar uma aba
abas = navegador.window_handles
navegador.switch_to.window(abas[1])
# navegar para um site diferente
navegador.get("https://www.hashtagtreinamentos.com/curso-python")
# escrever em um campo/formulario
navegador.find_element("id", "firstname").send_keys("Lira")
navegador.find_element("id", "email").send_keys("[email protected]")
navegador.find_element("id", "phone").send_keys("2199999999")
botao_quero_clicar = navegador.find_element("id", "_form_2475_submit")
# dar scroll (colocar um elemento na tela)
navegador.execute_script("arguments[0].scrollIntoView({block: 'center'})",
botao_quero_clicar)
# opcao 2 - espera dinâmica
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
espera = WebDriverWait(navegador, 10)
espera.until(EC.element_to_be_clickable(botao_quero_clicar))
botao_quero_clicar.click()
time.sleep(10)Executando esse código, o processo de automação será realizado corretamente: acessando a página do curso, preenchendo o formulário, aguardando o botão estar clicável e enviando o formulário.
Conclusão – Selenium com Python – Automatize Qualquer Tarefa na Web
O Selenium é uma ferramenta poderosa para automação de tarefas na web, trazendo ao Python a capacidade de simular ações de usuários em navegadores.
Na aula de hoje, eu te mostrei o passo a passo da configuração e do uso do Selenium com Python, criando uma automação simples de envio de formulário para que você conheça um pouco das funcionalidades dessa ferramenta.
Com essa biblioteca, no entanto, você pode realizar diversas outras tarefas no navegador, como testes, raspagem de dados e até mesmo a automação de processos complexos de forma intuitiva e escalável.
Se você quiser aprender como criar uma automação completa com Selenium, do zero e passo a passo, confira nosso minicurso gratuito: Minicurso de Automação com Python
Hashtag Treinamentos
Para acessar outras publicações de Python, clique aqui!
Posts mais recentes de Python
- Automação Whatsapp Web com com Python: Guia Completo para Enviar Mensagens com PyWhatKit
Você já imaginou programar o envio de mensagens com uma automação WhatsApp Web com poucas linhas de código? - Como Gerar Relatórios em PDF com Python (Passo a Passo) Neste tutorial, você vai aprender a transformar dados de uma planilha do Excel em PDFs personalizados usando Python!
- API no Python – O que é e Como Criar Sua Própria API?
Nessa aula vamos te mostrar o o que é uma API no Python e como você pode criar sua própria API para seus projetos!
Posts mais recentes da Hashtag Treinamentos
- Funções do Copilot no Excel que vão TRANSFORMAR seu Trabalho Você sabia que o Copilot no Excel faz muito mais do que tirar dúvidas? Essa IA pode criar fórmulas, formatar dados e até gerar gráficos por você.
- 30 Frases de Small Talk em Inglês: Tenha Conversas Naturais em Inglês Domine o Small Talk em Inglês com 30 frases práticas para conversas rápidas. Aprenda a pronúncia, os usos e dicas para falar com mais naturalidade.
- Fórmula CALCULATE no Power BI [+Erro Comum e Como Evitar] Nessa aula vamos te mostrar como utilizar a fórmula CALCULATE no Power BI para que possa fazer seus cálculos com filtros específicos!
Expert em conteúdos da Hashtag Treinamentos. Auxilia na criação de conteúdos de variados temas voltados para aqueles que acompanham nossos canais.