I den här lektionen är det vad vi tänker göra. Vi kommer att ta reda på hur värden för olika HTML-taggar kan extraheras och åsidosätter också standardfunktionen för denna modul för att lägga till lite egen logik. Vi kommer att göra detta med hjälp av HTMLParser klass i Python i html.parser modul. Låt oss se koden i aktion.
Tittar på HTMLParser-klassen
För att analysera HTML-text i Python kan vi använda HTMLParser klass i html.parser modul. Låt oss titta på klassdfinitionen för HTMLParser klass:
klass html.parser.HTMLParser (*, convert_charrefs = True)De convert_charrefs fältet, om det är satt till True kommer alla teckenreferenser att konverteras till deras Unicode-ekvivalenter. Bara skript / stil element konverteras inte. Nu ska vi försöka förstå varje funktion för den här klassen för att bättre förstå vad varje funktion gör.
- handle_startendtag Detta är den första funktionen som utlöses när HTML-sträng skickas till klassinstansen. När texten når hit överförs kontrollen till andra funktioner i klassen som begränsar till andra taggar i strängen. Detta är också tydligt i definitionen för den här funktionen: def handle_startendtag (self, tag, attrs):
själv.handle_starttag (tag, attrs)
själv.handle_endtag (tag) - handle_starttag: Den här metoden hanterar starttaggen för de data den tar emot. Dess definition är som visas nedan: def handle_starttag (self, tag, attrs):
passera - handle_endtag: Den här metoden hanterar slutkoden för de data den tar emot: def handle_endtag (self, tag):
passera - handle_charref: Den här metoden hanterar karaktärshänvisningarna i den data den tar emot. Dess definition är som visas nedan: def handle_charref (själv, namn):
passera - handle_entityref: Denna funktion hanterar entitetsreferenser i HTML som skickats till den: def handle_entityref (själv, namn):
passera - hanteringsdata: Detta är den funktion där verkligt arbete görs för att extrahera värden från HTML-taggarna och skickas data relaterade till varje tagg. Dess definition är som visas nedan: def handle_data (self, data):
passera - handtag_kommentar: Med den här funktionen kan vi också få kommentarer kopplade till en HTML-källa: def handle_comment (self, data):
passera - handtag_pi: Eftersom HTML också kan ha bearbetningsinstruktioner är det funktionen där dessa har sin definition som visas nedan: def handle_pi (själv, data):
passera - handtag_decl: Denna metod hanterar deklarationerna i HTML, dess definition tillhandahålls som: def handle_decl (self, decl):
passera
Delklassificering av HTMLParser-klassen
I detta avsnitt kommer vi att underklassera HTMLParser-klassen och ta en titt på några av de funktioner som anropas när HTML-data skickas till klassinstans. Låt oss skriva ett enkelt skript som gör allt detta:
från html.parser importera HTMLParserklass LinuxHTMLParser (HTMLParser):
def handle_starttag (själv, tagg, attrs):
skriv ut ("Start tag:", tag)
def handle_endtag (själv, tagg):
skriva ut ("Slut taggen påträffad:", tag)
def handle_data (själv, data):
print ("Data hittades:", data)
parser = LinuxHTMLParser ()
parser.utfodra("
''
Python HTML-analyseringsmodul
')
Här är vad vi får tillbaka med det här kommandot:
Python HTMLParser-underklass
HTMLParser-funktioner
I det här avsnittet kommer vi att arbeta med olika funktioner i HTMLParser-klassen och titta på funktionaliteten hos var och en av dessa:
från html.parser importera HTMLParserfrån html.enheter importerar name2codepoint
klass LinuxHint_Parse (HTMLParser):
def handle_starttag (själv, tagg, attrs):
skriva ut ("Start tag:", tag)
för attr in attrs:
skriva ut ("attr:", attr)
def handle_endtag (själv, tagg):
skriv ut ("End tag:", tag)
def handle_data (själv, data):
skriva ut ("Data:", data)
def handle_comment (själv, data):
skriv ut ("Kommentar:", data)
def handle_entityref (själv, namn):
c = chr (name2codepoint [namn])
tryck ("Namngiven ent:", c)
def handle_charref (själv, namn):
om namn.startar med ('x'):
c = chr (int (namn [1:], 16))
annan:
c = chr (int (namn))
tryck ("Num ent:", c)
def handle_decl (själv, data):
skriv ut ("Decl:", data)
parser = LinuxHint_Parse ()
Med olika samtal, låt oss mata separata HTML-data till denna instans och se vilken effekt dessa samtal genererar. Vi börjar med ett enkelt DOKTYP sträng:
parser.utfodra(' ')Här är vad vi får tillbaka med det här samtalet:
DOCTYPE Sträng
Låt oss nu prova en bildtagg och se vilka data den extraherar:
parser.utfodra('')Här är vad vi får tillbaka med det här samtalet:
HTMLParser-bildtagg
Låt oss sedan prova hur skripttaggen beter sig med Python-funktioner:
parser.utfodra('')parser.utfodra('')
parser.feed ('# python color: green')
Här är vad vi får tillbaka med det här samtalet:
Skriptetikett i htmlparser
Slutligen skickar vi också kommentarer till avsnittet HTMLParser:
parser.utfodra('''''')
Här är vad vi får tillbaka med det här samtalet:
Analysera kommentarer
Slutsats
I den här lektionen tittade vi på hur vi kan analysera HTML med Pythons egen HTMLParser-klass utan något annat bibliotek. Vi kan enkelt ändra koden för att ändra källan till HTML-data till en HTTP-klient.
Läs mer Python-baserade inlägg här.