Die Dokumentenanalyse ist in vielen Bereichen – von der akademischen Forschung bis zur Unternehmensverwaltung – unerlässlich. Besonders Microsoft Word-Dokumente (.docx) enthalten oft wertvolle Kommentare, die Feedback, Anmerkungen oder Diskussionen dokumentieren. Doch wie sammelt man diese Informationen effizient aus einer Vielzahl von Dateien? In diesem Blogbeitrag stelle ich eine Python-Anwendung mit einer modernen PyQt6-Oberfläche vor, die genau das tut: Sie extrahiert Kommentare aus .docx-Dateien und speichert sie in einer übersichtlichen Excel-Tabelle. Mit Fortschrittsbalken, intuitiver Bedienung und robuster Fehlerbehandlung ist dieses Tool ein echter Zeitsparer.

Was macht das Tool?

Das Programm durchsucht einen Ordner (inklusive Unterordner) nach .docx-Dateien, extrahiert Kommentare (Autor, Datum, Text) und speichert sie in einer Excel-Datei. Die GUI sorgt für eine benutzerfreundliche Erfahrung, während der optimierte Code auch größere Dateimengen effizient verarbeitet.

Installation

Um das Tool zu nutzen, benötigst du folgende Python-Bibliotheken:

• PyQt6: Für die grafische Benutzeroberfläche.
• lxml: Zum Parsen der XML-Struktur in .docx-Dateien.
• pandas: Zur Erstellung der Excel-Tabelle.
• openpyxl: Als Engine zum Schreiben von Excel-Dateien.

Installiere sie mit diesem Befehl in deiner Kommandozeile:

bash

pip install PyQt6 lxml pandas openpyxl

Stelle sicher, dass du Python 3.8+ installiert hast, da PyQt6 mit älteren Versionen nicht kompatibel ist.

Der Quellcode

Hier ist der vollständige, optimierte Code:

python

import os
import sys
import zipfile
from lxml import etree
import pandas as pd
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QPushButton, 
                             QLabel, QFileDialog, QProgressBar, QMessageBox)
from PyQt6.QtCore import Qt

