Как парсить данные с сайта python

Почему стоит научиться «парсить» сайты, или как написать свой первый парсер на Python

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

Перейдем к этапам парсинга.

• Поиск данных
• Извлечение информации
• Сохранение данных

И так, рассмотрим первый этап парсинга — Поиск данных.

Так как нужно парсить что-то полезное и интересное давайте попробуем спарсить информацию с сайта work.ua.
Для начала работы, установим 3 библиотеки Python.

pip install beautifulsoup4

Без цифры 4 вы ставите старый BS3, который работает только под Python(2.х).

pip install requests
pip install pandas

Теперь с помощью этих трех библиотек Python, можно проанализировать нашу веб-страницу.

Второй этап парсинга — Извлечение информации.

Попробуем получить структуру html-кода нашего сайта.
Давайте подключим наши новые библиотеки.

import requests from bs4 import BeautifulSoup as bs import pandas as pd 

И сделаем наш первый get-запрос.

URL_TEMPLATE = "https://www.work.ua/ru/jobs-odesa/?page=2" r = requests.get(URL_TEMPLATE) print(r.status_code) 

Статус 200 состояния HTTP — означает, что мы получили положительный ответ от сервера. Прекрасно, теперь получим код странички.

print(r.text) 

Получилось очень много, правда? Давайте попробуем получить названия вакансий на этой страничке. Для этого посмотрим в каком элементе html-кода хранится эта информация.

Комірник

У нас есть тег h2 с классом «add-bottom-sm», внутри которого содержится тег a. Отлично, теперь получим title элемента a.

soup = bs(r.text, "html.parser") vacancies_names = soup.find_all('h2', class_='add-bottom-sm') for name in vacancies_names: print(name.a['title']) 

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

Some information about vacancy.

Получаем такой код.

vacancies_info = soup.find_all('p', class_='overflow') for name in vacancies_names: print('https://www.work.ua'+name.a['href']) for info in vacancies_info: print(info.text) 

И последний этап парсинга — Сохранение данных.

Давайте соберем всю полученную информацию по страничке и запишем в удобный формат — csv.

import requests from bs4 import BeautifulSoup as bs import pandas as pd URL_TEMPLATE = "https://www.work.ua/ru/jobs-odesa/?page=2" FILE_NAME = "test.csv" def parse(url = URL_TEMPLATE): result_list = r = requests.get(url) soup = bs(r.text, "html.parser") vacancies_names = soup.find_all('h2', class_='add-bottom-sm') vacancies_info = soup.find_all('p', class_='overflow') for name in vacancies_names: result_list['href'].append('https://www.work.ua'+name.a['href']) result_list['title'].append(name.a['title']) for info in vacancies_info: result_list['about'].append(info.text) return result_list df = pd.DataFrame(data=parse()) df.to_csv(FILE_NAME) 

После запуска появится файл test.csv — с результатами поиска.

Делаем парсер, чтобы массово тянуть с сайтов что угодно

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

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

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

Что делаем

Сегодня мы спарсим все статьи «Кода» кроме новостей и задач, причём сделаем всё так:

1. Научимся обрабатывать одну страницу.
2. Сделаем из этого удобную функцию для обработки.
3. Найдём все адреса всех нужных страниц.
4. Выберем нужные нам рубрики.
5. Для каждой рубрики создадим отдельный файл, в который добавим всё текстовое содержимое всех статей в этой рубрике.

Чтобы потом можно было нормально работать с текстом, мы не будем парсить вставки с примерами кода, а ещё постараемся избавиться от титров, рекламных баннеров и плашек.

Будем работать поэтапно: сначала научимся разбирать контент на одной странице, а потом подгрузим в скрипт все остальные статьи.

Выбираем страницу для отладки

Технически самый простой парсинг делается двумя командами в Python, одна из которых — подключение сторонней библиотеки. Но этот код не слишком полезен для нашей задачи, сейчас объясним.

