Vlákno názorů k článku Čtyři způsoby zpracování XML v Pythonu od johny - Ja už na Python, Javu a pod. nemám...

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".