Aunque no es su propósito principal, Selenium también se usa en Python para web scraping, porque puede acceder a contenido renderizado en JavaScript (lo que las herramientas de scraping normales como BeautifulSoup no pueden hacer).

Selenium también es útil cuando necesita interactuar con la página de alguna manera antes de recopilar los datos, como hacer clic en botones o completar campos. Este es el caso de uso que se cubrirá en este artículo.

Como ejemplo, haremos scraping a investing.com para extraer datos históricos de los tipos de cambio del dólar frente a una o más monedas.

Si busca en la web, puede encontrar APIs y paquetes de Python que facilitan mucho la recopilación de datos financieros (en lugar de hacer scraping manualmente). Sin embargo, la idea aquí es explorar cómo Selenium puede ayudarle con la extracción general de datos .

El sitio web que vamos a hacer scraping

En primer lugar, necesitamos entender el sitio web. Este sitio contiene los datos históricos del tipo de cambio del dólar frente al euro.

En esta página, puede ver una tabla con los datos y la opción de establecer el rango de fechas que queremos. Eso es lo que vamos a usar.

Para ver los datos de otras monedas frente al dólar, simplemente reemplace “eur” por el otro código de divisa en la URL.

Además, esto supone que solo querrá el tipo de cambio de la moneda frente al dólar. Si ese no es el caso, simplemente reemplace el “usd” en la URL.

El código scraper

Empezaremos con las importaciones, y no necesitamos mucho. Vamos a importar algunos elementos útiles de Selenium: la función sleep para insertar algunas pausas en el código, y Pandas para manipular la fecha cuando sea necesario.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from time import sleep
import pandas as pd

A continuación, escribiremos una función para hacer scraping a los datos. La función recibirá:

• Una lista de códigos de divisas
• Una fecha de inicio
• Una fecha de finalización
• Un booleano que informa si queremos exportar los datos como un archivo .csv. Usaré False como predeterminado.

Además, como la idea aquí es construir un scraper capaz de recopilar datos sobre múltiples monedas, también inicializaremos una lista vacía para almacenar los datos de cada moneda.

def get_currencies(currencies, start, end, export_csv=False):
    frames = []

Como la función ahora tiene una lista de monedas, probablemente imaginará que iteraremos sobre esta lista y obtendremos los datos por moneda. Ese es precisamente el plan.

Entonces, para cada moneda en la lista de monedas, crearemos una URL, instanciaremos un objeto driver , y lo usaremos para obtener la página. Luego maximizaremos la ventana, pero eso solo es visible si mantiene option.headless como False. De lo contrario, Selenium hará todo el trabajo sin mostrarte nada.

for currency in currencies:
    my_url = f'https://br.investing.com/currencies/usd-{currency.lower()}-historical-data'
    option = Options()
    option.headless = False
    driver = webdriver.Chrome(options=option)
    driver.get(my_url)
    driver.maximize_window()

Ya estamos viendo los datos históricos en este momento, y podríamos obtener la tabla con los datos. Sin embargo, de forma predeterminada, solo vemos los datos de los últimos 20 días. Queremos obtener estos datos para cualquier período de tiempo.

Para ello, usaremos algunas funcionalidades interesantes de Selenium para interactuar con el sitio web. ¡Aquí es cuando Selenium brilla!

Lo que haremos aquí es hacer clic en las fechas y completar los campos Fecha de Inicio y Fecha de Finalización con las fechas que queremos y presionar Aplicar.

Para ello, usaremos WebDriverWait, ExpectedConditions, y By  para asegurarnos de que el controlador web esperará a que se pueda hacer clic en los elementos con los que queremos interactuar.

Esto es importante porque si el driver intenta interactuar con algo antes de que se pueda hacer clic, se generará una excepción.

El tiempo de espera será de veinte segundos, pero depende de ti configurarlo como considere apropiado. Primero, seleccionemos el botón de fecha por su XPath y luego hagamos clic en él.

date_button = WebDriverWait(driver, 20).until(
              EC.element_to_be_clickable((By.XPATH,
              "/html/body/div[5]/section/div[8]/div[3]/div/div[2]/span")))

date_button.click()

Ahora, necesitamos llenar el campo Fecha de Inicio. Primero seleccionémoslo y luego usemos clear para eliminar la fecha predeterminada y send_keys para llenarlo con la fecha que queremos.

start_bar = WebDriverWait(driver, 20).until(
            EC.element_to_be_clickable((By.XPATH, 
	        "/html/body/div[7]/div[1]/input[1]")))

start_bar.clear()
start_bar.send_keys(start) 

Y ahora repetimos el proceso para el campo Fecha de Finalización.

end_bar = WebDriverWait(driver, 20).until(
          EC.element_to_be_clickable((By.XPATH, 
          "/html/body/div[7]/div[1]/input[2]")))

end_bar.clear()
end_bar.send_keys(end)

Una vez hecho esto, seleccionaremos el botón Aplicar y haremos clic en él. Luego usamos sleep para pausar el código durante unos segundos y asegurarnos de que la nueva página esté completamente cargada.

apply_button = WebDriverWait(driver, 20).until(
	           EC.element_to_be_clickable((By.XPATH,  
               "/html/body/div[7]/div[5]/a")))

apply_button.click()
sleep(5)

Si tenías option.headless como False, verás todo este proceso sucediendo frente a ti como si alguien estuviera haciendo clic en la página. Cuando Selenium haga clic en Aplicar, verá que la tabla se recarga para mostrar los datos para el período de tiempo que especifico.

Ahora usamos la función pandas.read_html para seleccionar todas las tablas de la página. Esta función recibirá el código fuente de la página. Finalmente, podemos salir del controlador.

dataframes = pd.read_html(driver.page_source)
driver.quit()
print(f'{currency} scraped.')

Cómo manejar excepciones en Selenium

El proceso de recopilación de datos está hecho. Pero tenemos que considerar que Selenium a veces puede ser un poco inestable y eventualmente podría no cargar la página en algún momento durante todas las acciones que estamos realizando aquí.

Para evitar eso, tendremos el código completo dentro de una cláusula try que estará dentro de un bucle infinito. Una vez que Selenium logre recopilar los datos como describí anteriormente, el ciclo se romperá. Pero cada vez que encuentre un problema, se activará una cláusula de expect.

En este escenario, el código:

• Salir del controlador – siempre es importante hacer esto para que no terminemos con docenas de controladores web que consumen memoria en ejecución.
• Imprime un mensaje indicando el error
• Dormir por treinta segundos
• Ir al inicio del bucle una vez más

Este proceso se repetirá hasta que los datos de cada moneda se recopilen correctamente. Y este es el código para todo esto:

 for currency in currencies:
        while True:
            try:
                # Opening the connection and grabbing the page
                my_url = f'https://br.investing.com/currencies/usd-{currency.lower()}-historical-data'
                option = Options()
                option.headless = False
                driver = webdriver.Chrome(options=option)
                driver.get(my_url)
                driver.maximize_window()
                   
                # Clicking on the date button
                date_button = WebDriverWait(driver, 20).until(
                            EC.element_to_be_clickable((By.XPATH,
                            "/html/body/div[5]/section/div[8]/div[3]/div/div[2]/span")))
                
                date_button.click()
                
                # Sending the start date
                start_bar = WebDriverWait(driver, 20).until(
                            EC.element_to_be_clickable((By.XPATH,
                            "/html/body/div[7]/div[1]/input[1]")))
                            
                start_bar.clear()
                start_bar.send_keys(start)

                # Sending the end date
                end_bar = WebDriverWait(driver, 20).until(
                            EC.element_to_be_clickable((By.XPATH,
                            "/html/body/div[7]/div[1]/input[2]")))
                            
                end_bar.clear()
                end_bar.send_keys(end)
               
                # Clicking on the apply button
                apply_button = WebDriverWait(driver,20).until(
                		EC.element_to_be_clickable((By.XPATH,
                		"/html/body/div[7]/div[5]/a")))
                
                apply_button.click()
                sleep(5)
                
                # Getting the tables on the page and quiting
                dataframes = pd.read_html(driver.page_source)
                driver.quit()
                print(f'{currency} scraped.')
                break
            
            except:
                driver.quit()
                print(f'Failed to scrape {currency}. Trying again in 30 seconds.')
                sleep(30)
                continue

Un último paso, sin embargo. Si recuerda, lo que tenemos hasta ahora es una lista que contiene todas las tablas de la página almacenadas como DataFrames. Necesitamos seleccionar la única tabla que contiene los datos históricos que queremos.

Para cada DataFrame en esta lista de marcos de datos, verificaremos si el nombre de sus columnas coincide con lo que esperamos. Si lo hacen, entonces ese es nuestro marco y rompemos el bucle. Y ahora finalmente estamos listos para agregar este DataFrame a la lista que se inicializó al principio.

for dataframe in dataframes:
    if dataframe.columns.tolist() == ['Date', 'Price', 'Open', 'High', 'Low', 'Change%']:
        df = dataframe
        break

frames.append(df)

Y sí, si el parámetro export_csv se estableció en True, necesitaríamos exportar un archivo .csv. Pero eso está lejos de ser un problema, ya que el método DataFrame.to_csv puede hacer esto fácilmente.

Y luego podemos terminar esta función devolviendo la lista de DataFrames. Este último paso está hecho después de que el bucle a través de la lista de monedas ha terminado, por supuesto.

if export_csv:
        df.to_csv('currency.csv', index=False)
        print(f'{currency}.csv exported.')

# Outside of the loop
return frames

¡Y eso es todo! Aquí está el código completo para estos dos últimos pasos combinados:

		# Selecting the correct table            
        for dataframe in dataframes:
            if dataframe.columns.tolist() == ['Date', 'Price', 'Open', 'High', 'Low', 'Change%']:
                df = dataframe
                break
        frames.append(df)

        # Exporting the .csv file
        if export_csv:
            df.to_csv('currency.csv', index=False)
            print(f'{currency}.csv exported.')
                  
  return frames

Próximos pasos y conclusión

Hasta ahora, este código obtiene los datos históricos del tipo de cambio de una lista de monedas frente al dólar y devuelve una lista de DataFrames y varios archivos .csv.

Pero siempre hay margen de mejora. Con algunas líneas más de código, no es difícil hacer que la función devuelva y exporte un único DataFrame que contenga los datos de cada moneda en la lista.

Otra sugerencia es escribir una función update utilizando las mismas funcionalidades de Selenium que recibe un dataframe existente y actualizar los datos históricos a la fecha actual.

Además, la misma lógica utilizada para hacer scraping las monedas se puede utilizar para hacer scraping acciones, índices, materias primas, futuros y mucho más. Hay tantas páginas que puedes hacer scraping.

Sin embargo, si ese es el objetivo, entonces es importante insertar más pausas en el código para evitar sobrecargar el servidor. También debes aprovechar un proveedor de proxy, como Infatica, para asegurarte de que tu código seguirá funcionando mientras queden páginas por hacer scraping y que tú y tu conexión estén protegidos.

Finalmente, Selenium puede ser útil en varias otras situaciones, como iniciar sesión en sitios web, completar formularios, seleccionar elementos en una lista desplegable y mucho más. Por supuesto, no es la única solución para estos problemas, pero definitivamente puede ser útil según el caso de uso.

Espero que hayas disfrutado este artículo y te haya ayudado. Si tiene alguna pregunta o sugerencia, no dude en ponerse en contacto.

Traducido del artículo de Otávio Simões Silveira - How to Code a Scraping Bot with Selenium and Python

En ese entonces, prefería frameworks ligeros como Flask y Express por tu flexibilidad y el control extra que me ofrecieron.

¿Qué cambió?

¡Parte de ello fue que me contrataron para trabajar en Django! La otra parte era cansarse de configurar las mismas características una y otra vez desde cero para diferentes empresas: ORM para la base de datos, migraciones, sistemas de autenticación, correos electrónicos, etc. Lleva mucho tiempo configurar todas estas características y funcionar correctamente.

Bueno, Django me da todo esto con una configuración mínima fuera de la caja. Sí, es increíble.

Con Django, puedo crear aplicaciones mucho más rápidamente sin sacrificar características. La experiencia del desarrollador también es bastante buena, y no sólo porque Python es impresionante. También es porque hay buenas herramientas de depuración, sesiones ya está configurado y hay un servidor que se reinicia automáticamente con cada cambio en el código.

Podría seguir y seguir con todas las buenas características de Django, pero aquí voy a enumerar mi top 5. Espero que esto despierte tu interés para que quiera probar Django para sus propias empresas y proyectos.

Interfaz de administración de Django

Estoy enumerando esto primero porque es mi característica favorita número uno que viene en Django.

Muchos clientes necesitan tener una vista en tu aplicación para poder administrar usuarios, datos o contenido en las páginas. Por lo general, el cliente no será técnico o tendrá tiempo suficiente para sumergirse en el código real y realizar cambios.

Entonces, ¿cuál es la mejor manera de manejar esta situación?

La interfaz de administración de Django es una gran solución. Sin ninguna configuración adicional, obtiene un área de administración potente, totalmente personalizable y protegida por inicio de sesión que muestra todos los datos de tu aplicación.

Los datos de esta área de administración incluye cualquier tabla que quieres mostrar allí, así como todas las tablas de paquetes de terceros como bibliotecas de autenticación.

Django tiene una Autenticación incorporada

