Wie man das OneNote-Dokument DOM in Python durchläuft

Aspose.Note FOSS for Python represents a OneNote section file as a tree of typed Python objects. Understanding how to traverse this tree efficiently is the foundation for all content extraction tasks. This guide covers all three traversal approaches: GetChildNodes, direkte Iteration und DocumentVisitor.

Das Dokumentobjektmodell

Die OneNote DOM ist ein Strength-Tree:

Document
  ├── Page
  │     ├── Title
  │     │     ├── TitleText (RichText)
  │     │     ├── TitleDate (RichText)
  │     │     └── TitleTime (RichText)
  │     └── Outline
  │           └── OutlineElement
  │                 ├── RichText
  │                 ├── Image
  │                 ├── AttachedFile
  │                 └── Table
  │                       └── TableRow
  │                             └── TableCell
  │                                   └── RichText / Image
  └── Page  (next page ...)

Jeder Knoten erbt von Node. Knoten, von denen Kinder geerbt werden. CompositeNode.

Methode 1: GetChildNodes (recursive, mit Typfilter)

CompositeNode.GetChildNodes(Type) führt eine rekursive, tiefgründige Suche des gesamten Unterbaumes durch und gibt eine flache Liste aller mit dem gegebenen Typ übereinstimmenden Knoten zurück. Dies ist der bequemste Ansatz für die Inhaltsentnahme:

from aspose.note import Document, RichText, Image, Table, AttachedFile

doc = Document("MyNotes.one")

##All RichText nodes anywhere in the document
texts = doc.GetChildNodes(RichText)
print(f"RichText nodes: {len(texts)}")

##All images
images = doc.GetChildNodes(Image)
print(f"Image nodes: {len(images)}")

##All tables
tables = doc.GetChildNodes(Table)
print(f"Table nodes: {len(tables)}")

##All attachments
attachments = doc.GetChildNodes(AttachedFile)
print(f"AttachedFile nodes: {len(attachments)}")

Die Suche auf eine einzelne Seite erweitern, indem Sie anrufen: GetChildNodes am 1. Januar Page statt der Document:

from aspose.note import Document, Page, RichText

doc = Document("MyNotes.one")
for page in doc.GetChildNodes(Page):
    page_texts = page.GetChildNodes(RichText)
    print(f"  Page has {len(page_texts)} text nodes")

Methode 2: Direkt-Kind-Iteration

for child in node die Iteration der unmittelbar Kinder von einem CompositeNode.Verwenden Sie das , wenn Sie eine bestimmte Ebene der Hierarchie benötigen:

from aspose.note import Document

doc = Document("MyNotes.one")

##Direct children of Document are Pages
for page in doc:
    title = (
        page.Title.TitleText.Text
        if page.Title and page.Title.TitleText
        else "(untitled)"
    )
    print(f"Page: {title}")
    # Direct children of Page are Outlines (and optionally Title)
    for child in page:
        print(f"  {type(child).__name__}")

Methode 3: Dokumentbesucher

DocumentVisitor Die Datenbank ist in der Regel nicht verfügbar. VisitXxxStart/End Die Besucher werden durch Anrufen der doc.Accept(visitor):

from aspose.note import (
    Document, DocumentVisitor, Page, Title,
    Outline, OutlineElement, RichText, Image,
)

class StructurePrinter(DocumentVisitor):
    def __init__(self):
        self._depth = 0

    def _indent(self):
        return "  " * self._depth

    def VisitPageStart(self, page: Page) -> None:
        t = page.Title.TitleText.Text if page.Title and page.Title.TitleText else "(untitled)"
        print(f"{self._indent()}Page: {t!r}")
        self._depth += 1

    def VisitPageEnd(self, page: Page) -> None:
        self._depth -= 1

    def VisitOutlineStart(self, outline) -> None:
        self._depth += 1

    def VisitOutlineEnd(self, outline) -> None:
        self._depth -= 1

    def VisitRichTextStart(self, rt: RichText) -> None:
        if rt.Text.strip():
            print(f"{self._indent()}Text: {rt.Text.strip()!r}")

    def VisitImageStart(self, img: Image) -> None:
        print(f"{self._indent()}Image: {img.FileName!r} ({img.Width}x{img.Height}pts)")

doc = Document("MyNotes.one")
doc.Accept(StructurePrinter())

Verfügbare Besuchermethoden

Methodenpaar	Knotenart
`VisitDocumentStart/End`	`Document`
`VisitPageStart/End`	`Page`
`VisitTitleStart/End`	`Title`
`VisitOutlineStart/End`	`Outline`
`VisitOutlineElementStart/End`	`OutlineElement`
`VisitRichTextStart/End`	`RichText`
`VisitImageStart/End`	`Image`

Auf dem Baum navigieren

Jeder Knoten zeigt sich . ParentNode und a Document Eigenschaft, nach oben zu navigieren:

from aspose.note import Document, RichText

doc = Document("MyNotes.one")
for rt in doc.GetChildNodes(RichText):
    parent = rt.ParentNode   # OutlineElement, TableCell, Title, etc.
    root = rt.Document       # always the Document root
    print(f"  '{rt.Text.strip()!r}' parent={type(parent).__name__}")
    break

Methoden zur Betreuung von Kindern

CompositeNode Die Datenbank ist in der Lage, die Informationen zu verarbeiten und umzusetzen. .one nicht unterstützt wird):

Verfahren	Beschreibung
`node.FirstChild`	Erster unmittelbarer Kind oder `None`
`node.LastChild`	Letztes unmittelbares Kind oder `None`
`node.AppendChildLast(child)`	Hinzufügen von Kind am Ende
`node.AppendChildFirst(child)`	Kind am Anfang hinzufügen
`node.InsertChild(index, child)`	Einfügen in Position
`node.RemoveChild(child)`	Entfernen Sie ein Kind .

Noten mit einem Besucher zählen

from aspose.note import Document, DocumentVisitor, Page, RichText, Image

class Counter(DocumentVisitor):
    def __init__(self):
        self.pages = self.texts = self.images = 0

    def VisitPageStart(self, page: Page) -> None:
        self.pages += 1

    def VisitRichTextStart(self, rt: RichText) -> None:
        self.texts += 1

    def VisitImageStart(self, img: Image) -> None:
        self.images += 1

doc = Document("MyNotes.one")
c = Counter()
doc.Accept(c)
print(f"Pages={c.pages}  RichText={c.texts}  Images={c.images}")

Die richtige Überfahrtsmethode wählen

Szenario	Beste Vorgehensweise
Alle Knoten eines Typs finden (z. B. alle RichText)	`GetChildNodes(RichText)`
Iterative direkte Kinder (nicht rekursiv)	`for child in node`
Den Baum mit dem Kontext durchlaufen (Tiefe, Elternzustand)	`DocumentVisitor`
Navigieren von Inhalt bis zum Eltern- oder Root-Dateienstück	`node.ParentNode` / `node.Document`

Verwandte Ressourcen: