La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Extracción de contenidos web con Python ======

<WRAP center round box 80%>
Módulo perteneciente al curso [[informatica:programacion:cursos:python_avanzado_proyectos_seguridad|Python avanzado para proyectos de seguridad]]
</WRAP>

Entre las técnicas que disponemos para extraer contenidos de la web podemos destacar:

  * **Screen scraping**: Técnica que permite obtener información moviéndote por la pantalla, por ejemplo registrando los clicks del usuario.
  * **Web scraping**: Trata es obtener la información de un recurso como por ejemplo de una página web en HTML y procesa esa información para extraer datos relevantes.
  * **Report mining**: Técnica que también pretende obtener información, pero en este caso a partir de un archivo (HTML, RDF, CSV, etc). Con esta aproximación de definición podemos crear un mecanismo simple y rápido sin necesidad de escribir una API y como característica principal podemos indicar que el sistema no necesita de una conexión ya que al trabajar a partir de un fichero es posible extraer la información de forma offline y sin necesidad de utilizar ninguna API.
  * **Spider**: Los spiders (crawlers/arañas) son scripts o programas que siguen unas reglas para moverse por un sitio web y tienen como objetivo recolectar información imitando la interacción que realizaría un usuario con el sitio web. La idea es que sea solo necesario escribir las reglas para extraer los datos que nos interesen y dejar que el spyder rastree todo el sitio web en busca de enlaces.

En esta unidad didáctica nos vamos a centrar en la técnica de webscraping que permite la recolección o extracción de datos de páginas web de forma automática. Es un campo muy activo y en continuo desarrollo que comparte objetivos con la web semántica, el procesamiento de textos automático, inteligencia artificial e interacción humano-computador.

El web scraping es una técnica que permite la extracción de información de sitios web, transformando datos no estructurados como los datos en formato HTML en datos estructurados.

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:web-scraping-services.png |}}

En esta unidad revisaremos el módulo **lxml** junto con los parsers xml, html y el módulo **BeautifulSoup**.

<WRAP center round info 60%>
El lenguaje de marcado extensible **XML** es una herramienta independiente de la plataforma, del software y del hardware para almacenar, transportar e intercambiar información. XML es una versión simplificada de SGML y es un metalenguaje, es decir, un lenguaje para definir otros lenguajes, que los programadores pueden usar para desarrollar un lenguaje que se ajuste a sus requisitos únicos. XML y HTML se complementan en tanto que XML describe los datos y HTML los representa.
</WRAP>


Complementamos el uso de estos módulos con el módulo **requests** para realizar peticiones y descargar el código HTML.

Por ejemplo, **BeautifulSoup** recibirá el contenido de la respuesta con el objetivo analizar el código HTML del sitio web y extraer los datos que nos interesen.

===== Parsers XML y HTML =====

Dentro del ecosistema de python encontramos diferentes módulos que nos puedes ayudar a parsear un documento que se encuentra en formato xml y html.

El módulo **[[http://lxml.de/|lxml]]** es un módulo que une las librerías **libxml2** para análisis de documentos XML y **libxslt**. Las principales características del módulo son:

  * Soporte para documentos XML y HTML
  * Dispone de una API basada en **ElementTree**
  * Soporte para seleccionar elementos del documento mediante expresiones **XPath** 

<WRAP center round info 60%>
**XPath** es un lenguaje que le permite seleccionar nodos de un documento XML y calcular valores a partir de su contenido. Hay varias versiones XPath aprobadas por el W3C. En esta URL, puede ver la documentación y todas las versiones de XPath https://www.w3.org/TR/xpath/all
</WRAP>


La instalación de este parser se puede hacer a través del repositorio oficial de python:

<code bash>
pip install lxml
</code>

En este primer ejemplo vamos a hacer uso del módulo **lxml.etree** que se trata de un submódulo dentro de la librería **lxml**, que proporciona métodos como ''XPath()'', que soporta expresiones utilizando como sintaxis selectores **XPath**.

Con este ejemplo vemos el uso del parser **lxml** para leer un fichero html y extraer el texto de la etiqueta ''title'' del documento html a través de una expresión Xpath.

Puede encontrar el siguiente código en el fichero ''obtener_title_xpath.py'':

<code python>
#!/usr/bin/env python3

import re
import requests

from lxml import etree

respuesta = requests.get('https://www.debian.org/releases/stable/index.en.html')

parser = etree.HTML(respuesta.text)

resultado = etree.tostring(parser,pretty_print=True, method="html")
#print(resultado)

obtener_texto_xpath = etree.XPath("//title/text()", smart_strings=False)
texto = obtener_texto_xpath(parser)[0]
print(texto)
</code>

===== Submódulo lxml.html =====

El módulo **lxml** también provee un submódulo de Python llamado **[[http://lxml.de/lxmlhtml.html|lxml.html]]** dedicado para trabajar con HTML.

En el siguiente ejemplo vamos a estudiar el mismo ejemplo que el caso anterior, esta vez utilizando el parser HTML.

Puede encontrar el siguiente código en el fichero ''obtener_title_xpath_parser_html.py'':

<code python>
#!/usr/bin/env python3

import re
import requests

from lxml import html

respuesta = requests.get('https://www.debian.org/releases/stable/index.en.html')
elementos = html.fromstring(respuesta.text)
obtener_texto_xpath = elementos.xpath("//title/text()", smart_strings=False)
texto = obtener_texto_xpath[0]
print(texto)
</code>

===== Extraer etiquetas de un sitio web con el módulo lxml =====

Antes de comenzar a analizar el código HTML, necesitamos extraer el contenido analizar.

En este ejemplo vamos a obtener la versión y el nombre en clave de la última versión estable de Debian del sitio web de Debian: https://www.debian.org/releases/stable/index.en.html

La información que queremos se muestra en el título de la página y en el primer párrafo.

Primero lo que tenemos que hacer es descargar la página con el módulo **requests**:

<code python>
import requests
response = requests.get('https://www.debian.org/releases/stable/index.en.html')
</code>

Posteriormente, analizamos el código fuente en un árbol **ElementTree**. Esto es lo mismo que analizar XML con **ElementTree** de la biblioteca estándar, excepto que aquí usaremos el parser HTML disponible en el módulo **lxml**:

<code python>
from lxml.etree import HTML
root = HTML(response.content)
</code>

La función ''HTML()'' es un acceso directo que lee el código HTML que se le pasa y produce un árbol XML. Tenga en cuenta que estamos pasando ''response.content'' y no ''response.text''. El módulo **lxml** produce mejores resultados cuando utiliza la respuesta sin procesar.

La implementación de **ElementTree** de la biblioteca **lxml** ha sido diseñada para ser 100 % compatible con la biblioteca estándar, por lo que podemos comenzar a explorar el documento de la misma manera que lo hicimos con XML. Por ejemplo podemos obtener las etiquetas raíz que se encuentran en un documento html.

<code python>
>>> [e.tag for e in root]

['head', 'body']
</code>

Si nos interesa el contenido de texto del elemento ''<title>'' del documento html, podríamos hacerlo de la siguiente forma:

<code python>
>>> root.find('head').find('title').text
'Debian -- Debian "stretch" Release Information '
</code>

===== Obtener formularios de un sitio web =====

En este ejemplo realizamos una petición al buscador duckduckgo y obtenemos el formulario que se utiliza para realizar las búsquedas.

Para ello accedemos al objeto ''forms'' que se estará contenido dentro de la respuesta de la url.

Puede encontrar el siguiente código en el fichero ''duckduckgo.py'':

<code python>
#!/usr/bin/env python3

from lxml.html import fromstring, tostring
from lxml.html import parse, submit_form

import requests
response = requests.get('https://duckduckgo.com')
form_page = fromstring(response.text)
form = form_page.forms[0]
print(tostring(form))

page = parse('http://duckduckgo.com').getroot()
print(tostring(page))
page.forms[0].fields['q'] = 'python'
busqueda = parse(submit_form(page.forms[0])).getroot()
print(tostring(busqueda))
</code>

Este es el resultado de la primera parte del script, donde podemos ver el objeto de formulario de DuckDuckGo:

<code python>
b'<form id="search_form_homepage" class="search search--home js-search-
       form" name="x" method="POST" action="/html">\n\t\t\t<input
        id="search_form_input_homepage" class="search__input js-search-input"
       type="text" autocomplete="off" name="q" tabindex="1"
        value="">\n\t\t\t<input id="search_button_homepage" class="search__button
         js-search-button" type="submit" tabindex="2" value="S">\n\t\t\t<input
         id="search_form_input_clear" class="search__clear empty js-search-clear"
        type="button" tabindex="3" value="X">\n\t\t\t<div
         id="search_elements_hidden" class="search__hidden js-search-
        hidden"></div&amp;gt;\n\t\t</form&amp;gt;\n\n\t\t\t\t\t\t'
</code>

===== Expresiones XPath =====

Con el objetivo de optimizar la comprobación de los elementos html, necesitamos usar XPath, que es un lenguaje de consulta que se desarrolló específicamente para XML y es compatible con el módulo **lxml**. Para comenzar con XPath, use el shell de Python de la última sección y haga lo siguiente:

<code python>
>>> root.xpath('body')
[<Element body at 0x4477530>]
</code>

Esta es la forma más simple de una expresión XPath; lo que hace es buscar hijos del elemento actual que tienen nombres de etiquetas que coinciden con el nombre de la etiqueta especificada. El elemento actual es el que llamamos ''xpath()'', en este caso, root. El elemento raíz es el elemento ''<html>'' de nivel superior en el documento HTML, por lo que el elemento devuelto es el elemento ''<body>''

Las expresiones XPath pueden contener múltiples niveles de elementos donde las búsquedas comienzan desde el nodo en el que se realiza la llamada ''xpath()''. Por ejemplo, podemos usar expresiones xpath para encontrar solo los elementos secundarios ''%%<div>%%'' dentro de ''<body>''.

<code python>
>>> root.xpath('body/div')
[<Element div at 0x447a1e8>, <Element div at 0x447a210>, <Element div at 0x447a238>]
</code>

Las consultas anteriores son relativas al elemento al que llamamos con el método ''xpath()'', pero podemos forzar una búsqueda desde la raíz del árbol añadiendo una barra diagonal al comienzo de la expresión. También podemos realizar una búsqueda en todos los descendientes de un elemento, con la ayuda de una barra doble.

<code python>
>>> root.xpath('//h1')
[<Element h1 at 0x447aa58>]
</code>

La verdadera potencia de XPath está en que podemos aplicar condiciones adicionales a los elementos en la expresión:

<code python>
>>> root.xpath('//div[@id="content"]')
[<Element div at 0x3d6d800>]
</code>

Los corchetes después de ''div'', ''%%[@id = "content"]%%'', forman una condición que colocamos en los elementos ''%%<div>%%''. El signo ''@'' antes de la palabra clave ''id'' significa que id se refiere a un atributo, por lo que la condición significa: obtener aquellos elementos cuyo atributo ''id'' sea igual a ''%%"content"%%''. Así es como podemos encontrar nuestra etiqueta de contenido ''%%<div>%%''.

Antes de mostrar un ejemplo completo, vamos a analizar algunos casos de uso. Podemos especificar solo un nombre de etiqueta, como se muestra aquí:

<code python>
>>> root.xpath('//div[h1]')
[<Element div at 0x3d6d800>]
</code>

En el ejemplo anterior la expresión xpath devuelve todos los elementos ''%%<div>%%'' que tienen un elemento hijo ''<h1>'':

<code python>
>>> root.xpath('body/div[2]')
[<Element div at 0x3d6d800>]
</code>

En el ejemplo anterior estamos accediendo al segundo elemento hijo ''%%<div>%%'' de ''%%<body>%%''. Poner un número como condición devolverá el elemento en esa posición en la lista. Hay que tener en cuenta que estos índices comienzan en 1, a diferencia de la indexación de Python que comienza en 0.

La especificación completa de XPath es un estándar del **World Wide Web Consortium** (W3C): https://www.w3.org/TR/xpath-3

===== Ejemplo de script utilizando expresiones xpath =====

En el siguiente script obtenemos la versión de debían utilizando expresiones xpath.

Puede encontrar el siguiente código en el fichero ''get_debian_version.py'':

<code python>
#!/usr/bin/env python3

import re
import requests

from lxml.etree import HTML
response = requests.get('https://www.debian.org/releases/stable/index.en.html')
root = HTML(response.content)

title_text = root.find('head').find('title').text
print(title_text)

release = re.search('\u201c(.*)\u201d', title_text).group(1)
p_text = root.xpath('//div[@id="content"]/p[1]')[0].text
version = p_text.split()[1]
print('Codename: {}\nVersion: {}'.format(release, version))
</code>

En el script anterior analizamos la página web extrayendo el texto que queremos con la ayuda de XPath. Hemos utilizado una expresión regular para extraer el nombre y el número de versión.

<code>
$ python3 get_debian_version.py
Debian -- Debian “bookworm” Release Information
Codename: bookworm
Version: 12.4
</code>

===== Extracción de enlaces con el módulo lxml con expresiones xpath =====

Una de las principales funcionalidades que podríamos desarrollar es la extracción de diferentes elementos html.

Podríamos definir una clase llamada **Scraping** y definir un método por cada tipo de recurso a extraer.

En este caso estamos utilizando el parser **xml** y expresiones regulares del tipo xpath para obtener cada uno de los recursos a extraer.

Para el caso de **extraer enlaces** a partir de una url podemos hacer uso de la expresión xpath ''%%//a/@href%%''.

Esto nos devolverá el valor del atributo ''href'' para todos aquellos elementos correspondientes a un enlace html.

Puede encontrar el siguiente código en el fichero ''obtener_links_lxml.py'':

<code python>
#!/usr/bin/env python3

import os
import requests
from lxml import html

class Scraping:
                
    def scrapingLinks(self,url):
            print("Obtener links de la url:"+ url)
        
            try:
                response = requests.get(url)  
                parsed_body = html.fromstring(response.text)
    
                # expresion regular para obtener links
                links = parsed_body.xpath('//a/@href')
    
                print('Links encontrados %s' % len(links))
    
                for link in links:
                    if(link.startswith("http")):
                        print(link)
                    else:
                        print(url+link)
                    
            except Exception as e:
                    print("Error de conexión en:  " + url)
                    pass
                    
if __name__ == "__main__":
    target = "https://www.python.org"
    scraping = Scraping()
    scraping.scrapingLinks(target)
</code>

Desde nuestro programa principal ''main'' llamaríamos al método ''scrapingLinks'' **Scraping** pasándole por parámetro la url o target a analizar.

Como podemos ver en la salida, nos devuelve aquellos enlaces tanto absolutos como relativos a la página principal que estamos analizando.:

<code>
$ python3 obtener_links_lxml.py
Obtener links de la url:https://www.python.org
Links encontrados 206
https://www.python.org#content
https://www.python.org#python-network
https://www.python.org/
https://www.python.org/psf-landing/
https://docs.python.org
https://pypi.org/
https://www.python.org/jobs/
https://www.python.org/community/
https://www.python.org#top
https://www.python.org/
https://psfmember.org/civicrm/contribute/transact?reset=1&amp;id=2
https://www.python.org#site-map
https://www.python.org#
https://www.python.orgjavascript:;
</code>

===== Extracción de documentos PDF con el módulo lxml con expresiones xpath =====

Para el caso de **extraer documentos pdf** a partir de una url podemos hacer uso de la expresión xpath ''%%//a[@href[contains(., ".pdf")]]/@href%%''.

Esto nos devolverá el valor de atributo ''href'' para todos aquellos elementos correspondientes a un documento pdf.

Puede encontrar el siguiente código en el fichero ''obtener_pdfs_lxml.py'':

<code python>
#!/usr/bin/env python3

import os
import requests
from lxml import html

class Scraping:
           
    def scrapingPDFs(self,url):
        print("Obtener pdfs de la url:"+ url)
    
        try:
            response = requests.get(url)  
            parsed_body = html.fromstring(response.text)

            # expresion regular para obtener pdf
            pdfs = parsed_body.xpath('//a[@href[contains(., ".pdf")]]/@href')

            print('Pdfs encontrados %s' % len(pdfs))
    
            #crear directorio para guardar los documentos
            os.system("mkdir pdfs")
    
            for pdf in pdfs:
                if pdf.startswith("http") == False:
                    download = url + "/"+ pdf
                else:
                    download = pdf
                print(download)
                # download document en el directorio creado
                r = requests.get(download)
                f = open('pdfs/%s' % download.split('/')[-1], 'wb')
                f.write(r.content)
                f.close()
                
        except Exception as e:
                print("Error de conexión en: " + url)
                pass
                    
if __name__ == "__main__":
    target = "https://docs.python-guide.org"
    scraping = Scraping()
    scraping.scrapingPDFs(target)
</code>

Desde nuestro programa principal main llamaríamos al método ''scrapingPDFs'' de la clase **Scraping** pasándole por parámetro la url o target a analizar.

Como podemos ver en la salida nos devuelve aquellos documentos pdfs que se encuentran en la página principal que estamos analizando.

<code>
Obtener pdfs de la url:https://docs.python-guide.org
Pdfs encontrados 1
https://media.readthedocs.org/pdf/python-guide/latest/python-guide.pdf
</code>

===== Actividad práctica: Completar el código que permite la extracción de imágenes con el módulo lxml con expresiones xpath =====

**Completar el código que permite la extracción de imágenes con el módulo lxml con expresiones xpath**

<code python>
#!/usr/bin/env python3

import os
import requests
from lxml import xxx

class Scraping:

    def scrapingImages(self,xxx):
        print("Obtener imágenes de la url:"+ xxx)

        try:
            response = requests.xxx(xxx) 
            parsed_body = html.xxx(response.xxx)

            # expresion regular para obtener imagenes
            images = parsed_body.xxx(xxx)

            print('Imágenes encontradas %s' % len(images))

            #crear directorio para guardar las imagenes
            os.xxx("mkdir imagenes")

            for image in xxx:
                if xxx.startswith("http") == False:
                    download = url + "/"+ xxx
                else:
                    download = xxx
                print(download)
                # descargar las imagenes en el directorio creado
                r = requests.xxx(xxx)
                f = open('imagenes/%s' % xxx.split('/')[-1], 'wb')
                f.xxx(r.xxx)
                f.xxx()

        except Exception as e:
                print("Error de conexión en: " + url)
                pass
               

if __name__ == "__main__":
    target = "https://www.python.org"
    scraping = Scraping()
    scraping.xxx(target)
</code>

Para el caso de extraer imágenes a partir de una url podemos hacer uso de la expresión xpath ''%%//img/@src%%''

Esto nos devolverá el valor del atributo ''src'' para todos aquellos elementos correspondientes a una imagen html.

Desde nuestro programa principal ''main'' llamaríamos al método ''scrapingImages'' de la clase ''Scraping'' pasándole por parámetro la url o target a analizar.

Como podemos ver en la salida, nos devuelve aquellas imágenes que se encuentran en la página principal que estamos analizando.

<code>
Obtener imágenes de la url:https://www.python.org
Imágenes encontradas 1
https://www.python.org//static/img/python-logo.png
</code>

==== Solución ====

<code python>
#!/usr/bin/env python3

import os
import requests
from lxml import html

class Scraping:
   		
    def scrapingImages(self,url):
        print("Obtener imágenes de la url:"+ url)
    
        try:
            response = requests.get(url)  
            parsed_body = html.fromstring(response.text)

            # expresion regular para obtener imagenes
            images = parsed_body.xpath('//img/@src')

            print('Imágenes encontradas %s' % len(images))
    
            #crear directorio para guardar las imagenes
            os.system("mkdir imagenes")
    
            for image in images:
                if image.startswith("http") == False:
                    download = url + "/"+ image
                else:
                    download = image
                print(download)
                # descargar las imagenes en el directorio creado
                r = requests.get(download)
                f = open('imagenes/%s' % download.split('/')[-1], 'wb')
                f.write(r.content)
                f.close()
                
        except Exception as e:
                print("Error de conexión en: " + url)
                pass
                
					
if __name__ == "__main__":
	target = "https://www.python.org"
	scraping = Scraping()
	scraping.scrapingImages(target)

</code>