class CommentExtractorApp(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("DOCX Kommentar-Extraktor")
        self.setGeometry(100, 100, 600, 300)
        self.init_ui()

    def init_ui(self):
        main_widget = QWidget()
        self.setCentralWidget(main_widget)
        layout = QVBoxLayout(main_widget)

        self.label = QLabel("Wähle einen Ordner mit DOCX-Dateien aus:")
        self.label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(self.label)

        self.select_button = QPushButton("Ordner auswählen")
        self.select_button.clicked.connect(self.select_folder)
        layout.addWidget(self.select_button)

        self.progress_bar = QProgressBar()
        self.progress_bar.setVisible(False)
        layout.addWidget(self.progress_bar)

        self.status_label = QLabel("")
        self.status_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
        layout.addWidget(self.status_label)

        layout.addStretch()

    def select_folder(self):
        folder_path = QFileDialog.getExistingDirectory(self, "Ordner auswählen")
        if not folder_path:
            return

        self.label.setText(f"Ausgewählter Ordner: {folder_path}")
        self.select_button.setEnabled(False)
        self.progress_bar.setVisible(True)
        self.status_label.setText("Verarbeitung läuft...")

        comments_list = process_folder(folder_path, self.update_progress)
        output_path = os.path.join(folder_path, "Kommentare_protokoll.xlsx")
        save_to_excel(comments_list, output_path)

        self.progress_bar.setValue(100)
        self.status_label.setText(f"Abgeschlossen! Protokoll gespeichert unter: {output_path}")
        QMessageBox.information(self, "Erfolg", f"Kommentare wurden in '{output_path}' gespeichert.")
        self.select_button.setEnabled(True)

    def update_progress(self, value, total):
        self.progress_bar.setMaximum(total)
        self.progress_bar.setValue(value)
        QApplication.processEvents()

def extract_comments_from_docx(docx_path):
    """Extrahiert Kommentare aus einer DOCX-Datei."""
    try:
        with zipfile.ZipFile(docx_path, 'r') as docx_zip:
            if 'word/comments.xml' not in docx_zip.namelist():
                print(f"Keine Kommentare in {docx_path}")
                return []

            comments_xml = docx_zip.read('word/comments.xml')
            tree = etree.fromstring(comments_xml)
            ns = {'w': 'http://schemas.openxmlformats.org/wordprocessingml/2006/main'}

            return [
                {
                    'author': comment.get(f'{{{ns["w"]}}}author') or 'Unbekannt',
                    'date': comment.get(f'{{{ns["w"]}}}date') or 'Kein Datum',
                    'text': ''.join(t.text or '' for t in comment.xpath('.//w:p//w:t', namespaces=ns))
                }
                for comment in tree.xpath('//w:comment', namespaces=ns)
            ]
    except Exception as e:
        print(f"Fehler bei {docx_path}: {e}")
        return []

def process_folder(folder_path, progress_callback=None):
    """Verarbeitet alle DOCX-Dateien im Ordner und gibt eine Kommentarliste zurück."""
    comments_list = []
    docx_files = [os.path.join(root, file) 
                  for root, _, files in os.walk(folder_path) 
                  for file in files if file.endswith('.docx')]

    for i, docx_path in enumerate(docx_files, 1):
        print(f"Verarbeite: {docx_path}")
        comments = extract_comments_from_docx(docx_path)
        comments_list.extend({
            'Dateipfad': docx_path,
            'Author': c['author'],
            'Date': c['date'],
            'Comment': c['text']
        } for c in comments)

        if progress_callback:
            progress_callback(i, len(docx_files))

    return comments_list

def save_to_excel(comments_list, output_path):
    """Speichert die Kommentare in einer Excel-Datei."""
    try:
        pd.DataFrame(comments_list).to_excel(output_path, index=False)
        print(f"Gespeichert: {output_path}")
    except Exception as e:
        print(f"Fehler beim Speichern: {e}")

def main():
    app = QApplication(sys.argv)
    window = CommentExtractorApp()
    window.show()
    sys.exit(app.exec())

if __name__ == "__main__":
    main()

Speichere diesen Code in einer Datei, z. B. comment_extractor.py, und starte ihn mit python comment_extractor.py.

Einsatzszenarien

Dieses Tool ist vielseitig einsetzbar. Hier sind einige Beispiele:

1. Akademische Forschung
   Wissenschaftler können Kommentare aus Peer-Reviews oder Entwürfen sammeln, um Feedback zu analysieren. Kombiniere es mit Tools wie Mendeley für Literaturverwaltung.
2. Projektmanagement
   Teams, die Microsoft Teams oder SharePoint nutzen, können Kommentare aus gemeinsam bearbeiteten Dokumenten extrahieren, um Entscheidungen nachzuvollziehen.
3. Rechtswesen
   Juristen können Anmerkungen aus Vertragsentwürfen sammeln, um Änderungsvorschläge zu konsolidieren. Ergänze es mit Tools wie DocuSign für digitale Workflows.
4. Bildung
   Lehrer können Schüler-Feedback aus Hausarbeiten analysieren und so den Lernfortschritt dokumentieren. Nutze es mit Google Classroom für eine hybride Umgebung.
5. Qualitätskontrolle
   Unternehmen können Prüfberichte mit Kommentaren auswerten, um Schwachstellen in Prozessen zu identifizieren. Integriere es mit Power BI für visuelle Analysen.
6. Verlagsbranche
   Lektoren können Autoren-Feedback aus Manuskripten extrahieren, um den Bearbeitungsprozess zu optimieren. Kombiniere es mit Adobe InDesign für Layout-Workflows.

Warum dieses Tool nutzen?

• Automatisierung: Spart Stunden manueller Arbeit.
• Flexibilität: Funktioniert mit beliebig vielen Dateien und Ordnern.
• Integration: Die Excel-Ausgabe lässt sich leicht in Tools wie Excel Online oder Google Sheets importieren.
• Open Source: Der Code ist anpassbar – füge z. B. Filter für Autoren oder Datum hinzu.

Erweiterungsmöglichkeiten

• Filterfunktionen: Ergänze eine GUI-Option, um nur Kommentare bestimmter Autoren anzuzeigen.
• Cloud-Integration: Verbinde es mit Dropbox oder Google Drive für direkten Zugriff auf Dateien.
• Visualisierung: Exportiere die Daten in Matplotlib oder Seaborn für Diagramme.

Fazit

Die Kombination aus Dokumentenanalyse und moderner GUI macht dieses Tool zu einem wertvollen Helfer für alle, die mit kommentierten Word-Dateien arbeiten. Egal, ob du Feedback sammelst, Prozesse dokumentierst oder Daten analysierst – dieses Skript bietet eine solide Basis, die du nach Belieben erweitern kannst.