Cara Mengurai Feed XML dan RSS di Python

Parse xml rss feeds python cover

Data tersedia dalam berbagai format – mulai dari tabel CSV sederhana dan objek JSON hingga dokumen XML yang lebih deskriptif dan hierarkis. XML mungkin terlihat agak kuno, namun masih ada di mana-mana: di RSS feed, API, dan konfigurasi perangkat lunak.

Sebelum Anda bisa menggunakan data XML, Anda perlu menguraikannya. Dengan kata lain, Anda mengajarkan program Anda untuk membaca apa yang ada di dalamnya. Dengan pustaka Python seperti ElementTree, minidom, dan lxml, penguraian XML adalah proses yang jelas dan intuitif.

Apa pun format data yang Anda temui, mempelajari cara menggunakannya, terutama XML, adalah keterampilan yang harus dimiliki oleh pengembang mana pun. Dalam panduan ini, Anda akan mempelajari cara membaca, menavigasi, dan mengekstrak data dari XML langkah demi langkah.

Dasar-dasar XML

XML adalah singkatan dari eXtensible Markup Language dan merupakan format universal untuk menyimpan dan mengangkut data. Strukturnya memungkinkannya mudah dibaca oleh manusia namun tetap kompatibel dengan mesin. Bahasa ini dibangun dengan fokus pada kesederhanaan, kemampuan beradaptasi, dan kegunaan luas secara online.

XML paling tepat digambarkan sebagai pohon. Mirip dengan pohon asli dengan cabang dan daun, ia memiliki elemen akar dan anak yang bersarang. Kerangka kerja ini menggambarkan bagaimana XML mengatur data dalam format hierarki. Python menawarkan berbagai metode untuk menangani data XML, dengan modul ElementTree menjadi salah satu opsi paling populer. Modul ElementTree mencakup dua kelas utama: ElementTree, yang menandakan keseluruhan dokumen, dan Element, yang menunjukkan node individual. 

Bagaimana pengembang mengurai XML: teknik utama

Dengan Python, itu fungsi parse() biasanya merupakan langkah awal untuk menangani file XML. Ini memproses dokumen XML dan mengubahnya menjadi struktur pohon yang dapat dinavigasi oleh program Anda. Fungsi ini berfungsi sebagai dasar untuk berbagai metode penguraian, baik Anda menggunakan ElementTree, lxml, atau pustaka lainnya.

Untuk memahami metode parsing, Anda harus terlebih dahulu mengetahui elemen file XML:

  • Ruang nama – membantu menghindari konflik penamaan dengan mengkualifikasikan nama elemen dan atribut.
  • Elemen akar – wadah utama yang mencakup semua elemen lainnya.
  • Atribut – pasangan kunci dan nilai yang menawarkan informasi tambahan tentang elemen.
  • Elemen anak – elemen bersarang yang mengatur data secara hierarki.
  • Konten teks – informasi aktual yang terkandung dalam elemen.

Elemen-elemen ini menciptakan format terstruktur yang memungkinkan program untuk menyimpan dan berbagi data yang kompleks. Setelah memahami strukturnya, kita dapat menyelidiki teknik parsing XML utama dengan Python: 

1. Modul Pohon Elemen  

Pustaka bawaan dengan Python dengan API yang mudah digunakan untuk menjelajahi pohon XML. Ini berfungsi dengan baik untuk sebagian besar tugas karena menyeimbangkan kegunaan dengan kinerja.  

2. lxml  

Pustaka pihak ketiga yang mencakup dukungan untuk XPath, XSLT, dan validasi. Ini lebih cepat dan memiliki lebih banyak fitur daripada ElementTree. Ini sempurna untuk pemrosesan XML yang kompleks.  

3.DOM (Model Objek Dokumen)  

Ini memuat dokumen XML lengkap ke dalam memori sebagai struktur pohon. Ketika mudah untuk dinavigasi dan dimodifikasi, dan dapat memakan banyak memori untuk file yang lebih besar. 

4. saksofon (API sederhana untuk XML)  

Parser berbasis peristiwa yang memproses XML secara berurutan. Ini efisien dalam hal penggunaan memori dan cepat untuk menangani file besar, namun kurang intuitif untuk mengelola operasi yang kompleks.  

5. Menguraikan  

Mengubah data XML menjadi objek Python untuk memudahkan akses. Ini sempurna untuk penguraian cepat dengan kode minimal. Namun,  ini kurang dapat beradaptasi dengan struktur XML yang rumit.  

Untuk tutorial ini, Anda memerlukan…

  • Permintaan Python dan Python 

Jika Anda belum menginstal Python 3.x di komputer Anda, Anda dapat mendownloadnya dari https://www.python.org/. Buka terminal dan instal Permintaan menggunakan pip:

permintaan pemasangan pip atau  permintaan pemasangan pip3

  • Kode Visual Studio (Kode VS)

Untuk menjalankan semua perintah yang diperlukan, Anda dapat menggunakan terminal di Visual Studio Code (VS Code). Unduh saja dari situs web resmi dan ikuti petunjuk instalasi untuk sistem operasi Anda.

  • Umpan RSS

Umpan RSS adalah format file XML khusus yang digunakan untuk mengirimkan berita atau pembaruan secara otomatis dari situs web. Sederhananya, ini adalah semacam “daftar postingan terbaru” yang disusun sedemikian rupa sehingga dapat dibaca oleh program.

Misalnya, di situs web kami, ada bagian yang berisi tutorial. Daripada memeriksa situs setiap hari untuk melihat apakah tutorial baru telah diterbitkan, situs ini menyediakan RSS feed – file XML yang berisi informasi tentang semua postingan terbaru. Kami akan menggunakan Umpan RSS DataImpulse untuk tutorial kami. Sekarang, mari kita lihat perpustakaan yang kita perlukan dan kode berikut.

ElementTree

Mari kita lihat cara menggunakan modul ElementTree bawaan Python untuk mengurai data XML dari umpan RSS. 

Langkah pertama adalah mengimpor xml.etree.ElementTree. Prosesnya sederhana: kami mengirimkan permintaan GET ke URL umpan RSS, dan server merespons dengan data XML. Itu .content atribut respon memberi kita data byte mentah yang dapat diurai oleh ElementTree. Menggunakan ET.fromstring(), kami mengonversi teks XML ini menjadi struktur pohon dan mendapatkan elemen root. Di dalamnya, sebagian besar konten diatur dalam <channel> → <item> elemen.

Itu find() metode mengembalikan elemen pertama yang cocok, sementara findall() mengembalikan semua elemen anak dengan tag yang diberikan. Di sini, item adalah daftar semua elemen, masing-masing mewakili tutorial atau artikel.

Contoh kodenya: 


import xml.etree.ElementTree as ET
import requests

# URL of the RSS feed (from DataImpulse site)
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse the XML
root = ET.fromstring(xml_data)

# In RSS feeds, items are inside 
channel = root.find("channel")
items = channel.findall("item")

# Print titles and links of the items
for item in items:
   title = item.findtext("title")
   link = item.findtext("link")
   print(f"Title: {title}")
   print(f"Link: {link}\n")

Terakhir, kami mengekstrak dan mencetak judul dan tautan untuk setiap item yang digunakan findtext(), yang mendapatkan konten teks secara langsung. Saat Anda menjalankan skrip, Anda akan mendapatkan daftar semua judul tutorial dan URL-nya yang tercetak rapi. 

lxml 

Lxml adalah perpustakaan eksternal yang memperluas fungsionalitas ElementTree dan menambahkan dukungan untuk XPath, bahasa kueri untuk menavigasi dokumen XML. Dalam contoh ini, kita akan menggunakan lxml.etree untuk mengurai RSS feed dan mengekstrak judul posting.

Kami mulai dengan mengambil RSS feed menggunakan requests.get(), sama seperti sebelumnya. Konten respons diteruskan ke etree.fromstring(), yang mengurai XML dan mengembalikan elemen root. Dengan lxml, kita dapat menggunakan ekspresi XPath untuk menemukan elemen karena membuat navigasi lebih cepat dan fleksibel dibandingkan metode ElementTree standar.


import requests
from lxml import etree

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download the XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML
root = etree.fromstring(xml_data)
items = root.xpath("//channel/item")

# Show list of titles with numbers
print("Available blog posts:\n")
for item in items:
   title = item.findtext("title")
   print(title)

Akhirnya, kami mengulanginya <item> elemen, ekstrak judul setiap posting menggunakan findtext(“title”), dan mencetaknya.

Minidom 

Dalam contoh ini, kami menggunakan Minidom, kependekan dari Minimal DOM Implementation. Ini adalah bagian dari perpustakaan standar Python dan bekerja dengan memuat seluruh dokumen XML ke dalam memori sebagai Document Object Model (DOM). 

Kami menelepon minidom.parseString() untuk mengurai XML dan membangun objek DOM (doc). Di antara metode DOM yang sudah dikenal, ada dua metode yang akan kita gunakan. Yang pertama adalah getElementsByTagName(“tag”,) yang menemukan semua elemen dengan nama tag tertentu. Dan yang berikutnya adalah .firstChild.nodeValue yang mengambil konten teks dari sebuah node.

Akhirnya, kami menggunakan toprettyxml(). Ini digunakan untuk mencetak elemen item pertama dalam tata letak XML yang diformat.  

Berikut cara mengurai data dari RSS feed menggunakan Minidom:


import requests
from xml.dom import minidom

# URL of the RSS feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML data
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with minidom
doc = minidom.parseString(xml_data)

# Get all  elements
items = doc.getElementsByTagName("item")

print(f"Total articles found in feed: {len(items)}\n")

# Show titles with links
for i, item in enumerate(items, start=1):
   title = item.getElementsByTagName("title")[0].firstChild.nodeValue
   link = item.getElementsByTagName("link")[0].firstChild.nodeValue
   print(f"{i}. {title}")
   print(f"   Link: {link}\n")

# Show raw XML of the first  (just for demo)
print("First  as raw XML:\n")
print(items[0].toprettyxml())

SAX 

