Lalkarz kontra Selenium: co wybrać do skrobania sieci?

Czy próbujesz wybrać pomiędzy Puppeteerem a Selenium do skrobania sieci? Obydwa są potężnymi strukturami automatyzacji przeglądarki, a dokonanie właściwego wyboru zależy od konkretnych potrzeb w zakresie skrobania i dostępnych zasobów.

Aby pomóc Ci podjąć świadomą decyzję, w poniższej tabeli podkreśliliśmy kluczowe różnice między Puppeteer i Selenium. Następnie zagłębimy się w szczegóły i przedstawimy przykład skrobania dla każdego frameworka, aby zademonstrować jego skuteczność w wydobywaniu danych ze stron internetowych.

Przejdźmy do szczegółowego omówienia tych bibliotek i przeprowadźmy przykład skrobania dla każdej z nich, aby zilustrować ich skuteczność w wyodrębnianiu danych ze strony internetowej.

Lalkarz

Lalkarz to biblioteka Node.js, która zapewnia interfejs API wysokiego poziomu do kontrolowania przeglądarki Chrome lub Chromium za pośrednictwem protokołu DevTools. Przeznaczony jest do automatyzacji zadań w przeglądarce Chrome lub Chromium, takich jak robienie zrzutów ekranu, generowanie plików PDF i nawigacja po stronach.

Puppeteer może być również używany do testowania stron internetowych poprzez symulację interakcji użytkownika, takich jak klikanie przycisków, wypełnianie formularzy i weryfikacja wyświetlanych wyników.

Zalety Lalkarza

• Łatwość użycia: Prosty i łatwy w użyciu.
• W zestawie z chromem: Nie jest wymagana żadna dodatkowa konfiguracja.
• Tryb bezgłowy: Domyślnie działa w trybie bezgłowym, ale można go skonfigurować tak, aby działał w trybie pełnej przeglądarki.
• Architektura sterowana zdarzeniami: Eliminuje potrzebę ręcznych wywołań uśpienia w kodzie.
• Wszechstronne możliwości: Może robić zrzuty ekranu, generować pliki PDF i automatyzować wszystkie działania przeglądarki.
• Zarządzanie wydajnością: Oferuje narzędzia do rejestrowania czasu działania i wydajności obciążenia w celu optymalizacji i debugowania skrobaka.
• Pełzanie SPA: Możliwość przeszukiwania aplikacji jednostronicowych (SPA) i generowania wstępnie renderowanej zawartości (renderowanie po stronie serwera).
• Nagrywanie skryptu: Umożliwia tworzenie skryptów Puppeteer poprzez rejestrowanie działań w przeglądarce za pomocą konsoli DevTools.

Wady Lalkarza

• Ograniczona obsługa przeglądarek: Obsługuje mniej przeglądarek w porównaniu do Selenium.
• Koncentruje się na JavaScript: Obsługuje głównie JavaScript, chociaż istnieją nieoficjalne porty dla Pythona i PHP.

Przykład skrobania sieci za pomocą Puppeteera

Przejdźmy przez samouczek dotyczący skrobania sieci Puppeteer, aby wyodrębnić elementy z kategorii Kryminał i Thriller w witrynie Dunaj.

Sklep Danube: kryminały i thrillery

Aby rozpocząć, zaimportuj moduł Puppeteer i utwórz funkcję asynchroniczną, aby uruchomić kod Puppeteer:

const puppeteer = require('puppeteer'); 

async function main() { 
    // Launch a headless browser instance 
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object 
    const page = await browser.newPage();

    // Navigate to the target URL and wait until the loading finishes
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    // Wait for the left-side bar to load
    await page.waitForSelector('ul.sidebar-list');

    // Click on the first element and wait for the navigation to finish
    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    // Wait for the book previews to load
    await page.waitForSelector("li[class='preview']");

    // Extract the book previews
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    // Extract the relevant data using page.evaluate
    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    // Print out the extracted data
    console.log(processed_data);

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the main function to scrape the data
main();

Oczekiwany wynik

Po uruchomieniu kodu wynik powinien wyglądać następująco:

[
    {
        title: 'Does the Sun Also Rise?',
        author: 'Ernst Doubtingway',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'The Insiders',
        author: 'E. S. Hilton',
        rating: '★★★★☆',
        price: '$9.95'
    },
    {
        title: 'A Citrussy Clock',
        author: 'Bethany Urges',
        rating: '★★★★★',
        price: '$9.95'
    }
]

Inny przykład użycia Puppeteer

Oprócz zgarniania danych ze stron internetowych, Puppeteer może być używany do różnych zadań automatyzacji. Jednym z typowych przypadków użycia jest wygenerowanie pliku PDF strony internetowej. Przeanalizujmy przykład, w którym Puppeteer jest używany do generowania pliku PDF ze strony internetowej.

Generowanie pliku PDF w programie Puppeteer

Krok 1: Zaimportuj Lalkarza i utwórz funkcję asynchroniczną

const puppeteer = require('puppeteer');

async function generatePDF() {
    // Launch a headless browser instance
    const browser = await puppeteer.launch({ headless: true });

    // Create a new page object
    const page = await browser.newPage();

    // Navigate to the target URL
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Generate a PDF from the web page
    await page.pdf({
        path: 'example.pdf', // Output file path
        format: 'A4',        // Paper format
        printBackground: true, // Include background graphics
    });

    // Close the page and browser respectively
    await page.close();
    await browser.close();
}

// Run the function to generate the PDF
generatePDF();

Dodatkowe opcje lalkarza

Puppeteer udostępnia kilka opcji generowania plików PDF, które można dostosować do własnych potrzeb. Oto niektóre opcje, z których możesz skorzystać:

• path: Ścieżka pliku, w którym ma zostać zapisany plik PDF.
• format: Format papieru (np. „A4”, „Letter”).
• printBackground: Określa, czy dołączyć grafikę tła.
• landscape: Ustawić true do orientacji poziomej.
• margin: Określ marginesy pliku PDF (górny, prawy, dolny, lewy).

Przykład z dodatkowymi opcjami:

const puppeteer = require('puppeteer');

async function generatePDF() {
    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    await page.pdf({
        path: 'example.pdf',
        format: 'A4',
        printBackground: true,
        landscape: true,
        margin: {
            top: '20px',
            right: '20px',
            bottom: '20px',
            left: '20px',
        },
    });

    await page.close();
    await browser.close();
}

generatePDF();

Przykładowe wyjście

Uruchomienie powyższego kodu spowoduje utworzenie pliku PDF o nazwie example.pdf w bieżącym katalogu z zawartością strony internetowej https://example.com.

Puppeteer to wszechstronne narzędzie do zadań automatyzacji sieci, od skrobania danych po generowanie plików PDF. Łatwość obsługi i zaawansowane funkcje sprawiają, że jest to doskonały wybór do automatyzacji szerokiego zakresu działań przeglądarki. Niezależnie od tego, czy zgarniasz dane, generujesz raporty, czy testujesz strony internetowe, Puppeteer zapewnia narzędzia potrzebne do wydajnej pracy.

Selen

Selen to narzędzie typu open source do kompleksowego testowania i automatyzacji sieci, często używane do skrobania sieci. Jego główne komponenty obejmują Selenium IDE, Selenium WebDriver i Selenium Grid.

• Selen IDE: Służy do rejestrowania działań przed ich automatyzacją.
• Selenium WebDriver: Wykonuje polecenia w przeglądarce.
• Siatka selenowa: Umożliwia wykonanie równoległe.

Zalety selenu

• Łatwość użycia: Prosty i łatwy w użyciu.
• Wsparcie językowe: Obsługuje różne języki programowania, takie jak Python, Java, JavaScript, Ruby i C#.
• Automatyzacja przeglądarki: Może automatyzować przeglądarki takie jak Firefox, Edge, Safari, a nawet niestandardowe przeglądarki QtWebKit.
• Skalowalność: Możliwość skalowania Selenium do setek instancji przy użyciu serwerów w chmurze z różnymi ustawieniami przeglądarki.
• Wieloplatformowy: Działa w systemach Windows, macOS i Linux.

Wady selenu

• Złożona konfiguracja: Metody konfiguracji Selenium mogą być złożone.

Próbka skrobania sieci z selenem

Podobnie jak w przypadku Puppeteera, przejrzyjmy samouczek dotyczący skrobania stron internetowych za pomocą Selenium przy użyciu tej samej witryny docelowej. Zapowiedzi książek pobierzemy z kategorii Kryminał i Thriller na stronie Dunaj.

Sklep Danube: kryminały i thrillery

Krok 1: Zaimportuj niezbędne moduły i skonfiguruj Selenium

import time
from selenium import webdriver
from selenium.webdriver.common.by import By

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Krok 2: Zainicjuj sterownik Chrome WebDriver

driver = webdriver.Chrome(options=options)

Krok 3: Przejdź do docelowej witryny internetowej

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Krok 4: Kliknij kategorię Kryminały i thrillery i wyodrębnij podglądy książek

time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

Krok 5: Zdefiniuj funkcję wyodrębniającą dane z każdego podglądu książki

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

Krok 6: Przejdź przeglądanie podglądów, wyodrębnij dane i zamknij sterownik

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)
driver.quit()

