Dane z XML do DataFrame #3

W artykule opiszę jak wczytać dane z pliku XML do obiektu DataFrame przy użyciu modułu minidom – minimalnej implementacji modelu DOM.

Pliki projektu są do pobrania: >>tutaj<<

Używany jest identyczny plik XML, jaki opisałem we wcześniejszym wpisie.

Oprócz xml.dom.minidom używam jeszcze podobnie jak poprzednio moduł pandas oraz klasę defaultdict z modułu collections.

Przy użyciu menadżera kontekstu otwieram plik XML, który zostaje wczytany i z którego utworzony jest dokument DOM.

W utworzonym dokumencie wyszukuję listę elementów z pliku XML o nazwie person i po kolei wszystkie pobieram dla każdego z nich wartość atrybutu id, który zapisuję w słowniku persons. Ponadto dla każdego tagu potomnego tj. position, first_name, last_name itp. zapisuję jego wartość.

Tak utworzony słownik persons jest podawany jako argument przy tworzeniu obiektu ramki DataFrame.

kod źródłowy:

import xml.dom.minidom
from collections import defaultdict
import pandas as pd

persons = defaultdict(list)
with xml.dom.minidom.parse(open('persons.xml')) as tree:
    persons_list = tree.getElementsByTagName('person')
    for person in persons_list:
        persons['id'].append(person.getAttribute('id'))
        for tag in ('position', 'first_name', 'last_name', 'email', 'salary'):
            persons[tag].append(person.getElementsByTagName(tag)[0].firstChild.data)


df = pd.DataFrame(persons, columns=persons.keys()).set_index('id')
df['salary'] = df['salary'].astype(float)
print(df.sort_values(by='salary', ascending=False))

Dane z XML do DataFrame #2

W artykule opiszę jak wczytać dane z pliku XML do obiektu DataFrame przy użyciu modułu xml.sax.

Pliki projektu są do pobrania: >>tutaj<<

Używany jest identyczny plik XML, jaki opisałem we wcześniejszym wpisie.

Oprócz xml.sax używam jeszcze podobnie jak poprzednio moduł pandas oraz klasę defaultdict z modułu collections.

Pierwszym etapem przy odczycie danych z pliku XML przy użyciu SAX jest implementacja własnej klasy, która dziedziczy po klasie ContentHandler(). Klasa handlera przesłania trzy metody bazowej klasy: metodę startElement(), która wywoływana jest przy rozpoczęciu odczytu kolejnego taga, metodę characters(), która odczytuje wartości zapisane dla poszczególnego elementu oraz metodę endElement(), która jest wywoływana po zakończeniu odczytu odpowiedniego tagu. Oprócz tego w metodzie __init__() tworzę egzemplarz słownika, w którym będą zapisywane dane odczytane z pliku XML.

W metodzie startElement() definiuję atrybut klasy o nazwie tag, a także jeśli przetwarzanym tagiem jest ‘person’ zapisuję numer id dla osoby.

Następnie w metodzie characters() zapisuję wartości przechowywane w poszczególnych elementach jako odpowiednie zmienne klasy.

W metodzie endElement() zapisuję pobrane wartości do słownika persons.

Parsowanie pliku XML za pomocą modułu xml.sax polega na wywołaniu metody make_parser(), która zwraca instancję parsera. Następnie do utworzonego parsera jest jako argument funkcji setContentHandler przypisywana jest instancja handlera – w tym przypadku klasy PersonsHandler.

Następnie wywoływana jest metoda parse(), która dokonuje parsowania źródłowego dokumentu XML.

Zmienna persons przechowuje wartości słownika utworzonego przez handlera i ten słownik jest podawany jako parametr przy tworzeniu ramki DataFrame.

kod źródłowy:

import xml.sax
from collections import defaultdict
import pandas as pd

class PersonsHandler(xml.sax.ContentHandler):
    def __init__(self):
        self.persons = defaultdict(list)
    def startElement(self, tag, attr):
        self.tag = tag
        if tag == 'person':
            self.persons['id'].append(attr['id'])
            
    def characters(self, content):
        if content.strip():
            if self.tag == 'position': self.position = content
            elif self.tag == 'first_name': self.first_name = content
            elif self.tag == 'last_name': self.last_name = content
            elif self.tag == 'email': self.email = content
            elif self.tag == 'salary': self.salary = content
    
    def endElement(self, tag):
        if tag == 'position': self.persons['position'].append(self.position)
        elif tag == 'first_name': self.persons['first_name'].append(self.first_name)
        elif tag == 'last_name': self.persons['last_name'].append(self.last_name)
        elif tag == 'email': self.persons['email'].append(self.email)
        elif tag == 'salary': self.persons['salary'].append(self.salary)

parser = xml.sax.make_parser()
parser.setContentHandler(PersonsHandler())
parser.parse(open('persons.xml'))
persons = parser.getContentHandler().persons


df = pd.DataFrame(persons, columns=persons.keys()).set_index('id')
df['salary'] = df['salary'].astype(float)
print(df.sort_values(by='salary', ascending=False))

Dane z XML do DataFrame #1

W artykule opiszę jak wczytać dane z pliku XML do obiektu DataFrame przy użyciu modułu xml.etree.ElementTree.

Pliki projektu są do pobrania: >>tutaj<<

Przykładowy plik XML będzie opisywał osoby zatrudnione w firmie i będzie miał następującą postać:

<persons>
    <person id="">
        <position></position>
        <first_name></first_name>
        <last_name></last_name>
        <email></email>
        <salary></salary>
    </person>
</persons>

Dla każdej osoby, która posiada unikalny atrybut id zapisane są następujące dane: stanowisko, imię, nazwisko, email i wynagrodzenie.

Na początek importuję niezbędne moduły tj. xml.etree.ElementTree do parsowania dokumentu XML. Z modułu collections importuję defaultdict, który będzie przechowywał listy zawierające imiona, nazwiska , wynagrodzenia itd., który to słownik podaję następnie jako argument klasy DataFrame.

import xml.etree.ElementTree as et
from collections import defaultdict
import pandas as pd

W kolejnym wierszu tworzę słownik, który będzie przechowywał dane o pracownikach pozyskane z pliku XML:

persons = defaultdict(list)

Następnie wczytuję plik XML i pobieram element nadrzędny – root – persons, a następnie dla każdego elementu podrzędnego – person pobieram wartość jego atrybutu id, a także wartości jego elementów: position, first_name, last_name itd. Każda z tych wartości jest dodawana jako kolejny element odpowiedniej listy słownika.

tree = et.parse("persons.xml")
root = tree.getroot()
for child in root:
    id = child.attrib.get('id')
    position = child.find('position').text
    first_name = child.find('first_name').text
    last_name = child.find('last_name').text
    email = child.find('email').text
    salary = child.find('salary').text
    
    persons['id'].append(id)
    persons['position'].append(position)
    persons['first_name'].append(first_name)
    persons['last_name'].append(last_name)
    persons['email'].append(email)
    persons['salary'].append(salary)

Tak utworzony słownik podaję jako argument do tworzonego obiektu ramki, przy czym jako nazwy kolumn podaję nazwy kluczy słownika, a jako indeks ramki podaję kolumnę id.

Następnie typ danych kolumny salary zmieniam na float, aby posortować ramkę względem malejących wartości z tej kolumny. Ewentualnie konwersji na float można by dokonać przy tworzeniu obiektu DataFrame podając dodatkowo argument dtype.