Názory k článku Čtyři způsoby zpracování XML v Pythonu

Pěkný článek.
Já teda používám na parsování knihovnu xml ElementTree. Vyrábím si dataframe pro další použití. Přišlo mi, že je jednoduchá a korektně zpracuje xml soubor třetí strany - zejména ho pak uloží v tom stejném formátu co ho načte. (V kódu níže jsem ponechal následně nevyužité načítání Name. )

import xml.etree.Ele­mentTree as ETree
import numpy as np
import pandas as pd
def Tmp_xmlParse(a­file):
#Parsing a XML file to get a TMP coefficients into Dataframe
tree = ETree.ElementTre­e(file=afile)
root = tree.getroot()
# print(ETree.tos­tring(root, encoding='utf8')­.decode('utf8'))
Name = []
Value = []
for x in root.iter('Name'):
Name.append(x.text)
for x in root.iter('Value'):
Value.append(x­.text)
Value = np.array(Value).T
TMP = pd.DataFrame(Va­lue).T
Col_Keep = np.array([5,6,8,9,1­2,13,14,15,16,17])
Col_Keep= Col_Keep-1
TMPa = TMP.iloc[:, Col_Keep].copy()
Colnames=[ "TIS","TIS2",­"TPVR1","TPVR2","A0","A1­","A2","A3","F10","F11"]
TMPa.columns = Colnames
return TMPa # An explicit return statement


Koukám, že code mi sebralo taby formátování pythonu :-(

Takhle vypadá můj xml soubor

<Data>
<DataInfo>
<ComponentClas­s>Machine</Com­ponentClass>
<ComponentType>AS­peed</Componen­tType>
<Version>2003</Ver­sion>
</DataInfo>
<RecordSet>
<Record>
<Field>
<Name>TModel</Name>
<Value>9024</Value>
</Field>
...
<Field>
<Name>F10Coef</Na­me>
<Value>0.0</Value>
</Field>
<Field>
<Name>F11Coef</Na­me>
<Value>0.08617260481­268542</Value>
</Field>
</Record>
</RecordSet>
</Data>


17. 2. 2022, 08:57 editováno autorem komentáře

Jaké taby?

že by odsazení pomocí tabulátorů? ;-) ... a nezačínej s bajkou o čtyřech mezerách brácho :-D

Jo jo, přesně ty mezery. Dík. :)

Když bajka o tom, jak čtyři chudé mezery porazily namyšleného tab obra, je tak dobrá.

Ty odrážky, mezery, zkrátka taby na začátku řádku, co si dělám tabelátorem. Ale hlavní přínos mojeho příspěvku je nacpání hodnot z toho xml přímo do dataframu.
Mě osobně se s těma seznamama, rootama, stromama, childama, atp., dost blbě pracuje, stejně si to musim převýst do nějakýho pole, aby se s tim dalo vůbec nějak počítat.
Tohle mi v tom článku chybí.

Priste zkus pre namisto code...

Ajo to máš v podstatě jednoduchý záznamy z DB uložené v XML, žádná hluboká stromová struktura. Potom to dává smysl dávat do dataframu. Ale pokud je to obecnější strom, to už je někdy peklo.

V praxi člověk naráží na to, že to xml občas není validní, takže nakonec stejně vždycky skončí u knihovny https://beautiful-soup-4.readthedocs.io/en/latest/ která si s tím poradí.

Zalezi o co sa pokusame, ak ideme parsovat human-generated content (spravidla nejake HTML), tak ano. Ine dokumenty by mali byt validne, inak XML s validovanim podla schemy tak nejak prestava mat zmysel.

Já nedávno řešil jak upravit něco v XML ale při uložení to celé nezměnit resp. neformátovat prostě najít nějaký tag a změnit mu hodnotu. Bohužel jsem nenašel nic použitelného. Všechno pak při uložení ten XML soubor změní.

Je to v praxi velký problém? Možná pro (git) diff, ale jinak?

Právě, že je právě kvůli tomu gitu. Usecase byl úprava maven pom.xml a opravdu nechcete přijít o snadnou historii kdo kdy co přidal. Přitom třeba maven versions plugin to umí tak jsem si říkal, že to musí jít nějak snadno a nejde. Obecně je to problém u jakéhokoliv XML u zdrojaku.

Stačí akorát při zpracování neodstraňovat bílé znaky a zachovat pořadí atributů. Třeba z dom4j by to tak šlo určitě uložit, jenom nevím, zda to umí už standardní XMLWriter, nebo by bylo nutné některé parametry překonfigurovat. Nebo je druhá možnost, udělat to tak, jak se to dělá s ostatními zdrojáky – používat formátovač, který mají nakonfigurovaný všichni stejně.

Chtěl jsem to dělat v Pythonu. Formatter je k ničemu protože třeba dělám prázdné řádky abych oddělil různé groupy co spolu souvisí.

jj potom to chápu

Ja už na Python, Javu a pod. nemám nervy.

import groovy.xml.XmlSlurper

def data = '''<?xml version="1.0" encoding="utf-8"?>
<products>
    <product>
        <id>1</id>
        <name>Product A</name>
        <price>780</price>
    </product>

    <product>
        <id>2</id>
        <name>Product B</name>
        <price>1100</price>
    </product>

    <product>
        <id>3</id>
        <name>Product C</name>
        <price>1050</price>
    </product>

    <product>
        <id>4</id>
        <name>Product D</name>
        <price>950</price>
    </product>
</products>
'''

