Парсинг HTML и XML в Python: лучшие инструменты и библиотеки

pip install requests beautifulsoup4 lxml

import requests
from bs4 import BeautifulSoup

# Отправляем GET-запрос
response = requests.get('https://news.ycombinator.com/')
# Проверяем успешность запроса
if response.status_code == 200:
# Создаем объект BeautifulSoup для парсинга
soup = BeautifulSoup(response.text, 'html.parser')
# Находим все заголовки новостей
titles = soup.select('.titleline > a')
# Выводим заголовки
for title in titles:
print(title.text)
else:
print(f"Ошибка запроса: {response.status_code}")

# Найти первый div с классом 'content'
content_div = soup.find('div', class_='content')

# Найти все ссылки внутри абзацев
links_in_paragraphs = soup.select('p a')

# Найти элемент по ID
element_by_id = soup.find(id='main-content')

# Найти все элементы с определенным атрибутом
elements_with_attr = soup.find_all(attrs={'data-type': 'article'})

# Извлечение данных из таблицы
table = soup.find('table')
rows = table.find_all('tr')
for row in rows:
cells = row.find_all('td')
row_data = [cell.text.strip() for cell in cells]
print(row_data)

# Использование заголовков для имитации браузера
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
'Accept-Language': 'ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7',
}

# Создание сессии для сохранения cookies
session = requests.Session()
session.headers.update(headers)

# Авторизация
login_data = {'username': 'user', 'password': 'pass'}
session.post('https://example.com/login', data=login_data)

# Доступ к защищенным страницам
protected_page = session.get('https://example.com/protected')

import requests
from lxml import html

# Отправляем GET-запрос
response = requests.get('https://news.ycombinator.com/')
# Создаем дерево элементов
tree = html.fromstring(response.content)
# Используем XPath для поиска заголовков
titles = tree.xpath('//span[@class="titleline"]/a/text()')
links = tree.xpath('//span[@class="titleline"]/a/@href')

# Выводим результаты
for title, link in zip(titles, links):
print(f"{title} – {link}")

# Выбрать все элементы div
all_divs = tree.xpath('//div')

# Выбрать div с определенным классом
content_divs = tree.xpath('//div[@class="content"]')

# Выбрать элементы с конкретным атрибутом
data_elements = tree.xpath('//*[@data-id]')

# Комбинирование условий
specific_elements = tree.xpath('//div[@class="item" and @data-type="product"]')

# Выбор по позиции
first_item = tree.xpath('(//div[@class="item"])[1]')

# Выбор по тексту
elements_with_text = tree.xpath('//a[contains(text(), "Python")]')

# Получение родительского элемента
parent_elements = tree.xpath('//a[@href="#top"]/parent::*')

# Получение атрибутов
all_links = tree.xpath('//a/@href')

from lxml import etree

# Создание нового XML-документа
root = etree.Element("root")
child = etree.SubElement(root, "child")
child.text = "This is a child element"
child.set("attribute", "value")

# Добавление комментария
comment = etree.Comment("This is a comment")
root.append(comment)

# Преобразование в строку
xml_string = etree.tostring(root, pretty_print=True).decode()
print(xml_string)

from lxml.cssselect import CSSSelector

# Создание CSS-селектора
selector = CSSSelector('div.product')
products = selector(tree)

# Эквивалентно
products = tree.cssselect('div.product')

# Обработка результатов
for product in products:
name = product.cssselect('h2.title')[0].text_content()
price = product.cssselect('span.price')[0].text_content()
print(f"{name}: {price}")

import xml.etree.ElementTree as ET

# Парсинг XML-файла
tree = ET.parse('sample.xml')
root = tree.getroot()

# Получение информации о корневом элементе
print(f"Корневой элемент: {root.tag}")
print(f"Атрибуты: {root.attrib}")

# Итерация по дочерним элементам
for child in root:
print(f"Дочерний элемент: {child.tag}, атрибуты: {child.attrib}")

# Поиск всех элементов с определенным тегом
for item in root.findall('./item'):
# Получение текста из дочернего элемента
name = item.find('name').text
price = item.find('price').text
print(f"Товар: {name}, Цена: {price}")

# Получение значения атрибута
for item in root.findall('./item[@category="electronics"]'):
print(f"Электроника: {item.find('name').text}")

# Создание нового XML-документа
root = ET.Element("catalog")
item = ET.SubElement(root, "item", category="book")
ET.SubElement(item, "name").text = "Python Programming"
ET.SubElement(item, "price").text = "29.99"

# Сохранение в файл
tree = ET.ElementTree(root)
tree.write("new_catalog.xml", encoding="utf-8", xml_declaration=True)

from xml.dom import minidom

# Парсинг XML-файла
doc = minidom.parse('sample.xml')

# Получение всех элементов с определенным тегом
items = doc.getElementsByTagName('item')
for item in items:
# Получение значения атрибута
category = item.getAttribute('category')
# Получение текста из дочернего элемента
name_element = item.getElementsByTagName('name')[0]
name = name_element.firstChild.data
print(f"Категория: {category}, Название: {name}")

# Создание нового документа
new_doc = minidom.getDOMImplementation().createDocument(None, "catalog", None)
root = new_doc.documentElement

# Создание нового элемента
item = new_doc.createElement("item")
item.setAttribute("category", "software")
root.appendChild(item)

# Добавление текстового содержимого
name = new_doc.createElement("name")
text = new_doc.createTextNode("Development Tools")
name.appendChild(text)
item.appendChild(name)

# Сохранение в файл с красивым форматированием
xml_string = new_doc.toprettyxml(encoding="utf-8")
with open("new_catalog_dom.xml", "wb") as f:
f.write(xml_string)

# Эффективная обработка больших XML-файлов
for event, elem in ET.iterparse('large.xml', events=('start', 'end')):
if event == 'end' and elem.tag == 'item':
# Обработка элемента
print(elem.find('name').text)
# Очистка элемента для освобождения памяти
elem.clear()

import requests
from bs4 import BeautifulSoup
import time
import smtplib
from email.message import EmailMessage

# Список товаров для отслеживания
products = [
{"url": "https://example.com/product1", "name": "Смартфон X", "desired_price": 15000},
{"url": "https://example.com/product2", "name": "Ноутбук Y", "desired_price": 45000},
]

headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
}

def check_price(url, name, desired_price):
response = requests.get(url, headers=headers)
soup = BeautifulSoup(response.text, 'html.parser')

# Селекторы зависят от конкретного сайта
price_element = soup.select_one('.product-price .value')
if not price_element:
return None

# Извлечение и преобразование цены
price_text = price_element.text.strip().replace(' ', '').replace('₽', '')
current_price = float(price_text)

if current_price <= desired_price:
return current_price
return None

def send_notification(product, price):
msg = EmailMessage()
msg.set_content(f"Цена на {product['name']} снизилась до {price} ₽!")
msg['Subject'] = 'Снижение цены на товар'
msg['From'] = 'your_email@gmail.com'
msg['To'] = 'your_email@gmail.com'

# Настройки SMTP-сервера
server = smtplib.SMTP('smtp.gmail.com', 587)
server.starttls()
server.login('your_email@gmail.com', 'your_password')
server.send_message(msg)
server.quit()

def monitor_prices():
while True:
for product in products:
price = check_price(product['url'], product['name'], product['desired_price'])
if price:
print(f"Цена на {product['name']} снизилась до {price} ₽!")
send_notification(product, price)
else:
print(f"Цена на {product['name']} всё ещё высока.")

# Проверка раз в день
time.sleep(86400)

if __name__ == "__main__":
monitor_prices()

import requests
from bs4 import BeautifulSoup
import sqlite3
import datetime
from concurrent.futures import ThreadPoolExecutor

# Настройка базы данных
conn = sqlite3.connect('news.db')
cursor = conn.cursor()
cursor.execute('''
CREATE TABLE IF NOT EXISTS news (
id INTEGER PRIMARY KEY,
title TEXT,
url TEXT UNIQUE,
source TEXT,
published_date TEXT,
content TEXT,
collected_at TIMESTAMP
)
''')
conn.commit()

# Список источников новостей
news_sources = [
{"name": "Tech News", "url": "https://example.com/tech", "article_selector": ".article", 
"title_selector": "h2", "link_selector": "a", "content_selector": ".article-content"},
{"name": "Science Daily", "url": "https://example.com/science", "article_selector": ".news-item", 
"title_selector": ".title", "link_selector": "a", "content_selector": ".content"},
]

def parse_news_list(source):
try:
response = requests.get(source["url"])
soup = BeautifulSoup(response.text, 'html.parser')
articles = soup.select(source["article_selector"])

news_items = []
for article in articles:
title_elem = article.select_one(source["title_selector"])
if not title_elem:
continue

title = title_elem.text.strip()
link_elem = article.select_one(source["link_selector"])
if not link_elem or not link_elem.has_attr('href'):
continue

link = link_elem['href']
# Обработка относительных URL
if link.startswith('/'):
link = source["url"] + link if source["url"].endswith('/') else source["url"] + '/' + link

news_items.append({"title": title, "url": link, "source": source["name"]})
return news_items
except Exception as e:
print(f"Ошибка при парсинге {source['name']}: {e}")
return []

def parse_article_content(article):
try:
response = requests.get(article["url"])
soup = BeautifulSoup(response.text, 'html.parser')

# Поиск источника в списке
source_config = next((s for s in news_sources if s["name"] == article["source"]), None)
if not source_config:
return article

content_elem = soup.select_one(source_config["content_selector"])
if content_elem:
article["content"] = content_elem.text.strip()

# Поиск даты публикации (может отличаться в зависимости от сайта)
date_elem = soup.select_one('.published-date, .date, time')
if date_elem:
if date_elem.has_attr('datetime'):
article["published_date"] = date_elem['datetime']
else:
article["published_date"] = date_elem.text.strip()
else:
article["published_date"] = datetime.datetime.now().strftime("%Y-%m-%d")

return article
except Exception as e:
print(f"Ошибка при парсинге статьи {article['url']}: {e}")
article["content"] = "Не удалось получить содержимое"
article["published_date"] = datetime.datetime.now().strftime("%Y-%m-%d")
return article

def save_to_database(article):
try:
cursor.execute(
"INSERT OR IGNORE INTO news (title, url, source, published_date, content, collected_at) VALUES (?, ?, ?, ?, ?, ?)",
(article["title"], article["url"], article["source"], article["published_date"], 
article.get("content", ""), datetime.datetime.now())
)
conn.commit()
except Exception as e:
print(f"Ошибка при сохранении в БД: {e}")

def collect_news():
# Сбор списков новостей со всех источников
all_news = []
for source in news_sources:
news_items = parse_news_list(source)
all_news.extend(news_items)

print(f"Найдено {len(all_news)} новостей")

# Параллельный парсинг содержимого статей
with ThreadPoolExecutor(max_workers=5) as executor:
articles_with_content = list(executor.map(parse_article_content, all_news))

# Сохранение в базу данных
for article in articles_with_content:
save_to_database(article)

print("Новости успешно собраны и сохранены")

if __name__ == "__main__":
collect_news()
conn.close()

import requests
import xml.etree.ElementTree as ET
import datetime
import html
import os

# Список RSS-лент
rss_feeds = [
{"name": "Tech News", "url": "https://example.com/tech/rss"},
{"name": "Science News", "url": "https://example.com/science/rss"},
{"name": "Business News", "url": "https://example.com/business/rss"}
]

def parse_rss_feed(feed):
try:
response = requests.get(feed["url"])
# Парсинг XML-содержимого
root = ET.fromstring(response.content)

# Обработка различных форматов RSS
items = root.findall('.//item') or root.findall('.//{http://www.w3.org/2005/Atom}entry')

articles = []
for item in items:
# Извлечение данных с учетом возможного наличия пространства имен
title_elem = item.find('./title') or item.find('.//{http://www.w3.org/2005/Atom}title')
link_elem = item.find('./link') or item.find('.//{http://www.w3.org/2005/Atom}link')
desc_elem = (item.find('./description') or item.find('.//{http://www.w3.org/2005/Atom}summary') 
or item.find('.//{http://www.w3.org/2005/Atom}content'))
date_elem = (item.find('./pubDate') or item.find('.//{http://www.w3.org/2005/Atom}updated') 
or item.find('.//{http://www.w3.org/2005/Atom}published'))

if title_elem is None or (link_elem is None and not hasattr(link_elem, 'attrib')):
continue

title = title_elem.text

# Обработка различных форматов элемента link
if hasattr(link_elem, 'attrib') and 'href' in link_elem.attrib:
link = link_elem.attrib['href']
else:
link = link_elem.text

description = desc_elem.text if desc_elem is not None else ""
pub_date = date_elem.text if date_elem is not None else ""

articles.append({
"title": title,
"link": link,
"description": description,
"pub_date": pub_date,
"source": feed["name"]
})

return articles
except Exception as e:
print(f"Ошибка при парсинге ленты {feed['name']}: {e}")
return []

def clean_html(text):
# Простая очистка HTML-тегов и декодирование HTML-сущностей
if text:
# Удаляем теги
text = text.replace('<p>', '\n').replace('</p>', '\n')
text = ''.join([line for line in text.splitlines() if line.strip()])
text = html.unescape(text)
# Ограничиваем длину для дайджеста
if len(text) > 200:
text = text[:197] + '...'
return text

def generate_digest(articles):
today = datetime.datetime.now().strftime("%Y-%m-%d")
digest = f"# Дайджест новостей за {today}\n\n"

# Группировка по источникам
sources = {}
for article in articles:
source = article["source"]
if source not in sources:
sources[source] = []
sources[source].append(article)

# Формирование дайджеста
for source, items in sources.items():
digest += f"## {source}\n\n"
for item in items[:5]: # Берем до 5 новостей из каждого источника
digest += f"### {item['title']}\n"
digest += f"{clean_html(item['description'])}\n"
digest += f"[Читать полностью]({item['link']})\n\n"

# Сохранение в файл
file_path = f"news_digest_{today}.md"
with open(file_path, "w", encoding="utf-8") as f:
f.write(digest)

print(f"Дайджест сохранен в файл: {os.path.abspath(file_path)}")

def collect_and_digest():
all_articles = []
for feed in rss_feeds:
articles = parse_rss_feed(feed)
all_articles.extend(articles)

# Сортировка по дате (если есть)
all_articles.sort(key=lambda x: x.get("pub_date", ""), reverse=True)

generate_digest(all_articles)

if __name__ == "__main__":
collect_and_digest()