L'analisi HTML è uno dei compiti più comuni svolti oggi per raccogliere informazioni dai siti Web e estrarle per vari scopi, come stabilire le prestazioni dei prezzi di un prodotto nel tempo, le recensioni di un libro su un sito Web e molto altro. Esistono molte biblioteche come Beautifulsoup in Python che estraggono così tanti punti dolorosi nell'analoga HTML, ma vale la pena sapere come quelle biblioteche funzionano effettivamente sotto quel livello di astrazione.

In questa lezione, questo è quello che intendiamo fare. Scopriremo come possono essere estratti i valori di diversi tag HTML e anche sovrascrivere la funzionalità predefinita di questo modulo per aggiungere un po 'di logica. Lo faremo usando il Htmlparser Classe in Python in html.parser modulo. Vediamo il codice in azione.

Guardando la classe htmlparser

Per analizzare il testo HTML in Python, possiamo usare Htmlparser classe in html.parser modulo. Diamo un'occhiata alla Dfinizione di classe per il Htmlparser classe:

Classe HTML.parser.Htmlparser (*, convert_charrefs = true)

IL convert_charrefs campo, se impostato su true farà convertire tutti i riferimenti di personaggi ai loro equivalenti Unicode. Solo il Script/stile Gli elementi non sono convertiti. Ora cercheremo di capire ogni funzione per questa classe e per capire meglio cosa fa ogni funzione.

• Handle_stantendtag Questa è la prima funzione che viene attivata quando la stringa HTML viene passata all'istanza della classe. Una volta che il testo raggiunge qui, il controllo viene passato ad altre funzioni della classe che si restringe ad altri tag nella stringa. Questo è anche chiaro nella definizione per questa funzione:

  Def Handle_stantendtag (self, tag, atrs):
  se stesso.Handle_starttag (tag, atrs)
  se stesso.Handle_endtag (tag)

• Handle_starttag: Questo metodo gestisce il tag di avvio per i dati che riceve. La sua definizione è come mostrato di seguito:

  def handle_starttag (self, tag, atrs):
  passaggio

• Handle_endtag: Questo metodo gestisce il tag finale per i dati che riceve:

  def handle_endtag (self, tag):
  passaggio

• Handle_Charref: Questo metodo gestisce i riferimenti dei caratteri nei dati che riceve. La sua definizione è come mostrato di seguito:

  def handle_charref (self, name):
  passaggio

• Handle_entyref: Questa funzione gestisce i riferimenti di entità nell'HTML passato ad esso:

  def manding_entyref (self, name):
  passaggio

• Handle_data: Questa è la funzione in cui viene svolto il lavoro reale per estrarre valori dai tag HTML e viene passata i dati relativi a ciascun tag. La sua definizione è come mostrato di seguito:

  def handle_data (self, dati):
  passaggio

• Handle_comment: Utilizzando questa funzione, possiamo anche ottenere commenti allegati a una fonte HTML:

  def handle_comment (self, dati):
  passaggio

• Handle_pi: Poiché HTML può anche avere istruzioni di elaborazione, questa è la funzione in cui questa è la sua definizione come mostrato di seguito:

  def handle_pi (self, dati):
  passaggio

• Handle_decl: Questo metodo gestisce le dichiarazioni nell'HTML, la sua definizione è fornita come:

  def handle_decl (self, decl):
  passaggio

Sottoclassando la classe HTMLPARSER

In questa sezione, sottoposeremo la classe HTMLPARSER e daremo un'occhiata ad alcune delle funzioni chiamate quando i dati HTML vengono passati all'istanza della classe. Scriviamo una semplice sceneggiatura che fa tutto questo:

da html.Parser Import htmlparser
Classe LinuxhtmlParser (htmlparser):
def handle_starttag (self, tag, atrs):
Stampa ("Avvia il tag incontrato:", tag)
def handle_endtag (self, tag):
Print ("End Tag incontrato:", tag)
def handle_data (self, dati):
Stampa ("Dati trovati:", dati)
parser = linuxhtmlparser ()
parser.foraggio("
'

Modulo di analisi Python HTML

')

Ecco cosa torniamo con questo comando:

Python HtmlParser Sottoclasse

Funzioni htmlparser

In questa sezione, lavoreremo con varie funzioni della classe HTMLPARSER e esamineremo la funzionalità di ciascuno di questi:

da html.Parser Import htmlparser
da html.Entità Importazione Nome2CodePoint
Classe LinuxHint_Parse (htmlparser):
def handle_starttag (self, tag, atrs):
Stampa ("Avvia tag:", tag)
per attr in atrs:
stampa ("attr:", attr)
def handle_endtag (self, tag):
print ("end tag:", tag)
def handle_data (self, dati):
print ("Data:", dati)
def handle_comment (self, dati):
Print ("Commento:", dati)
def manding_entyref (self, name):
C = Chr (name2CodePoint [nome])
Stampa ("Nominato Ent:", C)
def handle_charref (self, name):
Se il nome.startWith ('x'):
c = chr (int (nome [1:], 16))
altro:
c = chr (int (nome))
Stampa ("Numt:", C)
def handle_decl (self, dati):
Print ("Decl:", Data)
parser = linuxhint_parse ()

Con varie chiamate, diamo alimentare i dati HTML separati a questa istanza e vedere quale output generano queste chiamate. Inizieremo con un semplice Doctype corda:

parser.foraggio(''"http: // www.W3.org/tr/html4/rigoroso.dtd "> ')

Ecco cosa torniamo con questa chiamata:

String Doctype

Proviamo ora un tag immagine e vediamo quali dati estrae:

parser.foraggio('')

Ecco cosa torniamo con questa chiamata:

Tag immagine htmlparser

Successivamente, proviamo come il tag script si comporta con le funzioni di Python:

parser.foraggio(''
'mettere in guardia("Linuxhint Python"); ')
parser.feed ('#Python Color: Green')
parser.feed ('#Python Color: Green')

Ecco cosa torniamo con questa chiamata:

Tag di script in htmlparser

Infine, passiamo i commenti anche alla sezione HTMLPARSER:

parser.foraggio(''
"Contenuto specifico per IE")

Ecco cosa torniamo con questa chiamata:

Analisi dei commenti

Conclusione

In questa lezione, abbiamo esaminato come possiamo analizzare HTML usando la classe HTMLPARSER Python senza alcuna altra libreria. Possiamo facilmente modificare il codice per modificare l'origine dei dati HTML in un client HTTP.

Leggi di più post basati su Python qui.