Guía para crear un sencillo rastreador de precios de criptomonedas

El seguimiento de los datos de precios de las criptodivisas más populares puede resultar complicado debido a su alta volatilidad. Llevar a cabo una investigación exhaustiva y estar preparado para capitalizar las oportunidades de beneficio son esenciales cuando se trata de criptodivisas. A veces puede resultar difícil obtener datos precisos sobre los precios. Las API se utilizan comúnmente para este propósito, pero las suscripciones gratuitas a menudo vienen con limitaciones.

Exploraremos cómo raspar periódicamente los precios actuales de las 150 principales cryptocurrencies usando Python. Nuestro rastreador de precios de criptodivisas recopilará los siguientes datos:

• Nombre de la moneda;
• Ticker;
• Precio;
• Porcentaje de variación del precio en 24 horas.

Paso 1: importación de bibliotecas

El primer paso en nuestro script Python es importar las librerías necesarias. Utilizaremos las librerías `requests` y `BeautifulSoup` para enviar peticiones y extraer datos de archivos HTML, respectivamente.

import requests
from bs4 import BeautifulSoup
import csv
import time
import random

También utilizaremos `csv` para operaciones con ficheros CSV y `time` y `random` para controlar la frecuencia de actualización de precios y la rotación de proxies, respectivamente.

Paso 2: Configuración de proxies

Al enviar peticiones sin un proxy premium, es posible que te encuentres con respuestas de "Acceso denegado".

Puedes configurar un proxy de esta manera:

proxy = {
 "http": "http://Your_proxy_IP_Address:Your_proxy_port",
}
html = requests.get(url, proxies=proxy)

Para proxies autenticados, utilice el siguiente formato:

proxy = {
 "http": "http://username:password@Your_proxy_IP_Address:Your_proxy_port",
}
html = requests.get(url, proxies=proxy)

Recuerda sustituir "Tu_dirección_IP_proxy" y "Tu_puerto_proxy" por la dirección real del proxy. Además, sustituye el valor de "username" y "password" por tus credenciales.

Paso 3: Rotación de proxies

Rotar los proxies es una técnica muy importante para hacer scraping con éxito en los sitios web modernos, ya que suelen bloquear o restringir el acceso a bots y scrapers cuando detectan múltiples peticiones desde la misma dirección IP. Para configurar la rotación de proxies, importa la librería random.

Crea una lista de proxies para la rotación:

# Lista de apoderados
proxies = [ 
 "username:password@Your_proxy_IP_Address:Your_proxy_port1",
 "username:password@Your_proxy_IP_Address:Your_proxy_port2",
 "username:password@Your_proxy_IP_Address:Your_proxy_port3",
 "username:password@Your_proxy_IP_Address:Your_proxy_port4",
 "username:password@Your_proxy_IP_Address:Your_proxy_port5",
]

A continuación, definimos una función get_proxy() para seleccionar aleatoriamente un proxy de nuestra lista para cada petición.

# para rotar sus proxies
def get_proxy(): 
  # Elija un proxy al azar de la lista
  proxy = random.choice(proxies) 
  return {
            "http": f'http://{proxy}',
            "https": f'http://{proxy}'
    }

Esta función devuelve un diccionario con el proxy seleccionado para el protocolo HTTP. Esta configuración nos ayuda a aparecer como múltiples usuarios orgánicos en el sitio web que estamos raspando, mejorando nuestras posibilidades de eludir las medidas anti-scraping.

Paso 4: Obtención y análisis sintáctico de nuestros datos criptográficos

La función get_crypto_prices() extrae los precios de las criptomonedas de Coindesk. Envía una solicitud GET al sitio web utilizando la función requests.get(), con nuestros proxies giratorios pasados como argumento. Pasamos el texto de la respuesta y el parser "html.parser" al constructor BeautifulSoup.