SAX membaca XML secara berurutan, elemen demi elemen.  itu memicu peristiwa spesifik untuk setiap bagian XML:

  • startElement(nama, attrs) → saat tag dimulai
  • characters(content) → ketika teks dibaca di antara tag
  • endElement(name) → ketika sebuah tag berakhir

Simpan kode dalam file dan jalankan: 


import requests
import xml.sax

# Custom handler for SAX parsing
class RSSHandler(xml.sax.ContentHandler):
   def __init__(self):
       super().__init__()
       self.current_tag = ""
       self.in_item = False
       self.title = ""
       self.link = ""
       self.counter = 0

   def startElement(self, name, attrs):
       if name == "item":
           self.in_item = True
           self.title = ""
           self.link = ""
       self.current_tag = name

   def characters(self, content):
       if self.in_item:
           if self.current_tag == "title":
               self.title += content
           elif self.current_tag == "link":
               self.link += content

   def endElement(self, name):
       if name == "item":
           self.counter += 1
           print(f"{self.counter}. {self.title.strip()}")
           print(f"   Link: {self.link.strip()}\n")
           self.in_item = False
       self.current_tag = ""

# Download the XML feed
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"
response = requests.get(FEED_URL)
xml_data = response.content

# Parse XML with SAX
print("Parsing RSS feed with SAX...\n")
handler = RSSHandler()
xml.sax.parseString(xml_data, handler)

print(f"Total items parsed: {handler.counter}")

Keuntungan metode ini adalah efisiensi memori, karena tidak menyimpan keseluruhan dokumen. 

Untangle

Metode ini dianggap sebagai cara yang lebih sederhana untuk menangani XML. Pustaka Untangle mengubah dokumen XML menjadi objek Python. Artinya tidak diperlukan traversal elemen atau penanganan event secara manual. 

Saat Anda mengurai XML dengan untangle.parse(), fitur ini otomatis membaca file XML,  mengonversi setiap tag XML menjadi objek Python, dan menyimpan data tag di dalamnya .cdata atribut (jika itu adalah konten teks). Daripada bekerja dengan node atau peristiwa, Anda cukup menavigasi struktur XML seperti objek Python biasa. 

Ini kodenya: 


import requests
import untangle
from io import BytesIO

# RSS feed from DataImpulse
FEED_URL = "https://dataimpulse.com/tutorials-category/web-scraping-seo/feed/"

# Download XML
resp = requests.get(FEED_URL)
resp.raise_for_status()
xml_bytes = resp.content

# Parse XML with untangle (use BytesIO for bytes input)
doc = untangle.parse(BytesIO(xml_bytes))

# Get all  elements
items = doc.rss.channel.item

print("Articles from DataImpulse RSS:\n")

# Print articles
for i, it in enumerate(items, start=1):
   title = it.title.cdata if hasattr(it, "title") else ""
   link = it.link.cdata if hasattr(it, "link") else ""
   desc = it.description.cdata if hasattr(it, "description") else ""
  
   print(f"{i}. {title}")
   print(f"   Link: {link}")
   if desc:
       print(f"   Description: {desc}")
   print()

Beberapa rekomendasi tambahan

  • Periksa kesalahan selama penguraian

Terkadang feed mungkin tidak tersedia atau berisi tag yang tidak terduga. Dalam kasus seperti itu, gunakan coba/kecuali saat mengunduh atau menguraikan XML.

  • Memilih .content untuk unduhan XML

Itu .content atribut mengembalikan data byte mentah, mencegah masalah pengkodean itu .text atribut mungkin menyebabkan.

  • Verifikasi bahwa elemen ada 

Tidak semua file XML memiliki struktur yang sama. Gunakan kondisi seperti if item.find(‘title’) is not None sebelum mengakses tag.

  • Perhatikan penggunaan sumber daya untuk file besar

Untuk dokumen XML berukuran besar, gunakan SAX, yang membaca data secara berurutan tanpa memuat semuanya ke dalam memori.

Mengambil XML dari situs eksternal bisa merepotkan. Proksi membantu memastikan kelancaran akses di seluruh lokasi dan menjaga privasi.

Sorotan Utama

  • Parsing XML adalah proses membaca file XML dan mengekstraksi data dengan cara yang terstruktur dan dapat digunakan.
  • ElementTree menyediakan pendekatan berbasis pohon untuk menavigasi dan mengekstrak elemen XML.
  • lxml adalah perpustakaan yang mendukung kueri XPath untuk penguraian XML yang lebih cepat.
  • Minidom memuat seluruh XML sebagai pohon DOM, memungkinkan Anda mengakses node dan teks seperti objek terstruktur.
  • SAX ideal untuk file XML besar karena memproses XML langkah demi langkah tanpa menyimpan semuanya di memori.
  • Untangle mengubah XML menjadi objek Python untuk sekadar mengakses tag dan kontennya.

Artikel Terkait 

Mengintegrasikan proxy dengan permintaan Python

Cara mengikis eBay dengan Python dan proxy

Cara mengonfigurasi proxy DataImpulse di Java

Mengikis data produk Amazon dengan Python

Membangun rotator proxy khusus dengan Python

Tangani pemeriksaan keamanan menggunakan Python dan Selenium

Share article: