Data er bogstaveligt talt overalt, i alle slags dokumenter. Men ikke alt er nyttigt, derfor behovet for at analysere det for at få de dele, der er nødvendige. XML-dokumenter er et af sådanne dokumenter, der indeholder data. De ligner meget HTML-filer, da de har næsten samme slags struktur. Derfor skal du analysere dem for at få vigtige oplysninger, ligesom du ville gøre, når du arbejder med HTML.

Der er to hovedaspekter ved parsing af XML-filer. De er:

• Find tags
• Uddrag fra tags

Du bliver nødt til at finde det tag, der indeholder de ønskede oplysninger, og derefter udpakke disse oplysninger. Du lærer, hvordan du gør begge dele, når du arbejder med XML-filer inden slutningen af ​​denne artikel.

Installation

BeautifulSoup er et af de mest anvendte biblioteker, når det kommer til webskrabning med Python. Da XML-filer ligner HTML-filer, er det også i stand til at analysere dem. For at analysere XML-filer ved hjælp af BeautifulSoup er det dog bedst, at du bruger Pythons lxml parser.

Du kan installere begge biblioteker ved hjælp af pip installationsværktøj via kommandoen nedenfor:

pip installer bs4 lxml

For at bekræfte, at begge biblioteker er installeret, kan du aktivere den interaktive shell og prøve at importere begge. Hvis der ikke vises nogen fejl, er du klar til at gå med resten af ​​artiklen.

Her er et eksempel:

$ python
Python 3.7.4 (tags / v3.7.4: e09359112e, 8. juli 2019, 20:34:20)
[MSC v.1916 64 bit (AMD64)] på win32
Skriv "hjælp", "copyright", "credits" eller "licens" for at få flere oplysninger.
>>> import bs4
>>> import lxml
>>>

Før du går videre, skal du oprette en XML-fil ud fra nedenstående kodestykke. Det er ret simpelt og skal passe til de anvendelsestilfælde, du lærer om resten af ​​artiklen. Du skal blot kopiere, indsætte i din editor og gemme; et navn som prøve.xml skal være tilstrækkelig.

Træet

Først
Sekund

Tredje

En
To
Tvillinger


Fjerde

Nu i dit Python-script; skal du læse XML-filen som en normal fil og derefter sende den til BeautifulSoup. Resten af ​​denne artikel vil gøre brug af bs_indhold variabel, så det er vigtigt, at du tager dette trin.

# Importér BeautifulSoup
fra bs4 importerer BeautifulSoup som bs
indhold = []
# Læs XML-filen
med åben ("prøve.xml "," r ") som fil:
# Læs hver linje i filen, readlines () returnerer en liste med linjer
indhold = fil.readlines ()
# Kombiner linjerne på listen i en streng
indhold = "".deltage (indhold)
bs_content = bs (indhold, "lxml")

Kodeprøven ovenfor importeres Smuk suppe, så læser den XML-filen som en almindelig fil. Derefter overfører det indholdet til det importerede Smuk suppe bibliotek samt den valgte parser.

Du bemærker, at koden ikke importeres lxml. Det behøver ikke at være som Smuk suppe vælger lxml parser som et resultat af forbipasseringen “Lxml” ind i objektet.

Nu kan du fortsætte med resten af ​​artiklen.

Find tags

Et af de vigtigste trin i parsing af XML-filer er søgning efter tags. Der er forskellige måder at gøre dette på, når du bruger BeautifulSoup; så du skal vide, om en håndfuld af dem har de bedste værktøjer til den rette situation.

Du kan finde tags i XML-dokumenter ved at:

• Navne
• Relationer

Find tags efter navne

Der er to BeautifulSoup-metoder, du kan bruge, når du finder tags efter navne. Brugssagerne er imidlertid forskellige; lad os se på dem.

finde

Fra personlig erfaring bruger du finde metode oftere end de andre metoder til at finde tags i denne artikel. Find-tag modtager navnet på det tag, du vil hente, og returnerer et BeautifulSoup-objekt af tagget, hvis det finder et; ellers vender det tilbage Ingen.

Her er et eksempel:

>>> resultat = bs_indhold.find ("data")
>>> print (resultat)
En
>>> resultat = bs_indhold.find ("unik")
>>> print (resultat)
Tvillinger
>>> resultat = bs_indhold.find ("far")
>>> print (resultat)
Ingen
>>> resultat = bs_indhold.find ("mor")
>>> print (resultat)
Ingen

Hvis du ser på eksemplet, kan du se, at finde metoden returnerer et mærke, hvis det matcher navnet, ellers returnerer det Ingen. Men hvis du ser det nærmere, ser du, at det kun returnerer et enkelt tag.

For eksempel når find (“data”) blev kaldt, returnerede det kun det første datakode, men returnerede ikke de andre.

GOTCHA: Det finde metode returnerer kun det første tag, der matcher dets forespørgsel.

Så hvordan kommer du også til at finde andre tags? Det fører os til den næste metode.

find_all

Det find_all metoden er meget lig den finde metode. Den eneste forskel er, at den returnerer en liste med tags, der matcher dens forespørgsel. Når den ikke finder noget mærke, returnerer det simpelthen en tom liste. Derfor, find_all vil altid returnere en liste.

Her er et eksempel:

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

En
To
Tvillinger

, Fjerde]
>>> resultat = bs_indhold.find_all ("far")
>>> print (resultat
[]
>>> resultat = bs_indhold.find_all ("mor")
>>> print (resultat)
[]

Nu hvor du ved, hvordan du bruger finde og find_all metoder, kan du søge efter tags overalt i XML-dokumentet. Du kan dog gøre dine søgninger mere effektive.

Sådan gør du:

Nogle tags kan have samme navn, men forskellige attributter. F.eks barn tags har en navn attribut og forskellige værdier. Du kan foretage specifikke søgninger baseret på disse.

Se på dette:

>>> resultat = bs_indhold.find ("child", "name": "Rose")
>>> print (resultat)
Sekund
>>> resultat = bs_indhold.find_all ("child", "name": "Rose")
>>> print (resultat)
[Sekund]
>>> resultat = bs_indhold.find ("child", "name": "Jack")
>>> print (resultat)
Først
>>> resultat = bs_indhold.find_all ("child", "name": "Jack")
>>> print (resultat)
[Først]

Du vil se, at der er noget andet ved brugen af finde og find_all metoder her: de har begge en anden parameter.

Når du sender en ordbog som en anden parameter, vises finde og find_all metoder fremmer deres søgning for at få tags, der har attributter og værdier, der passer til den angivne nøgle: værdipar.

For eksempel på trods af brug af finde metode i det første eksempel, returnerede den anden barn tag (i stedet for det første barn tag), fordi det er det første tag, der matcher forespørgslen. Det find_all tag følger det samme princip, bortset fra at det returnerer alle de tags, der matcher forespørgslen, ikke kun den første.

Find tags efter forhold

Selvom det er mindre populært end at søge efter tagnavne, kan du også søge på tags efter forhold. I reel forstand er det dog mere at navigere end at søge.

Der er tre nøgleforhold i XML-dokumenter:

• Forælder: Mærket, hvor referencemærket findes.
• Børn: De tags, der findes i referencetagget.
• Søskende: De tags, der findes på samme niveau som referencetagget.

Fra forklaringen ovenfor kan du udlede, at referencetagget er den vigtigste faktor i søgning efter tags efter relationer. Lad os derfor kigge efter referencemærket og fortsætte artiklen.

Se på dette:

>>> tredje_barn = bs_indhold.find ("child", "name": "Blue Ivy")
>>> udskriv (tredje barn)

Tredje

En
To
Tvillinger

Fra ovenstående kodeeksempel er referencemærket for resten af ​​dette afsnit det tredje barn tag, gemt i en tredje_barn variabel. I underafsnittene nedenfor kan du se, hvordan du søger efter tags baseret på deres forældres, søskendes og børns forhold til referencetagget.

Find forældre

For at finde det overordnede mærke til et referencetag skal du bruge forælder attribut. Hvis du gør dette, returneres det overordnede tag såvel som tags under det. Denne adfærd er ret forståelig, da børnetags er en del af det overordnede mærke.

Her er et eksempel:

>>> resultat = tredjebarn.forælder
>>> print (resultat)

Først
Sekund

Tredje

En
To
Tvillinger


Fjerde

Finde børn

For at finde børnetaggene til et referencetag skal du bruge børn attribut. Hvis du gør dette, returneres underordnede tags samt under-tags under hver af dem. Denne adfærd er også forståelig, da børnemærker ofte også har deres egne børnemærker.

En ting du skal bemærke er, at børn attribut returnerer underordnede tags som en generator. Så hvis du har brug for en liste over børnetags, skal du konvertere generatoren til en liste.

Her er et eksempel:

>>> resultat = liste (tredjebarn.børn)
>>> print (resultat)
['\ n Tredje \ n',
En
To
Tvillinger
, '\ n']

Hvis du ser nærmere på eksemplet ovenfor, vil du bemærke, at nogle værdier på listen ikke er tags. Det er noget, du skal passe på.

GOTCHA: Det børn attribut returnerer ikke kun underordnede tags, men returnerer også teksten i referencetagget.

Find søskende

Det sidste i dette afsnit er at finde tags, der er søskende til referencetagget. For hvert referencemærke kan der være søskendemærker før og efter det. Det previous_siblings attribut returnerer søskendekoder før referencekoden, og næste søskende attribut returnerer søskendekoder efter det.

Ligesom børn attribut, den previous_siblings og næste_søskende attributter returnerer generatorer. Så du skal konvertere til en liste, hvis du har brug for en liste over søskende.

Se på dette:

>>> forrige søskende = liste (tredjebarn.forrige søskende)
>>> Udskriv (tidligere søskende)
['\ n', Sekund, '\ n',
Først, '\ n']
>>> næste søskende = liste (tredjebarn.næste søskende)
>>> udskriv (næste søskende)
['\ n', Fjerde]
>>> udskriv (forrige søskende + næste søskende)
['\ n', Sekund, '\ n', Først,
'\ n', '\ n', Fjerde, '\ n']

Det første eksempel viser de tidligere søskende, det andet viser de næste søskende; derefter kombineres begge resultater for at generere en liste over alle søskende til referencemærket.

Uddrag fra tags

Når man analyserer XML-dokumenter, ligger meget af arbejdet i at finde de rigtige tags. Når du finder dem, vil du muligvis også udtrække visse oplysninger fra disse tags, og det er hvad dette afsnit vil lære dig.

Du kan se, hvordan du udtrækker følgende:

• Tag attributværdier
• Tagtekst
• Tagindhold

Udpakning af tagattributværdier

Nogle gange har du muligvis en grund til at udtrække værdierne for attributter i et tag. I følgende parring af attribut-værdi for eksempel: navn = ”Rose”, du vil måske udtrække “Rose.”

For at gøre dette kan du gøre brug af få metode eller adgang til attributens navn ved hjælp af [] som et indeks, ligesom du ville gøre, når du arbejder med en ordbog.

Her er et eksempel:

>>> resultat = tredjebarn.få ("navn")
>>> print (resultat)
Blå vedbend
>>> resultat = tredjebarn ["navn"]
>>> print (resultat)
Blå vedbend

Uddragning af tagtekst

Når du vil have adgang til tekstværdierne for et tag, kan du bruge tekst eller strenge attribut. Begge returnerer teksten i et tag, og endda børnetaggene. Men den tekst attribut returnerer dem som en enkelt streng, sammenkædet; mens strenge attribut returnerer dem som en generator, som du kan konvertere til en liste.

Her er et eksempel:

>>> resultat = tredjebarn.tekst
>>> print (resultat)
'\ n Tredje \ n \ nEn \ nTo \ nTvins \ n \ n'
>>> resultat = liste (tredjebarn.strenge)
>>> print (resultat)
['\ n Tredje \ n', '\ n', 'Én', '\ n', 'To', '\ n', 'Tvillinger', '\ n', '\ n']

Uddragning af tagindhold

Bortset fra at udtrække attributværdierne og tagteksten kan du også udpakke alt tagsindhold. For at gøre dette kan du bruge indhold attribut det ligner lidt på børn attribut og vil give de samme resultater. Imidlertid mens børn attribut returnerer en generator, den indhold attribut returnerer en liste.

Her er et eksempel:

>>> resultat = tredjebarn.indhold
>>> print (resultat)
['\ n Tredje \ n',
En
To
Tvillinger
, '\ n']

Udskrivning smuk

Indtil videre har du set nogle vigtige metoder og attributter, der er nyttige, når du analyserer XML-dokumenter ved hjælp af BeautifulSoup. Men hvis du bemærker, at når du udskriver tags på skærmen, har de et eller andet klynget look. Selvom udseende måske ikke har direkte indflydelse på din produktivitet, kan det hjælpe dig med at analysere mere effektivt og gøre arbejdet mindre kedeligt.

Her er et eksempel på udskrivning på normal måde:

>>> udskriv (tredje barn)

Tredje

En
To
Tvillinger

Du kan dog forbedre dets udseende ved at bruge prettify metode. Ring bare til prettify metode på tagget under udskrivning, og du får noget visuelt tiltalende.

Se på dette:

Konklusion

Parsing af dokumenter er et vigtigt aspekt ved sourcing af data. XML-dokumenter er ret populære, og forhåbentlig er du bedre rustet til at tage dem på og udtrække de ønskede data.

Fra denne artikel er du nu i stand til at:

• søg efter tags enten efter navne eller forhold
• udtræk data fra tags

Hvis du føler dig ret tabt og er ret ny i BeautifulSoup-biblioteket, kan du tjekke BeautifulSoup-vejledningen til begyndere.