Se necesita algún tipo de autenticación en casi todas las aplicaciones, por lo que el mercado tiene muchas herramientas, servicios y bibliotecas para usar. Debido a que hay tantas opciones, puede ser difícil elegir una. Incluso si utiliza un servicio administrado, conectarlo no siempre es fácil.

Bueno, Django viene con autenticación incorporada a través de sesiones. ¿Qué sucede si desea usar tokens? Simplemente instale la biblioteca de Django REST Framework (DRF) que viene con autenticación de token.

Personalmente me gusta usar DRF con la biblioteca adicional dj-rest-auth para características extras como tokens que caducan. De cualquier manera, todas estas piezas funcionan perfectamente juntas en el ecosistema de Django y requieren muy poca configuración.

Este es un ejemplo de un repositorio de Django donde tengo la configuración de autenticación de token (y autenticación de GitHub) en Django con Django REST Framework.

Cualquier sistema de autenticación que utilice en un proyecto de Django también utilizará ORM. Hablemos de algunos de los beneficios de eso a continuación.

ORM

¿Alguna vez ha intentado configurar manualmente una ORM para conectar tu base de datos a tu aplicación? Por ejemplo, SQLAlchemy, TypeORM o Sequelize. Incluso con buena documentación, no es fácil. Tiene que conseguir diferentes tipos de consultas para trabajar, así como migraciones, seeding, y mucho más.

Django te proporciona todo eso fuera de la caja. Simplemente conecta las credenciales de tu base de datos favorita - Postgres, MySQL, Mongo, etc. - y Django se encarga del resto. Puede crear modelos e interactuar con ellos a través de la misma interfaz de Python sin importar la base de datos que elija.

Sólo una nota aquí: a menos que usted es un maestro de SQL o tiene un caso muy especial, tú debes estar usando un ORM para interactuar con bases de datos en cada aplicación.

Todas las características listadas hasta ahora no son exclusivas solo de Django de Python. La diferencia es que la mayoría de los frameworks le permiten configurar tu propio ORM, autenticación, etc. Django hace todo esto con muy poco esfuerzo. Esto significa que puede enviar características, MVPs y aplicaciones más rápidamente.

Velocidad de Desarrollo

Python es un lenguaje que se utiliza comúnmente para crear prototipos y desarrollar aplicaciones rápidamente. Django le da la velocidad y la potencia de Python con muchas características integradas adicionales para ayudar a crear aplicaciones web y APIs mucho más rápido.

Tomar decisiones e investigar herramientas y bibliotecas lleva mucho tiempo en lugar de escribir código. Django tiene formas bien documentadas para hacer las cosas, lo que elimina todo el tiempo extra que podrías usar en averiguar una buena solución por ti mismo.

Desde el arranque un proyecto para ti, hasta crear consultas complejas y la implementación de su aplicación, Django lo tiene cubierto con una gran documentación y una gran comunidad para ayudarlo si se queda atascado.

Sin embargo, no son solo las bibliotecas principales de Django las que pueden ayudarlo a crear aplicaciones más rápidamente. Django también tiene miles de plugins con una API común para que pueda tener ciertas expectativas sobre cómo utilizar cualquiera de ellos en tu proyecto.

Django Plugins

¿Deseas crear un CMS? Django tiene un plugin para eso. En realidad, bastantes de ellos. Si buscas en Github y DjangoPackages.org, encontrarás una gran cantidad de soluciones para casi cualquier caso de uso.

Aquí algunos de mis favoritos:

• Django Rest Framework: Routers, serializers, y otras harramientas para crear APIs simples.
• Django Graphene: Facilita añadir la funcionalidad GraphQL a las aplicaciones de Django.
• Wagtail: Añade una hermosa interfaz de estilo CMS a Django con un montón de características integradas para casos comunes de uso de CMS
• Django Crispy Forms: Si está creando aplicaciones full-stack, este paquete hace que trabajar con formularios dentro de plantillas sea mucho más limpio y fácil.
• Django Debug Toolbar: Esto es necesario para los proyectos de Django. Puede depurar todo, desde consultas SQL hasta plantillas mediante esta herramienta.

Espero haberte dado una prueba suficiente de Django para que lo pruebes por ti mismo. Déjame saber como te va :)

Trabajo con un gran equipo como un senior software developer en RocketBuild! Construimos muchos proyectos interesantes en Django, React y otras tecnologías.

Si quieres ver más contenidos de Django, Python, and JavaScript, echa un vistazo a mi canal de YouTube, Faraday Academy. O mantente en contacto conmigo en Twitter, @faradayacademy.

Traducido del artículo de Gwendolyn Faraday - What is Python's Django used for? 5 Key Reasons I Use the Django Framework for Client Projects