Analyse av HTML er en av de vanligste oppgavene som gjøres i dag for å samle inn informasjon fra nettstedene og utvinne den til forskjellige formål, som å etablere prisytelse for et produkt over tid, anmeldelser av en bok på et nettsted og mye mer. Det finnes mange biblioteker som BeautifulSoup in Python som trekker bort så mange smertefulle punkter i analysering av HTML, men det er verdt å vite hvordan disse bibliotekene faktisk fungerer under det laget av abstraksjon.

I denne leksjonen er det det vi har tenkt å gjøre. Vi vil finne ut hvordan verdier for forskjellige HTML-koder kan trekkes ut og også overstyre standardfunksjonaliteten til denne modulen for å legge til litt egen logikk. Vi vil gjøre dette ved hjelp av HTMLParser klasse i Python i html.parser modul. La oss se koden i aksjon.

Ser på HTMLParser-klassen

For å analysere HTML-tekst i Python, kan vi bruke HTMLParser klasse i html.parser modul. La oss se på klassedefinisjonen for HTMLParser klasse:

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

De convert_charrefs felt, hvis satt til True vil alle tegnreferansene konverteres til deres Unicode-ekvivalenter. Bare den skript / stil elementene blir ikke konvertert. Nå vil vi prøve å forstå hver funksjon for denne klassen for å bedre forstå hva hver funksjon gjør.

• handle_startendtag Dette er den første funksjonen som utløses når HTML-streng overføres til klasseinstansen. Når teksten når hit, blir kontrollen overført til andre funksjoner i klassen som begrenses til andre koder i strengen. Dette er også tydelig i definisjonen for denne funksjonen: def handle_startendtag (self, tag, attrs):
  selv-.handle_starttag (tag, attrs)
  selv-.handle_endtag (tag)
• handle_starttag: Denne metoden administrerer start-koden for dataene den mottar. Definisjonen er som vist nedenfor: def handle_starttag (self, tag, attrs):
  sende
• handle_endtag: Denne metoden administrerer sluttkoden for dataene den mottar: def handle_endtag (selv, tag):
  sende
• handle_charref: Denne metoden administrerer tegnreferansene i dataene den mottar. Definisjonen er som vist nedenfor: def handle_charref (selv, navn):
  sende
• handle_entityref: Denne funksjonen håndterer enhetsreferansene i HTML-en som sendes til den: def handle_entityref (selv, navn):
  sende
• handle_data: Dette er funksjonen der det reelle arbeidet gjøres for å trekke ut verdier fra HTML-kodene og sendes dataene relatert til hver kode. Definisjonen er som vist nedenfor: def handle_data (self, data):
  sende
• håndtak_kommentar: Ved hjelp av denne funksjonen kan vi også få kommentarer knyttet til en HTML-kilde: def handle_comment (selv, data):
  sende
• handle_pi: Siden HTML også kan ha behandlingsinstruksjoner, er dette funksjonen der definisjonen er som vist nedenfor: def handle_pi (selv, data):
  sende
• håndtak_dekl: Denne metoden håndterer erklæringene i HTML, dens definisjon er gitt som: def handle_decl (self, decl):
  sende

Underklassering av HTMLParser-klassen

I denne delen vil vi underklasse HTMLParser-klassen og se på noen av funksjonene som blir kalt når HTML-data overføres til klasseinstans. La oss skrive et enkelt skript som gjør alt dette:

fra html.parser importerer HTMLParser
klasse LinuxHTMLParser (HTMLParser):
def handle_starttag (selv, tag, attrs):
skriv ut ("Start-tag oppdaget:", tag)
def handle_endtag (selv, tag):
skriv ut ("End tag stuit:", tag)
def handle_data (selv, data):
print ("Data funnet:", data)
parser = LinuxHTMLParser ()
parser.mate("
'

Python HTML-parsingsmodul

')

Her er hva vi kommer tilbake med denne kommandoen:

Python HTMLParser-underklasse

HTMLParser-funksjoner

I denne delen vil vi arbeide med forskjellige funksjoner i HTMLParser-klassen og se på funksjonaliteten til hver av dem:

fra html.parser importerer HTMLParser
fra html.enheter importerer name2codepoint
klasse LinuxHint_Parse (HTMLParser):
def handle_starttag (selv, tag, attrs):
skriv ut ("Start tag:", tag)
for attr i attrs:
skriv ut ("attr:", attr)
def handle_endtag (selv, tag):
print ("End tag:", tag)
def handle_data (selv, data):
skriv ut ("Data:", data)
def handle_comment (selv, data):
print ("Kommentar:", data)
def handle_entityref (selv, navn):
c = chr (name2codepoint [name])
utskrift ("Navngitt ent:", c)
def handle_charref (selv, navn):
hvis navn.starter med ('x'):
c = chr (int (navn [1:], 16))
ellers:
c = chr (int (navn))
trykk ("Num ent:", c)
def handle_decl (selv, data):
print ("Decl:", data)
parser = LinuxHint_Parse ()

Med forskjellige samtaler, la oss mate separate HTML-data til denne forekomsten og se hvilket output disse samtalene genererer. Vi starter med en enkel DOKTYPE streng:

parser.mate(''"http: // www.w3.org / TR / html4 / streng.dtd "> ')

Dette er hva vi får tilbake med denne samtalen:

DOCTYPE streng

La oss nå prøve en bildekode og se hvilke data den trekker ut:

parser.mate('')

Dette er hva vi får tilbake med denne samtalen:

HTMLParser-bildekode

Deretter, la oss prøve hvordan skripttaggen oppfører seg med Python-funksjoner:

parser.mate('')
parser.mate('')
parser.feed ('# python color: green')

Dette er hva vi får tilbake med denne samtalen:

Skriptekode i htmlparser

Til slutt sender vi også kommentarer til HTMLParser-delen:

parser.mate(''
'')

Dette er hva vi får tilbake med denne samtalen:

Analyserer kommentarer

Konklusjon

I denne leksjonen så vi på hvordan vi kan analysere HTML ved hjelp av Pythons egen HTMLParser-klasse uten noe annet bibliotek. Vi kan enkelt endre koden for å endre kilden til HTML-dataene til en HTTP-klient.

Les flere Python-baserte innlegg her.