Парсинг сайтов с использованием Selenium WebDriver

Это набор инструментов для автоматизации действий веб-браузеров. По сути, он представляет из себя библиотеку, которая позволяет имитировать действия пользователя: переходы по страницам, заполнение форм, клики по элементам и другое. Selenium поддерживает множество языков программирования, таких как Python, Java, C#, Ruby и других, и совместим с большинством современных веб-браузеров.

Установка и настройка Selenium с ChromeDriver

Для работы с Selenium вам необходимо выполнить следующие шаги:

Это можно сделать с помощью менеджера пакетов pip для Python:

pip install selenium

• Скачивание ChromeDriver. Вам необходимо скачать ChromeDriver, соответствующий версии вашего браузера Chrome. Вы можете найти его на официальной странице ChromeDriver.
• Указание пути к ChromeDriver. Если вы не добавите ChromeDriver в переменную среды PATH, вам нужно будет указать путь к нему в вашем коде.
• Инициализация драйвера в коде. После установки Selenium и скачивания ChromeDriver вы можете начать писать скрипты для автоматизации браузера.

Пример инициализации:

from selenium import webdriver

# Указание пути к ChromeDriver
chrome_driver_path = '/path/to/chromedriver'

# Запуск Chrome с использованием Selenium
driver = webdriver.Chrome(chrome_driver_path)

# Открытие веб-страницы
driver.get('http://example.com')

# Закрытие браузера
driver.quit()

Выполнение этого кода откроет браузер Chrome, перейдет на страницу http://example.com, а затем закроет браузер.

Рассмотрим некоторые основные опции инициализации на основе примера для Chrome с использованием ChromeDriverManager:

from selenium import webdriver
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager

# Инициализация опций Chrome
chrome_options = Options()
chrome_options.add_argument("--headless") # Режим без головы (без GUI)
chrome_options.add_argument("--disable-gpu") # Отключение GPU (необходимо в некоторых случаях для headless режима)
chrome_options.add_argument("--no-sandbox") # Отключение песочницы (используется в контейнерах и Linux системах)
chrome_options.add_argument("--disable-dev-shm-usage") # Отключение использования /dev/shm
chrome_options.add_argument("start-maximized") # Максимизация окна при запуске
chrome_options.add_argument("--disable-extensions") # Отключение расширений
chrome_options.add_argument("--remote-debugging-port=9222") # Порт для удаленной отладки, если необходимо
chrome_options.add_argument("--incognito") # Запуск браузера в режиме инкогнито
chrome_options.add_argument("--disable-popup-blocking") # Отключить блокировку всплывающих окон
chrome_options.add_argument("--disable-default-apps") # Отключить установленные по умолчанию приложения в Chrome
chrome_options.add_argument("--disable-infobars") # Отключить информационные бары, которые Chrome показывает в верхней части окна
chrome_options.add_argument("--disable-sync") # Отключить синхронизацию в Chrome
chrome_options.add_argument("--disable-extensions-file-access-check") # Отключить проверку доступа файлов расширений
chrome_options.add_argument("--ignore-certificate-errors") # Игнорировать ошибки сертификатов, полезно при работе с самоподписанными сертификатами
chrome_options.add_argument("--lang=en") # Установка языка браузера
chrome_options.add_argument("--user-data-dir=/path/to/your/custom/profile") # Задать путь к пользовательскому профилю Chrome
chrome_options.add_argument("--profile-directory=YourProfileName") # Задать имя профиля пользователя Chrome
chrome_options.add_argument("--log-level=3") # Установить уровень логирования (3 - ошибка, 2 - предупреждение, 1 - информация, 0 - отладка)
chrome_options.add_experimental_option("excludeSwitches", ["enable-logging"]) # Исключить переключатели, такие как включение логирования
chrome_options.add_experimental_option("prefs", {
    "download.default_directory": "/path/to/download/directory", # Задать путь по умолчанию для скачивания файлов
    "download.prompt_for_download": False, # Отключить запрос на скачивание файлов
    "download.directory_upgrade": True, # Автоматически перенести загрузки в новую папку по умолчанию
    "safebrowsing.enabled": True # Включить функции безопасного просмотра Chrome
})

# Установка пути к драйверу (WebDriverManager упрощает этот процесс)
service = Service(ChromeDriverManager().install())

# Инициализация драйвера с указанными опциями
driver = webdriver.Chrome(service=service, options=chrome_options)

• --headless: Запускает Chrome в режиме без головы, что означает, что браузер будет работать без графического интерфейса. Это полезно для серверов и автоматизированных сценариев, где не требуется отображение GUI.
• --disable-gpu: Используется для отключения GPU-ускорения, что полезно в headless режиме, поскольку некоторые операции не будут работать без GPU в визуальном режиме.
• --no-sandbox: Отключает режим песочницы. В Linux системах это может быть необходимо, если вы запускаете ваш сценарий в контейнере, таком как Docker.
• --disable-dev-shm-usage: Отключает использование временного хранилища для обмена данными между процессами, что может устранить некоторые ошибки в контейнерах.
• start-maximized: Открывает браузер в максимизированном окне.
• --disable-extensions: Отключает расширения браузера, что может повысить производительность и безопасность.
• --remote-debugging-port: Открывает порт для удаленной отладки, если вам нужно подключиться к сеансу браузера для отладки.
• --incognito: Запуск браузера в режиме инкогнито помогает обеспечить, что ваши тесты или парсинг не будут влиять на сохраненные данные и историю браузера.
• --disable-popup-blocking: Отключение блокировки всплывающих окон может быть полезным, если вы хотите тестировать поведение сайта с всплывающими окнами.
• --disable-infobars: Иногда Chrome отображает информационные бары, которые могут мешать автоматизации. Эта опция позволяет отключить их.
• --ignore-certificate-errors: При работе с тестовыми серверами, которые используют самоподписанные сертификаты, игнорирование ошибок сертификатов помогает избежать ложных сбоев.
• --user-data-dir и --profile-directory: Позволяют указать драйверу использовать определенный пользовательский профиль, что может быть полезно для сохранения определенных настроек между сессиями.
• --log-level: Эта опция позволяет управлять уровнем логирования ChromeDriver, что может быть полезно при отладке.
• excludeSwitches и prefs: Это экспериментальные опции, которые позволяют исключать определенные переключатели и задавать предпочтения в браузере.

Важно помнить, что использование некоторых опций может изменить поведение браузера, поэтому они должны быть тщательно протестированы в контексте ваших задач.

После установки Selenium и ChromeDriver вы можете запустить браузер и управлять им с помощью следующего кода на Python.

from selenium import webdriver

# Указание пути к ChromeDriver (если он не в PATH)
chrome_driver_path = '/path/to/chromedriver'

# Запуск экземпляра браузера
driver = webdriver.Chrome(chrome_driver_path)

# Максимизировать окно браузера
driver.maximize_window()

# Переход на веб-страницу
driver.get('https://www.example.com')

# Ожидание загрузки страницы (пример с 10 секундами)
driver.implicitly_wait(10)

# Пример работы с cookies, добавление куки
driver.add_cookie({"name": "key", "value": "value"})

# Получение заголовка страницы
title = driver.title
print(title)  # Вывод заголовка страницы

# Получение текущего URL
current_url = driver.current_url
print(current_url)  # Вывод URL страницы

# Закрытие текущей вкладки
driver.close()

# Закрытие всего браузера
driver.quit()

Переходы и загрузка страниц

• get(url): Переходит на указанный URL.
• back(): Возвращает на предыдущую страницу в истории браузера.
• forward(): Перемещает вперед по истории браузера.
• refresh(): Обновляет текущую страницу.

Управление окном браузера

• maximize_window(): Максимизирует окно браузера.
• minimize_window(): Минимизирует окно браузера.
• set_window_size(width, height): Устанавливает новый размер окна браузера.

