<jupyter_start><jupyter_text>1. MEU PRIMEIRO SCRAPING  1.1. Introdução  *Web Scraping* é o termo utilizado para definir a prática de coletar automaticamente informações na Internet. Isto é feito, geralmente, por meio de programas que simulam a navegação humana na Web.  1.2. Ambiente e bibliotecas Utilizaremos em nosso treinamento o navegador Google Chrome<jupyter_code>import bs4
import urllib.request as urllib_request
import pandas

print("BeautifulSoup ->", bs4.__version__)
print("urllib ->", urllib_request.__version__)
print("pandas ->", pandas.__version__)<jupyter_output>BeautifulSoup -> 4.9.3
urllib -> 3.8
pandas -> 1.2.4<jupyter_text>1.3. Meu primeiro scraping<jupyter_code>from urllib.request import urlopen
from bs4 import BeautifulSoup
url = 'https://alura-site-scraping.herokuapp.com/hello-world.php'
response = urlopen(url)
html = response.read()
soup = BeautifulSoup(html, 'html.parser')
soup.find('h1', id = "hello-world").get_text()
soup.find('h1', {'class': 'sub-header'}).get_text()<jupyter_output><empty_output><jupyter_text>--- 2. OBTENDO E TRATANDO O CONTEÚDO DE UM           2.1. Entendendo a web   2.2. Obtendo o conteúdo HTML de um site  urllib.request https://docs.python.org/3/library/urllib.html<jupyter_code>from urllib.request import urlopen

url = 'https://alura-site-scraping.herokuapp.com/index.php'
response = urlopen(url)
html = response.read()
html<jupyter_output><empty_output><jupyter_text>https://docs.python.org/3/library/urllib.request.htmlurllib.request.Request<jupyter_code>from urllib.request import Request, urlopen
from urllib.error import URLError , HTTPError
#Utilizando Tratamento de erros com Headers, URLError, HTTPError,Request
url = 'https://www.alura123.com.br/'
#Header da pagina aonde quer fazer a busca
headers ={'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/93.0.4577.63 Safari/537.36'}
#Tratamento de erro
try:
    req = Request(url, headers = headers)
    response = urlopen(req)
    print(response.read())

except HTTPError as e:
    #.Status mostra status do erro, .reason é a razão do erro
    print(e.status, e.reason)
    
except URLError as e:
    #Erro ao digitar URL, não tem o status somente a razão do erro
    print(e.reason)
#Lembrar de sempre utilizar na ordem HTTPError e após isso o URLError
#Exercicio 
"""
Assinale a alternativa que indica as modificações necessárias para conseguirmos ter acesso ao conteúdo HTML do site da Alura.
from urllib.request import Request, urlopen

url = 'https://www.alura.com.br'

req = Request(url)
response = urlopen(req)
response.read()
""""
from urllib.request import Request, urlopen

url = 'https://www.alura.com.br'
headers = {'User-Agent': 'Chrome/76.0.3809.100'}

req = Request(url, headers = headers)
response = urlopen(req)
response.read()<jupyter_output><empty_output><jupyter_text>2.3. Tratamento de string<jupyter_code>from urllib.request import urlopen
from bs4 import BeautifulSoup
url = 'https://alura-site-scraping.herokuapp.com/index.php'

response = urlopen(url)
html = response.read()
html<jupyter_output><empty_output><jupyter_text>Convertando o tipo bytes para string<jupyter_code>#tipo de dados
type(html)
#Tratando Strings
html = html.decode('utf-8')
#tipo de dados
type(html)<jupyter_output><empty_output><jupyter_text>Eliminando os caracteres de tabulação, quebra de linha etc.<jupyter_code>html.split()
#Juntar tudo com um espaço em branco
" ".join(html.split())<jupyter_output><empty_output><jupyter_text>Eliminando os espaços em branco entre as TAGS<jupyter_code>" ".join(html.split()).replace('> <', '><')<jupyter_output><empty_output><jupyter_text>Função de tratamento de strings<jupyter_code>def trata_html (input):
    return " ".join(input.split()).replace('> <', '><')
html = trata_html(html)
html<jupyter_output><empty_output><jupyter_text>--- 3. INTRODUÇÃO AO BEAUTIFULSOUP  3.1. HTML da nossa página **HTML** (*HyperText Markup Language*) é uma linguagem de marcação composta por **tags** que deteminam o papel que cada parte do documento vai assumir. As **tags** são formadas pelo seu nome e atributos. Os atributos servem para configurar e também modificar as características padrões de uma **tag**. Estrutura básica```html                    Alura Motors                            Alura            Cursos de Tecnologia            Você vai estudar, praticar, discutir e aprender.            Clique aqui            ````````` - determina o início do documento.`````` - cabeçalho. Contém informações e configurações do documento.`````` - é o corpo do documento, onde todo o conteúdo é colocado. Esta é a parte visível em um navegador. Tags mais comuns`````` - define uma divisão da página. Pode ser formatada de diversas maneiras.```, , , , , ``` - marcadores de títulos.`````` - marcador de parágrafo.`````` - hiperlink.`````` - exibição de imagens.`````` - definição de tabelas.```, ``` - definição de listas.  3.2. Criando um objeto BeautifulSoup  https://www.crummy.com/software/BeautifulSoup/ Sobre parser ver: https://www.crummy.com/software/BeautifulSoup/bs4/doc/parser-installation<jupyter_code>from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'html.parser')
soup
print(soup.prettify()) #Visualização melhorada<jupyter_output><!DOCTYPE html>
<html lang="pt-br">
 <head>
  <meta charset="utf-8"/>
  <meta content="width=device-width, initial-scale=1, shrink-to-fit=no" name="viewport"/>
  <title>
   Alura Motors
  </title>
  <link crossorigin="anonymous" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css" integrity="<KEY>" rel="stylesheet"/>
  <link href="css/styles.css" media="all" rel="stylesheet"/>
  <script src="https://code.jquery.com/jquery-1.12.4.js">
  </script>
  <script crossorigin="anonymous" integrity="<KEY>" src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/js/bootstrap.min.js">
  </script>
  <script src="js/index.js" type="text/javascript">
  </script>
 </head>
 <body cz-shortcut-listen="true">
  <noscript>
   You need to enable JavaScript to run this app.
  </noscript>
  <div id="root">
   <header>
    <nav class="navbar navbar-inverse" st[...]<jupyter_text>3.3. Acessando tags<jupyter_code>soup.html.head.title #Pegando o Titulo do site
soup.html.div.div.div.ul
soup.h5
#Exercicio
from bs4 import BeautifulSoup

html = """
    <html>
        <body>
            <div id="container-a">
                <h1>Título A</h1>
                <h2 class="ref-a">Sub título A</h2>
                <p>Texto de conteúdo A</p>
                <div id="container-a-1">
                    <h1>Título A.1</h1>
                    <h2 class="ref-a">Sub título A.1</h2>
                    <p>Texto de conteúdo A.1</p>
                </div>
            </div>
        </body>
    </html>
"""
soup = BeautifulSoup(html, 'html.parser')
soup
soup.div.div.h2 #Resolução<jupyter_output><empty_output><jupyter_text>3.4. Acessando o conteúdo das tags<jupyter_code>soup.html.head.title
soup.title.getText()
soup.get_text()
#Exercicio
soup = BeautifulSoup('<h1>Título 1</h1><h2>Título 1.1</h2><p>Conteúdo</p>')
soup.get_text(' # ')
#Exercicio
'''
Considerando o código acima e as novas informações sobre o método get_text(), 
assinale a alternativa que indica o código que retorna todo o conteúdo das tags no seguinte formato:
'Título A || Sub título A || Texto de conteúdo A || Título A.1 || Sub título A.1 || Texto de conteúdo A.1
'''
from bs4 import BeautifulSoup

html2 = """
    <html>
        <body>
            <div id="container-a">
                <h1>Título A</h1>
                <h2 class="ref-a">Sub título A</h2>
                <p>Texto de conteúdo A</p>
                <div id="container-a-1">
                    <h1>Título A.1</h1>
                    <h2 class="ref-a">Sub título A.1</h2>
                    <p>Texto de conteúdo A.1</p>
                </div>
            </div>
        </body>
    </html>
"""
soup = BeautifulSoup(html2, 'html.parser')
soup
#Resolução
soup.get_text(separator=' || ', strip=True)<jupyter_output><empty_output><jupyter_text>3.5. Acessando os atributos de uma tag<jupyter_code>soup = BeautifulSoup(html, 'html.parser')
soup.img
soup.img.attrs #Attrs transforma em dicionario
soup.img.attrs.keys() #Chaves dos dicionarios
soup.img.attrs.values() #Valores dos dicionarios
soup.img['class'] #Mostra somente o atributo class da img
soup.img.get('src') #Pega aonde esta a img<jupyter_output><empty_output><jupyter_text>--- 4. PESQUISANDO COM O BEAUTIFULSOUP  4.1. Os métodos *find()* e *findAll()* -  *find(tag, attributes, recursive, text, **kwargs)*-  *findAll(tag, attributes, recursive, text, limit, **kwargs)* https://www.crummy.com/software/BeautifulSoup/bs4/doc/find https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-all> **Observação:**> - *findAll()* também pode ser utilizado como *find_all()*  Método *find()*<jupyter_code>soup.find('img')<jupyter_output><empty_output><jupyter_text>Método *findAll()*<jupyter_code>soup = BeautifulSoup(html, 'html.parser')
soup.findAll('img', limit = 1) #Limit tu limita quandos elementos você quer<jupyter_output><empty_output><jupyter_text>Comando equivalente ao método *find()*<jupyter_code>soup.findAll('img', limit = 1)[0] #Limit tu limita quandos elementos você quer + posição<jupyter_output><empty_output><jupyter_text>Atalho para o método *findAll()*<jupyter_code>soup('img')<jupyter_output><empty_output><jupyter_text>Passando listas de TAGs<jupyter_code>soup.findAll(['img','h1','h2','h4','div']) #Uma lista de pesquisa, nomeando os elementos que você deseja<jupyter_output><empty_output><jupyter_text>Utilizando o argumento *attributes*<jupyter_code>soup.findAll('p',{"class": "txt-value"}) #Passar os argumentos em formato de dicionario<jupyter_output><empty_output><jupyter_text>Buscando por conteúdo de uma TAG<jupyter_code>soup.findAll('p', text = "Belo Horizonte - MG") #Pode ser usado string ao inves de text<jupyter_output><empty_output><jupyter_text>Utilizando diretamente os atributos<jupyter_code>soup.findAll('img', alt='Foto')
for item in soup.findAll('img', alt='Foto'):
        print(item.get('src')) #Pegando os links das imagens<jupyter_output>https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/lamborghini-aventador/lamborghini-aventador-2932196__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/bmw-m2/bmw-m2-2970882__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/alfa/alfa-1823056__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/puech/puech-4055386__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/lamborghini-murcielago/lamborghini-murcielago-2872974__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/aston-martin/aston-martin-2977916__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/tvr/tvr-2943925__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/excalibur/excalibur-2916730__340.jpg
https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/mclaren/mclaren-2855240__340.jpg
htt[...]<jupyter_text>Cuidado com o atributo "class"<jupyter_code>soup.findAll('p', class_= "txt-value") #Class não pode ser utilizado pois é do Python, utilizar o _ na frente<jupyter_output><empty_output><jupyter_text>Obtendo todo o conteúdo de texto de uma página<jupyter_code>soup.findAll(text=True)

#Exercicio
from bs4 import BeautifulSoup

html2 = """
    <html>
        <body>
            <div id="container-a">
                <h1>Título A</h1>
                <h2 class="ref-a">Sub título A</h2>
                <p>Texto de conteúdo A</p>
            </div>
            <div id="container-b">
                <h1>Título B</h1>
                <h2 class="ref-b">Sub título B</h2>
                <p>Texto de conteúdo B</p>
            </div>
        </body>
    </html>
"""
soup = BeautifulSoup(html2, 'html.parser')
soup.find('h2', {'class': 'ref-b'}) #Out<h2 class="ref-b">Sub título B</h2>
soup.find('div',{'id': 'container-b'}).p.get_text() #Out'Texto de conteúdo B'
soup.findAll('h1') #Out[<h1>Título A</h1>, <h1>Título B</h1>]<jupyter_output><empty_output><jupyter_text>4.2. Outros métodos de pesquisa -  *findParent(tag, attributes, text, **kwargs)*-  *findParents(tag, attributes, text, limit, **kwargs)* https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-parents-and-find-parent> **Observação:**> - *findParent()* e *findParents()* também podem ser utilizados como *find_parent()* e *find_parents()*, respectivamente.----  *findNextSibling(tag, attributes, text, **kwargs)*-  *findNextSiblings(tag, attributes, text, limit, **kwargs)*-  *findPreviousSibling(tag, attributes, text, **kwargs)*-  *findPreviousSiblings(tag, attributes, text, limit, **kwargs)* https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-next-siblings-and-find-next-sibling https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-previous-siblings-and-find-previous-sibling> **Observação:**> - *findNextSibling()*, *findNextSiblings()*, *findPreviousSibling()* e *findPreviousSiblings()* também podem ser utilizados como *find_next_sibling()*, *find_next_siblings()*, *find_previous_sibling()* e *find_previous_siblings()*, respectivamente.----  *findNext(tag, attributes, text, **kwargs)*-  *findAllNext(tag, attributes, text, limit, **kwargs)*-  *findPrevious(tag, attributes, text, **kwargs)*-  *findAllPrevious(tag, attributes, text, limit, **kwargs)* https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-all-next-and-find-next https://www.crummy.com/software/BeautifulSoup/bs4/doc/find-all-previous-and-find-previous> **Observação:**> - *findNext()*, *findAllNext()*, *findPrevious* e *findAllPrevious* também podem ser utilizados como *find_next()*, *find_all_next()*, *find_previous()* e *find_all_previous()*, respectivamente.  HTML de exemplo para ilustrar a utilização dos métodos de pesquisa do BeautifulSoup  --- Resultado                         Título A            Sub título A            Texto de conteúdo A                            Título B            Sub título B            Texto de conteúdo B<jupyter_code>soup.findAll(text=True)
html_teste = '''<html>
    <body>
        <div id="container-a">
            <h1>Título A</h1>
            <h2>Subtítulo A</h2>
            <p>Texto de conteúdo A</p>
        </div>
    </body>
</html>'''<jupyter_output><empty_output><jupyter_text>Tratamentos para a string HTML<jupyter_code>html_teste
html_teste = trata_html (html_teste)
html_teste<jupyter_output><empty_output><jupyter_text>Criando o objeto BeautifulSoup<jupyter_code>soup = BeautifulSoup(html_teste, 'html.parser')
soup<jupyter_output><empty_output><jupyter_text>Parents<jupyter_code>soup.find('h2')
soup.find('h2').find_parent('div') #find_parent é o "pai" da função chamada no inicio pelo find
soup.find('h2').find_parents() 
soup.findAll('h2')
for item in soup.findAll('h2'): #Printando os parents 
    print(item.find_parent('div'))<jupyter_output><div id="container-a"><h1>Título A</h1><h2>Subtítulo A</h2><p>Texto de conteúdo A</p></div><jupyter_text>Siblings<jupyter_code>soup.find('h2').findNextSibling() #Acha o próximo "irmão" do argumento passado pelo find
soup.find('h2').findPreviousSibling() #Acha o "irmão" anterior do argumento passado pelo find
soup.find('p').findPreviousSiblings() #Acha os "irmãos" anteriores do argumento passado pelo find<jupyter_output><empty_output><jupyter_text>Next e Previous<jupyter_code>soup.find('h1').findNext()
soup.find('h1').findPrevious()
#Exercicio
from bs4 import BeautifulSoup

html_3 = """
    <html>
        <body>
            <div id="container-a">
                <h1>Título A</h1>
                <h2 class="ref-a">Sub título A</h2>
                <p>Curso de</p>
                <p>Web</p>
                <p>Scraping</p>
                <p>com Python</p>
            </div>
        </body>
    </html>
"""
soup = BeautifulSoup(html_3, 'html.parser')
soup.find('p').findNextSiblings('p', limit=2)#Resolução<jupyter_output><empty_output><jupyter_text>5. WEB SCRAPING DO SITE ALURA MOTORS - OBTENDO OS DADOS DE UM ANÚNCIO  5.1. Identificando e selecionando os dados no HTML  Obtendo o HTML e criando o objeto BeautifulSoup<jupyter_code>response = urlopen('https://alura-site-scraping.herokuapp.com/index.php')
html = response.read().decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')
soup<jupyter_output><empty_output><jupyter_text>Criando variávels para armazenar informações<jupyter_code>cards = []
card = {}<jupyter_output><empty_output><jupyter_text>Obtendo os dados do primeiro CARD<jupyter_code>anuncio = soup.find('div', {'class': 'well card'})
anuncio #AChando a div e armazenando o valor necessário para fazer a raspagem<jupyter_output><empty_output><jupyter_text>5.2. Obtendo o VALOR do veículo anunciado<jupyter_code>valor_carro = anuncio.find('div', {'class': 'value-card'}).getText()
valor_carro
anuncio.find('div', {'class': 'value-card'}).findNext().getText()
carros = []
for item in anuncio.find('div', {'class': 'value-card'}).getText(): 
    item = anuncio.findPrevious('div').getText()
    carros.append(item)
    #print(item)