from urllib.request import urlopen inner_html_code = str(urlopen('АДРЕС СТРАНИЦЫ').read(),'utf-8')

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

Чтобы скрипт научился отбрасывать ненужное, придётся ему прописать, что именно отбрасывать. А для этого нужно знать, что нам не нужно. А значит, нам нужно взять какую-то старую статью, в которой будут все ненужные элементы, и на этой одной странице всё объяснить.

Для настройки скрипта мы возьмём нашу старую статью. В ней есть всё нужное для отладки:

• текст статьи,
• подзаголовки,
• боковые ссылки,
• кат с кодом,
• просто вставки кода в текст,
• титры,
• рекламный баннер.

Получаем сырой текст

Вот что мы сейчас сделаем:

1. Подключим библиотеку urlopen для обработки адресов страниц.
2. Подключим библиотеку BeautifulSoup для разбора исходного кода страницы на теги.
3. Получим исходный код страницы по её адресу.
4. Распарсим его по тегам.
5. Выведем текстовое содержимое распарсенной страницы.

На языке Python это выглядит так:

# подключаем urlopen из модуля urllib from urllib.request import urlopen # подключаем библиотеку BeautifulSoup from bs4 import BeautifulSoup # получаем исходный код страницы inner_html_code = str(urlopen('https://thecode.media/parsing/').read(),'utf-8') # отправляем исходный код страницы на обработку в библиотеку inner_soup = BeautifulSoup(inner_html_code, "html.parser") # выводим содержимое страницы print(inner_soup.get_text())

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

Чистим текст

Так как нам требуется только сама статья, найдём раздел, в котором она лежит. Для этого посмотрим исходный код страницы, нажав Ctrl+U или ⌘+⌥+U. Видно, что содержимое статьи лежит в блоке , причём такой блок на странице один.

Чтобы из всего исходного кода оставить только этот блок, используем команду find() с параметром ‘div’, — она найдёт нужный нам блок, у которого есть характерный признак класса.

Добавим эту команду перед выводом текста на экран:

# оставляем только блок с содержимым статьи
​​inner_soup = inner_soup.find(‘div’, )

Стало лучше: нет мусора до и после статьи, но в тексте всё ещё много лишнего — содержимое ката с кодом, преформатированный код ( вот такой ), вставки с кодом, титры и рекламный баннер.

Чтобы избавиться и от этого, нам нужно знать, в каких тегах или блоках это лежит. Для этого нам снова понадобится заглянуть в исходный код страницы. Логика будет такая: находим фрагмент текста → смотрим код, который за него отвечает, → удаляем этот код из нашей переменной.Например, если мы хотим убрать титры, то находим блок, где они лежат, а потом в цикле удаляем его командой decompose() .

Сделаем функцию, которая очистит наш код от любых разделов и тегов, которые мы укажем в качестве параметра:

# очищаем код от выбранных элементов def delete_div(code,tag,arg): # находим все указанные теги с параметрами for div in code.find_all(tag, arg): # и удаляем их из кода div.decompose()

А теперь добавим такой код перед выводом содержимого:

# удаляем титры delete_div(inner_soup, "div", )

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

# удаляем боковые ссылки delete_div(inner_soup, "div", ) # удаляем баннеры, перебирая все их возможные индексы в цикле (потому что баннеры в коде имеют номера от 1 до 99) for i in range(99): delete_div(inner_soup, "div", ) # удаляем кат delete_div(inner_soup, "div", ) # удаляем преформатированный код delete_div(inner_soup, 'pre','') # удаляем вставки с кодом delete_div(inner_soup,'code','')

Теперь всё в порядке: у нас есть только текст статьи, без внешнего обвеса, лишнего кода и ссылок. Можно переходить к массовой обработке.

Собираем функцию

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

Если запустить этот скрипт, получим тот же результат, что и в предыдущем разделе.