Взаимодействие с cookies

• add_cookie(cookie_dict): Добавляет куки в вашу текущую сессию.
• get_cookies(): Возвращает список всех куки текущей сессии.
• delete_cookie(name): Удаляет куки по имени.
• delete_all_cookies(): Удаляет все куки текущей сессии.

Взаимодействие с вкладками и окнами

• current_window_handle: Получение идентификатора текущего окна.
• window_handles: Получение списка всех открытых окон/вкладок.
• switch_to.window(window_name): Переключение между окнами/вкладками.

Работа с элементами страницы

• find_element_by_*: Находит первый элемент, соответствующий заданному критерию (например, find_element_by_id, find_element_by_name и др.).
• find_elements_by_*: Находит все элементы, соответствующие заданному критерию.

Взаимодействие с элементами

• click(): Клик по элементу.
• send_keys(value): Ввод текста в элемент ввода.
• clear(): Очищает текстовое поле.

Получение информации об элементах

• text: Получает текст элемента.
• get_attribute(name): Получает значение атрибута элемента.

Эти методы являются основой для работы с веб-страницами и их элементами. Используя их, вы можете автоматизировать почти любые действия в браузере, а в сочетании с ожиданиями и другими расширенными методами - создавать сложные скрипты для парсинга данных.

Чтобы взаимодействовать с элементами на веб-странице, сначала необходимо их найти. Selenium предоставляет множество методов для поиска элементов по различным критериям.

Пример поиска элемента по ID:

search_box = driver.find_element_by_id('searchBoxId')

Поиск элементов по классу:

buttons = driver.find_elements_by_class_name('buttonClass')

Поиск элемента по имени тега:

headings = driver.find_elements_by_tag_name('h1')

Поиск элемента по XPath:

element = driver.find_element_by_xpath('//div[@class="myClass"]')

Поиск элемента по CSS-селектору:

element = driver.find_element_by_css_selector('div.myClass')

Стоит заметить, что начиная с Selenium 4, методы вроде find_element_by_* считаются устаревшими и рекомендуется использовать find_element() с использованием классов By:

from selenium.webdriver.common.by import By

search_box = driver.find_element(By.ID, 'searchBoxId')
buttons = driver.find_elements(By.CLASS_NAME, 'buttonClass')

Взаимодействие с элементами (ввод текста, клики)

После того как элемент найден, можно с ним взаимодействовать. Для ввода текста используется метод send_keys(), для клика — метод click().

Пример ввода текста в текстовое поле:

search_box.send_keys('Selenium')

Пример клика по кнопке:

button = driver.find_element(By.ID, 'submitButton')
button.click()

Получение текста из элементов

Для извлечения текста, который содержится в элементе, используется свойство text.

Пример получения текста с элемента:

heading = driver.find_element(By.TAG_NAME, 'h1')
print(heading.text)

Эти примеры демонстрируют базовое взаимодействие с элементами на веб-странице. Однако перед тем, как взаимодействовать с элементами, часто требуется убедиться, что они загружены и доступны для действий. Для этого используются различные стратегии ожидания, о которых будет рассказано далее.

Ожидания (waits) в Selenium используются для управления временем ожидания появления элементов или выполнения определённых условий. Они необходимы, так как веб-страницы часто загружают содержимое асинхронно, и элементы могут стать доступными не сразу после загрузки страницы.

Явные ожидания в Selenium позволяют задать условие для ожидания и время, в течение которого WebDriver будет проверять наличие элемента в DOM дереве страницы перед тем, как выбросить исключение TimeoutException.

Пример использования явных ожиданий:

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

# Предполагается, что драйвер уже инициализирован

# Устанавливаем явное ожидание
wait = WebDriverWait(driver, 10)  # ожидание в 10 секунд

# Ожидаем, пока не появится элемент с ID 'myElementId'
element = wait.until(EC.presence_of_element_located((By.ID, 'myElementId')))

# Теперь с элементом можно взаимодействовать
element.click()

