Guida alla costruzione di un semplice tracker dei prezzi delle criptovalute

Tracciare i dati di prezzo delle criptovalute più popolari può essere impegnativo a causa della loro elevata volatilità. Condurre ricerche approfondite ed essere pronti a capitalizzare le opportunità di profitto sono essenziali quando si tratta di criptovalute. Ottenere dati precisi sui prezzi può essere talvolta difficile. Le API sono comunemente utilizzate a questo scopo, ma gli abbonamenti gratuiti spesso presentano delle limitazioni.

Analizzeremo come raccogliere periodicamente i prezzi correnti delle 150 principali criptovalute utilizzando Python. Il nostro tracker dei prezzi delle criptovalute raccoglierà i seguenti dati:

• Nome della moneta;
• Ticker;
• Prezzo;
• Percentuale di variazione del prezzo nelle 24 ore.

Fase 1: Importare le librerie

Il primo passo del nostro script Python è importare le librerie necessarie. Utilizzeremo le librerie `requests` e `BeautifulSoup` per inviare richieste ed estrarre dati da file HTML, rispettivamente.

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

Utilizzeremo anche `csv` per le operazioni sui file CSV e `time` e `random` per controllare la frequenza degli aggiornamenti dei prezzi e la rotazione dei proxy, rispettivamente.

Fase 2: Impostazione dei proxy

Quando si inviano richieste senza un proxy premium, è possibile che si verifichino risposte del tipo "Accesso negato".

È possibile impostare un proxy in questo modo:

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

Per i proxy autenticati, utilizzare il seguente formato:

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

Ricordarsi di sostituire "Your_proxy_IP_Address" e "Your_proxy_port" con l'indirizzo proxy effettivo. Inoltre, sostituire il valore di "username" e "password" con le proprie credenziali.

Fase 3: Rotazione dei proxy

La rotazione dei proxy è una tecnica molto importante per eseguire con successo lo scraping dei siti web moderni, che spesso bloccano o limitano l'accesso a bot e scrapers quando rilevano richieste multiple dallo stesso indirizzo IP. Per impostare la rotazione dei proxy, importare la libreria random.

Creare un elenco di proxy per la rotazione:

# Elenco dei proxy
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",
]

In seguito, definiamo una funzione get_proxy() per selezionare casualmente un proxy dal nostro elenco per ogni richiesta.

# per ruotare i proxy
def get_proxy(): 
  # Scegliere un proxy a caso dall'elenco
  proxy = random.choice(proxies) 
  return {
            "http": f'http://{proxy}',
            "https": f'http://{proxy}'
    }

Questa funzione restituisce un dizionario con il proxy selezionato per il protocollo HTTP. Questa configurazione ci aiuta ad apparire come più utenti organici del sito web che stiamo scrapando, aumentando le nostre possibilità di aggirare le misure anti-scraping.

Fase 4: Ottenere e analizzare i dati crittografici

La funzione get_crypto_prices() raccoglie i prezzi delle criptovalute da Coindesk. Invia una richiesta GET al sito web usando la funzione requests.get(), con i nostri proxy rotanti passati come argomento. Al costruttore di BeautifulSoup passiamo il testo della risposta e il parser "html.parser".

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

Fase 5: Comprendere la struttura del sito

Prima di iniziare l'estrazione dei dati, è necessario comprendere la struttura del sito. Possiamo usare gli Strumenti per gli sviluppatori del browser per ispezionare l'HTML della pagina web. Per accedere agli Strumenti per gli sviluppatori, si può fare clic con il tasto destro del mouse sulla pagina web e selezionare "Ispeziona".

Troviamo quindi tutti i contenitori dei prezzi nella pagina utilizzando la funzione find_all() di BeautifulSoup e il selettore CSS "tr", class_='css-1cxc880' ed estraiamo il nome della moneta, il ticker, il prezzo e la variazione percentuale di 24 ore per ogni contenitore. Questi dati vengono memorizzati in un dizionario e poi aggiunti all'elenco dei prezzi.

Estrarre il nome della moneta

Qui, utilizziamo row.find('p', class_='css-rkws3') per individuare l'elemento 'p' con la classe "css-rkws3". Quindi, estraiamo il testo e lo memorizziamo in una variabile "name".

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

Estrazione del ticker

Allo stesso modo, utilizziamo row.find("span", class_="css-1jj7b1a") per individuare l'elemento span con la classe "css-1jj7b1a". Il metodo get_text() estrae il contenuto del testo, fornendoci il ticker.

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

Estrarre il prezzo

Individuiamo l'elemento "div" con la classe "css-b1ilzc". Il contenuto del testo viene quindi estratto e assegnato alla variabile prezzo. Utilizziamo un'istruzione condizionale per gestire i casi in cui l'elemento potrebbe non essere presente.

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

Estrazione della variazione percentuale

Allo stesso modo, individuiamo l'elemento "p" con la classe "css-yyku61" per estrarre la variazione percentuale. Il contenuto del testo viene eliminato e una dichiarazione condizionale gestisce la potenziale assenza.

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

Mettendo tutto insieme, abbiamo un ciclo for che si presenta così:

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

Fase 6: Esportazione dei dati in CSV

La funzione export_to_csv() è definita per esportare i dati scraped in un file CSV. Utilizziamo la libreria CSV per scrivere i dati del listino prezzi nel file CSV specificato.

 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)

Fase 7: Esecuzione del tracker

Nella parte principale del nostro script, chiamiamo la funzione get_crypto_prices() per raccogliere i prezzi e export_to_csv() per esportarli in un file CSV. Aspettiamo quindi 5 minuti (300) prima di aggiornare nuovamente i prezzi. Questo viene fatto in un ciclo infinito, quindi i prezzi continueranno ad essere aggiornati ogni 5 minuti fino a quando il programma non verrà interrotto.

if __name__ == "__main__":
       while True:
           prices = get_crypto_prices()
           export_to_csv(prices)
           print("Prices updated. Waiting for the next update...")
           time.sleep(300)  # Aggiornamento dei prezzi ogni 5 minuti

Codice completo

Ecco il codice completo che integrerà tutte le tecniche e i passaggi che abbiamo trattato, fornendo un approccio semplificato per costruire un tracker dei prezzi delle criptovalute come abbiamo fatto in questo progetto.

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

# Elenco dei proxy
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",
]

# Metodo personalizzato per ruotare i proxy
def get_proxy():
    # Scegliere un proxy a caso dall'elenco
    proxy = random.choice(proxies)
    # Restituisce un dizionario con il proxy per il protocollo 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)  # Aggiornare i prezzi ogni 5 minuti (regolare secondo necessità)

Risultati

I risultati del nostro tracker dei prezzi delle criptovalute vengono salvati in un file CSV chiamato "proxy_crypto_prices.csv", come si vede qui sotto:

La sintassi semplice di Python lo rende la scelta ideale per costruire un tracker automatico dei prezzi delle criptovalute. Questo linguaggio di programmazione facilita l'aggiunta di nuove funzionalità e l'espansione delle capacità del tracker. L'esempio fornito mostra come creare uno scraper di base in grado di aggiornare automaticamente i tassi delle criptovalute a intervalli specifici, raccogliere i dati attraverso un proxy e salvarli in un formato di facile utilizzo.