Aspose.Note FOSS
Python
Como cruzar o DOM do documento OneNote em Python

Como cruzar o DOM do documento OneNote em Python

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, iteração direta, e DocumentVisitor.

Modelo de objeto do documento

O DOM do OneNote é uma árvore estrita:

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

Cada nó herda de Node.Nodos que têm filhos herdados de . CompositeNode.

Método 1: GetChildNodes (Recursivo, Filtrado por Tipo)

CompositeNode.GetChildNodes(Type) executa uma pesquisa recursiva de profundidade-primeira da subárvore inteira e retorna uma lista plana de todos os nós que correspondem ao tipo dado. Esta é a abordagem mais conveniente para extração de conteúdo:

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)}")

Ampliar a pesquisa para uma única página chamando GetChildNodes em 1 de Setembro de Page em vez de: 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")

Método 2: Iteração directa de filhos

for child in node Iteração do imediato filhos de um CompositeNode.Use isto quando precisar de um nível específico da hierarquia:

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__}")

Método 3: DocumentVisitor

DocumentVisitor fornece um padrão de visitante para a travessa estruturada. VisitXxxStart/End O visitante é despachado através de um telefone. 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())

Métodos de visita disponíveis

Par de métodosTipo de nó
VisitDocumentStart/EndDocument
VisitPageStart/EndPage
VisitTitleStart/EndTitle
VisitOutlineStart/EndOutline
VisitOutlineElementStart/EndOutlineElement
VisitRichTextStart/EndRichText
VisitImageStart/EndImage

Navegação até a árvore

Todos os nós expõem ParentNode e a Document propriedade para navegar em direcção ao alto:

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

Métodos de gestão dos filhos

CompositeNode também expõe a gestão de crianças em memória (útil para a construção de documentos programáticos, embora o write-back para .one não é suportado):

Método de avaliaçãoDescrição:
node.FirstChildPrimeiro filho direto ou None
node.LastChildÚltimo filho direto ou None
node.AppendChildLast(child)Adicionar criança no final
node.AppendChildFirst(child)Adicionar criança no início
node.InsertChild(index, child)Insiração em posição
node.RemoveChild(child)Remova uma criança.

Contar Nodos com um Visitante 

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}")

Escolher o método certo de atravessamento

Cenário:Melhor abordagem
Encontre todos os nós de um tipo (por exemplo, todo o RichText)GetChildNodes(RichText)
Crianças directas iteradas (não recursivas)for child in node
Caminhar na árvore com contexto (profundidade, estado pai)DocumentVisitor
Navegue do conteúdo até o pai ou raiznode.ParentNode / node.Document

Recursos relacionados:

Ver também:

 Português