В этом примере WebDriverWait используется с expected_conditions, которые предоставляют набор стандартных условий для ожидания.

Неявные ожидания задают фиксированное время ожидания, в течение которого WebDriver будет пытаться найти элемент, если он не доступен сразу.

Пример установки неявных ожиданий:

from selenium import webdriver

# Предполагается, что драйвер уже инициализирован

# Устанавливаем неявное ожидание на 10 секунд
driver.implicitly_wait(10)

# WebDriver будет ожидать до 10 секунд перед тем как выбросить исключение,
# если элемент не был найден
element = driver.find_element(By.ID, 'myElementId')

# Можно сразу взаимодействовать с найденным элементом
element.click()

Неявные ожидания применяются ко всем попыткам поиска элементов в течение жизни объекта WebDriver и могут вносить нежелательную задержку. Явные ожидания предпочтительнее, так как они позволяют программе ожидать наличие элемента в DOM только когда это действительно необходимо и с конкретными условиями.

Следует быть осторожным с использованием неявных и явных ожиданий вместе, так как это может привести к непредсказуемому времени ожидания. Обычно лучшей практикой считается выбор одного типа ожидания в зависимости от конкретного тестового случая.

Переходы между страницами выполняются с использованием базовых методов Selenium WebDriver, таких как get, back, forward, и refresh.

Примеры переходов:

# Переход на новую страницу
driver.get('https://www.example.com')

# Возврат на предыдущую страницу
driver.back()

# Переход вперед (если был совершен возврат)
driver.forward()

# Обновление текущей страницы
driver.refresh()

WebDriver может управлять несколькими окнами и вкладками браузера. Вы можете переключаться между ними, закрывать и открывать новые.

Примеры работы с вкладками:

# Открытие новой вкладки с помощью JavaScript
driver.execute_script("window.open('');")

# Переключение на новую вкладку
driver.switch_to.window(driver.window_handles[1])
driver.get('https://www.example.com')

# Возвращение на первоначальную вкладку
driver.switch_to.window(driver.window_handles[0])

# Закрытие текущей вкладки
driver.close()

# После закрытия вкладки необходимо переключиться обратно, если остались другие вкладки
if len(driver.window_handles) > 0:
    driver.switch_to.window(driver.window_handles[0])

Selenium WebDriver позволяет напрямую выполнять JavaScript на странице с помощью метода execute_script.

Примеры использования execute_script:

# Скролл страницы на определенное количество пикселей
driver.execute_script("window.scrollTo(0, 500);")

# Возвращение объекта из JavaScript обратно в Python
inner_width = driver.execute_script("return window.innerWidth;")
print(inner_width)

# Вызов JavaScript Alert
driver.execute_script("alert('Hello Selenium!');")

Выполнение JavaScript полезно во множестве сценариев, например, когда вы хотите взаимодействовать с элементами, которые скрыты или неактивны и не могут быть непосредственно доступны через стандартные методы Selenium.

Каждый из этих методов и подходов важен при разработке надежных скриптов для автоматизации работы с веб-страницами и обеспечения корректного взаимодействия с веб-приложениями различной степени сложности.

Скроллинг страницы важен для доступа к элементам, которые изначально не видны на экране. Вы можете использовать JavaScript или специальные Selenium Actions для этого.

Скроллинг с использованием JavaScript:

# Скролл до конца страницы
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

# Скролл до определенного элемента
element = driver.find_element(By.ID, 'elementId')
driver.execute_script("arguments[0].scrollIntoView(true);", element)

Скроллинг с помощью Actions:

from selenium.webdriver.common.action_chains import ActionChains

# Скролл с использованием метода move_to_element
element = driver.find_element(By.ID, 'elementId')
actions = ActionChains(driver)
actions.move_to_element(element).perform()

Работа с выпадающими списками и формами

Для взаимодействия с выпадающими списками Selenium предоставляет класс Select.

Пример работы с выпадающими списками:

from selenium.webdriver.support.ui import Select