def products = new XmlSlurper().parseText(data)

def id1 = products.product[0].id
def name1 = products.product[0].name
def price1 = products.product[0].price

println "$id1 $name1 $price1"

def names = products.'**'.findAll { node -> node.name() == 'name' }*.text()
println names

def prices = products.product.'*'.find { node ->

    node.name() == 'price' && node.text() as Integer < 1000
}

println prices

Jaký je z toho výstup?

$ groovy simple.gvy
1 Product A 780
[Product A, Product B, Product C, Product D]
780

F# má tiež parádne riešenie.

Akonáhle človek raz vyskúša expresívne jazyky ako F#, Clojure, či Groovy, tak už viac nechce ísť naspäť do tuctových jazykov.

#r "nuget: FSharp.Data"

open FSharp.Data
open System

[<Literal>]
let data = """<?xml version="1.0" encoding="utf-8"?>
<products>
    <product>
        <id>1</id>
        <name>Product A</name>
        <price>780</price>
    </product>
    <product>
        <id>2</id>
        <name>Product B</name>
        <price>1100</price>
    </product>

    <product>
        <id>3</id>
        <name>Product C</name>
        <price>1050</price>
    </product>

    <product>
        <id>4</id>
        <name>Product D</name>
        <price>950</price>
    </product>
</products>
"""

type xml = XmlProvider<data>

let d = xml.GetSample().Products
d |> Seq.iter (fun p -> Console.WriteLine($"{p.Name} {p.Price}"))

let res = d |> Seq.filter (fun p -> p.Price < 1000)

for v in res do
    Console.WriteLine v

printfn "%A" d[..2]

Výstup:

$ fsx parse.fsx
Product A 780
Product B 1100
Product C 1050
Product D 950
<product>
        <id>1</id>
        <name>Product A</name>
        <price>780</price>
    </product>
<product>
        <id>4</id>
        <name>Product D</name>
        <price>950</price>
    </product>
[|<product>
        <id>1</id>
        <name>Product A</name>
        <price>780</price>
    </product>;
  <product>
        <id>2</id>
        <name>Product B</name>
        <price>1100</price>
    </product>;
  <product>
        <id>3</id>
        <name>Product C</name>
        <price>1050</price>
    </product>|]

tohle je hodne pekne, opravdu expresivni, na to ze je to staticky typovane. Type providery jsou skvela vec, snad se dostanou do typescriptu.

Jediné co mně na F# trochu štve, je ta návaznost na C# viz ty PascalCase metody... `GetSample()` ... nebo se pletu? Přijde mi, že se často sahá po knihovnách, co jsou původně pro C#, což je logické, ale esteticky trpím.

21. 2. 2022, 14:48 editováno autorem komentáře

lxml umi take nacist xml do objektu, kte jsou tagy atributy, ale je to mene obecne

from lxml import objectify


data = b'''<?xml version="1.0" encoding="utf-8"?>
<products>
    <product>
        <id>1</id>
        <name>Product A</name>
        <price>780</price>
    </product>

    <product>
        <id>2</id>
        <name>Product B</name>
        <price>1100</price>
    </product>

    <product>
        <id>3</id>
        <name>Product C</name>
        <price>1050</price>
    </product>

<product>
        <id>4</id>
        <name>Product D</name>
        <price>950</price>
    </product>
</products>
'''

products = objectify.fromstring(data)

p = products.product[0]

print(p.id, p.name, p.price)

names = [p.name for p in products.product]

print(names)

prices = [p.price for p in products.product if int(p.price) < 1000]

print(prices)

21. 2. 2022, 13:52 editováno autorem komentáře

> lxml umi take nacist xml do objektu, kte jsou tagy atributy, ale je to mene obecne

Už jsem se bál, že to budu "muset" řešit já, díky. Jsem se divil, že by tenhle pro Python celkem přirozený přístup nebyl k dispozici. Ještě víc jsem se divil, že OP strčil Python do stejného pytle s Javou...

V dynamickem jazyce je tohle trivialita, neni moc velky rozdil mezi slovnikem a objektem. Zajimavejsi je ten jeho priklad s F#.

Zajímavé snad jo, ale neumím rozklíčovat, díky čemu to funguje. F# má pokud vím nějakou podporu OOP a ten kód ve mě vyvolává dojem, že pod kapotou to řešení bude dost podobné.

A co když tam jsou namespaces? Teď jsem zkoušel ElementTree a s namespace je to nepoužitelné.

Co konkretne chcete? lxml je nadstavba nad ElementTree, umi toho vic, podivejte se na dokumentaci.

edit: Kdyztak otevrete vlakno ve foru. Tady se kvuli prodleve zpusobene schvalovanim prispevku diskutovat moc neda.

21. 2. 2022, 20:38 editováno autorem komentáře

Zkoušel jsem to právě na pom.xml, které má default namespace (xmlns) a ElementTree udělá všechny tagy právě s tím namespace. Takže místo tagu dependency je název tagu {namespace}de­pendency takže ho z toho bez namespace nedostanete a u XPath musíte buď psát {*} u každého tagu nebo dát namespace jako parametr. Tohle mi přijde naprosto nepoužitelné a navíc ElementTree neumí ten namespace z elementu získat, takže když ho nechcete hardcode (což asi nikdo nechce), tak to z toho názvu tagu musíte vyparsovat. Proto se ptám zda lxml umí ten default namespace "ignorovat".