def get_crypto_prices():
    url = "https://crypto.com/price"
    html = requests.get(url, proxies=get_proxy())
    soup = BeautifulSoup(html.text, "html.parser")

Paso 5: Comprender la estructura del sitio

Antes de comenzar la extracción de datos, necesitamos entender la estructura del sitio. Podemos utilizar las Herramientas para desarrolladores del navegador para inspeccionar el HTML de la página web. Para acceder a las Herramientas para desarrolladores, puedes hacer clic con el botón derecho en la página web y seleccionar "Inspeccionar".

A continuación, encontramos todos los contenedores de precios de la página utilizando la función find_all() de BeautifulSoup y el selector CSS "tr", class_='css-1cxc880' y extraemos el nombre de la moneda, el ticker, el precio y el cambio porcentual de 24 horas de cada contenedor. Estos datos se almacenan en un diccionario y luego se anexan a la lista de precios.

Extracción del nombre de la moneda

Aquí, utilizamos row.find('p', class_='css-rkws3') para localizar el elemento 'p' con la clase "css-rkws3" . Luego, extraemos el texto y lo almacenamos en una variable "name".

coin_name_tag = row.find('p', class_='css-rkws3')
name = coin_name_tag.get_text() if coin_name_tag else "no name entry"

Extracción del teletipo

Del mismo modo, utilizamos row.find("span", class_="css-1jj7b1a") para localizar el elemento span con la clase "css-1jj7b1a". El método get_text() extrae el contenido del texto, proporcionándonos el ticker.

coin_ticker_tag = row.find('span', class_='css-1jj7b1a')
ticker = coin_ticker_tag.get_text() if coin_ticker_tag else "no ticker entry"

Extrayendo el precio

Localizamos el elemento "div" con la clase "css-b1ilzc". A continuación, extraemos el contenido de texto y lo asignamos a la variable precio. Utilizamos una sentencia condicional para manejar los casos en los que el elemento podría no estar presente.

coin_price_tag = row.find('div', class_='css-b1ilzc')
price = coin_price_tag.text.strip() if coin_price_tag else "no price entry"

Extracción del cambio porcentual

Del mismo modo, localizamos el elemento "p" con la clase "css-yyku61" para extraer el cambio porcentual. Se extrae el contenido de texto y una sentencia condicional se encarga de la posible ausencia.

coin_percentage_tag = row.find('p', class_='css-yyku61')
percentage = coin_percentage_tag.text.strip() if coin_percentage_tag else "no percentage entry"

Poniendo todo junto, tenemos un bucle for que se parece a esto:

for row in price_rows:
        coin_name_tag = row.find('p', class_='css-rkws3')
        name = coin_name_tag.get_text() if coin_name_tag else "no name entry"

        coin_ticker_tag = row.find('span', class_='css-1jj7b1a')
        ticker = coin_ticker_tag.get_text() if coin_ticker_tag else "no ticker entry"
        
        coin_price_tag = row.find('div', class_='css-b1ilzc')
        price = coin_price_tag.text.strip() if coin_price_tag else "no price entry"

        coin_percentage_tag = row.find('p', class_='css-yyku61')
        percentage = coin_percentage_tag.text.strip() if coin_percentage_tag else "no percentage entry"
        
        prices.append({
            "Coin": name,
            "Ticker": ticker,
            "Price": price,
            "24hr-Percentage": percentage
        })
    
    return prices

Paso 6: Exportar los datos a CSV

La función export_to_csv() se define para exportar los datos raspados a un archivo CSV. Utilizamos la biblioteca CSV para escribir los datos de la lista de precios en el archivo CSV especificado.

 def export_to_csv(prices, filename="proxy_crypto_prices.csv"):
       with open(filename, "w", newline="") as file:
           fieldnames = ["Coin", "Ticker", "Price", "24hr-Percentage"]
           writer = csv.DictWriter(file, fieldnames=fieldnames)
           writer.writeheader()
           writer.writerows(prices)

Paso 7: Ejecutar el rastreador

En la parte principal de nuestro script, llamamos a la función get_crypto_prices() para scrapear los precios y export_to_csv() para exportarlos a un archivo CSV. A continuación, esperamos 5 minutos (300) antes de volver a actualizar los precios. Esto se hace en un bucle infinito, por lo que los precios se seguirán actualizando cada 5 minutos hasta que se detenga el programa.

if __name__ == "__main__":
       while True:
           prices = get_crypto_prices()
           export_to_csv(prices)
           print("Prices updated. Waiting for the next update...")
           time.sleep(300)  # Actualización de precios cada 5 minutos

Código completo

Aquí está el código completo que integrará todas las técnicas y pasos que hemos cubierto, proporcionando un enfoque racionalizado para construir un rastreador de precios crypto como lo hemos hecho en este proyecto.

import requests
from bs4 import BeautifulSoup
import csv
import time
import random

# Lista de apoderados
proxies = [
     "username:password@Your_proxy_IP_Address:Your_proxy_port1",
     "username:password@Your_proxy_IP_Address:Your_proxy_port2",
     "username:password@Your_proxy_IP_Address:Your_proxy_port3",
     "username:password@Your_proxy_IP_Address:Your_proxy_port4",
     "username:password@Your_proxy_IP_Address:Your_proxy_port5",
]

# Método personalizado para rotar proxies
def get_proxy():
    # Elija un proxy al azar de la lista
    proxy = random.choice(proxies)
    # Devuelve un diccionario con el proxy para el protocolo http
    return {"http": f'http://{proxy}',
            "https": f'http://{proxy}'
          }


def get_crypto_prices():
    url = "https://crypto.com/price"
    html = requests.get(url, proxies=get_proxy())
    print(html.status_code)
    soup = BeautifulSoup(html.content, "html.parser")

    price_rows = soup.find_all('tr', class_='css-1cxc880')

    prices = []
    for row in price_rows:
        coin_name_tag = row.find('p', class_='css-rkws3')
        name = coin_name_tag.get_text() if coin_name_tag else "no name entry"

        coin_ticker_tag = row.find('span', class_='css-1jj7b1a')
        ticker = coin_ticker_tag.get_text() if coin_ticker_tag else "no ticker entry"
        
        coin_price_tag = row.find('div', class_='css-b1ilzc')
        price = coin_price_tag.text.strip() if coin_price_tag else "no price entry"

        coin_percentage_tag = row.find('p', class_='css-yyku61')
        percentage = coin_percentage_tag.text.strip() if coin_percentage_tag else "no percentage entry"
        
        prices.append({
            "Coin": name,
            "Ticker": ticker,
            "Price": price,
            "24hr-Percentage": percentage
        })
    
    return prices



def export_to_csv(prices, filename="proxy_crypto_prices.csv"):
    with open(filename, "w", newline="") as file:
        fieldnames = ["Coin", "Ticker", "Price", "24hr-Percentage"]
        writer = csv.DictWriter(file, fieldnames=fieldnames)

        writer.writeheader()
        writer.writerows(prices)


if __name__ == "__main__":
    while True:
        prices = get_crypto_prices()
        export_to_csv(prices)
        print("Prices updated. Waiting for the next update...")
        time.sleep(300)  # Actualice los precios cada 5 minutos (ajústelos según sea necesario)

Resultados

Los resultados de nuestro rastreador de precios de criptomonedas se guardan en un archivo CSV llamado "proxy_crypto_prices.csv" como se ve a continuación:

Python's straightforward syntax makes it the ideal choice for building an automated cryptocurrency price tracker. This programming language facilitates the addition of new features and the expansion of the tracker's capabilities. The example provided demonstrates how to create a basic scraper that can automatically update cryptocurrency rates at specified intervals, collect data through a proxy, and save it in a user-friendly format.