carros<jupyter_output><empty_output><jupyter_text>Resumo<jupyter_code># Valor
valor_carro = anuncio.find('div', {'class': 'value-card'}).getText()<jupyter_output><empty_output><jupyter_text>5.3. Obtendo as INFORMAÇÕES sobre o veículo anunciado<jupyter_code>anuncio.findAll('div', {'class': 'body-card'})
infos = anuncio.findNext('div', {'class': 'body-card'}).findAll('p')
infos

for info in infos:
    print(info.get('class'), ' - ', info.get_text())
for info in infos:
    print(info.get('class')[0].split() , ' - ', info.get_text())
for info in infos:
    card[info.get('class')[0].split('-')[-1]] = info.get_text()
card
#exercicio
from bs4 import BeautifulSoup

html2 = """
    <html>
        <body>
            <div id="container-a">
                <h1>Curso de Web Scraping</h1>
                <h3>Treinamento Alura</h3>
                <p class="main descr">Curso para ensinar técnicas de coleta de dados na web.</p>
            </div>
            <div id="tools">
                <p class="main lib-a">BeautifulSoup</p>
                <p class="libs">findAll()</p>
                <p class="libs">getText()</p>
                <p class="main lib-b">urllib.request</p>
                <p class="libs">urlopen()</p>
                <p class="main lib-c">pandas</p>
                <p class="libs">DataFrame()</p>
            </div>
        </body>
    </html>
"""
items = soup.find('div', {'id': 'tools'}).findAll('p', {'class': 'main'})
for item in items:
    print(item.getText())
ou
items = soup.find('div', {'id': 'tools'})('p', {'class': 'main'})
for item in items:
    print(item.getText())<jupyter_output>BeautifulSoup
urllib.request
pandas<jupyter_text>Resumo<jupyter_code># Informações
infos = anuncio.findNext('div', {'class': 'body-card'}).findAll('p')
for info in infos:
    card[info.get('class')[0].split('-')[-1]] = info.get_text()
card<jupyter_output><empty_output><jupyter_text>5.4. Obtendo os ACESSÓRIOS do veículo anunciado<jupyter_code>#anuncio.find('div',{'class': 'body-card'} ).findAll('ul') 
#outra maneira
anuncio.find('div',{'class': 'body-card'} ).ul.findAll('li')

acessories = anuncio.find('div',{'class': 'body-card'} ).ul.findAll('li')
#primeiro tratamento removendo o ultimo item de uma lista
acessories.pop()
#Segundo tratamento removendo ►
#for acessory in acessories:
#    print(acessory.getText().split('►')[-1])
#outro metodo
for acessory in acessories:
    print(acessory.getText().replace('►', ''))
acessorios = []
for acessory in acessories:
    acessorios.append((acessory.getText().replace('►', '')))
acessorios
card['items'] = acessorios
card
#Exercicio
from bs4 import BeautifulSoup
'''Utilizando somente o método pop() para tratamento de listas Python,
assinale a alternativa que cria uma lista somente com as tags que tenham conteúdos numéricos.'''
html2 = """
    <html>
        <body>
            <ul>
                <li>Abertura</li>
                <li>10%</li>
                <li>11%</li>
                <li>10.5%</li>
                <li>9%</li>
                <li>Fechamento</li>
            </ul>
        </body>
    </html>
"""
soup = BeautifulSoup(html2, 'html.parser')
valores = soup.ul('li')[1:-1]
valores<jupyter_output><empty_output><jupyter_text>Resumo<jupyter_code># Acessórios
anuncio.find('div',{'class': 'body-card'} ).ul.findAll('li')
acessories = anuncio.find('div',{'class': 'body-card'} ).ul.findAll('li')
#primeiro tratamento removendo o ultimo item de uma lista
acessories.pop()
#Segundo tratamento removendo ►
for acessory in acessories:
    print(acessory.getText().replace('►', ''))
#Criando uma lista para os acessorios 
acessorios = []
for acessory in acessories:
    acessorios.append((acessory.getText().replace('►', '')))
acessorios
#Adicionando ao dicionario Card a lista de acessorios do carro
card['items'] = acessorios
card<jupyter_output>4 X 4
 Câmera de estacionamento
 Controle de tração
 Sensor de estacionamento<jupyter_text>5.5 Criando um DataFrame com os dados coletados do Alura Motors<jupyter_code>card
import pandas as pd
dataset = pd.DataFrame(card)
dataset
dataset = pd.DataFrame.from_dict(card,orient = 'index').T
dataset
#Alocando o dataset no formato CSV numa pasta determinada
dataset.to_csv('./output/data/dataset.csv', sep = ';', index= False, encoding = 'utf-8-sig')<jupyter_output><empty_output><jupyter_text>5.6. Obtendo a FOTO do anúncio<jupyter_code>image = anuncio.find('div', {'class': 'image-card'}).img
image
print(image.get('src'))<jupyter_output>https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/lamborghini-aventador/lamborghini-aventador-2932196__340.jpg<jupyter_text>Visualizando a FOTO no notebook (extra)<jupyter_code>from IPython.core.display import display, HTML

display(HTML(str(anuncio.find('div', {'class': 'image-card'}).img)))
display(HTML("<img src=" + anuncio.find('div', {'class': 'image-card'}).img.get('src') + ">"))<jupyter_output><empty_output><jupyter_text>Rotina para acessar e salvar a FOTO do anúncio  https://docs.python.org/3/library/urllib.request.htmlurllib.request.urlretrieve<jupyter_code>from urllib.request import urlretrieve
#'./output/img/' é aonde ele fazer o upload da(s) imagens, o que vem após o + seria o nome da imagem
urlretrieve(image.get('src'), './output/img/' + image.get('src').split('/')[-1])
image.get('src').split('/')[-1]<jupyter_output><empty_output><jupyter_text>Resumo<jupyter_code>from urllib.request import urlretrieve
image = anuncio.find('div', {'class': 'image-card'}).img
image
print(image.get('src'))
#'./output/img/' é aonde ele fazer o upload da(s) imagens, o que vem após o + seria o nome da imagem
urlretrieve(image.get('src'), './output/img/' + image.get('src').split('/')[-1])<jupyter_output><empty_output><jupyter_text>6. WEB SCRAPING DO SITE ALURA MOTORS - OBTENDO OS DADOS DE TODOS OS ANÚNCIOS DE UMA PÁGINA  6.1. Identificando as informações no HTML<jupyter_code>len(soup.find('div',{'id': 'container-cards'}).findAll('div', class_ = "card"))

anuncios = soup.find('div',{'id': 'container-cards'}).findAll('div', class_ = "card") 
for anuncio in anuncios:
    print(str(anuncio)+ "\n\n")<jupyter_output><div class="well card">
<div class="col-md-3 image-card">
<img alt="Foto" height="155" src="https://caelum-online-public.s3.amazonaws.com/1381-scraping/01/img-cars/lamborghini-aventador/lamborghini-aventador-2932196__340.jpg" width="220"/>
</div>
<div class="col-md-6 body-card">
<p class="txt-name inline">LAMBORGHINI AVENTADOR</p>
<p class="txt-category badge badge-secondary inline">USADO</p>
<p class="txt-motor">Motor 1.8 16v</p>
<p class="txt-description">Ano 1993 - 55.286 km</p>
<ul class="lst-items">
<li class="txt-items">► 4 X 4</li>
<li class="txt-items">► Câmera de estacionamento</li>
<li class="txt-items">► Controle de tração</li>
<li class="txt-items">► Sensor de estacionamento</li>
<li class="txt-items">...</li>
</ul>
<p class="txt-location">Belo Horizonte - MG</p>
</div>
<div class="col-md-3 value-card">
<div class="value">
<p class="txt-value">R$ 338.000</p>
</div>
</div>
</div>


<div class="well card">
<div class="col-md-3 image-card">
<img alt="Foto" height="155" src="ht[...]<jupyter_text>6.2. Criando uma rotina de scraping<jupyter_code># Importando bibliotecas
from urllib.request import urlopen, urlretrieve
from bs4 import BeautifulSoup
import pandas as pd

# Declarando variável cards
cards = []
card = {}

# Obtendo o HTML
response = urlopen('https://alura-site-scraping.herokuapp.com/index.php') #Página de busca
html = response.read().decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')

# Obtendo as TAGs de interesse
anuncios = soup.find('div',{'id': 'container-cards'}).findAll('div', class_ = "card") 

# Coletando as informações dos cards
for anuncio in anuncios:
    card = {}
    # Valor
    card['value'] = anuncio.find('p', {'class': 'txt-value'}).getText()

    # Informações
    infos = anuncio.find('div', {'class': 'body-card'}).findAll('p')
    for info in infos:
        card[info.get('class')[0].split('-')[-1]] = info.get_text()

    # Acessórios
    items = anuncio.find('div', {'class': 'body-card'}).ul.findAll('li')
    items.pop()
    acessorios = []
    for item in items:
        acessorios.append(item.get_text().replace('► ', ''))
    card['items'] = acessorios
    # Adicionando resultado à lista cards
    cards.append(card)
    # Imagens
    image = anuncio.find('div', {'class': 'image-card'}).img
    urlretrieve(image.get('src'), './output/img/' + image.get('src').split('/')[-1])    



# Criando um DataFrame com os resultados
dataset = pd.DataFrame(cards)
dataset.to_csv('./output/data/dataset.csv', sep=';', index = False, encoding = 'utf-8-sig')
dataset<jupyter_output><empty_output><jupyter_text>7. WEB SCRAPING DO SITE ALURA MOTORS - OBTENDO OS DADOS DE TODOS OS ANÚNCIOS DO SITE  7.1. Identificando as informações no HTML<jupyter_code>#Pegando o total de págians do site
soup.find('span', class_ = 'info-pages').getText()
soup.find('span', class_ = 'info-pages').getText().split()[-1]
#transformando o valor em inteiro
int(soup.find('span', class_ = 'info-pages').getText().split()[-1])<jupyter_output><empty_output><jupyter_text>7.2. Criando uma rotina de scraping<jupyter_code># Importando bibliotecas
from urllib.request import urlopen, urlretrieve
from bs4 import BeautifulSoup
import pandas as pd

# Declarando variável cards
cards = []

## Obtendo o HTML e o total de páginas
response = urlopen('https://alura-site-scraping.herokuapp.com/index.php')
html = response.read().decode('utf-8')
soup = BeautifulSoup(html, 'html.parser')
pages = int(soup.find('span', class_ = 'info-pages').getText().split()[-1])
## Iterando por todas as páginas do site
for i in range(pages):
    
    ## Obtendo o HTML
    response = urlopen('https://alura-site-scraping.herokuapp.com/index.php?page=' + str(i+1))
    html = response.read().decode('utf-8')
    soup = BeautifulSoup(html, 'html.parser')
    # Obtendo as TAGs de interesse
    anuncios = soup.find('div', {"id": "container-cards"}).findAll('div', class_="card")

    # Coletando as informações dos CARDS
    for anuncio in anuncios:
        card = {}

        # Valor
        card['value'] = anuncio.find('p', {'class': 'txt-value'}).getText()

        # Informações
        infos = anuncio.find('div', {'class': 'body-card'}).findAll('p')
        for info in infos:
                card[info.get('class')[0].split('-')[-1]] = info.get_text()

        # Acessórios
        items = anuncio.find('div', {'class': 'body-card'}).ul.findAll('li')
        items.pop()
        acessorios = []
        for item in items:
            acessorios.append(item.get_text().replace('► ', ''))
        card['items'] = acessorios

        # Adicionando resultado a lista cards
        cards.append(card)

        # Imagens
        image = anuncio.find('div', {'class': 'image-card'}).img
        urlretrieve(image.get('src'), './output/img/' + image.get('src').split('/')[-1])     

    
# Criando um DataFrame com os resultados
dataset = pd.DataFrame(cards)
dataset.to_csv('./output/data/dataset.csv', sep=';', index = False, encoding = 'utf-8-sig')
dataset<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.15904432035060437, 'fraction_numerical': 0.01749487523856648, 'mean_word_length': 4.216629793510324, 'pattern_counts': {'":': 2, '<': 404, '<?xml version=': 0, '>': 416, 'https://': 36, 'lorem ipsum': 0, 'www.': 12, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '47', 'dir': 'jupyter-structured-clean-dedup', 'id': '163203', 'license': 'MIT', 'n_tokens_mistral': 10779, 'n_tokens_neox': 10499, 'n_words': 2139, 'path': 'Web Scraping.ipynb', 'repo_name': 'RamonNicolas/Scraping-com-Python-Coleta-de-dados-na-web', 'size': '28426'}