Oczekiwany wynik

Uruchomienie powyższego kodu da wynik podobny do poniższego:

[
    {'title': 'Does the Sun Also Rise?', 'author': 'Ernst Doubtingway', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'The Insiders', 'author': 'E. S. Hilton', 'rating': '★★★★☆', 'price': '$9.95'},
    {'title': 'A Citrussy Clock', 'author': 'Bethany Urges', 'rating': '★★★★★', 'price': '$9.95'}
]

Dodatkowy przykład Selenium: robienie zrzutu ekranu

Oprócz skrobania danych Selenium można również używać do robienia zrzutów ekranu stron internetowych. Oto przykład wykonania zrzutu ekranu strony internetowej przy użyciu Selenium.

Krok 1: Zaimportuj niezbędne moduły i skonfiguruj Selenium

from selenium import webdriver

options = webdriver.ChromeOptions()
options.add_argument("--headless")

Krok 2: Zainicjuj sterownik Chrome WebDriver

driver = webdriver.Chrome(options=options)

Krok 3: Przejdź do docelowej witryny internetowej

url = "https://example.com"
driver.get(url)

Krok 4: Zrób zrzut ekranu

driver.save_screenshot("example_screenshot.png")

Krok 5: Zamknij sterownik

driver.quit()

Selenium to wszechstronne narzędzie do zadań automatyzacji sieci, w tym skrobania sieci i robienia zrzutów ekranu. Obsługa wielu języków programowania i przeglądarek, a także skalowalność sprawia, że jest to doskonały wybór w przypadku różnych potrzeb związanych z automatyzacją. Niezależnie od tego, czy wyodrębniasz dane, czy generujesz raporty, Selenium zapewnia możliwości skutecznej automatyzacji zadań.

Lalkarz kontra Selen: porównanie prędkości

Czy Puppeteer jest szybszy niż Selenium? Odpowiedź brzmi tak — Puppeteer jest generalnie szybszy niż Selenium.

Aby porównać szybkość Puppeteera i Selenium, użyliśmy piaskownicy sklepu Danube i uruchomiliśmy przedstawione powyżej skrypty 20 razy, uśredniając czas wykonania.

Test prędkości Selenu

Korzystaliśmy z time moduł w Pythonie do pomiaru czasu wykonania skryptu Selenium. Czas rozpoczęcia zapisano na początku, a czas zakończenia na końcu scenariusza. Różnica pomiędzy tymi czasami dała całkowity czas wykonania.

Oto kompletny skrypt używany dla Selenium:

import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

def extract(element):
    title = element.find_element(By.CSS_SELECTOR, "div.preview-title").text
    author = element.find_element(By.CSS_SELECTOR, "div.preview-author").text
    rating = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-rating").text
    price = element.find_element(By.CSS_SELECTOR, "div.preview-details p.preview-price").text
    return {"title": title, "author": author, "rating": rating, "price": price}

# Start the timer
start_time = time.time()

options = webdriver.ChromeOptions()
options.add_argument("--headless")

# Create a new instance of the Chrome driver
driver = webdriver.Chrome(options=options)

url = "https://danube-webshop.herokuapp.com/"
driver.get(url)

# Click on the Crime & Thrillers category
time.sleep(1)
crime_n_thrillers = driver.find_element(By.CSS_SELECTOR, "ul[class='sidebar-list'] > li")
crime_n_thrillers.click()
time.sleep(1)

# Extract the book previews
books = driver.find_elements(By.CSS_SELECTOR, "div.shop-content li.preview")

extracted_data = []
for element in books:
    data = extract(element)
    extracted_data.append(data)

print(extracted_data)

# End the timer
end_time = time.time()
print(f"The whole script took: {end_time - start_time:.4f} seconds")

driver.quit()

Test szybkości lalkarza

W skrypcie Puppeteer użyliśmy rozszerzenia Date obiekt do pomiaru czasu wykonania. Czas rozpoczęcia zapisano na początku, a czas zakończenia na końcu scenariusza. Różnica pomiędzy tymi czasami dała całkowity czas wykonania.

Oto kompletny skrypt użyty w Puppeteer:

const puppeteer = require('puppeteer');

async function main() {
    const start = Date.now();

    const browser = await puppeteer.launch({ headless: true });
    const page = await browser.newPage();
    await page.goto('https://danube-webshop.herokuapp.com/', { waitUntil: 'networkidle2' });

    await page.waitForSelector('ul.sidebar-list');

    await Promise.all([
        page.waitForNavigation(),
        page.click("ul[class='sidebar-list'] > li > a"),
    ]);

    await page.waitForSelector("li[class='preview']");
    const books = await page.evaluateHandle(
        () => [...document.querySelectorAll("li[class='preview']")]
    );

    const processed_data = await page.evaluate(elements => {
        let data = [];
        elements.forEach(element => {
            let title = element.querySelector("div.preview-title").innerHTML;
            let author = element.querySelector("div.preview-author").innerHTML;
            let rating = element.querySelector("div.preview-details > p.preview-rating").innerHTML;
            let price = element.querySelector("div.preview-details > p.preview-price").innerHTML;

            let result = { title, author, rating, price };
            data.push(result);
        });
        return data;
    }, books);

    console.log(processed_data);
    await page.close();
    await browser.close();

    const end = Date.now();
    console.log(`Execution time: ${(end - start) / 1000} seconds`);
}

main();

Wyniki testu wydajności

Testy wydajnościowe wykazały, że Puppeteer jest o około 60% szybszy od Selenium. Ta przewaga szybkości sprawia, że Puppeteer jest bardziej odpowiednim wyborem w przypadku projektów wymagających szybkiego przeglądania i automatyzacji sieci, szczególnie podczas pracy z przeglądarkami opartymi na Chromium.

Podsumowanie wyników prędkości:

Poniższy wykres ilustruje różnicę w wydajności pomiędzy Puppeteer i Selenium:

Skalowanie aplikacji Puppeteer pod kątem projektów wymagających szybkiego i wydajnego przeglądania sieci jest w tym kontekście optymalnym wyborem.

Lalkarz kontra Selen: co jest lepsze?

Który z nich jest lepszy do skrobania między Selenium a Puppeteer? Nie ma bezpośredniej odpowiedzi na to pytanie, ponieważ zależy to od wielu czynników, takich jak długoterminowe wsparcie bibliotek, obsługa różnych przeglądarek i Twoje potrzeby w zakresie skrobania sieci.

Puppeteer jest szybszy, ale w porównaniu do Selenium obsługuje mniej przeglądarek. Selenium obsługuje także więcej języków programowania w porównaniu do Puppeteer.

Wniosek

Chociaż używanie Puppeteera lub Selenium jest dobrą opcją do skrobania stron internetowych, skalowanie i optymalizacja projektu skrobania sieci może być wyzwaniem, ponieważ zaawansowane zabezpieczenia przed botami mogą wykrywać i blokować te biblioteki. Najlepszym sposobem na uniknięcie tego jest użycie interfejsu API do skrobania sieci, takiego jak OneProxy.

Korzystanie z Puppeteera z serwerami proxy

Aby używać Puppeteera z serwerem proxy, możesz przekazać ustawienia proxy w pliku args opcja podczas uruchamiania instancji przeglądarki. Oto przykład:

const puppeteer = require('puppeteer');

async function main() {
    const proxyServer = 'http://your-proxy-server:port';
    
    const browser = await puppeteer.launch({
        headless: true,
        args: [`--proxy-server=${proxyServer}`]
    });

    const page = await browser.newPage();
    await page.goto('https://example.com', { waitUntil: 'networkidle2' });

    // Perform your web scraping tasks here

    await browser.close();
}

main();

Używanie Selenium z serwerami proxy

Aby używać Selenium z serwerem proxy, możesz ustawić opcje proxy za pomocą webdriver.Proxy klasa. Oto przykład:

from selenium import webdriver
from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "your-proxy-server:port"
proxy.ssl_proxy = "your-proxy-server:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

options = webdriver.ChromeOptions()
options.add_argument("--headless")

driver = webdriver.Chrome(desired_capabilities=capabilities, options=options)
driver.get("https://example.com")

# Perform your web scraping tasks here

driver.quit()

Korzystanie z serwerów proxy w połączeniu z Puppeteer i Selenium może pomóc ominąć ograniczenia oparte na adresach IP i zmniejszyć ryzyko zablokowania, zwiększając efektywność zadań związanych z przeglądaniem sieci. Obrotowe serwery proxy OneProxy może jeszcze bardziej zoptymalizować ten proces, zapewniając płynne skrobanie.