Data finns bokstavligen överallt, i alla typer av dokument. Men inte allt är användbart, därav behovet av att analysera det för att få de delar som behövs. XML-dokument är ett av sådana dokument som innehåller data. De liknar mycket HTML-filer, eftersom de har nästan samma typ av struktur. Därför måste du analysera dem för att få viktig information, precis som när du arbetar med HTML.

Det finns två huvudaspekter på att analysera XML-filer. Dom är:

• Hitta taggar
• Extraherar från taggar

Du måste hitta taggen som innehåller den information du vill ha och sedan extrahera den informationen. Du lär dig hur du gör båda när du arbetar med XML-filer innan slutet av denna artikel.

Installation

BeautifulSoup är ett av de mest använda biblioteken när det gäller webbskrapning med Python. Eftersom XML-filer liknar HTML-filer kan den också analysera dem. För att analysera XML-filer med hjälp av BeautifulSoup är det dock bäst att du använder Pythons lxml parser.

Du kan installera båda biblioteken med hjälp av pip installationsverktyg, genom kommandot nedan:

pip installera bs4 lxml

För att bekräfta att båda biblioteken har installerats kan du aktivera det interaktiva skalet och försöka importera båda. Om inget fel dyker upp är du redo att gå med resten av artikeln.

Här är ett exempel:

$ python
Python 3.7.4 (taggar / v3.7.4: e09359112e, 8 jul 2019, 20:34:20)
[MSC v.1916 64 bitar (AMD64)] på win32
Skriv "hjälp", "copyright", "credits" eller "licens" för mer information.
>>> importera bs4
>>> importera lxml
>>>

Innan du går vidare bör du skapa en XML-fil från kodavsnittet nedan. Det är ganska enkelt och borde passa de användningsfall som du lär dig om i resten av artikeln. Kopiera, klistra in i din redigerare och spara; ett namn som prov.xml borde räcka.

Trädet

Först
Andra

Tredje

Ett
Två
tvillingar


Fjärde

Nu, i ditt Python-skript; du måste läsa XML-filen som en vanlig fil och sedan skicka den till BeautifulSoup. Resten av denna artikel kommer att använda bs_content variabel, så det är viktigt att du tar det här steget.

# Importera BeautifulSoup
från bs4 importera BeautifulSoup som bs
innehåll = []
# Läs XML-filen
med öppen ("prov.xml "," r ") som fil:
# Läs varje rad i filen, readlines () returnerar en lista med rader
innehåll = fil.readlines ()
# Kombinera raderna i listan till en sträng
innehåll = "".gå med (innehåll)
bs_content = bs (innehåll, "lxml")

Kodprovet ovanför importen Vacker soppa, sedan läser den XML-filen som en vanlig fil. Därefter överför det innehållet till det importerade Vacker soppa biblioteket liksom valfri analysator.

Du märker att koden inte importeras lxml. Det behöver inte som Vacker soppa kommer att välja lxml parser som ett resultat av passering “Lxml” in i objektet.

Nu kan du fortsätta med resten av artikeln.

Hitta taggar

Ett av de viktigaste stegen för att analysera XML-filer är att söka efter taggar. Det finns olika sätt att göra detta när du använder BeautifulSoup; så du måste veta om en handfull av dem för att ha de bästa verktygen för rätt situation.

Du kan hitta taggar i XML-dokument genom att:

• Namn
• Relationer

Hitta taggar efter namn

Det finns två BeautifulSoup-metoder som du kan använda när du hittar taggar efter namn. Användningsfallet skiljer sig dock åt; låt oss ta en titt på dem.

hitta

Från personlig erfarenhet använder du hitta metod oftare än de andra metoderna för att hitta taggar i den här artikeln. Söktaggen tar emot namnet på taggen du vill få och returnerar ett BeautifulSoup-objekt av taggen om den hittar en; annars återkommer den Ingen.

Här är ett exempel:

>>> resultat = bs_innehåll.hitta ("data")
>>> skriva ut (resultat)
Ett
>>> resultat = bs_innehåll.hitta ("unik")
>>> skriva ut (resultat)
tvillingar
>>> resultat = bs_innehåll.hitta ("far")
>>> skriva ut (resultat)
Ingen
>>> resultat = bs_innehåll.hitta ("mor")
>>> skriva ut (resultat)
Ingen

Om du tittar på exemplet ser du att hitta metoden returnerar en tagg om den matchar namnet, annars returnerar den Ingen. Men om du tittar närmare på det ser du att det bara returnerar en enda tagg.

Till exempel när hitta (“data”) kallades, den returnerade bara den första datataggen, men returnerade inte de andra.

FICK DIG: De hitta metoden returnerar bara den första taggen som matchar sökningen.

Så hur kan du hitta andra taggar också? Det leder oss till nästa metod.

hitta alla

De hitta alla metoden är ganska lik den hitta metod. Den enda skillnaden är att den returnerar en lista med taggar som matchar dess fråga. När den inte hittar någon tagg returnerar den helt enkelt en tom lista. Därav, hitta alla kommer alltid att returnera en lista.

Här är ett exempel:

>>> resultat = bs_innehåll.find_all ("data")
>>> skriva ut (resultat)
[Ett, Två]
>>> resultat = bs_innehåll.find_all ("barn")
>>> skriva ut (resultat)
[Först, Andra,
Tredje

Ett
Två
tvillingar

, Fjärde]
>>> resultat = bs_innehåll.find_all ("far")
>>> utskrift (resultat
[]
>>> resultat = bs_innehåll.find_all ("mor")
>>> skriva ut (resultat)
[]

Nu när du vet hur du använder hitta och hitta alla metoder kan du söka efter taggar var som helst i XML-dokumentet. Du kan dock göra dina sökningar mer kraftfulla.

Här är hur:

Vissa taggar kan ha samma namn, men olika attribut. Till exempel barn taggar har en namn attribut och olika värden. Du kan göra specifika sökningar baserat på dessa.

Ta en titt på detta:

>>> resultat = bs_innehåll.hitta ("barn", "namn": "Rose")
>>> skriva ut (resultat)
Andra
>>> resultat = bs_innehåll.find_all ("child", "name": "Rose")
>>> skriva ut (resultat)
[Andra]
>>> resultat = bs_innehåll.hitta ("barn", "namn": "Jack")
>>> skriva ut (resultat)
Först
>>> resultat = bs_innehåll.find_all ("child", "name": "Jack")
>>> skriva ut (resultat)
[Först]

Du ser att det är något annorlunda med användningen av hitta och hitta alla metoder här: de har båda en andra parameter.

När du skickar in en ordbok som en andra parameter, kommer hitta och hitta alla metoder för att söka vidare för att få taggar som har attribut och värden som passar den angivna nyckeln: värdepar.

Till exempel, trots att du använder hitta metod i det första exemplet, returnerade den andra barn tagg (istället för den första barn tag), eftersom det är den första taggen som matchar frågan. De hitta alla taggen följer samma princip, förutom att den returnerar alla taggar som matchar frågan, inte bara den första.

Hitta taggar efter relationer

Även om det är mindre populärt än att söka efter taggnamn kan du också söka efter taggar efter relationer. I verklig mening är det mer att navigera än att söka.

Det finns tre viktiga förhållanden i XML-dokument:

• Förälder: Taggen i vilken referenskoden finns.
• Barn: Taggarna som finns i referenstaggen.
• Syskon: Taggarna som finns på samma nivå som referenstaggen.

Från förklaringen ovan kan du dra slutsatsen att referenstaggen är den viktigaste faktorn för att söka efter taggar efter relationer. Låt oss därför leta efter referenskoden och fortsätta artikeln.

Titta på det här:

>>> tredje_barn = bs_innehåll.hitta ("child", "name": "Blue Ivy")
>>> skriva ut (tredje barn)

Tredje

Ett
Två
tvillingar

Från kodprovet ovan blir referensmärket för resten av detta avsnitt det tredje barn tagg, lagrad i en tredje_barn variabel. I underavsnitten nedan ser du hur du söker efter taggar baserat på deras förälders, syskons och barns förhållande till referenstaggen.

Hitta föräldrar

För att hitta överordnad tagg för en referenstagg använder du förälder attribut. Genom att göra detta returneras den överordnade taggen, liksom taggarna under den. Detta beteende är ganska förståeligt, eftersom barntaggarna är en del av den överordnade taggen.

Här är ett exempel:

>>> resultat = tredje_barn.förälder
>>> skriva ut (resultat)

Först
Andra

Tredje

Ett
Två
tvillingar


Fjärde

Hitta barn

För att hitta underordnade taggar för en referenstagg använder du barn attribut. Genom att göra detta returneras underordnade taggar, liksom underetiketterna under var och en av dem. Detta beteende är också förståeligt, eftersom barntaggar ofta också har sina egna barntaggar.

En sak du bör notera är att barn attribut returnerar underordnade taggar som en generator. Så om du behöver en lista över barntaggarna måste du konvertera generatorn till en lista.

Här är ett exempel:

>>> resultat = lista (tredje_barn.barn)
>>> skriva ut (resultat)
['\ n Tredje \ n',
Ett
Två
tvillingar
, '\ n']

Om du tittar närmare på exemplet ovan kommer du att märka att vissa värden i listan inte är taggar. Det är något du måste se upp för.

FICK DIG: De barn attribut returnerar inte bara underordnade taggar, utan returnerar också texten i referenstaggen.

Hitta syskon

Det sista i detta avsnitt är att hitta taggar som är syskon till referenstaggen. För varje referenskod kan det finnas syskontaggar före och efter den. De föregående_syskon attribut returnerar syskonstaggarna före referenstaggen och nästa_syskon attribut returnerar syskonstaggarna efter det.

Precis som barn attribut, den föregående_syskon och nästa_syskon attribut kommer att generera generatorer. Så du måste konvertera till en lista om du behöver en lista över syskon.

Titta på det här:

>>> föregående_syskon = lista (tredje barn.föregående_syskon)
>>> skriva ut (tidigare_syskon)
['\ n', Andra, '\ n',
Först, '\ n']
>>> nästa_syskon = lista (tredje_barn.nästa_syskon)
>>> skriv ut (nästa_syskon)
['\ n', Fjärde]
>>> skriva ut (föregående_syskon + nästa_syskon)
['\ n', Andra, '\ n', Först,
'\ n', '\ n', Fjärde, '\ n']

Det första exemplet visar föregående syskon, det andra visar nästa syskon; sedan kombineras båda resultaten för att generera en lista över alla syskon för referensmärket.

Extraherar från taggar

När man analyserar XML-dokument ligger mycket av arbetet i att hitta rätt taggar. Men när du hittar dem kanske du också vill extrahera viss information från dessa taggar, och det är vad detta avsnitt kommer att lära dig.

Du får se hur man extraherar följande:

• Tagga attributvärden
• Taggtext
• Tagginnehåll

Extraherar taggattributvärden

Ibland kan du ha en anledning att extrahera värdena för attribut i en tagg. I följande attribut-värde-parning till exempel: namn = ”Rose”, du kanske vill extrahera “Rose.”

För att göra detta kan du använda skaffa sig metod eller åtkomst till attributets namn med [] som ett index, precis som när du arbetar med en ordbok.

Här är ett exempel:

>>> resultat = tredje_barn.hämta namn")
>>> skriva ut (resultat)
Blue Ivy
>>> resultat = tredje_barn ["namn"]
>>> skriva ut (resultat)
Blue Ivy

Extrahera taggtext

När du vill komma åt textvärdena för en tagg kan du använda text eller strängar attribut. Båda kommer att returnera texten i en tagg, och även barn-taggarna. Men den text attribut kommer att returnera dem som en enda sträng, sammanfogad; medan strängar attribut returnerar dem som en generator som du kan konvertera till en lista.

Här är ett exempel:

>>> resultat = tredje_barn.text
>>> skriva ut (resultat)
'\ n Tredje \ n \ nEn \ nTvå \ nTvillingar \ n \ n'
>>> resultat = lista (tredje_barn.strängar)
>>> skriva ut (resultat)
['\ n Tredje \ n', '\ n', 'En', '\ n', 'Två', '\ n', 'Tvillingar', '\ n', '\ n']

Extrahera tagginnehåll

Förutom att extrahera attributvärdena och taggtexten kan du också extrahera allt tagginnehåll. För att göra detta kan du använda innehåll attribut; det är lite som barn attribut och kommer att ge samma resultat. Men medan barn attribut returnerar en generator, den innehåll attribut returnerar en lista.

Här är ett exempel:

>>> resultat = tredje_barn.innehåll
>>> skriva ut (resultat)
['\ n Tredje \ n',
Ett
Två
tvillingar
, '\ n']

Utskrift vacker

Hittills har du sett några viktiga metoder och attribut som är användbara när du analyserar XML-dokument med hjälp av BeautifulSoup. Men om du märker, när du skriver ut taggarna till skärmen, har de ett slags klustrat utseende. Även om utseendet kanske inte har en direkt inverkan på din produktivitet kan det hjälpa dig att analysera mer effektivt och göra arbetet mindre tråkigt.

Här är ett exempel på att skriva ut på normalt sätt:

>>> skriva ut (tredje barn)

Tredje

Ett
Två
tvillingar

Du kan dock förbättra dess utseende genom att använda försköna metod. Ring bara försköna metod på taggen när du skriver ut, och du får något visuellt tilltalande.

Titta på det här:

Slutsats

Att analysera dokument är en viktig aspekt av att skaffa data. XML-dokument är ganska populära, och förhoppningsvis är du bättre rustad att ta på dem och extrahera de data du vill ha.

Från den här artikeln kan du nu:

• sök efter taggar antingen efter namn eller relationer
• extrahera data från taggar

Om du känner dig ganska förlorad och är ganska ny i BeautifulSoup-biblioteket kan du kolla in BeautifulSoup-handledningen för nybörjare.