# Находим выпадающий список
select_element = driver.find_element(By.ID, 'dropdownId')
select_object = Select(select_element)

# Выбираем опцию по видимому тексту
select_object.select_by_visible_text('Option Text')

# Выбираем опцию по значению value
select_object.select_by_value('optionValue')

# Выбираем опцию по индексу
select_object.select_by_index(2)

Для работы с формами используйте стандартные методы ввода текста и кликов, а также специальные методы для работы с радиокнопками и чекбоксами:

# Ввод текста
text_field = driver.find_element(By.ID, 'textFieldId')
text_field.send_keys('Some text')

# Установка радиокнопки
radio_button = driver.find_element(By.ID, 'radioButtonId')
radio_button.click()

# Отметка чекбокса
checkbox = driver.find_element(By.ID, 'checkboxId')
if not checkbox.is_selected():
    checkbox.click()

Загрузка и скачивание файлов

Для загрузки файлов используйте send_keys() для ввода пути к файлу в элемент input:

file_input = driver.find_element(By.ID, 'fileInputId')
file_input.send_keys('/path/to/file.txt')

Скачивание файлов требует предварительной настройки профиля браузера, чтобы указать предпочтительное местоположение для сохранения файлов и избежать всплывающих окон браузера.

Пример настройки Chrome для автоматической загрузки файлов:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

chrome_options = Options()
chrome_options.add_experimental_option('prefs', {
  "download.default_directory": "/path/to/download/directory", # Укажите путь к папке для скачивания
  "download.prompt_for_download": False, # Отключение всплывающего окна
  "download.directory_upgrade": True,
  "safebrowsing.enabled": True
})

driver = webdriver.Chrome(options=chrome_options)

Используя эти техники, вы можете повысить эффективность и надежность скриптов Selenium, обрабатывая динамические веб-страницы, которые требуют сложных взаимодействий и управления файлами.

Куки (cookies) являются ключевой частью управления состоянием сессии в веб-браузерах. Selenium позволяет читать и устанавливать куки в сессии браузера.

Чтение куки:

Чтобы получить все куки, используйте метод get_cookies(), и get_cookie(name) для получения конкретной куки.

# Получить все куки
all_cookies = driver.get_cookies()
print(all_cookies)

# Получить куки по имени
cookie = driver.get_cookie('cookie_name')
print(cookie)

Добавление куки:

Вы можете добавить куки в текущую сессию с помощью метода add_cookie(cookie_dict).

# Добавить куку
cookie = {'name': 'new_cookie', 'value': 'cookie_value'}
driver.add_cookie(cookie)

# Проверить добавленную куку
print(driver.get_cookie('new_cookie'))

Хранение состояния сессии позволяет вам сохранять текущее состояние взаимодействия пользователя с сайтом, так что вы можете восстановить его позже, это включает в себя куки, локальное хранилище и сессионное хранилище.

Сохранение состояния сессии:

# Сохранить все куки в файл
import json

with open('cookies.txt', 'w') as file:
    json.dump(driver.get_cookies(), file)

Восстановление состояния сессии:

# Загрузить куки из файла и добавить их в текущую сессию
with open('cookies.txt', 'r') as file:
    cookies = json.load(file)
    for cookie in cookies:
        driver.add_cookie(cookie)

# Важно, чтобы URL домена был загружен в браузере перед восстановлением кук:
driver.get('https://www.example.com')

Управление куками и состоянием сессии особенно важно при автоматизации тестирования и сценариев, которые требуют аутентификации или сохранения определенного состояния взаимодействия между различными запусками тестов. Это позволяет создать более эффективные и стабильные тестовые сценарии, которые не требуют повторного входа в систему или ручного восстановления состояния между тестами.

При парсинге сайтов с помощью Selenium вы можете столкнуться с рядом исключений. Вот некоторые из наиболее распространенных:

• NoSuchElementException: Элемент не был найден.
• TimeoutException: Превышено время ожидания при выполнении операции.
• ElementNotVisibleException: Элемент существует, но не видим.
• ElementNotInteractableException: Элемент существует, но с ним невозможно взаимодействовать.
• StaleElementReferenceException: Элемент устарел (например, если DOM изменился).
• WebDriverException: Общая ошибка веб-драйвера.

Обработка NoSuchElementException:

from selenium.common.exceptions import NoSuchElementException

try:
    element = driver.find_element(By.ID, "nonexistent-id")
except NoSuchElementException:
    print("Элемент не найден!")

Обработка TimeoutException при использовании явных ожиданий:

from selenium.common.exceptions import TimeoutException
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

try:
    element = WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "may-be-delayed-element")))
except TimeoutException:
    print("Время ожидания истекло для элемента!")

Перехват ElementNotVisibleException:

from selenium.common.exceptions import ElementNotVisibleException

try:
    button = driver.find_element(By.ID, "invisible-button")
    button.click()
except ElementNotVisibleException:
    print("Элемент найден, но в данный момент не видим!")

Управление StaleElementReferenceException:

from selenium.common.exceptions import StaleElementReferenceException

try:
    element = driver.find_element(By.ID, "may-change-element")
    element_text = element.text
except StaleElementReferenceException:
    print("Элемент устарел. Попробуйте заново найти элемент!")

Правильное использование обработки исключений не только поможет избежать сбоев ваших скриптов при возникновении ошибок, но и позволит вам предусмотреть действия для их разрешения. Например, если элемент не найден, вы можете записать это в лог и продолжить выполнение скрипта, или попробовать найти элемент снова через некоторое время. Это создает надежные и устойчивые к ошибкам автоматизированные сценарии.

При парсинге важно учитывать нагрузку, которую ваш скрипт создаёт на целевой сайт. Чтобы минимизировать её, используйте следующие методы:

• Ограничение числа запросов: Не делайте слишком много запросов за короткий промежуток времени. Реализуйте паузы (time.sleep()) между запросами.
• Кэширование: Если вам необходимо несколько раз работать с одними и теми же данными, сохраняйте их локально.
• Обход пагинации: Если возможно, используйте API сайта для получения данных, вместо обхода страниц пагинации через браузер.
• Ограничение поиска элементов: Ищите только те элементы, которые действительно нужны, избегайте использования методов типа find_elements, если достаточно find_element.

Прокси могут использоваться для распределения запросов по различным IP-адресам и снижения риска блокировки. В Selenium для работы с прокси нужно настроить объект Options и передать его при создании экземпляра драйвера:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

proxy = 'ip:port'

chrome_options = Options()
chrome_options.add_argument(f'--proxy-server={proxy}')

driver = webdriver.Chrome(options=chrome_options)

Некоторые сайты могут ограничивать доступ при обнаружении стандартного user-agent от Selenium. Чтобы избежать этого, измените user-agent на более "обычный":

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

user_agent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'

chrome_options = Options()
chrome_options.add_argument(f'user-agent={user_agent}')

driver = webdriver.Chrome(options=chrome_options)

Используйте эти методы с умом и всегда уважайте правила и политику целевых сайтов. Неправильное использование парсинга может привести к юридическим последствиям и нарушению этических норм.

Функции поиска элементов

from selenium.webdriver.common.by import By

# Найти элемент по ID
def find_by_id(driver, element_id):
    return driver.find_element(By.ID, element_id)

# Найти элементы по классу
def find_by_class_name(driver, class_name):
    return driver.find_elements(By.CLASS_NAME, class_name)

# Найти элементы по XPath
def find_by_xpath(driver, xpath):
    return driver.find_elements(By.XPATH, xpath)

# Найти элемент по CSS селектору
def find_by_css(driver, css_selector):
    return driver.find_element(By.CSS_SELECTOR, css_selector)

Функции кликов и ввода данных

# Клик по элементу
def click_element(element):
    element.click()

# Ввести текст в элемент
def enter_text(element, text):
    element.clear()
    element.send_keys(text)

