Dostęp do danych od gigantów handlu elektronicznego, takich jak Amazon, ma kluczowe znaczenie dla analizy rynku, strategii cenowych i badań produktów. Dane te mogą być gromadzone poprzez web scraping, metodę polegającą na wyodrębnianiu dużych ilości informacji ze stron internetowych. Jednak Amazon rygorystycznie chroni swoje dane, przez co tradycyjne techniki scrapingu są często nieskuteczne. W tym kompleksowym przewodniku zagłębimy się w metody zbierania danych o produktach z Amazon i omówimy strategie obchodzenia solidnych systemów anty-scrapingowych platformy. Zbadamy wykorzystanie Pythona, serwerów proxy i zaawansowanych technik skrobania, które mogą pomóc w pokonaniu tych wyzwań i skutecznym zbieraniu danych potrzebnych do celów biznesowych lub badawczych.
Aby skutecznie skrobać dane z Amazon, można postępować zgodnie z algorytmem strukturalnym opisanym poniżej. Metoda ta zapewnia wydajne i dokładne pobieranie potrzebnych informacji.
Krok 1: Wysyłanie żądań HTTP do stron produktów Amazon:
Krok 2: Parsowanie zawartości HTML:
Krok 3: Przechowywanie danych:
Amazon stosuje kilka środków utrudniających skrobanie, w tym ograniczenia prędkości połączenia, integrację CAPTCHA i blokowanie adresów IP. Użytkownicy mogą zastosować środki zaradcze w celu obejścia tych przeszkód, takie jak wykorzystanie wysokiej jakości serwerów proxy.
W przypadku szeroko zakrojonych działań związanych ze skrobaniem można zastosować zaawansowane techniki Pythona w celu zebrania znacznych ilości danych o produktach. Techniki te obejmują header stuffing i TLS fingerprinting, które pomagają uniknąć wykrycia i zapewniają udaną ekstrakcję danych.
Kroki te zostaną wyjaśnione w kolejnych sekcjach artykułu, w których zobaczymy ich praktyczną implementację przy użyciu Pythona 3.12.2.
Aby zainicjować projekt skrobania stron internetowych, zaczniemy od skonfigurowania podstawowego skrobaka przy użyciu biblioteki lxml do analizowania HTML i biblioteki requests do zarządzania żądaniami HTTP kierowanymi do serwera Amazon.
Skupimy się na wyodrębnianiu istotnych informacji, takich jak nazwy produktów, ceny i oceny ze stron produktów Amazon. Zaprezentujemy również techniki efektywnego analizowania HTML i zarządzania żądaniami, zapewniając precyzyjne i zorganizowane wydobywanie danych.
Aby utrzymać zależności projektu i uniknąć konfliktów, zaleca się utworzenie oddzielnego środowiska wirtualnego dla tego przedsięwzięcia skrobania stron internetowych. Do konfigurowania środowisk wirtualnych zaleca się korzystanie z narzędzi takich jak "venv" lub "pyenv".
Potrzebne będą następujące biblioteki Python innych firm:
Służy do wysyłania żądań HTTP i pobierania treści internetowych. Jest często używana do skrobania stron internetowych i interakcji z internetowymi interfejsami API.
Instalacja:
PHP
Node.js
Python
Java
Golang
pl 
English 
Español 
中國人 
Tiếng Việt 
Deutsch 
Українська 
Português 
Français 
भारतीय 
Türkçe 
한국인 
Italiano 
Gaeilge 
اردو 
Indonesia pip install requests
Biblioteka do analizowania i manipulowania dokumentami XML i HTML. Jest często używana do skrobania stron internetowych i pracy z danymi strukturalnymi ze stron internetowych.
Instalacja:
pip install lxml
Tutaj musimy zaimportować wymagane biblioteki niezbędne do działania naszego scrapera. Obejmuje to bibliotekę request do obsługi żądań HTTP, bibliotekę CSV do obsługi operacji na plikach CSV, bibliotekę random do generowania losowych wartości i dokonywania losowych wyborów, bibliotekę lxml do analizowania surowej zawartości HTML oraz biblioteki Dict i List do podpowiadania typów.
import requests
import csv
import random
from lxml import html
from typing import Dict, List
Poniższy fragment kodu odczytuje plik CSV o nazwie amazon_product_urls.csv, w którym każdy wiersz zawiera adres URL strony produktu Amazon. Kod iteruje po wierszach, wyodrębniając adresy URL z każdego wiersza i dołączając je do listy o nazwie URL.
with open('amazon_product_urls.csv', 'r') as file:
reader = csv.DictReader(file)
for row in reader:
urls.append(row['url'])
Nagłówki żądań odgrywają ważną rolę w żądaniach HTTP, dostarczając złożonych informacji o kliencie i żądaniu. Podczas skrobania ważne jest, aby skopiować tytuły autoryzowanych użytkowników, aby uniknąć wykrycia i łatwo uzyskać dostęp do żądanych informacji. Naśladując powszechnie używane nagłówki, scraperzy mogą uniknąć technik wykrywania, zapewniając, że dane są wyodrębniane w sposób spójny, przy jednoczesnym zachowaniu standardów etycznych.
Proxy działają jako pośrednicy w skrobaniu stron internetowych, maskując adres IP skrobaka, aby zapobiec wykryciu i zablokowaniu serwera. Obrotowy serwer proxy umożliwia wysyłanie każdego żądania z nowym adresem IP, unikając potencjalnych blokad. Korzystanie z domowych lub mobilnych serwerów proxy zwiększa odporność na środki zapobiegające skrobaniu dzięki wykrywaniu prawdziwego hosta i dostawcy.
Kod do integracji nagłówków żądań i serwerów proxy z autoryzacją adresów IP:
headers = {
'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7',
'accept-language': 'en-IN,en;q=0.9',
'dnt': '1',
'sec-ch-ua': '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"Windows"',
'sec-fetch-dest': 'document',
'sec-fetch-mode': 'navigate',
'sec-fetch-site': 'same-origin',
'sec-fetch-user': '?1',
'upgrade-insecure-requests': '1',
}
proxies = {'http': '', 'https': ''}
W tym przypadku utworzymy listę kolekcji agentów użytkownika, z której dla każdego żądania zostanie wybrany losowy agent użytkownika. Wdrożenie mechanizmu rotacji nagłówków, takiego jak rotacja User-Agent po każdym żądaniu, może dodatkowo pomóc w ominięciu środków wykrywania botów.
useragents = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
"Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
]
headers['user-agent'] = random.choice(useragnets)
Wysyła żądanie HTTP GET do określonego adresu URL z niestandardowymi nagłówkami, limitem czasu wynoszącym 30 sekund i serwerami proxy określonymi dla żądania.
response = requests.get(url=url, headers=headers, proxies=proxies, timeout=30)Wymagane punkty danych: tytuł, cena i oceny. Teraz sprawdźmy i zidentyfikujmy odpowiednie XPath dla elementów pokazanych na zrzutach ekranu wraz z ich odpowiednimi punktami danych.
Poniższy zrzut ekranu pokazuje funkcję Chrome DevTools "Inspect" używaną do znalezienia XPath `//span[@id="productTitle"]/text()` w celu wyodrębnienia tytułu produktu ze strony produktu Amazon.
Poniższy zrzut ekranu pokazuje znalezienie odpowiedniego XPath `//div[@id="corePrice_feature_div"]/div/div/span/span/text()` do wyodrębnienia ceny produktu ze strony produktu Amazon.
Zrzut ekranu pokazuje znalezienie odpowiedniego XPath `//span[@id="acrPopover"]/@title'` do wyodrębnienia ocen produktów ze strony produktu Amazon.
Utwórz słownik, który zawiera wyrażenia XPath w celu wyodrębnienia określonych informacji ze strony internetowej: tytułu, ocen i ceny produktu.
xpath_queries = {'title': '//span[@id="productTitle"]/text()', 'ratings': '//span[@id="acrPopover"]/@title', 'price': '//span[@class="a-offscreen"]/text()'}Poniższy kod przetwarza zawartość HTML uzyskaną z żądania GET do serwera Amazon na ustrukturyzowany format przypominający drzewo, umożliwiając łatwiejszą nawigację i manipulację jego elementami i atrybutami.
tree = html.fromstring(response.text)
Poniższy fragment kodu wyodrębnia dane z przeanalizowanego drzewa HTML za pomocą zapytania XPath i przypisuje je do słownika z określonym kluczem. strip() służy do usuwania białych znaków na początku i na końcu, jeśli występują. Pobiera pierwszy wynik zapytania XPath i przechowuje go pod podanym kluczem w słowniku extracted_data.
data = tree.xpath(xpath_query)[0].strip()
extracted_data[key] = data
Poniższy kod zapisuje dane ze słownika extracted_data do pliku CSV o nazwie product_data.csv. Upewnij się, że wiersz nagłówka jest zapisywany tylko wtedy, gdy plik jest pusty. Jeśli plik nie jest pusty, dane są dodawane jako dodatkowy wiersz do pliku CSV. Ta funkcja umożliwia ciągłą aktualizację pliku CSV o nowe wyodrębnione dane bez nadpisywania istniejącego tekstu.
csv_file_path = 'product_data.csv'
fieldnames = ['title', 'ratings', 'price']
with open(csv_file_path, 'a', newline='') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
if csvfile.tell() == 0:
writer.writeheader()
writer.writerow(extracted_data)
Zapoznaj się z naszym kompletnym kodem, który pomoże Ci szybko rozpocząć pracę. Kod jest dobrze zorganizowany i udokumentowany, dzięki czemu jest przyjazny dla początkujących. Aby wykonać ten kod, użytkownik musi mieć plik CSV o nazwie "amazon_product_urls" w tym samym katalogu. Poniżej znajduje się struktura pliku CSV:
import requests
import csv
import random
from lxml import html
from typing import Dict, List
def send_requests(
url: str, headers: Dict[str, str], proxies: Dict[str, str]
) -> List[Dict[str, str]]:
"""
Wysyła żądania HTTP GET do wielu adresów URL z nagłówkami i serwerami proxy.
Args:
urls (str): Adres URL do wysyłania żądań.
headers (Dict[str, str]): Słownik zawierający nagłówki żądań.
proxies (Dict[str, str]): Słownik zawierający ustawienia proxy.
Returns:
Response: Obiekt odpowiedzi zawierający dane odpowiedzi dla każdego adresu URL.
"""
try:
response = requests.get(url, headers=headers, proxies=proxies, timeout=30)
# Response validation
if len(response.text)> 10000:
return response
return None
except Exception as e:
print(f"Error occurred while fetching URL {url}: {str(e)}")
def extract_data_from_html(
response, xpath_queries: Dict[str, str]
) -> Dict[str, List[str]]:
"""
Wyodrębnia dane z treści HTML za pomocą zapytań XPath.
Args:
response (Response): Obiekt odpowiedzi.
xpath_queries (Dict[str, str]): Słownik zawierający zapytania XPath do ekstrakcji danych.
Returns:
Dict[str, str]: Słownik zawierający wyodrębnione dane dla każdego zapytania XPath.
"""
extracted_data = {}
tree = html.fromstring(response.text)
for key, xpath_query in xpath_queries.items():
data = tree.xpath(xpath_query)[0].strip()
extracted_data[key] = data
return extracted_data
def save_to_csv(extracted_data: Dict[str, any]):
"""
Zapisuje słownik jako wiersz w pliku CSV przy użyciu DictWriter.
Args:
extracted_data (Dict[str, any]): Słownik reprezentujący wiersz danych.
"""
csv_file_path = "product_data.csv"
fieldnames = ["title", "ratings", "price"]
with open(csv_file_path, "a", newline="") as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
if csvfile.tell() == 0:
writer.writeheader() # Zapisz nagłówek tylko jeśli plik jest pusty
writer.writerow(extracted_data)
def main():
# Odczytywanie adresów URL z pliku CSV
urls = []
with open("amazon_product_urls.csv", "r") as file:
reader = csv.DictReader(file)
for row in reader:
urls.append(row["url"])
# Definiowanie nagłówków żądań
headers = {
"accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
"accept-language": "en-IN,en;q=0.9",
"dnt": "1",
"sec-ch-ua": '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
"sec-ch-ua-mobile": "?0",
"sec-ch-ua-platform": '"Windows"',
"sec-fetch-dest": "document",
"sec-fetch-mode": "navigate",
"sec-fetch-site": "same-origin",
"sec-fetch-user": "?1",
"upgrade-insecure-requests": "1",
"user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36",
}
useragents = [
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4591.54 Safari/537.36",
"Mozilla/5.0 (Windows NT 7_0_2; Win64; x64) AppleWebKit/541.38 (KHTML, like Gecko) Chrome/105.0.1585 Safari/537.36",
"Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/107.0.0.0 Safari/537.36",
"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/102.0.7863.44 Safari/537.36"
]
# Definiowanie serwerów proxy
proxies = {"http": "IP:Port", "https": "IP:Port"}
# Wysyłanie żądań do adresów URL
for url in urls:
# Rotacja Useragent w nagłówkach
headers["user-agent"] = random.choice(useragnets)
response = send_requests(url, headers, proxies)
if response:
# Wyodrębnianie danych z zawartości HTML
xpath_queries = {
"title": '//span[@id="productTitle"]/text()',
"ratings": '//span[@id="acrPopover"]/@title',
"price": '//span[@class="a-offscreen"]/text()',
}
extracted_data = extract_data_from_html(response, xpath_queries)
# Zapisywanie wyodrębnionych danych do pliku CSV
save_to_csv(extracted_data)
if __name__ == "__main__":
main()
W celu nieprzerwanego pozyskiwania danych dostępne są różne rozwiązania proxy, w tym Datacenter IPv4, rotacyjne proxy mobilne, ISP i proxy domowe. Odpowiednia logika rotacji i agenci użytkownika są wykorzystywani do symulacji rzeczywistego zachowania użytkownika, podczas gdy specjalne serwery proxy obsługują skrobanie na dużą skalę z wewnętrzną rotacją i rozległymi pulami adresów IP. Zrozumienie zalet i wad każdej opcji proxy ma kluczowe znaczenie dla nieprzerwanego pozyskiwania danych.
| Typ | Plusy | Minusy |
|---|---|---|
| Serwery proxy dla centrów danych |
Wysoka prędkość i wydajność. Opłacalność. Idealny dla dużych zamówień. |
Może być łatwo wykryty i umieszczony na czarnej liście. Nie jest niezawodny przeciwko systemom anty-skrobiącym lub anty-botom. |
| Pełnomocnicy mieszkaniowi |
Wysoka legalność dzięki prawdziwym adresom IP. Szeroka globalna dostępność adresów IP do skrobania danych specyficznych dla lokalizacji. Możliwość rotacji adresów IP. |
Droższe niż serwery proxy centrów danych. |
| Mobilne serwery proxy |
Bardzo legalne adresy IP. Skuteczne w unikaniu blokad i monitów weryfikacyjnych. |
Droższe niż inne typy proxy. Wolniejsze niż serwery proxy centrów danych ze względu na zależność od sieci komórkowej. |
| Serwery proxy dostawców usług internetowych |
Wysoce niezawodne adresy IP. Szybsze niż domowe adresy IP. |
Ograniczona dostępność adresów IP. Rotacja IP nie jest dostępna. |
Skrobanie danych produktowych z Amazon wymaga skrupulatnego przygotowania, aby skutecznie poruszać się po mechanizmach anty-skrobiących platformy. Wykorzystanie serwerów proxy wraz z Pythonem umożliwia wydajne przetwarzanie danych i ukierunkowaną ekstrakcję niezbędnych informacji. Wybierając serwery proxy do skrobania stron internetowych, należy wziąć pod uwagę takie czynniki, jak wydajność, koszt, niezawodność serwera i specyficzne wymagania projektu. Zastosowanie dynamicznych serwerów proxy i wdrożenie strategii przeciwdziałania środkom bezpieczeństwa może zminimalizować ryzyko zablokowania i zwiększyć ogólną wydajność procesu skrobania.
Komentarze: 0