Het ontleden van HTML is een van de meest voorkomende taken die tegenwoordig worden gedaan om informatie van de websites te verzamelen en voor verschillende doeleinden te ontginnen, zoals het vaststellen van de prijsprestaties van een product in de loop van de tijd, beoordelingen van een boek op een website en nog veel meer. Er bestaan ​​veel bibliotheken zoals BeautifulSoup in Python die zoveel pijnlijke punten wegneemt bij het ontleden van HTML, maar het is de moeite waard om te weten hoe die bibliotheken eigenlijk werken onder die laag van abstractie.

In deze les, dat is wat we van plan zijn te doen. We zullen ontdekken hoe waarden van verschillende HTML-tags kunnen worden geëxtraheerd en ook de standaardfunctionaliteit van deze module overschrijven om wat eigen logica toe te voegen. Dit doen we met behulp van de HTMLParser klasse in Python in html.parser module. Laten we de code in actie zien.

Kijken naar de HTMLParser-klasse

Om HTML-tekst in Python te ontleden, kunnen we gebruik maken van: HTMLParser klas in html.parser module. Laten we eens kijken naar de klassedefinitie voor de HTMLParser klasse:

klasse html.parser.HTMLParser(*, convert_charrefs=True)

De convert_charrefs veld, indien ingesteld op True, worden alle tekenreferenties geconverteerd naar hun Unicode-equivalenten. Alleen de script/stijl elementen worden niet geconverteerd. Nu zullen we ook proberen elke functie voor deze klasse te begrijpen om beter te begrijpen wat elke functie doet.

• handle_startendtag Dit is de eerste functie die wordt geactiveerd wanneer HTML-tekenreeks wordt doorgegeven aan de klasse-instantie. Zodra de tekst hier is aangekomen, wordt de besturing doorgegeven aan andere functies in de klasse, wat zich beperkt tot andere tags in de String. Dit is ook duidelijk in de definitie van deze functie: def handle_startendtag(self, tag, attrs):
  zelf.handle_starttag(tag, attrs)
  zelf.handle_endtag(tag)
• handle_starttag: Deze methode beheert de starttag voor de gegevens die het ontvangt. De definitie is zoals hieronder weergegeven: def handle_starttag(self, tag, attrs):
  voorbij lopen
• handle_endtag: Deze methode beheert de eindtag voor de gegevens die het ontvangt: def handle_endtag(self, tag):
  voorbij lopen
• handle_charref: Deze methode beheert de tekenreferenties in de gegevens die het ontvangt. De definitie is zoals hieronder weergegeven: def handle_charref(self, name):
  voorbij lopen
• handle_entityref: Deze functie verwerkt de entiteitsreferenties in de HTML die eraan wordt doorgegeven: def handle_entityref(self, name):
  voorbij lopen
• handle_data:Dit is de functie waar echt werk wordt gedaan om waarden uit de HTML-tags te extraheren en de gegevens met betrekking tot elke tag worden doorgegeven. De definitie is zoals hieronder weergegeven: def handle_data(self, data):
  voorbij lopen
• handvat_comment: Met deze functie kunnen we ook opmerkingen aan een HTML-bron toevoegen: def handle_comment(self, data):
  voorbij lopen
• handle_pi: Aangezien HTML ook verwerkingsinstructies kan hebben, is dit de functie waar deze De definitie is zoals hieronder getoond: def handle_pi(self, data):
  voorbij lopen
• handle_decl: Deze methode verwerkt de declaraties in de HTML, de definitie wordt gegeven als: def handle_decl(self, decl):
  voorbij lopen

Subclasseren van de HTMLParser-klasse

In deze sectie zullen we de HTMLParser-klasse subclasseren en enkele van de functies bekijken die worden aangeroepen wanneer HTML-gegevens worden doorgegeven aan de klasse-instantie. Laten we een eenvoudig script schrijven dat dit allemaal doet:

van html.parser import HTMLParser
klasse LinuxHTMLParser(HTMLParser):
def handle_starttag(zelf, tag, attrs):
print("Begin tag aangetroffen:", tag)
def handle_endtag(zelf, tag):
print("Eindtag aangetroffen :", tag)
def handle_data(zelf, data):
print("Gegevens gevonden :", gegevens)
parser = LinuxHTMLParser()
parser.eten geven("
'

Python HTML-parseermodule

')

Dit is wat we terugkrijgen met deze opdracht:

Python HTMLParser-subklasse

HTMLParser-functies

In deze sectie zullen we werken met verschillende functies van de HTMLParser-klasse en kijken naar de functionaliteit van elk van deze:

van html.parser import HTMLParser
van html.entiteiten importeren naam2codepunt
klasse LinuxHint_Parse(HTMLParser):
def handle_starttag(zelf, tag, attrs):
print("Begin tag:", tag)
voor attr in attrs:
print(" attr:", attr)
def handle_endtag(zelf, tag):
print("Eindtag :", tag)
def handle_data(zelf, data):
print("Gegevens :", gegevens)
def handle_comment (zelf, gegevens):
print("Commentaar:", gegevens)
def handle_entityref(zelf, naam):
c = chr(naam2codepunt[naam])
print("Genoemd ent:", c)
def handle_charref(zelf, naam):
als naam.begint met('x'):
c = chr(int(naam[1:], 16))
anders:
c = chr(int(naam))
print("Aantal :", c)
def handle_decl (zelf, gegevens):
print("Decl :", gegevens)
parser = LinuxHint_Parse()

Laten we bij verschillende aanroepen afzonderlijke HTML-gegevens aan deze instantie toevoegen en kijken welke uitvoer deze aanroepen genereren. We beginnen met een eenvoudige DOCTYPE draad:

parser.eten geven(''"http://www.w3.org/TR/html4/strict.dtd">')

Dit is wat we terugkrijgen met deze oproep:

DOCTYPE-tekenreeks

Laten we nu een afbeeldingstag proberen en kijken welke gegevens het extraheert:

parser.eten geven('')

Dit is wat we terugkrijgen met deze oproep:

HTMLParser-afbeeldingstag

Laten we vervolgens proberen hoe scripttags zich gedragen met Python-functies:

parser.eten geven('')
parser.eten geven('')
parser.feed('#python kleur: groen ')

Dit is wat we terugkrijgen met deze oproep:

Scripttag in htmlparser

Ten slotte geven we ook opmerkingen door aan de HTMLParser-sectie:

parser.eten geven(''
'')

Dit is wat we terugkrijgen met deze oproep:

Opmerkingen parseren

Conclusie

In deze les hebben we gekeken hoe we HTML kunnen ontleden met behulp van de Python eigen HTMLParser-klasse zonder enige andere bibliotheek. We kunnen de code eenvoudig aanpassen om de bron van de HTML-gegevens te wijzigen in een HTTP-client.

Lees hier meer op Python gebaseerde berichten.