# подключаем urlopen из модуля urllib from urllib.request import urlopen # подключаем библиотеку BeautifulSout from bs4 import BeautifulSoup # очищаем код от выбранных элементов def delete_div(code,tag,arg): # находим все указанные теги с параметрами for div in code.find_all(tag, arg): # и удаляем их из кода div.decompose() # очищаем текст по указанному адресу def clear_text(url): # получаем исходный код страницы inner_html_code = str(urlopen(url).read(),'utf-8') # отправляем исходный код страницы на обработку в библиотеку inner_soup = BeautifulSoup(inner_html_code, "html.parser") # оставляем только блок с содержимым статьи inner_soup = inner_soup.find('div', ) # удаляем титры delete_div(inner_soup, "div", ) # удаляем боковые ссылки delete_div(inner_soup, "div", ) # удаляем баннеры for i in range(11): delete_div(inner_soup, "div", ) # удаляем кат delete_div(inner_soup, "div", ) # удаляем преформатированный код delete_div(inner_soup, 'pre','') # удаляем вставки с кодом delete_div(inner_soup,'code','') # возвращаем содержимое страницы return(inner_soup.get_text()) print(clear_text('https://thecode.media/parsing/'))

Получаем адреса всех страниц

Одна из самых сложных вещей в парсинге — получить список адресов всех нужных страниц. Для этого можно использовать:

• карту сайта,
• внутренние рубрикаторы,
• разделы на сайте,
• готовые страницы со всеми ссылками.

В нашем случае мы воспользуемся готовой страницей — там собраны все статьи с разбивкой по рубрикам: https://thecode.media/all. Но даже в этом случае нам нужно написать код, который обработает эту страницу и заберёт оттуда только адреса статей. Ещё нужно предусмотреть, что нам не нужны ссылки из новостей и задач.

Идём в исходный код общей страницы и видим, что все ссылки лежат внутри списка:

При этом каждая категория статей лежит в своём разделе — именно это мы и будем использовать, чтобы обработать только нужные нам категории. Например, вот как рубрика «Ахах» выглядит на странице:

А вот она же — но в исходном коде. По названию легко понять, какой блок за неё отвечает:

Чтобы найти раздел в коде по атрибуту, используем команду find() с параметром attrs — в нём мы укажем название рубрики. А чтобы найти адрес в ссылке — используем команду select(), в которой укажем, что ссылка должна лежать внутри элемента списка.

Теперь логика будет такая:

1. Создаём список с названиями нужных нам рубрик.
2. Делаем функцию, куда будем передавать эти названия.
3. Внутри функции находим рубрику по атрибуту.
4. Перебираем все элементы списка со ссылками.
5. Находим там адреса и записываем в переменную.
6. Для проверки — выводим переменную с адресами на экран.

def get_all_url(data_title): html_code = str(urlopen('https://thecode.media/all').read(),'utf-8') soup = BeautifulSoup(html_code, "html.parser") # находим рубрику по атрибуту s = soup.find(attrs=) # тут будут все найденные адреса url = [] # перебираем все теги ссылок, которые есть в списке for tag in s.select("li:has(a)"): # добавляем адрес ссылки в нашу общую переменную url.append(tag.find("a")["href"]) # выводим найденные адреса print(url) # названия рубрик, которые нам нужны division = ['Ахах','Не стыдно','Это баг','Это как'] # перебираем все рубрики for el in division: # и обрабатываем каждую рубрику отдельно get_all_url(el)

На выходе у нас все адреса страниц из нужных рубрик. Теперь объединим обе функции и научим их сохранять текст в файл.

Сохраняем текст в файл

Единственное, чего нам сейчас не хватает, — это сохранения в файл. Чтобы каждая рубрика хранилась в своём файле, привяжем имя файла к названию рубрики. Дальше логика будет такая:

1. Берём функцию get_all_url(), которая формирует список всех адресов для каждой рубрики.
2. В конец этой функции добавляем команду создания файла с нужным названием.
3. Открываем файл для записи.
4. Перебираем в цикле все найденные адреса и тут же отправляем каждый адрес в функцию clear_text().
5. Результат работы этой функции — готовый контент — записываем в файл и переходим к следующему.

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

# подключаем urlopen из модуля urllib from urllib.request import urlopen # подключаем библиотеку BeautifulSout from bs4 import BeautifulSoup # очищаем код от выбранных элементов def delete_div(code,tag,arg): # находим все указанные теги с параметрами for div in code.find_all(tag, arg): # и удаляем их из кода div.decompose() # очищаем текст по указанному адресу def clear_text(url): # получаем исходный код страницы inner_html_code = str(urlopen(url).read(),'utf-8') # отправляем исходный код страницы на обработку в библиотеку inner_soup = BeautifulSoup(inner_html_code, "html.parser") # оставляем только блок с содержимым статьи inner_soup = inner_soup.find('div', ) # удаляем титры delete_div(inner_soup, "div", ) # удаляем боковые ссылки delete_div(inner_soup, "div", ) # удаляем баннеры for i in range(11): delete_div(inner_soup, "div", ) # удаляем кат delete_div(inner_soup, "div", ) # удаляем преформатированный код delete_div(inner_soup, 'pre','') # удаляем вставки с кодом delete_div(inner_soup,'code','') # возвращаем содержимое страницы return(inner_soup.get_text()) # формируем список адресов для указанной рубрики def get_all_url(data_title): # считываем страницу со всеми адресами html_code = str(urlopen('https://thecode.media/all').read(),'utf-8') # отправляем исходный код страницы на обработку в библиотеку soup = BeautifulSoup(html_code, "html.parser") # находим рубрику по атрибуту s = soup.find(attrs=) # тут будут все найденные адреса url = [] # перебираем все теги ссылок, которые есть в списке for tag in s.select("li:has(a)"): # добавляем адрес ссылки в нашу общую переменную url.append(tag.find("a")["href"]) # имя файла для содержимого каждой рубрики content_file_name = data_title + '_content.txt' # открываем файл и стираем всё, что там было file = open(content_file_name, "w") # перебираем все адреса из списка for x in url: # сохраняем обработанный текст в файле и переносим курсор на новую строку file.write(clear_text(x) + '\n') # закрываем файл file.close() # названия рубрик, которые нам нужны division = ['Ахах','Не стыдно','Это баг','Это как'] # перебираем все рубрики for el in division: # и обрабатываем каждую рубрику отдельно get_all_url(el)

Что дальше

Теперь у нас есть все тексты всех статей. Как-нибудь проанализируем частотность слов в них (как в проекте с текстами Льва Толстого) или научим нейросеть писать новые статьи на основе старых.

Как парсить данные с сайта python

Этим уроком мы начинаем курс, про который нас часто спрашивали — курс по парсингу данных с помощью Python. Мы уже рассказывали о парсинге без программирования, с помощью расширений для браузера, но их возможности ограничены и подходят не для всех сайтов. А вот Python поможет вам спарсить практически что угодно.

Съемка и монтаж: Глеб Лиманский

Чтобы правильно парсить, нужно понимать, как устроены сайты. Почти все они сверстаны с помощью языка HTML. Разберемся в его устройстве на примере сайта «КиноПоиск» и попробуем спарсить список из 250 лучших фильмов по версии пользователей сайта.

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

Для этого курса мы используем браузер Google Chrome, поэтому, чтобы вам было проще понимать наши действия и не путаться в названиях функций, советуем использовать его же. Но в других браузерах, Firefox или Opera, например, все эти функции тоже есть.

Если вы кликнете на любое место сайта правой кнопкой мыши и нажмете на «Посмотреть код», то справа появится панель с кодом HTML (ее еще называют панелью разработчика).

Этот язык строится по тегам. Главный — html, в head обычно прописана метаинформация (заголовок, например), а нас сейчас интересует тег body, где лежит основная информация страницы.

Чтобы посмотреть код конкретного элемента, нужно кликнуть именно на него и нажать «Посмотреть код» — тогда в панели разработчика подсветится нужный тег.

И наоборот, если двигаться по коду в панели справа, то слева, на самой странице, будет подсвечиваться сверстанный этим тегом элемент.

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

Открываем Jupyter, импортируем библиотеку с помощью import requests. Чтобы обратиться к сайту, создаем переменную url и присваиваем ей значение нужного сайта (у нас это ссылка на топ «КиноПоиска»).

Отправим на сервер запрос с помощью команды get, на вход которой мы передаем переменную url. С помощью команды text посмотрим, что получилось.

Как видите, код получился нечитаемым. Справиться с этим поможет другая библиотека, Beautifulsoup. Импортируем ее с помощью команды from bs4 import BeautifulSoup. Возможно, для этого понадобится сначала установить библиотеку через pip install.

Мы должны передать библиотеке ответ, полученный с помощью Requests. Создадим переменную soup, передадим r.text и укажем необходимый формат (в нашем случае lxml).

Код упорядочен, теги идут один за одним — теперь мы можем вынимать из кода то, что нам нужно. Для этого вернемся в браузер, на страницу с данными. Как видно на скриншоте, подряд расположены несколько тегов div с классом desktop-rating-selection-file-item — это карточка каждого из фильмов в списке.

Сначала вытащим данные только из первой карточки, а затем перепишем код так, чтобы он сработал на все фильмы со страницы. Скопируем название класса — для этого два раза кликните на него мышкой и нажмите Ctrl+C (Cmd+C для macOS).

В Beautifulsoup есть команда find — укажем ей нужный тег (div) и через запятую класс (desktop-rating-selection-file-item). После class обязательно нужно поставить нижнее подчеркивание.

Отобразился уже не весь код, а только нужный элемент, в котором видно название фильма. Вернемся на сайт, чтобы углубиться в карточку и посмотреть, как называются нужные нам детали. Кликнем на название фильма «Зеленая миля» и снова выберем «Посмотреть код».

Например, мы видим, что ссылка на фильм лежит в теге a и имеет собственный класс selection-film-item-meta__link. В теге a, в свою очередь, есть теги p с русским и оригинальным названиями фильмов. Эти три элемента мы и заберем.

Дополним нашу первую команду: ставим точку, снова пишем find, указываем тег a и его класс.

Чтобы сделать ссылку на фильм работающей, в начале нужно дописать к ней домен. Сама ссылка лежит внутри тега, поэтому find мы применить не сможем. Воспользуемся командой get и укажем нужный атрибут (в нашем случае href).

Допишем в начало команды домен «КиноПоиска» и запустим еще раз — так мы получим готовую ссылку. Положим этот код в переменную link.

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

Еще мы можем достать из карточки страну производства и жанр — все будет работать точно так же, только класс будет не p, как у названий, а span. Страну положим в переменную country.

Однако в коде «КиноПоиска» страна и жанр имеют одинаковый класс selection-film-item-meta__meta-additional-item — а команда find находит только первое соответствие вашему запросу. Применим команду findAll, а все остальное оставим как раньше, чтобы получить список.

Чтобы вытащить только жанр, добавим нумерацию в квадратных скобках (не забывайте, что в Python отсчет идет с 0, поэтому нам нужен номер 1) и команду text. Переменную назовем film_type.

Основную информацию о фильме мы достали, но можем получить и кое-что еще — например, оценку. Проверим, как называется класс этого элемента на странице «КиноПоиска» с помощью уже известного метода «Посмотреть код». Как видите, нам повезло — класс имеет уникальное название, глубоко копать не придется.

Скопируем ту часть изначальной команды find, где мы заходим в первый div карточки фильма и сразу укажем новый поиск по тегу span и классу rating__value rating__value_positive (и не забудем про text). Переменную назовем rate.

Мы уже сделали почти всю работу, но пока что наш код работает только для первой карточки фильма в списке. Исправим это. Создадим переменную films, зададим новый поиск по самому первому div, но уже с командой findAll. И заодно посмотрим длину списка с помощью команды len. Их будет 50, потому что список топ-250 разбит на 5 страниц. Далее мы научим код ходить и по другим страницам.

Напишем цикл для каждого film в списке films. Пока скопируем команду по поиску link и посмотрим, что там нужно поправить. Нам не нужен запрос к первому div, потому что до этого мы обратились к нему через findAll — заменим его на film. Повторим так с каждым элементом.

Создадим переменную data, в который будем добавлять все переменные, которые запрашиваем.

Запустим код и посмотрим, что отображается в data.

Все ровно так, как нам было нужно. Осталось только разобраться, как собирать данные и со следующих страниц. Если мы перейдем на вторую страницу списка, то увидим, что ссылка в адресной строке браузера изменилась — там появилось page=2.

То есть, нам нужно передать этот параметр в цикл. Создадим перед циклом переменную url и воспользуемся методом f-строк, чтобы поместить внутрь фигурных скобок тот параметр, который нам нужен — номер страницы. Назовем параметр p и поместим его в цикл в промежутке от 1 до 6.

Переменную data при этом нужно вынести в начало кода, чтобы она не перезаписывалась с каждым новым циклом, а дополнялась. После этого скопируем код для запуска Requests и Beautifulsoup.

Код готов к работе. Но еще мы советуем добавить временные промежутки между запросами, чтобы не перегружать сервер, к которому обращаемся. Вернемся в область, где ранее импортировали Beautifulsoup, и импортируем из библиотеки time функцию sleep.

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

Все должно сработать. Если сейчас снова проверить длину нашего списка командой len(data), там будет 250 — как и в топе «КиноПоиска». Теперь сохраним наши данные в таблицу. Снова вернемся в область импорта и добавим туда Pandas и используем его для записи в csv.

Введем названия для колонок — пусть они дублируют названия переменных, которые мы присвоили ранее (не забудьте поместить их в ‘кавычки’). И после этого экспортируем наши данные.

Как парсить данные с сайта python

Парсинг полученных данных

Извлечь адрес ссылки можно 4 разными способами – с помощью:

• Методов строк.
• Регулярного выражения.
• Запроса XPath.
• Обработки BeautifulSoup.

Рассмотрим все эти способы по порядку.

Методы строк

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

В приведенном выше примере для извлечения ссылки к пути /html/body/div/p[2]/a/ мы добавили указание для получения значения ссылки @href , и индекс [0] , поскольку результат возвращается в виде списка. Если @href заменить на text() , программа вернет текст ссылки, а не сам URL :

Пока страница не прокручена, полный HTML -код с информацией о планшетах получить невозможно. Для имитации прокрутки мы воспользуемся скриптом ‘window.scrollTo(0, document.body.scrollHeight);’ . Цены планшетов находятся в тегах h 4 класса pull-right price, а названия моделей – в тексте ссылок a класса title. Готовый код выглядит так :

Пример результата:

from bs4 import BeautifulSoup import requests import re url = 'https://www.livelib.ru/book/1002978643-ohotnik-za-tenyu-donato-karrizi' headers = res = requests.get(url, headers=headers) soup = BeautifulSoup(res.text,'html.parser') sp = soup.find('div', class_='bc-menu__image-wrapper') img_url = re.findall(r'(?:https\:)?//.*\.(?:jpeg)', str(sp))[0] response = requests.get(img_url, headers=headers) if response.status_code == 200: file_name = url.split('-', 1)[1] with open(file_name + '.jpeg', 'wb') as file: file.write(response.content) 

Задание 6

Напишите программу, которая составляет рейтинг топ-100 лучших триллеров на основе этого списка.

Пример результата:

1. "Побег из Шоушенка", Стивен Кинг - 4.60 2. "Заживо в темноте", Майк Омер - 4.50 3. "Молчание ягнят", Томас Харрис - 4.47 4. "Девушка с татуировкой дракона", Стиг Ларссон - 4.42 5. "Внутри убийцы", Майк Омер - 4.38 . 98. "Абсолютная память", Дэвид Болдаччи - 4.22 99. "Сломанные девочки", Симона Сент-Джеймс - 4.11 100. "Цифровая крепость", Дэн Браун - 3.98 

from bs4 import BeautifulSoup import requests url = 'https://www.livelib.ru/genre/%D0%A2%D1%80%D0%B8%D0%BB%D0%BB%D0%B5%D1%80%D1%8B/top' headers = res = requests.get(url, headers=headers) soup = BeautifulSoup(res.content,'html.parser') titles = soup.find_all('a', class_='brow-book-name with-cycle') authors = soup.find_all('a', class_='brow-book-author') rating = soup.find_all('span', class_='rating-value stars-color-orange') i = 1 for t, a, r in zip(titles, authors, rating): print(f'. "", - ') i += 1 

Задание 7

Напишите программу, которая составляет топ-20 языков программирования на основе рейтинга популярности TIOBE .

Пример результата:

1. Python: 14.83% 2. C: 14.73% 3. Java: 13.56% 4. C++: 13.29% 5. C#: 7.17% 6. Visual Basic: 4.75% 7. JavaScript: 2.17% 8. SQL: 1.95% 9. PHP: 1.61% 10. Go: 1.24% 11. Assembly language: 1.11% 12. MATLAB: 1.08% 13. Delphi/Object Pascal: 1.06% 14. Scratch: 1.00% 15. Classic Visual Basic: 0.98% 16. R: 0.93% 17. Fortran: 0.79% 18. Ruby: 0.76% 19. Rust: 0.73% 20. Swift: 0.71% 

import requests from lxml import html url = 'https://www.tiobe.com/tiobe-index/' headers = page = requests.get(url, headers=headers) tree = html.fromstring(page.content) languages, rating = [], [] for i in range(1, 21): languages.append(tree.xpath(f'//*[@id="top20"]/tbody/tr[]/td[5]/text()')[0]) rating.append(tree.xpath(f'//*[@id="top20"]/tbody/tr[]/td[6]/text()')[0]) i = 1 for l, r in zip(languages, rating): print(f'. : ') i += 1 

Задание 8

Напишите программу для получения рейтинга 250 лучших фильмов по версии IMDb. Названия должны быть на русском языке.

Пример результата:

1. Побег из Шоушенка, (1994), 9,2 2. Крестный отец, (1972), 9,2 3. Темный рыцарь, (2008), 9,0 . 248. Аладдин, (1992), 8,0 249. Ганди, (1982), 8,0 250. Танцующий с волками, (1990), 8,0 

import requests from lxml import html url = 'https://www.imdb.com/chart/top/' headers = page = requests.get(url, headers=headers) tree = html.fromstring(page.content) movies, year, rating = [], [], [] for i in range(1, 251): movies.append(tree.xpath(f'//*[@id="main"]/div/span/div/div/div[3]/table/tbody/tr[]/td[2]/a/text()')[0]) year.append(tree.xpath(f'//*[@id="main"]/div/span/div/div/div[3]/table/tbody/tr[]/td[2]/span/text()')[0]) rating.append(tree.xpath(f'//*[@id="main"]/div/span/div/div/div[3]/table/tbody/tr[]/td[3]/strong/text()')[0]) i = 1 for m, y, r in zip(movies, year, rating): print(f'. , , ') i += 1 

Задание 9

Напишите программу, которая сохраняет в текстовый файл данные о фэнтези фильмах с 10 первых страниц соответствующего раздела IMDb . Если у фильма/сериала еще нет рейтинга, следует указать N / A .

Ожидаемый результат в файле fantasy . txt – 500 записей:

Мандалорец, (2019– ), 8,7 Всё везде и сразу, (2022), 8,0 Атака титанов, (2013–2023), 9,0 Peter Pan & Wendy, (2023), N/A Игра престолов, (2011–2019), 9,2 . Шрэк 3, (2007), 6,1 Кунг-фу Панда 3, (2016), 7,1 Смерть ей к лицу, (1992), 6,6 Исход: Цари и боги, (2014), 6,0 Кошмар на улице Вязов 3: Воины сна, (1987), 6,6 

import requests import mechanicalsoup from lxml import html import time url = 'https://www.imdb.com/search/title/?genres=fantasy' headers = browser = mechanicalsoup.StatefulBrowser() j = 51 for _ in range(10): browser.open(url) page = requests.get(url, headers=headers) tree = html.fromstring(page.content) titles, year, rating = [], [], [] for i in range(1, 51): if tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/p[1]/b/text()') != []: titles.append(tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/h3/a/text()')[0]) year.append(tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/h3/span[2]/text()')[0]) rating.append('N/A') else: titles.append(tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/h3/a/text()')[0]) year.append(tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/h3/span[2]/text()')[0]) rating.append(tree.xpath(f'//*[@id="main"]/div/div[3]/div/div[]/div[3]/div/div[1]/strong/text()')[0]) with open('fantasy.txt', 'a', encoding='utf-8') as file: for t, y, r in zip(titles, year, rating): file.write(f', , \n') time.sleep(2) lnk = browser.follow_link('start=' + str(j)) url = browser.url j += 50 

Задание 10

Напишите программу для получения главных новостей (на русском) с портала Habr. Каждый заголовок должен сопровождаться ссылкой на полный текст новости.

Пример вывода:

Bethesda назвала дату релиза Starfield на ПК, Xbox Series и Xbox Game Pass — 6 сентября 2023 года https://habr.com/ru/news/t/721148/ Honda запатентовала съёмные подушки безопасности для мотоциклистов https://habr.com/ru/news/t/721142/ . Microsoft увольняет 689 сотрудников из своих офисов в Сиэтле https://habr.com/ru/news/t/721010/ «Ъ»: в России образовались большие запасы бытовой техники из-за низкого спроса https://habr.com/ru/news/t/721006/ 

from bs4 import BeautifulSoup import requests url = 'https://habr.com/ru/news/' headers = res = requests.get(url, headers=headers) soup = BeautifulSoup(res.content,'html.parser') articles = soup.find_all('a', class_='tm-article-snippet__title-link') for a in articles: print(f'\nhttps://habr.com') 

Заключение

Мы рассмотрели основные приемы работы с главными Python -инструментами для скрапинга и парсинга. Способы извлечения и обработки данных варьируются от сайта к сайту – в некоторых случаях эффективнее использование XPath , в других – разбор с BeautifulSoup , а иногда может потребоваться применение регулярных выражений.

В следующей главе приступим к изучению основ ООП (объектно-ориентированного программирования).

1. Особенности, сферы применения, установка, онлайн IDE
2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
3. Типы данных: преобразование и базовые операции
4. Методы работы со строками
5. Методы работы со списками и списковыми включениями
6. Методы работы со словарями и генераторами словарей
7. Методы работы с кортежами
8. Методы работы со множествами
9. Особенности цикла for
10. Условный цикл while
11. Функции с позиционными и именованными аргументами
12. Анонимные функции
13. Рекурсивные функции
14. Функции высшего порядка, замыкания и декораторы
15. Методы работы с файлами и файловой системой
16. Регулярные выражения
17. Основы скрапинга и парсинга
18. Основы ООП – инкапсуляция и наследование
19. Основы ООП – абстракция и полиморфизм
20. Графический интерфейс на Tkinter
21. Основы разработки игр на Pygame
22. Основы работы с SQLite
23. Основы веб-разработки на Flask
24. Основы работы с NumPy
25. Основы анализа данных с Pandas