# Ввести текст в элемент и отправить форму
def enter_text_and_submit(element, text):
    element.clear()
    element.send_keys(text)
    element.submit()

Функции работы со скроллом и навигацией

# Скролл до элемента
def scroll_to_element(driver, element):
    driver.execute_script("arguments[0].scrollIntoView();", element)

# Скролл на заданное количество пикселей
def scroll_by_offset(driver, x_pixels, y_pixels):
    driver.execute_script(f"window.scrollBy({x_pixels}, {y_pixels})")

# Перейти по URL
def navigate_to_url(driver, url):
    driver.get(url)

# Переход на предыдущую страницу
def navigate_back(driver):
    driver.back()

# Переход на следующую страницу
def navigate_forward(driver):
    driver.forward()

Функции ожидания элементов

from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Явное ожидание элемента по ID
def wait_for_element_by_id(driver, element_id, timeout=10):
    return WebDriverWait(driver, timeout).until(EC.presence_of_element_located((By.ID, element_id)))

# Явное ожидание кликабельности элемента
def wait_for_clickable_element(driver, element, timeout=10):
    return WebDriverWait(driver, timeout).until(EC.element_to_be_clickable(element))

# Неявное ожидание
def set_implicit_wait(driver, seconds):
    driver.implicitly_wait(seconds)

Эти шаблоны помогут сделать ваш код более читаемым и легко поддерживаемым. Вы можете адаптировать эти функции под свои нужды, инкапсулируя часто используемые паттерны и операции.

• Уважайте robots.txt: Перед началом парсинга проверьте файл robots.txt сайта, чтобы убедиться, что ваша деятельность разрешена.
• Пользовательское соглашение: Прочтите условия использования сайта, чтобы убедиться, что парсинг не нарушает их положения.
• Заголовок User-Agent: Установите информативный User-Agent, который идентифицирует вашего бота, чтобы администраторы сайтов могли связаться с вами в случае возникновения проблем.
• Разумное количество запросов: Не перегружайте сервера сайта. Ограничьте частоту запросов и, по возможности, используйте данные из кэша.

• Головной режим (Headless browsing): Если вам не нужен GUI, используйте браузер в безголовом режиме. Это снижает использование ресурсов и ускоряет парсинг.
• Оптимизация ожиданий: Используйте явные ожидания вместо неявных, чтобы ваш код ждал только необходимое время.
• Совместное использование сессий: Если вам нужно сделать несколько запросов на один и тот же сайт, используйте один и тот же экземпляр веб-драйвера для совместного использования сессии и куки.
• Обработка исключений: Пишите устойчивый к ошибкам код, готовый к обработке исключений, которые могут возникнуть в процессе парсинга.
• Работа с AJAX и динамическим контентом: Иногда элементы загружаются асинхронно. В таких случаях используйте ожидания или JavaScript-запросы, чтобы дождаться загрузки данных.

Если ваш парсинг включает работу с большими объемами данных:

• Пагинация: Обрабатывайте данные постранично, если это возможно, чтобы снизить нагрузку на память.
• Распределенный парсинг: Используйте распределенные системы или многопоточность для параллельной обработки данных.
• Базы данных: Сохраняйте собранные данные в базу данных для удобства обработки и анализа.

• Логирование: Ведите журналы своей деятельности, чтобы можно было отследить, что произошло в случае возникновения ошибок.
• Обновление драйверов: Регулярно обновляйте свои веб-драйверы для обеспечения совместимости с последними версиями браузеров.
• Безопасность: Будьте осторожны с тем, как храните и передаете чувствительные данные, такие как логины, пароли и личная информация.
• Уважение к данным: Если данные защищены авторским правом или являются частной собственностью, всегда получайте разрешение на их использование.

Эти практики помогут вам избежать возможных проблем с владельцами сайтов, а также сделать процесс парсинга более эффективным и безопасным.

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

options = Options()
options.headless = True
driver = webdriver.Chrome(options=options)