- Что такое Selenium
- Зачем нужен Selenium
- Архитектура Selenium
- Принцип работы Selenium
- Selenium vs. простой парсинг: что выбрать
- Установка Selenium
- Начало работы с Selenium
- Обход блокировок и CAPTCHA при парсинге через Selenium
- Сохранение данных после парсинга
- Типичные ошибки при работе с Selenium
- Аналоги Selenium
- Заключение
Еще несколько лет назад для сбора данных хватало простого HTTP-запроса и парсинга HTML-кода. Страница возвращалась целиком, нужные элементы находились по тегам или классам, данные извлекались без лишних сложностей. Сегодня подобная схема все чаще оказывается бесполезной – и вот почему:
- Контент формируется в браузере, а не на сервере. Современные сайты активно используют JavaScript. Сервер отдает лишь заготовку – минимальный HTML и набор скриптов. Реальный контент появляется позже: браузер сам догружает его, выполняя скрипты – например, отправляет AJAX-запросы или реагирует на действия пользователя. Обычный скрапер видит только исходный HTML, в котором нужных данных просто нет.
- Асинхронная загрузка данных. Данные на сайте появляются не сразу: блоки подгружаются с задержкой. А классический парсер работает моментально: он не ждет, пока скрипты выполнят свою работу, не следит за сетевыми запросами и не дожидается появления элементов на странице. В итоге он забирает информацию слишком рано – когда нужных данных еще нет.
- Динамическая структура DOM. На современных сайтах DOM может меняться на лету: элементы создаются и удаляются, классы и атрибуты меняются, а один и тот же блок выглядит по-разному в зависимости от состояния страницы. Из‑за этого привычные способы поиска элементов – например, жесткие XPath или CSS‑селекторы – перестают работать: они либо ломаются, либо просто не могут найти то, что нужно.
- Защита от ботов. Многие сайты специально защищают себя от автоматических сборщиков данных. Они проверяют, работает ли JavaScript, есть ли cookies, анализируют, как пользователь ведет себя на странице. Если система замечает что‑то подозрительное – например, необычный User‑Agent или слишком частые запросы – она может заблокировать доступ, показать CAPTCHA или ограничить скорость запросов. Когда обычный скрапер обращается к сайту, он не ведет себя как настоящий пользователь и быстро попадает под фильтры.
- Зависимость от пользовательских действий. Чтобы увидеть некоторые данные на сайте, нужно с ним взаимодействовать: кликнуть, пролистать или выбрать параметр в фильтре. Классический скрапер этого не умеет – он просто забирает код страницы в тот момент, когда она только открылась. В результате он пропускает данные, которые подгружаются позже.
Иными словами, обычный скрапинг рассчитан на статические сайты и предсказуемый HTML. Современные веб-проекты работают иначе: данные формируются динамически, логика вынесена в JavaScript, структура страницы постоянно меняется, а защита от автоматизации стала нормой.
В таких условиях нужен инструмент, который ведет себя как реальный пользователь и полноценный браузер – иначе парсер просто не увидит то, что требуется извлечь.
Что такое Selenium
Selenium – это инструмент для автоматизации работы с браузером. Он управляет реальным браузером, имитируя действия пользователя: открывает страницы, кликает по кнопкам, вводит текст, прокручивает экран и взаимодействует с динамическими элементами.
Изначально Selenium создавался для автоматического тестирования веб-приложений, но со временем стал универсальным инструментом и для других задач – в том числе для парсинга современных сайтов.
В отличие от классических HTTP-скраперов, Selenium:
- запускает полноценный браузер;
- выполняет JavaScript-код страницы;
- видит финальный DOM, сформированный после всех загрузок;
- может ждать появления элементов;
- поддерживает пользовательские сценарии взаимодействия.
По сути, Selenium работает так же, как обычный человек, который открывает сайт в браузере, – только автоматически и по заданному сценарию.
Зачем нужен Selenium
Selenium нужен в тех случаях, когда сайт невозможно корректно обработать на уровне простых HTTP-запросов. Он работает не с сырой разметкой, а с реальной страницей в браузере, со всем ее JavaScript-кодом, событиями и динамическим поведением.
Основные задачи, для которых используют Selenium:
- Автоматизация тестирования веб-приложений. Чтобы не тестировать сайт вручную, используют Selenium. Он автоматически выполняет типовые действия: нажимает на кнопки, обрабатывает формы, отслеживает изменения на странице. Это экономит время – не нужно вручную перепроверять каждую функцию сайта.
- Парсинг динамических сайтов. На сайтах с динамическим контентом (где данные подгружаются через JavaScript) стандартные парсеры бесполезны – они фиксируют только исходный код без итоговых данных. Selenium решает эту проблему: он ждет, пока выполнятся все скрипты, и только потом извлекает нужную информацию.
- Эмуляция сложного пользовательского поведения. Чтобы увидеть часть информации на сайте, часто требуется выполнить цепочку действий: прокрутить страницу, кликнуть по элементам, раскрыть меню. Обычный парсер с этим не справится, а Selenium может полностью воспроизвести поведение пользователя – и добыть итоговые данные, которые появляются только после всех этих манипуляций.
- Проверка доступности и производительности сайта. Используя Selenium, тестировщики могут комплексно оценить сайт: измерить, сколько времени уходит на загрузку отдельных элементов, убедиться, что навигация работает корректно, а страница правильно отображается в разных браузерах и при разных разрешениях экрана.
- Обход элементарных антибот-защит. Некоторые сайты блокируют автоматические запросы, но пропускают трафик из реального браузера. Selenium позволяет обойти такую защиту: он запускает страницу в полноценном браузере, где работают все необходимые компоненты – JavaScript, cookies, HTTP‑заголовки – как у обычного пользователя.
Архитектура Selenium
Selenium состоит из четырех компонентов:
- Selenium IDE (Integrated Development Environment) – это простая программа в виде расширения для браузера. Она записывает все действия пользователя: клики, ввод текста, переходы по страницам. Затем эти действия можно воспроизвести как тест или сценарий. IDE подходит для тех, кто хочет быстро автоматизировать сайт без программирования – просто включить запись, выполнить нужные шаги и сохранить результат.
- Selenium RC (Remote Control) – устаревший компонент, который когда-то использовался для управления браузером через специальный сервер. Он позволял писать тесты на разных языках и отправлять команды в браузер. Сейчас RC уже не применяется, потому что его заменил более современный и быстрый WebDriver.
- Selenium WebDriver – это главный и самый популярный инструмент в составе Selenium. Он управляет браузером напрямую, без промежуточных серверов. WebDriver открывает страницы, нажимает кнопки, заполняет формы и даже ждет загрузки элементов. Он умеет работать с современными сайтами, где контент подгружается с помощью JavaScript. Почти все нынешние проекты с Selenium используют именно WebDriver.
- Selenium Grid нужен для запуска сценариев на нескольких компьютерах и в разных браузерах одновременно. Например, можно проверить, как сайт работает в Chrome, Firefox и Edge сразу. Grid помогает ускорить тестирование и экономит время, особенно если нужно обработать большое количество сценариев.
Принцип работы Selenium
Когда скрипт обращается к странице, Selenium передает инструкции браузеру через WebDriver. Он служит посредником между кодом программы и браузером: принимает команды вроде «открой страницу», «найди элемент по селектору», «кликни сюда» или «получи текст», выполняет их и возвращает результат обратно в код. Таким образом, Selenium имитирует реальную сессию пользователя, в которой отрабатывают JavaScript, AJAX-запросы и другие элементы клиентской логики.
Типичный цикл работы Selenium выглядит так:
- Скрипт создает экземпляр WebDriver и запускает браузер.
- Драйвер получает от программы команду (например, открыть страницу или кликнуть по кнопке).
- Браузер выполняет действие и обновляет DOM.
- Selenium получает актуальное состояние страницы, включая весь загруженный динамический контент.
- После завершения всех операций браузер закрывается, а результаты обрабатываются в коде.
Selenium vs. простой парсинг: что выбрать
На первый взгляд, разница неочевидна – обе техники помогают извлекать информацию со страниц. Однако от правильного решения зависит не только время разработки, но и сама возможность получить нужные данные.
Когда можно обойтись простым парсингом
Если сайт статический, то есть весь контент доступен сразу после загрузки страницы, Selenium будет излишним. Проще и быстрее использовать стандартные библиотеки для парсинга.
Простой парсинг подходит, если:
- нужные данные есть прямо в исходном HTML-коде;
- сайт не использует JavaScript для отображения контента;
- структура страниц простая и предсказуемая;
- можно получить те же данные через открытое API;
- важна скорость обработки большого количества страниц.
- В таких случаях запрос к странице через requests и анализ HTML с помощью BeautifulSoup, lxml или parsel даст тот же результат, но с меньшими затратами по времени и ресурсам.
Когда лучше Selenium
Selenium пригодится там, где сайт активно использует JavaScript или подгружает данные динамически. В таких случаях обычный парсинг не увидит нужный контент, потому что он появляется уже после загрузки страницы в браузере.
Типичные ситуации:
- контент загружается через JavaScript после открытия страницы;
- сайт представляет собой SPA-приложение;
- данные подгружаются по мере прокрутки страницы;
- нужная информация появляется после клика, выбора фильтра или заполнения формы;
- страница активно меняет DOM во время работы;
- сайт проверяет наличие JavaScript, cookies и человеческого поведения.
В таких случаях обычный парсер получает пустой или неполный HTML, потому что он видит только начальную версию страницы. Selenium же выполняет скрипты, ждет загрузку элементов и позволяет получить финальный результат – именно тот, который видит пользователь.
Плюсы и минусы Selenium для парсинга
| Плюсы | Минусы |
| Работает с JavaScript и динамической загрузкой данных | Низкая скорость по сравнению с обычным парсингом |
| Видит финальный DOM, как обычный пользователь | Высокое потребление памяти и CPU |
| Поддерживает клики, прокрутку, ввод текста | Сложнее масштабировать на большие объемы данных |
| Подходит для SPA и сложных интерфейсов | Требует настройки браузеров и драйверов |
| Корректно работает с cookies и сессиями | Возможны сбои из-за обновлений браузер |
| Позволяет обходить простые антибот-проверки | Не гарантирует обход сложных защит и CAPTCHA |
| Универсален для разных сайтов | Избыточен для статических страни |
Установка Selenium
Сначала убедитесь, что браузер установлен в системе. Проверить наличие Google Chrome можно командой:
Если браузер не установлен, выполните установку:
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo apt install ./google-chrome-stable_current_amd64.deb -y
Далее рекомендуется создать виртуальное окружение. Оно понадобится, если парсер будет запускаться на сервере или использоваться в нескольких проектах – так проще управлять версиями библиотек и избегать конфликтов.
source venv/bin/activate
Наконец, установите Selenium:
Важно! В Selenium 4.6.0 и более новых версиях появился встроенный инструмент – Selenium Manager. Его ключевая функция заключается в автоматической загрузке подходящего драйвера для браузера. Благодаря этому механизму процесс настройки Selenium становится значительно проще: пользователю больше не нужно вручную искать и устанавливать драйверы – система делает это самостоятельно при первом запуске.
Но иногда автоматически загруженный драйвер оказывается несовместим с установленной версией браузера. В таком случае потребуется вручную скачать нужную версию драйвера (например, ChromeDriver) с официального сайта и явно указать путь к нему в коде через параметр executable_path при создании экземпляра webdriver.Chrome.
После установки можно проверить, что Selenium работает корректно. Простейший тест – открыть страницу и получить ее заголовок:
# раскомментируйте следующие строки
# options.add_argument("--headless")
# options.add_argument("--no-sandbox")
# options.add_argument("--disable-dev-shm-usage")
driver.get("https://example.com")
Если код отработал без ошибок и вывел заголовок страницы, значит Selenium установлен и готов к работе.
Начало работы с Selenium
Сначала научимся простому: запускать браузер, открывать страницы, находить на них элементы, работать с ними и правильно закрывать сессию. Из этих шагов складывается любая задача – и простой сбор данных, и сложная автоматизация.
Запуск браузера
Работа с Selenium всегда начинается с создания объекта браузера. Через него выполняются все дальнейшие действия. Браузер можно запускать в обычном режиме или в headless-режиме, если интерфейс не нужен (например, на сервере).
Минимальный вариант запуска выглядит так:
Откроется окно браузера – с ним дальше и работает Selenium.
Но на практике браузер почти всегда запускают с параметрами. Они задаются через ChromeOptions. Через них можно управлять поведением браузера еще до открытия страницы:
from selenium import webdriver
driver = webdriver.Chrome(options=options)
print(driver.title)
driver.quit()
Такой вариант ничем не отличается от базового, но позволяет легко добавлять параметры, когда они понадобятся.
Если Selenium запускается на сервере или в окружении без графического интерфейса, браузер нужно запускать в headless-режиме. В этом случае окно не отображается, но браузер остается полностью рабочим:
options.add_argument("--headless")
driver.get("https://example.com")
print(driver.title)
driver.quit()
На Linux-серверах часто добавляют дополнительные параметры, которые повышают стабильность запуска и предотвращают ошибки:
options.add_argument("--disable-dev-shm-usage")
Открытие страницы
Чтобы перейти на нужный сайт, в Selenium используется метод get(). Он принимает URL страницы и открывает ее в браузере:
После вызова этого метода Selenium не просто загружает HTML-код, а дожидается, пока браузер откроет страницу, выполнит JavaScript и начнет формировать DOM. Поэтому Selenium видит страницу так же, как ее видит обычный пользователь в браузере.
Важно понимать, что get() не гарантирует загрузку всего динамического контента. Метод возвращает управление, когда страница считается загруженной с точки зрения браузера, но данные, подгружаемые через AJAX или по событиям, могут появиться позже.
Получение информации о странице
После открытия страницы в Selenium часто требуется получить базовую информацию о ней. Для этого у объекта браузера есть несколько простых, но полезных свойств:
print(driver.current_url)
print(driver.page_source)
Где:
- driver.title возвращает заголовок страницы – тот самый текст, который отображается во вкладке браузера. Его удобно использовать для быстрой проверки, что нужная страница действительно загрузилась.
- driver.current_url показывает фактический адрес страницы.
- driver.page_source содержит полный HTML-код страницы на текущий момент – уже после выполнения JavaScript и динамической подгрузки данных.
На практике при парсинге редко работают со всем page_source целиком. Гораздо удобнее и надежнее находить конкретные элементы страницы через селекторы и получать данные напрямую из них.
Поиск элементов
Selenium работает с элементами страницы через DOM, поэтому для парсинга и автоматизации нужно уметь находить нужные элементы. Поиск выполняется с помощью селекторов – правил, по которым Selenium определяет, какой элемент вас интересует.
Для начала используется модуль By, который задает тип селектора:
Самые простые и часто встречающиеся варианты поиска выглядят так:
elements = driver.find_elements(By.CLASS_NAME, "item")
Где:
- find_element возвращает один элемент – первый найденный.
- find_elements возвращает список элементов. Если элементы не найдены, список будет пустым, а не вызовет ошибку.
Помимо ID и CLASS_NAME, в Selenium регулярно используют и другие типы селекторов:
- By.NAME – поиск по атрибуту name;
- By.TAG_NAME – поиск по названию тега (div, a, span и т.д.);
- By.CSS_SELECTOR – универсальный и самый гибкий способ поиска;
- By.XPATH – мощный инструмент для сложных структур.
После того как элемент найден, из него можно извлекать данные. Чаще всего это текст или атрибуты:
print(element.get_attribute(“href”))
element.text возвращает видимый текст элемента, а get_attribute() позволяет получить значение любого атрибута – ссылки, идентификаторы, данные из data-* и других полей.
Как правило, для парсинга используют комбинацию селекторов и извлечения атрибутов, чтобы получать только нужную информацию, а не обрабатывать всю страницу целиком.
Ожидание элементов
На современных сайтах элементы редко появляются сразу после открытия страницы. Контент может загружаться через JavaScript, приходить по AJAX-запросам или отображаться только после выполнения части логики на стороне клиента. Если попытаться найти такой элемент сразу, Selenium просто не успеет его увидеть и вернет ошибку.
Для решения этой проблемы в Selenium используются ожидания. Они позволяют подождать появления элемента на странице в течение заданного времени.
Пример явного ожидания выглядит так:
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
EC.presence_of_element_located((By.CLASS_NAME, "item"))
)
В этом коде Selenium будет ждать до 10 секунд, пока элемент с классом item появится в DOM. Как только элемент найден, выполнение продолжается. Если за отведенное время элемент так и не появился, Selenium выбросит ошибку.
Взаимодействие с элементами
Selenium может не только находить элементы на странице, но и взаимодействовать с ними так же, как это делает обычный пользователь.
Базовые действия выглядят следующим образом:
element.send_keys("текст")
element.clear()
Метод click() используется для нажатия на кнопки, ссылки, чекбоксы и другие интерактивные элементы. Часто после клика на странице появляется дополнительный контент или меняется состояние интерфейса.
send_keys() имитирует ввод текста с клавиатуры. Его применяют для заполнения форм, полей поиска, логинов и паролей. При необходимости перед вводом данные поле можно очистить с помощью clear().
Взаимодействие с элементами позволяет решать задачи, которые невозможно выполнить без имитации действий пользователя. С помощью Selenium можно:
- открывать скрытые блоки и выпадающие списки;
- переключать фильтры и сортировки;
- запускать подгрузку данных;
- проходить многошаговые интерфейсы и формы.
Благодаря этим возможностям Selenium подходит для работы с современными сайтами, где большая часть логики завязана на кликах, вводе данных и изменении состояния страницы.
Прокрутка страницы
Если контент подгружается при прокрутке, Selenium может самостоятельно прокрутить страницу:
Часто одной прокрутки бывает недостаточно. Если контент загружается порциями, ее приходится выполнять несколько раз с небольшими паузами или ожиданиями, чтобы браузер успел получить новые данные. В реальных сценариях прокрутку комбинируют с ожиданиями появления новых элементов.
Работа с несколькими вкладками
Некоторые сайты открывают ссылки в новых вкладках или окнах браузера. Selenium умеет работать с такими сценариями и позволяет переключаться между вкладками в рамках одной сессии.
Все открытые вкладки доступны через список window_handles:
Каждый элемент в этом списке – это идентификатор отдельной вкладки. Чтобы переключиться на нужную, используется метод switch_to.window():
В этом примере Selenium переключается на вторую вкладку (нумерация начинается с нуля). После переключения все действия – поиск элементов, клики, парсинг – будут выполняться конкретно в этой вкладке.
При необходимости можно переключаться обратно на первую вкладку или закрывать ненужные окна, чтобы контролировать процесс и не перегружать браузер.
Завершение работы
Работу браузера в Selenium важно корректно завершать. Для этого используется метод quit():
Команда полностью закрывает браузер и завершает текущую сессию Selenium. Она освобождает системные ресурсы, закрывает все вкладки и останавливает фоновые процессы, связанные с браузером.
Если не вызывать driver.quit(), процессы браузера остаются в системе. При регулярном запуске скриптов это приводит к росту нагрузки, утечкам памяти и нестабильной работе сервера или компьютера.
Обход блокировок и CAPTCHA при парсинге через Selenium
Сайты все чаще внедряют защиту от автоматизации: определяют ботов, ставят капчи и блокируют подозрительные IP. Чтобы минимизировать риск блокировки при парсинге через Selenium, используйте разные методы маскировки и эмуляции реального поведения:
| Метод | Пример/Аргумент | Для чего нужно? |
| Отключение enable-automation | chrome_options.add_experimental_option("excludeSwitches", ["enable-automation"]) | Скрывает факт запуска браузера через Selenium, уменьшая шанс блокировки по navigator.webdriver. |
| Отключение Selenium Automation Extension | chrome_options.add_experimental_option("useAutomationExtension", False) | Скрывает наличие автоматического расширения Selenium, которое замечают некоторые сайты. |
| Отключение AutomationControlled | chrome_options.add_argument("--disable-blink-features=AutomationControlled") | Отключает признак автоматизации в движке браузера Chrome. |
| Отключение WebRTC | chrome_options.add_argument("--disable-webrtc") | Предотвращает утечку реального IP через WebRTC, что часто проверяют антибот-системы. |
| Использование прокси | chrome_options.add_argument("--proxy-server=IP:PORT") или через selenium-wire для прокси с авторизацией |
Позволяет менять IP-адрес, чтобы избежать блокировок по IP и обходить географические ограничения. |
| Замедление действий (ожидания) | WebDriverWait(driver, 10).until(EC.element_to_be_clickable(...)) | Эмулирует поведение реального пользователя: не кликает слишком быстро, ждет загрузки элементов. |
| Изменение User-Agent | chrome_options.add_argument("user-agent=...") | Маскирует браузер под обычного пользователя, скрывая факт автоматизации. |
| Интеграция сервисов решения капчи | Через API (RuCaptcha, 2Captcha и др.) | Позволяет автоматически решать капчи, эмулируя ручное прохождение проверки. |
Сохранение данных после парсинга
Сам по себе парсинг мало что дает. Главное – что вы делаете с полученными данными: кладете в базу, формируете отчет или передаете в другую систему. Поэтому важно понимать, как сохранить и отправить результаты:
Сохранение в CSV и Excel с помощью pandas
Один из самых удобных способов сохранить результаты парсинга – выгрузить их в табличный формат. CSV и Excel подходят для анализа, отчетов и передачи данных другим людям или системам.
Для работы с такими форматами в Python чаще всего используют библиотеку pandas. Если она еще не установлена, ее можно добавить в проект через pip:
Оптимальный формат сохранения данных – список словарей с одинаковыми ключами. Каждый словарь будет строкой таблицы, а ключи станут названиями столбцов.
Пример подготовки и сохранения данных в CSV:
{"name": "Кофеварка", "price": 12990, "rating": 4.6},
{"name": "Микроволновка", "price": 18990, "rating": 4.4},
{"name": "Блендер", "price": 5990, "rating": 4.2},
]
Из этого списка создается таблица DataFrame, с которой дальше можно работать:
import pandas as pd
table = pd.DataFrame(results)
table.to_csv("catalog.csv", index=False, encoding="utf-8")
Чтобы сохранить данные в CSV-файл, используется метод to_csv():
Параметр index=False убирает служебную нумерацию строк, а encoding="utf-8" позволяет корректно сохранять кириллицу.
Для экспорта в Excel применяется метод to_excel():
Excel-файл удобен, если данные будут просматриваться вручную или использоваться в отчетах. CSV чаще выбирают для автоматической обработки, импорта в базы данных или передачи между сервисами.
Хранение данных в базе: SQLite и MySQL
Таблицы CSV/Excel удобны, пока данных немного и выгрузка разовая. Если парсер запускается регулярно, нужно хранить историю, делать выборки и обновления, лучше складывать результат в базу данных.
Для парсинга чаще всего выбирают SQLite или MySQL: первая подходит для простых сценариев и локального хранения, вторая – для серверных проектов и многопользовательского доступа.
SQLite хороша тем, что не требует отдельного сервера: база – это обычный файл, который можно хранить рядом с проектом. В последних версиях Python модуль sqlite3 уже встроен, поэтому ничего ставить не нужно.
Создадим таблицу и попробуем сохранить результаты парсинга:
{"url": "https://shop.example/item/101", "title": "Роутер", "price": 4990},
{"url": "https://shop.example/item/102", "title": "SSD 1TB", "price": 7990},
{"url": "https://shop.example/item/103", "title": "Наушники", "price": 2590},
]
cur = conn.cursor()
CREATE TABLE IF NOT EXISTS products (
url TEXT PRIMARY KEY,
title TEXT NOT NULL,
price INTEGER NOT NULL,
scraped_at TEXT NOT NULL
)
""")
"INSERT OR REPLACE INTO products (url, title, price, scraped_at) VALUES (?, ?, ?, datetime('now'))",
[(r["url"], r["title"], r["price"]) for r in rows]
)
conn.close()
Важно! Команда INSERT OR REPLACE будет полезна, если вы парсите один и тот же товар каждый день – запись обновится, а не создаст дубль (при условии, что url – уникальный ключ).
MySQL выбирают, когда база должна работать на сервере, хранить большие объемы данных, обслуживать несколько процессов или пользователей, а также когда нужен нормальный контроль доступа и резервные копии.
Для подключения из Python часто используют mysql-connector-python:
Пример подключения и вставки данных:
{"sku": "A-1001", "name": "Кулер", "price": 1890},
{"sku": "A-1002", "name": "Видеокарта", "price": 42990},
{"sku": "A-1003", "name": "Блок питания", "price": 6990},
]
host="127.0.0.1",
user="parser_user",
password="strong_password",
database="scraping_db",
)
cur = conn.cursor()
CREATE TABLE IF NOT EXISTS catalog (
sku VARCHAR(64) PRIMARY KEY,
name VARCHAR(255) NOT NULL,
price INT NOT NULL,
scraped_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
)
""")
"REPLACE INTO catalog (sku, name, price) VALUES (%s, %s, %s)",
[(r["sku"], r["name"], r["price"]) for r in rows]
)
cur.close()
conn.close()
Команда REPLACE INTO работает похожим образом: если запись с таким sku уже есть, она будет заменена новой.
Типичные ошибки при работе с Selenium
Мы собрали распространенные проблемы, с которыми сталкиваются при автоматизации браузера через Selenium, и способы их решения:
| Ошибка или симптом | Ошибка или симптом | Решение |
| NoSuchElementException при попытке найти элемент | Элемент еще не отрисовался, селектор изменился или элемент находится внутри iframe/shadow DOM | Использовать WebDriverWait с expected_conditions, проверить и переключиться в нужный iframeили shadow root; актуализировать селектор |
| SessionNotCreatedException или «ChromeDriver not found» | Несовпадение версий браузера и драйвера | Скачать подходящую версию ChromeDriver/GeckoDriver или обновить браузер; с Selenium 4.6+ можно попробовать встроенный Selenium Manager |
| ElementClickInterceptedException | Целевой элемент перекрыт другим слоем или еще не стал кликабельным | Прокрутить страницу до элемента (element.location_once_scrolled_into_view), дождаться кликабельности через WebDriverWait, использовать JavaScript-клик |
| TimeoutException при ожидании | Условие ожидания никогда не выполняется в отведенный таймаут | Увеличить таймаут в WebDriverWait, убедиться, что условие (visibility_of_element_located, element_to_be_clickable) соответствует задаче |
| StaleElementReferenceException | Ссылка на элемент устарела после изменения DOM | Каждый раз перед взаимодействием заново находить элемент; избегать кеширования объектов WebElement |
| WebDriverException: unknown error: DevToolsActivePort file doesn’t exist | Headless-режим без необходимых зависимостей или права на --no-sandbox | Добавить опции --no-sandbox, --disable-dev-shm-usage, установить недостающие системные библиотеки для headless-регистра |
| ResourceWarning: unclosed ... | Несколько экземпляров браузера не закрываются | Всегда вызывать driver.quit() в блоке finally или использовать контекстный менеджер, чтобы гарантировать завершение сессии |
Аналоги Selenium
Selenium – не единственный инструмент для работы с браузером и динамическими сайтами. В зависимости от задачи и требований к скорости, есть более легкие или более современные альтернативы:
requests + BeautifulSoup
Подходят для простых сайтов без JavaScript. Если нужные данные уже есть в HTML, этого набора достаточно. Он работает быстро, почти не нагружает систему и легко настраивается. Для кликов, динамической загрузки и сложной логики такой вариант не подойдет.
Playwright
Современная альтернатива Selenium. Хорошо работает с динамическими сайтами, поддерживает headless-режим и удобные ожидания. Часто быстрее Selenium, особенно при параллельных задачах. Минус – инструмент относительно новый, примеров и готовых решений меньше.
Puppeteer
Инструмент для управления Chrome, изначально созданный для JavaScript. Есть версия для Python, но она используется реже и работает менее стабильно. Подходит, если нужна тесная работа именно с Chrome.
Scrapy
Фреймворк для парсинга больших объемов данных. Удобен, когда нужно обойти много страниц, хранить результаты и управлять процессом сбора. Лучше всего подходит для статических сайтов, а для динамики требует дополнительных инструментов.
Заключение
Selenium – это рабочий инструмент для тех случаев, когда обычный парсинг не справляется. Он позволяет взаимодействовать с сайтом как реальный пользователь: открывать страницы, ждать загрузку контента, кликать по элементам и получать данные, которые формируются только после выполнения JavaScript.
При этом Selenium не универсальное решение. Он медленнее и требовательнее к ресурсам, чем классические парсеры, поэтому лучше выбирать его осознанно – для динамических сайтов, сложных интерфейсов и пользовательских сценариев.