Data er bokstavelig talt overalt, i alle slags dokumenter. Men ikke alt er nyttig, derav behovet for å analysere det for å få delene som er nødvendige. XML-dokumenter er et av slike dokumenter som inneholder data. De ligner veldig på HTML-filer, siden de har nesten samme type struktur. Derfor må du analysere dem for å få viktig informasjon, akkurat som du ville gjort når du jobber med HTML.

Det er to hovedaspekter ved analyse av XML-filer. De er:

• Finne tagger
• Utdrag fra tagger

Du må finne taggen som inneholder informasjonen du ønsker, og deretter trekke ut den informasjonen. Du lærer hvordan du gjør begge deler når du arbeider med XML-filer før slutten av denne artikkelen.

Installasjon

BeautifulSoup er et av de mest brukte bibliotekene når det gjelder nettskraping med Python. Siden XML-filer ligner på HTML-filer, er det også i stand til å analysere dem. For å analysere XML-filer ved hjelp av BeautifulSoup, er det best at du bruker Pythons lxml parser.

Du kan installere begge biblioteker ved hjelp av pip installasjonsverktøy, gjennom kommandoen nedenfor:

pip installer bs4 lxml

For å bekrefte at begge bibliotekene er installert, kan du aktivere det interaktive skallet og prøve å importere begge. Hvis det ikke dukker opp noen feil, er du klar til å gå med resten av artikkelen.

Her er et eksempel:

$ python
Python 3.7.4 (koder / v3.7.4: e09359112e, 8. juli 2019, 20:34:20)
[MSC v.1916 64 bit (AMD64)] på win32
Skriv inn "help", "copyright", "credits" eller "lisens" for mer informasjon.
>>> importer bs4
>>> importer lxml
>>>

Før du går videre, bør du opprette en XML-fil fra kodebiten nedenfor. Det er ganske enkelt, og bør passe til brukstilfellene du vil lære om i resten av artikkelen. Bare kopier, lim inn redigereren og lagre; et navn som prøve.xml skal være tilstrekkelig.

Treet

Først
Sekund

Tredje

En
To
tvillinger


Fjerde

Nå, i Python-skriptet ditt; du må lese XML-filen som en vanlig fil, og deretter sende den til BeautifulSoup. Resten av denne artikkelen vil bruke bs_innhold variabel, så det er viktig at du tar dette trinnet.

# Importer BeautifulSoup
fra bs4 importerer BeautifulSoup som bs
innhold = []
# Les XML-filen
med åpen ("prøve.xml "," r ") som fil:
# Les hver linje i filen, readlines () returnerer en liste med linjer
innhold = fil.readlines ()
# Kombiner linjene i listen til en streng
content = "".bli med (innhold)
bs_content = bs (innhold, "lxml")

Kodeprøven over importen Vakker suppe, så leser den XML-filen som en vanlig fil. Etter det overfører den innholdet til det importerte Vakker suppe bibliotek, samt valgfri parser.

Du vil merke at koden ikke importeres lxml. Det trenger ikke å som Vakker suppe vil velge lxml parser som et resultat av passering “Lxml” inn i objektet.

Nå kan du fortsette med resten av artikkelen.

Finne tagger

En av de viktigste trinnene i å analysere XML-filer er å søke etter tagger. Det er forskjellige måter å gjøre dette når du bruker BeautifulSoup; så du trenger å vite om en håndfull av dem for å ha de beste verktøyene for den aktuelle situasjonen.

Du kan finne koder i XML-dokumenter ved å:

• Navn
• Forhold

Finne tagger etter navn

Det er to BeautifulSoup-metoder du kan bruke når du finner tagger etter navn. Imidlertid er brukstilfellene forskjellige; la oss ta en titt på dem.

finne

Fra personlig erfaring vil du bruke finne metoden oftere enn de andre metodene for å finne koder i denne artikkelen. Finne-koden mottar navnet på koden du vil få, og returnerer et BeautifulSoup-objekt av koden hvis den finner en; annet kommer det tilbake Ingen.

Her er et eksempel:

>>> resultat = bs_innhold.finn ("data")
>>> utskrift (resultat)
En
>>> resultat = bs_innhold.finn ("unik")
>>> utskrift (resultat)
tvillinger
>>> resultat = bs_innhold.finn ("far")
>>> utskrift (resultat)
Ingen
>>> resultat = bs_innhold.finn ("mor")
>>> utskrift (resultat)
Ingen

Hvis du tar en titt på eksemplet, vil du se at finne metoden returnerer en kode hvis den samsvarer med navnet, ellers returnerer den Ingen. Men hvis du ser nærmere på det, ser du at det bare returnerer en enkelt tag.

For eksempel når finn (“data”) ble kalt, returnerte den bare den første datakoden, men returnerte ikke de andre.

TOK DEG: De finne metoden returnerer bare den første koden som samsvarer med spørringen.

Så hvordan kommer du til å finne andre koder også? Det fører oss til neste metode.

find_all

De find_all metoden er ganske lik finne metode. Den eneste forskjellen er at den returnerer en liste med koder som samsvarer med spørringen. Når den ikke finner noen merke, returnerer den ganske enkelt en tom liste. Derfor, find_all vil alltid returnere en liste.

Her er et eksempel:

>>> resultat = bs_innhold.find_all ("data")
>>> utskrift (resultat)
[En, To]
>>> resultat = bs_innhold.find_all ("barn")
>>> utskrift (resultat)
[Først, Sekund,
Tredje

En
To
tvillinger

, Fjerde]
>>> resultat = bs_innhold.find_all ("far")
>>> utskrift (resultat
[]
>>> resultat = bs_innhold.find_all ("mor")
>>> utskrift (resultat)
[]

Nå som du vet hvordan du bruker finne og find_all metoder, kan du søke etter koder hvor som helst i XML-dokumentet. Du kan imidlertid gjøre søkene dine kraftigere.

Dette er hvordan:

Noen tagger kan ha samme navn, men forskjellige attributter. For eksempel barn tagger har en Navn attributt og forskjellige verdier. Du kan foreta spesifikke søk basert på disse.

Ta en titt på dette:

>>> resultat = bs_innhold.finn ("child", "name": "Rose")
>>> utskrift (resultat)
Sekund
>>> resultat = bs_innhold.find_all ("child", "name": "Rose")
>>> utskrift (resultat)
[Sekund]
>>> resultat = bs_innhold.finn ("child", "name": "Jack")
>>> utskrift (resultat)
Først
>>> resultat = bs_innhold.find_all ("child", "name": "Jack")
>>> utskrift (resultat)
[Først]

Du vil se at det er noe annet med bruken av finne og find_all metoder her: de har begge en andre parameter.

Når du sender inn en ordbok som en andre parameter, vises finne og find_all metoder videre i søket for å få tagger som har attributter og verdier som passer til den oppgitte nøkkelen: verdipar.

For eksempel, til tross for at du bruker finne metode i det første eksemplet, returnerte den andre barn tag (i stedet for den første barn tag), fordi det er den første taggen som samsvarer med spørringen. De find_all tag følger samme prinsipp, bortsett fra at den returnerer alle kodene som samsvarer med spørringen, ikke bare den første.

Finne tagger etter forhold

Selv om det er mindre populært enn å søke etter taggenavn, kan du også søke etter tagger etter forhold. I den virkelige forstand er det imidlertid mer å navigere enn å søke.

Det er tre viktige forhold i XML-dokumenter:

• Foreldre: Taggen som referanselappen finnes i.
• Barn: Taggene som finnes i referansetaggen.
• Søsken: Taggene som finnes på samme nivå som referansetaggen.

Fra forklaringen ovenfor kan du slutte at referansetaggen er den viktigste faktoren i å søke etter tagger etter forhold. La oss derfor lete etter referansetaggen og fortsette artikkelen.

Se på dette:

>>> tredje_barn = bs_innhold.finn ("child", "name": "Blue Ivy")
>>> utskrift (tredje barn)

Tredje

En
To
tvillinger

Fra kodeeksemplet ovenfor vil referansetaggen for resten av denne delen være den tredje barn tag, lagret i en tredje_barn variabel. I underavsnittene nedenfor ser du hvordan du søker etter tagger basert på foreldres, søsken og barns forhold til referansetaggen.

Finne foreldre

For å finne den overordnede taggen til en referansetag, bruker du foreldre Egenskap. Å gjøre dette returnerer foreldrekoden, så vel som kodene under den. Denne oppførselen er ganske forståelig, siden barnekoder er en del av foreldrekoden.

Her er et eksempel:

>>> resultat = tredje barn.foreldre
>>> utskrift (resultat)

Først
Sekund

Tredje

En
To
tvillinger


Fjerde

Finne barn

For å finne barnekodene til en referanselapp, bruker du barn Egenskap. Ved å gjøre dette returneres barnekodene, så vel som underkodene under hver av dem. Denne oppførselen er også forståelig, ettersom barnekoder ofte også har sine egne barnemerker.

En ting du bør merke deg er at barn attributt returnerer barnekoder som en generator. Så hvis du trenger en liste over barnekoder, må du konvertere generatoren til en liste.

Her er et eksempel:

>>> resultat = liste (tredje_barn.barn)
>>> utskrift (resultat)
['\ n Tredje \ n',
En
To
tvillinger
, '\ n']

Hvis du ser nærmere på eksemplet ovenfor, vil du legge merke til at noen verdier i listen ikke er koder. Det er noe du må passe på.

TOK DEG: De barn attributt returnerer ikke bare barnekoder, den returnerer også teksten i referansekoden.

Finne søsken

Det siste i denne delen er å finne koder som er søsken til referansekoden. For hver referansemerke kan det være søskenmerker før og etter den. De forrige_søsken attributt vil returnere søskenbrikkene før referansetaggen, og neste søsken attributt vil returnere søskenmerker etter det.

Akkurat som barn attributt, den forrige_søsken og neste_søsken attributter vil returnere generatorer. Så du må konvertere til en liste hvis du trenger en søskenliste.

Se på dette:

>>> forrige_søsken = liste (tredje barn.forrige_søsken)
>>> utskrift (forrige søsken)
['\ n', Sekund, '\ n',
Først, '\ n']
>>> neste søsken = liste (tredje barn.neste søsken)
>>> skriv ut (neste søsken)
['\ n', Fjerde]
>>> utskrift (forrige søsken + neste søsken)
['\ n', Sekund, '\ n', Først,
'\ n', '\ n', Fjerde, '\ n']

Det første eksemplet viser de forrige søsknene, det andre viser de neste søsknene; deretter blir begge resultatene kombinert for å generere en liste over alle søsknene for referansemerket.

Henter ut fra tagger

Når du analyserer XML-dokumenter, ligger mye av arbeidet i å finne de riktige kodene. Men når du finner dem, vil du kanskje også hente ut viss informasjon fra disse kodene, og det er det denne delen vil lære deg.

Du får se hvordan du trekker ut følgende:

• Merk attributtverdier
• Merketekst
• Merk innhold

Utpakking av tagattributtverdier

Noen ganger kan det hende du har en grunn til å trekke ut verdiene for attributter i en kode. I følgende parring av attributt-verdi for eksempel: navn = ”Rose”, vil du kanskje trekke ut “Rose.”

For å gjøre dette kan du benytte deg av få metode, eller få tilgang til attributtens navn ved hjelp av [] som en indeks, akkurat som når du jobber med en ordbok.

Her er et eksempel:

>>> resultat = tredje barn.få ("navn")
>>> utskrift (resultat)
Blue Ivy
>>> resultat = tredje barn ["navn"]
>>> utskrift (resultat)
Blue Ivy

Pakk ut taggtekst

Når du vil ha tilgang til tekstverdiene til en kode, kan du bruke tekst eller strenger Egenskap. Begge vil returnere teksten i en tagg, og til og med barnemerkene. Imidlertid, den tekst attributt vil returnere dem som en enkelt streng, sammenkoblet; mens strenger attributt vil returnere dem som en generator som du kan konvertere til en liste.

Her er et eksempel:

>>> resultat = tredje barn.tekst
>>> utskrift (resultat)
'\ n Tredje \ n \ nEn \ nTo \ nTvillinger \ n \ n'
>>> resultat = liste (tredje_barn.strenger)
>>> utskrift (resultat)
['\ n Tredje \ n', '\ n', 'En', '\ n', 'To', '\ n', 'Tvillinger', '\ n', '\ n']

Pakke ut tagginnhold

Bortsett fra å trekke ut attributtverdiene og merketeksten, kan du også trekke ut alt av kodens innhold. For å gjøre dette kan du bruke innholdet Egenskap; det ligner litt på barn attributt og vil gi de samme resultatene. Imidlertid mens barn attributt returnerer en generator, innholdet attributt returnerer en liste.

Her er et eksempel:

>>> resultat = tredje barn.innholdet
>>> utskrift (resultat)
['\ n Tredje \ n',
En
To
tvillinger
, '\ n']

Utskrift vakker

Så langt har du sett noen viktige metoder og attributter som er nyttige når du analyserer XML-dokumenter ved hjelp av BeautifulSoup. Men hvis du merker at når du skriver ut kodene på skjermen, har de et slags klynget utseende. Selv om utseendet kanskje ikke har direkte innvirkning på produktiviteten din, kan det hjelpe deg med å analysere mer effektivt og gjøre arbeidet mindre kjedelig.

Her er et eksempel på utskrift på vanlig måte:

>>> utskrift (tredje barn)

Tredje

En
To
tvillinger

Du kan imidlertid forbedre utseendet ved å bruke prettify metode. Bare ring prettify metode på merkelappen mens du skriver ut, og du får noe visuelt tiltalende.

Se på dette:

Konklusjon

Parsing av dokumenter er et viktig aspekt ved sourcing av data. XML-dokumenter er ganske populære, og forhåpentligvis er du bedre rustet til å ta dem på, og trekke ut dataene du ønsker.

Fra denne artikkelen er du nå i stand til å:

• søk etter koder enten etter navn eller forhold
• trekke ut data fra koder

Hvis du føler deg ganske fortapt, og er ganske ny i BeautifulSoup-biblioteket, kan du sjekke ut BeautifulSoup-opplæringen for nybegynnere.