Grundlegende Verwendung der lxml-Bibliothek

1. Lernen Sie lxml kennen

lxml ist eine leistungsstarke Python-XML-Bibliothek, die hauptsächlich zum Parsen und Generieren von XML- und HTML-Dateien (Parsing, Serialisierung, Konvertierung) verwendet wird. Es unterstützt nativ XPath1.0, XSLT1.0, benutzerdefinierte Elementklassen und sogar Datenbindungsschnittstellen im Python-Stil. lxml wird basierend auf Cpython implementiert und die unterste Ebene besteht aus zwei C-Sprachbibliotheken, libxml2 und libxslt. Daher ist die Leistung höher.

Offizielle Dokumentation: https://lxml.de/

2. Grundlegende Verwendung in lxml

In lxml ist das Modul lxml.etree das am häufigsten verwendete Modul zum Parsen von HTML- und XML-Dokumenten. Unter diesen ist lxml.etree.Element eine Kernklasse für die Verarbeitung von XML, und das Elementobjekt kann intuitiv als Knoten in XML verstanden werden. Mit der Element-Klasse können Sie Operationen an XML-Knoten, Knotenattributen und Text innerhalb von Knoten implementieren.

2.1 Installieren und importieren Sie das lxml-Modul

pip install lxml

from lxml import etree

2.2 Knotenbetrieb:

1. Erstellen Sie einen Knoten (erstellen Sie ein Elementobjekt):

root = etrre.Element('root')
print(root)

2. Ermitteln Sie den Knotennamen

print(root.tag)

3. Untergeordnete Knoten hinzufügen

Es gibt drei Möglichkeiten, Unterknoten hinzuzufügen: 1. Verwenden Sie direkt die SubElement-Methode, um Unterknoten hinzuzufügen. 2. Erstellen Sie ein Elementobjekt und hängen Sie das Objekt mit der Append-Methode an den übergeordneten Knoten an. 3. Erstellen Sie ein Elementobjekt und fügen Sie das Objekt mit der Einfügemethode an der angegebenen Position des übergeordneten Knotens hinzu.

• Verwenden Sie die SubElement-Methode, um Folgendes hinzuzufügen:

child_sub = etree.SubElement(root, 'child_sub')

• Verwenden Sie die Append-Methode, um Folgendes hinzuzufügen:

child_append = etree.Element('child_append')
root.append(child_append)

• Verwenden Sie die Einfügemethode, um Folgendes hinzuzufügen:

child_insert = etree.Element('child_insert')
root.insert(0, child_append)  #  第一个参数为添加的位置，第二个参数为添加的Element对象

4. Untergeordnete Knoten löschen:

Mit der Methode „remove()“ können Sie einen angegebenen untergeordneten Knoten löschen. Verwenden Sie die Methode clear(), um alle untergeordneten Knoten zu löschen

root.remove(child_sub)  # 删除名字为child_sub节点
root.clear()  # 清空root的所有子节点

5. Besuchen Sie den Knoten

Im Element-Objekt gibt es mehrere Möglichkeiten, auf Knoten zuzugreifen.

• Knoten können anhand einer Liste orientiert werden.
• Auf Knoten kann über Methoden wie getparent() zugegriffen werden.
• Sie können den angegebenen Knoten über die xpath-Syntax finden (noch nicht eingeführt).

(1) Zugriffsknoten über eine Liste:

child_sub = root[0]  # 通过下标来访问子节点
child_sub = root[0: 1][0]  # 通过切片的方式来访问节点
for c in root:  # 通过遍历来获取所有节点
    print(c.tag)
    
c_append_index = root.index(child_append)  # 获取节点的索引
print(len(root))  # 获取子节点的数量

(2) Zugriffsknoten über Methoden:

• Holen Sie sich den übergeordneten Knoten: getarent()
• Alle untergeordneten Knoten abrufen: getchildren()
• Holen Sie sich den Wurzelknoten: getroot()
• findall(): gibt alle passenden Elemente zurück, gibt eine Liste zurück
• find(): gibt das erste passende Element zurück

print(child_sub.getparent().tag)  # 查询父节点
print(root.getchildren())  # 查询所有子节点
print(root.getroot())  # 获取根节点
print(root.find('b'))  # 查询第一个b标签
print(root.findall('.//b'))  # 查询所有b标签

2.3 Attributoperationen:

In Element werden die Attribute von Knoten in Form von Wörterbüchern gespeichert.

Eigenschaften erstellen:

Es gibt zwei Möglichkeiten, Attribute zu erstellen. 1. Erstellen Sie beim Erstellen von Knoten Attribute. 2. Verwenden Sie die Methode set(), um Attribute zu erstellen.

root = etree.Element('root', language='中文')  # 创建节点时创建属性

root.set('hello', 'python')  # 使用set方法为root节点添加属性

Eigenschaften abrufen:

print(root.get('language'))  # 使用get方法获取属性
print(root['language'])
print(root.keys())
print(root.values())
print(root.items())

Eigenschaften ändern:

root['language'] = 'English'

2.4 Textmanipulation

Es gibt viele Möglichkeiten, auf XML-Text in lxml zuzugreifen, und Sie können die Attribute text und tail verwenden, um auf den Text zuzugreifen. Auf Text kann auch mithilfe der XPath-Syntax zugegriffen werden. Hier stellen wir nur die Methode vor, mit der Text und Tail die Eigenschaften des Textes abrufen und festlegen. Der XPath wird später ausführlich vorgestellt.

Der Unterschied zwischen Text- und Tail-Attributen:

Tags in XML erscheinen im Allgemeinen paarweise. Aber in HTML kann es einzelne Tags geben, wie zum Beispiel <html><body>text<br/>tail</body></html>.

• Das Textattribut wird zum Lesen und Setzen gepaarter Notizen verwendet
• Das Tail-Attribut wird zum Lesen und Setzen eines einzelnen Tags verwendet

html = etree.Element('html')
body = etree.SubElement(html, 'body')
body.text = 'text'  # 给body标签内写入text文本内容

br = etree.SubElement('body', 'br')
br.tail = 'tail'  # 在br标签中写入tail文本内容

2.5 XML-Dateianalyse und Serialisierung

1. Methoden zum Parsen von XML-Dateien:
Es gibt viele Methoden zum Parsen von XML-Dateien. Häufig werden Fromstring, XML, HTML und Parse verwendet. Die Parameter von XML und HTML können entweder Zeichenfolgen oder binäre Bytecodes sein.

• fromstring, XML, parse: Gibt ein Elementobjekt zurück, das ein Knoten ist. Wird hauptsächlich zum Parsen von Dokumentfragmenten verwendet.

• parse(): Der Rückgabewert ist ein Objekt vom Typ ElementTree, eine vollständige XML-Baumstruktur. Parse wird hauptsächlich zum Parsen vollständiger Dokumente verwendet, nicht zum Parsen von Elementobjekten.

• Parameter:
  Datei oder Dateitypobjekt öffnen (empfohlen wird,
  den Dateinamen oder die
  HTTP- oder FTP-URL in binärer Form zu öffnen).

  Hinweis: Das Parsen anhand eines Dateinamens oder einer URL ist normalerweise schneller als das Parsen anhand eines Dateiobjekts .

xml_data = '<root>data</root>'

 # fromstring
root_str = etree.formstring(xml_data)
print(root_str.tag)

 # XML
root_xml = etree.XML(xml_data)
print(root_xml.tag)

 # HTML，如果没有<html>和<body>标签，则会自动补上
 root_html = etree.HTML(xml_data)
 print(root_html.tag)
 
 # parse中的参数应该是一个完整的xml或html,同样返回值是一个ElementTree类型的对象，完整的xml树结构。parse主要用来解析完整的文档。
tree =etree.parse('text')   #文件解析成元素树
root = tree.getroot()      #获取元素树的根节点
print etree.tostring(root, pretty_print=True)

2. Die Serialisierungsmethode der XML-Datei:

Wir haben zwei Möglichkeiten, eine XML-Datei zu generieren: 1. Konvertieren Sie das Elementobjekt in einen XML-String und schreiben Sie ihn dann in die Datei. 2. Verwenden Sie die Methode write() im ElementTreee-Objekt, um die XML-Datei direkt in die Datei zu schreiben.

root = '<root>data</root>'

# 将Element对象转换成xml字符串写入文件
root_str = element.tostring(root, pretty_print=True, xml_declartion=True, encoding='utf-8')
with open('text.xml', 'w', encoding='utf-8') as f:
    f.write(root_str)


# 将节点（Element对象）转为ElementTree对象。
tree = etree.ElementTree(root)
tree.write('text.xml', pretty_print=True, xml_declartion=True, encoding='utf-8')

Parameterbedeutung:

• Der erste Parameter ist der Pfad, in dem die XML gespeichert ist (einschließlich des Dateinamens).
• Pretty_print: ob XML formatiert werden soll (Verschönerung)
• xml_declaration: Ob die XML-Deklaration geschrieben werden soll, also die erste Textzeile am Anfang von XML.
• Kodierung: Kodierungsformat

Ergänzung: Das ElementTree-Objekt kann als vollständiger XML-Baum verstanden werden, und jeder Knoten ist ein Elementobjekt. ElementPath entspricht XPath in XML. Wird zum Suchen und Lokalisieren von Elementelementen verwendet.

2.6 Verarbeitung des lxml-Namespace

Was ist ein Namensraum? https://www.w3school.com.cn/xml/xml_namespaces.asp

XML-Parsing-Verarbeitung mit Namespaces:

from lxml import etree

str_xml = """
<A xmlns="http://This/is/a/namespace">
    <B>dataB1</B>
    <B>dataB2</B>
    <B><C>datac</C></B>
</A>
"""

xml = etree.fromstring(str_xml)  # 解析字符串
ns = xml.nsmap  # 获取命名空间
print(ns)
print(ns[None])

>>> {
    
    None: 'http://This/is/a/namespace'}
>>> http://This/is/a/namespace

ns = xml.nsmap[None]  # 获取命名空间xmlns

# 1. 使用findall方法查找指定节点。
for item in xml.findall(f'{
      
      ns}b')
	print(item.text)
    
# 2. 使用xpath语法加命名空间查找指定节点
ns = {
    
    'x':root.nsmap[None]}  # 获取命名空间
b = root.xpath("//x:B", namespaces=ns)
print(b)

C = root.xapth("//x:B/X:C", namespaces=ns)
print(c)

Hinweis: Wenn XML einen Namespace (xmlns) enthält, muss bei der Suche nach Knoten jede Knotenebene einen Namespace hinzufügen. Wenn der Namespace nicht enthalten ist, kann der Knoten nicht abgefragt werden.
Darüber hinaus gibt es eine sehr einfache Möglichkeit, mit Namespaces umzugehen, nämlich alle Namespaces durch leere zu ersetzen und sie wie gewöhnliche Knoten zu behandeln.

Referenz: https://blog.csdn.net/rhx_qiuzhi/article/details/105345624

3. Verwenden Sie lxml, um den XML-Fall zu analysieren

(1) Importieren Sie die Etree-Bibliothek von lxml

from lxml import etree

(2) Verwenden Sie etree.HTML, um die HTML-Zeichenfolge (Byte-Typ oder Str-Typ) in ein Element-Objekt zu konvertieren. Das Element-Objekt verfügt über eine XPath-Methode und gibt eine Ergebnisliste zurück

html = etree.HTML(text)
ret_list = html.xpath("xpath语法规则字符串")

(3) Drei Situationen, in denen die xpath-Methode eine Liste zurückgibt

• Gibt eine leere Liste zurück: Gemäß der XPath-Syntaxregelzeichenfolge wird kein Element gefunden
• Gibt eine Liste von Zeichenfolgen zurück: xpath-Zeichenfolgenregeln müssen mit dem Textinhalt oder dem Wert eines Attributs übereinstimmen
• Gibt eine Liste von Elementobjekten zurück: Die XPath-Regelzeichenfolge stimmt mit der Bezeichnung überein und die Elementobjekte in der Liste können weiterhin für XPath verwendet werden

from lxml import etree
text = '''
<div>
  <ul>
    <li class="item-1">
      <a href="link1.html">first item</a>
    </li>
    <li class="item-1">
      <a href="link2.html">second item</a>
    </li>
    <li class="item-inactive">
      <a href="link3.html">third item</a>
    </li>
    <li class="item-1">
      <a href="link4.html">fourth item</a>
    </li>
    <li class="item-0">
      a href="link5.html">fifth item</a>
  </ul>
</div>
'''

html = etree.HTML(text)  # 也可以使用XML和fromstring方法

# 获取所有的class属性为item-1的href属性
href_list = html.xpath('//li[@class="item-1"]/a/@href')
# 获取所有的class属性为item-1的text内容
text_list = html.xpath('//li[@class="item-1"]/a/text()')

# 组装成字典
for href, title in zip(href_list, title_list):
    print({
    
    f'{
      
      href}': f'{
      
      title}'})

Hinweis: Die Methode lxml.etree.HTML(html_str) kann unvollständige Tags automatisch vervollständigen.

4. Verwenden Sie lxml, um ein Beispiel für eine XML-Datei zu generieren:

from lxml import etree

# 创建element对象
root = etree.Element('root')
print(root.tag)

# 添加子节点
child_sub = etree.SubElement(root, 'child_sub')

child = etree.Element('child')
child_append = root.append(child)  # 通过append向root节点里面追加子节点
child_insert = root.insert(0, child)  # 通过insert向root节点开始的位置添加子节点

# 3.删除子节点
# root.remove(child2)

# 4.删除所有子节点
# root.clear()

# 5.以列表的方式操作子节点
print(len(root))
print root.index(child)  # 索引号

# 6.生成xml字符串写入xml文件
# 将Element对象转换成xml字符串写入文件
root_str = etree.tostring(root, pretty_print=True, xml_declaration=True, encoding='utf-8')
with open('text.xml', 'wb') as f:
    f.write(root_str)

# 将节点（Element对象）转为ElementTree对象。
tree = etree.ElementTree(root)
tree.write('text.xml', pretty_print=True, xml_declartion=True, encoding='utf-8')

Referenzlink: https://blog.csdn.net/ydw_ydw/article/details/82227699

5. Ergänzung: xPath-Syntax

• XPath (XML Path Language) ist eine Sprache zum Suchen von Informationen in HTML\XML-Dokumenten und kann zum Durchlaufen von Elementen und Attributen in HTML\XML-Dokumenten verwendet werden .
• Offizielles W3School-Dokument: http://www.w3school.com.cn/xpath/index.asp
• Das Extrahieren von Daten in XML und HTML erfordert im Allgemeinen die Verwendung des LXML-Moduls und der XPath-Syntax

5.1 Syntax der Knotenauswahl:

Syntax für xpath zum Auffinden von Knoten und zum Extrahieren von Attributen oder Textinhalten:

Ausdruck	beschreiben
Knotenname	Wählen Sie das Element aus.
/	Wählen Sie vom Wurzelknoten oder vom Übergang von Element zu Element.
//	Wählt Knoten im Dokument aus dem aktuellen Knoten aus, der der Auswahl entspricht, unabhängig von ihrer Position.
.	Wählen Sie den aktuellen Knoten aus.
..	Wählen Sie den übergeordneten Knoten des aktuellen Knotens aus.
@	Wählen Sie Eigenschaften aus.
Text()	Text auswählen.

Hinweis: Wenn das @-Symbol am Ende erscheint, wird es zum Extrahieren von Attributen verwendet; wenn es in [] erscheint, wird es zum Abgleichen von Attributen verwendet

Syntax zur Auswahl unbekannter Knoten:
Unbekannte HTML- und XML-Elemente können über Platzhalter ausgewählt werden

Platzhalter	beschreiben
*	Entspricht jedem Elementknoten.
Knoten()	Entspricht jedem Knotentyp.

• Alle Tags://*
• Alle Eigenschaften://node()

5.2 Syntax der Knotendekoration:

Ein bestimmter Knoten kann anhand des Attributwerts, des Index usw. des Etiketts abgerufen werden

Pfadausdruck	Ergebnis
//title[@lang="eng"]	Wählt alle Titelelemente aus, deren lang-Attributwert eng ist
/bookstore/book[1]	Wählt das erste Buchelement aus, das ein untergeordnetes Element des Buchladenelements ist.
/bookstore/book[last()]	Wählt das letzte Buchelement aus, das ein untergeordnetes Element des Buchladens ist.
/bookstore/book[last()-1]	Wählt das vorletzte Buchelement aus, das ein untergeordnetes Element des Buchladenelements ist.
/bookstore/book[position()>1]	Wählen Sie unter Buchhandlung das Buchelement aus, beginnend mit dem zweiten
//book/title[text()='Harry Potter']	Wählen Sie alle Titelelemente unter dem Buch aus, wählen Sie nur das Titelelement aus, dessen Text Harry Potter ist
//book/title[contains(text(), „Harry“)]	Wählen Sie den gesamten Text unter dem Buch aus, der Harrys Titelelement enthält
/bookstore/book[price>35.00]/title	Wählen Sie alle Titelelemente des Buchelements im Buchladenelement aus, und der Wert des Preiselements muss größer als 35,00 sein.

Über den Index von xpath:

• In xpath ist die Position des ersten Elements 1
• Die Position des letzten Elements ist last()
• Der vorletzte ist last()-1

5.3 Installation und Verwendung des Google Chrome XPath-Hilfs-Plug-Ins

Um das lxml-Modul zum Extrahieren von Daten verwenden zu können, müssen wir die XPath-Syntaxregeln beherrschen. Schauen wir uns als Nächstes das XPath-Hilfs-Plugin an, das uns beim Üben der XPath-Syntax helfen kann.

Installation des XPath-Helper-Plugins:

1. Laden Sie das Chrome-Plugin XPath Helper herunter:

• Sie können es im Chrome Application Store herunterladen. Wenn Sie es nicht herunterladen können, können Sie es auch über den unten stehenden Link herunterladen
• Download-Adresse: https://pan.baidu.com/s/1UM94dcwgus4SgECuoJ-JcgPasswort : 337b

2. Ändern Sie das Suffix der Datei von crx in rar und dekomprimieren Sie sie dann in einen Ordner mit demselben Namen

3. Ziehen Sie den dekomprimierten Ordner in die Chrome-Browsererweiterungsoberfläche, während der Entwicklermodus aktiviert ist

4. Klicken Sie nach dem Neustart des Browsers auf das XPath-Symbol auf der Seite, nachdem Sie die URL aufgerufen haben, und Sie können es verwenden

5. Wenn es sich um ein Linux- oder macOS-Betriebssystem handelt, ist es nicht erforderlich, den obigen Schritt 2 auszuführen und die CRX-Datei direkt in die Chrome-Browser-Erweiterungsoberfläche zu ziehen, die den Entwicklermodus aktiviert hat