XML è un linguaggio di markup utilizzato per rappresentare e distribuire strutture di dati che possono essere spesso difficili da creare utilizzando formati tabulari più standard.

Fondamentalmente, il formato XML è simile all'HTML (che è un altro linguaggio di markup, appunto), in quanto i dati sono organizzati in elementi, che definiscono il tipo di informazioni esposte, e ogni elemento contiene il valore effettivo sotto forma di contenuto o attributi.

La pagina XML su Wikipedia offre una n visione completa di tutti i dettagli e aspetti tecnici di questo formato, ma i concetti chiave sono semplici. Ogni informazione è delimitata da un tag specifico, come questo:

<data> 
    <student name = "John"> 
        <email> john@mail.com </email> 
        <grade> A </grade> 
        <age> 16 </age> 
    </student> 
    <student name = "Alice" > 
        <email> alice@mail.com </email> 
        <grade> B </grade> 
        <age> 17 </age> 
    </student> 
    <student name = "Bob"> 
        <email> bob@mail.com < / email> 
        <grade> C </grade> 
        <age> 16 </age> 
    </student> 
    <student name = "Hannah"> 
        <email> hannah@mail.com </email>
        <grade> A </grade> 
        <age> 17 </age> 
    </student> 
</data>

In questo esempio, ogni studente è rappresentato da un <student>elemento, che ha un nameattributo contenente il nome di uno studente specifico. Ciascuno di questi elementi ha quindi sottoelementi definiti dai tag <email>, <grade>e <age>; tra questi tag è presente il contenuto effettivo dei dati riferiti allo studente dato. Supponiamo che questi dati vengano salvati in un file XML chiamato "students.xml".

Possiamo pensare a questa struttura come a un DataFrame panda in cui ogni studente rappresenta un'osservazione, con il suo nameattributo che è l'identificatore principale e i sottoelementi sono altre caratteristiche dell'osservazione. Una rappresentazione tabulare di questi dati sarebbe come questa:

Quindi vogliamo trovare un modo per convertire i dati strutturati in XML in una tabella più funzionale.

Data la struttura dei file XML, possiamo rappresentarli come un albero, e questo è l'approccio utilizzato dal modulo xml.etree.ElementTree Python. L'analisi del nostro file "students.xml" inizia dalla radice dell'albero, ovvero l' <data>elemento, che contiene l'intera struttura dati.

import xml.etree.ElementTree as et 

xtree = et.parse("students.xml")
xroot = xtree.getroot()

Ora possiamo iterare attraverso ogni nodo dell'albero, il che significa che otterremo ogni elemento studente e prenderemo il suo nameattributo e tutti i suoi sottoelementi per costruire il nostro dataframe.

for node in xroot: 
    s_name = node.attrib.get("name")
    s_mail = node.find("email").text
    s_grade = node.find("grade").text
    s_age = node.find("age").text

Per ottenere l' nameattributo utilizziamo la attrib.get()funzione, mentre il contenuto testuale di ogni elemento può essere recuperato utilizzando la find()funzione dei nodi. Ogni iterazione restituirà un set di dati che può essere pensato come un'osservazione in un DataFrame panda; possiamo costruire questa procedura come segue:

import pandas as pd 
import xml.etree.ElementTree as et 

xtree = et.parse("students.xml")
xroot = xtree.getroot() 

df_cols = ["name", "email", "grade", "age"]
rows = []

for node in xroot: 
    s_name = node.attrib.get("name")
    s_mail = node.find("email").text if node is not None else None
    s_grade = node.find("grade").text if node is not None else None
    s_age = node.find("age").text if node is not None else None

    rows.append({"name": s_name, "email": s_mail, 
                 "grade": s_grade, "age": s_age})

out_df = pd.DataFrame(rows, columns = df_cols)

Lo svantaggio di questo approccio è che devi conoscere in anticipo la struttura del file XML e devi codificare i nomi delle colonne di conseguenza. Possiamo provare a convertire questo codice in una funzione più utile e versatile, senza dover codificare alcun valore:

import pandas as pd 
import xml.etree.ElementTree as et 

def parse_XML (xml_file, df_cols): 
    "" "Analizza il file XML di input e memorizza il risultato in un 
    DataFrame panda con le colonne indicate. 
    
    Il primo elemento di df_cols dovrebbe essere la 
    variabile identificatore , che è un attributo di ogni elemento del nodo nei 
    dati XML; altre caratteristiche verranno analizzate dal contenuto 
    di testo di ogni sottoelemento. 
    "" " 
    
    xtree = et.parse(xml_file)
    xroot = xtree.getroot()
    rows = []

    for node in xroot: 
        res = []
        res.append(node.attrib.get(df_cols[0]))
        for el in df_cols[1:]: 
            if node is not None and node.find(el) is not None:
                res.append(node.find(el).text)
            else: 
                res.append(None)
        rows.append({df_cols[i]: res[i] 
                     for i, _ in enumerate(df_cols)})

    out_df = pd.DataFrame(rows, columns=df_cols)

    return out_df

Un pezzo di codice interessante è la comprensione dei dettami in:

{df_cols [i]: res [i] for i, _ in enumerate (df_cols)}

dove viene creato un dizionario nel nome della colonna del modulo: il valore del nodo e aggiunto all'elenco delle righe. Questi verranno infine utilizzati per creare il dataframe completo.

Utilizziamo ora la funzione

parse_XML("students.xml", ["name", "email", "grade", "age"])

Questa è un'implementazione più efficiente della funzione di analisi XML, sebbene abbiamo ancora bisogno di conoscere la struttura di base del documento XML di input che vogliamo analizzare.

Grazie per aver fatto qui la tua domanda, fammi sapere se funziona.