Przewodnik po tworzeniu prostego narzędzia do śledzenia cen kryptowalut

Śledzenie danych dotyczących cen popularnych kryptowalut może być trudne ze względu na ich dużą zmienność. Prowadzenie dokładnych badań i bycie przygotowanym na wykorzystanie możliwości zysku jest niezbędne w przypadku kryptowalut. Uzyskanie dokładnych danych cenowych może być czasami trudne. Interfejsy API są powszechnie wykorzystywane do tego celu, ale bezpłatne subskrypcje często wiążą się z ograniczeniami.

Zbadamy, jak okresowo skrobać bieżące ceny 150 najlepszych kryptowalut za pomocą Pythona. Nasz tracker cen kryptowalut będzie zbierał następujące dane:

• Nazwa monety;
• Ticker;
• Cena;
• Procentowa zmiana ceny w ciągu 24 godzin.

Krok 1: Importowanie bibliotek

Pierwszym krokiem w naszym skrypcie Python jest zaimportowanie niezbędnych bibliotek. Użyjemy bibliotek `requests` i `BeautifulSoup` odpowiednio do wysyłania żądań i wyodrębniania danych z plików HTML.

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

Będziemy również używać `csv` do operacji na plikach CSV oraz `time` i `random` do kontrolowania odpowiednio częstotliwości aktualizacji cen i rotacji proxy.

Krok 2: Konfiguracja serwerów proxy

Wysyłając żądania bez proxy premium, możesz napotkać odpowiedzi "Odmowa dostępu".

Możesz skonfigurować proxy w ten sposób:

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

W przypadku uwierzytelnionych serwerów proxy należy użyć następującego formatu:

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

Pamiętaj, aby zastąpić "Your_proxy_IP_Address" i "Your_proxy_port" rzeczywistym adresem proxy. Zastąp również wartości "username" i "password" swoimi poświadczeniami.

Krok 3: Rotacja serwerów proxy

Rotacja serwerów proxy jest bardzo ważną techniką skutecznego skrobania nowoczesnych stron internetowych, ponieważ często blokują one lub ograniczają dostęp do botów i skrobaków, gdy wykryją wiele żądań z tego samego adresu IP. Aby skonfigurować rotację proxy, zaimportuj bibliotekę random.

Utwórz listę serwerów proxy do rotacji:

# Lista pełnomocników
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",
]

Przechodząc dalej, definiujemy funkcję get_proxy(), aby losowo wybrać serwer proxy z naszej listy dla każdego żądania.

# metoda obracania serwerów proxy
def get_proxy(): 
  # Wybierz losowy serwer proxy z listy
  proxy = random.choice(proxies) 
  return {
            "http": f'http://{proxy}',
            "https": f'http://{proxy}'
    }

Ta funkcja zwraca słownik z wybranym proxy dla protokołu HTTP. Ta konfiguracja pomaga nam wyświetlać się jako wielu organicznych użytkowników witryny, którą skrobiemy, zwiększając nasze szanse na ominięcie środków zapobiegających skrobaniu.

Krok 4: Uzyskanie i przeanalizowanie naszych danych kryptograficznych

Funkcja get_crypto_prices() pobiera ceny kryptowalut z Coindesk. Wysyła żądanie GET do strony internetowej za pomocą funkcji requests.get(), z naszymi obrotowymi serwerami proxy przekazanymi jako argument. Przekazujemy tekst odpowiedzi i parser "html.parser" do konstruktora BeautifulSoup.

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

Krok 5: Zrozumienie struktury strony

Zanim rozpoczniemy ekstrakcję danych, musimy zrozumieć strukturę strony. Możemy użyć Narzędzi dla programistów przeglądarki, aby sprawdzić HTML strony internetowej. Aby uzyskać dostęp do Narzędzi dla programistów, należy kliknąć prawym przyciskiem myszy na stronie internetowej i wybrać opcję "Sprawdź".

Następnie znajdujemy wszystkie kontenery cenowe na stronie za pomocą funkcji find_all() BeautifulSoup i selektora CSS "tr", class_='css-1cxc880' i wyodrębniamy nazwę monety, ticker, cenę i 24-godzinną zmianę procentową dla każdego kontenera. Dane te są przechowywane w słowniku, a następnie dołączane do listy cen.

Wyodrębnianie nazwy monety

Tutaj używamy row.find('p', class_='css-rkws3'), aby zlokalizować element 'p' z klasą "css-rkws3". Następnie wyodrębniamy tekst i przechowujemy go w zmiennej "name".

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

Wyciąganie paska

Podobnie, używamy row.find("span", class_="css-1jj7b1a"), aby zlokalizować element span z klasą "css-1jj7b1a". Metoda get_text() wyodrębnia zawartość tekstową, dostarczając nam ticker.

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

Odliczanie ceny

Lokalizujemy element "div" z klasą "css-b1ilzc". Zawartość tekstowa jest następnie usuwana i przypisywana do zmiennej price. Używamy instrukcji warunkowej do obsługi przypadków, w których element może nie być obecny.

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

Wyciąganie zmiany procentowej

Podobnie, lokalizujemy element "p" z klasą "css-yyku61", aby wyodrębnić zmianę procentową. Zawartość tekstowa jest usuwana, a instrukcja warunkowa obsługuje potencjalny brak.

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

Łącząc to wszystko razem, mamy pętlę for, która wygląda następująco:

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

Krok 6: Eksport danych do CSV

Funkcja export_to_csv() jest zdefiniowana do eksportowania zeskrobanych danych do pliku CSV. Używamy biblioteki CSV, aby zapisać dane z listy cen do określonego pliku CSV.

 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)

Krok 7: Uruchomienie modułu śledzącego

W głównej części naszego skryptu wywołujemy funkcję get_crypto_prices(), aby pobrać ceny i export_to_csv(), aby wyeksportować je do pliku CSV. Następnie czekamy 5 minut (300) przed ponowną aktualizacją cen. Odbywa się to w nieskończonej pętli, więc ceny będą aktualizowane co 5 minut, dopóki program nie zostanie zatrzymany.

if __name__ == "__main__":
       while True:
           prices = get_crypto_prices()
           export_to_csv(prices)
           print("Prices updated. Waiting for the next update...")
           time.sleep(300)  # Update prices every 5 minutes

Pełny kod

Oto pełny kod, który zintegruje wszystkie techniki i kroki, które omówiliśmy, zapewniając usprawnione podejście do budowania narzędzia do śledzenia cen kryptowalut, tak jak zrobiliśmy to w tym projekcie.

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

# Lista pełnomocników
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",
]

# Niestandardowa metoda obracania serwerów proxy
def get_proxy():
    # Wybierz losowy serwer proxy z listy
    proxy = random.choice(proxies)
    # Zwraca słownik z proxy dla protokołu 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)  # Aktualizuj ceny co 5 minut (dostosuj w razie potrzeby)

Wyniki

Wyniki naszego narzędzia do śledzenia cen kryptowalut są zapisywane w pliku CSV o nazwie "proxy_crypto_prices.csv", jak pokazano poniżej:

Prosta składnia Pythona sprawia, że jest to idealny wybór do budowy automatycznego narzędzia do śledzenia cen kryptowalut. Ten język programowania ułatwia dodawanie nowych funkcji i rozszerzanie możliwości trackera. Przedstawiony przykład pokazuje, jak stworzyć podstawowy scraper, który może automatycznie aktualizować kursy kryptowalut w określonych odstępach czasu, zbierać dane za pośrednictwem proxy i zapisywać je w przyjaznym dla użytkownika formacie.