זיהוי שינויי מספור בעת השוואת קבצי Word ב-Python

כאשר אתה משווה שני קבצי Word וההבדל היחיד הוא איך רשימה ממוספרת, לדוגמה סעיפים שהיו 1. ו-2. הפכו ל-a. ו-b., או שרשימה ממוספרת הפכה לרשימה עם תבליטים, Aspose.Words מדווחת שאין הבדלים כברירת מחדל. מדריך זה מראה לך כיצד לאתר שינויי מספור בעת השוואת קבצי Word ב-Python. הוא גם מסביר כיצד לסקור, לקבל או לדחות את השינויים שהיא מוצאת.

נקודות מרכזיות

• בברירת מחדל, שינוי בסגנון המספור של רשימה או בתו הכדור אינו יוצר שינויים כאשר משווים קבצי Word.
• הגדרת options.advanced_options.compare_list_definitions = True מדווחת על כל פסקת רשימה מושפעת כחלופה FORMAT_CHANGE.
• שינויים בטקסט בתוך פריטי רשימה מדווחים בכל מקרה. האפשרות מוסיפה רק שינויים במספור ובתווי הכדור.
• ignore_formatting=True מסתיר שינויים במספור גם כאשר האפשרות מופעלת.

למה שינויים במספור אינם מופיעים כברירת מחדל

המספור והכדורים ב‑Word נובעים מהגדרת רשימה. היא מתארת כיצד נראה כל רמת רשימה: סגנון המספר (1., a., i.), תו הכדור, ועיצוב קשור. כאשר משווים מסמכים, Aspose.Words פועל לפי Microsoft Word כברירת מחדל ומשאיר את הגדרות הרשימה מחוץ להשוואה. ולכן אם השתנה רק המספור, ההשוואה לא תראה דבר לדווח.

לאפשרות compare_list_definitions אין מקבילה ב‑Word. היא מודיעה ל‑Aspose.Words לכלול הגדרות רשימות בהשוואה. הנה מה שראינו בעת השוואת רשימות של שני פריטים בגרסה 26.9:

השורה האחרונה חשובה בפועל. הפעלת האפשרות אינה יוצרת גרסאות נוספות עבור רשימות שהן זהות בשני הקבצים.

דרישות מוקדמות

אתה צריך Aspose.Words for Python via .NET 26.9 או גרסה מאוחרת יותר. התקן או עדכן אותו מ‑PyPI:

pip install --upgrade "aspose-words>=26.9"

ללא רישיון, Aspose.Words פועל במצב הערכה עם מגבלות. רישיון זמני מסיר אותם בזמן שאתה בודק.

ראה את ההבדל: שינויי המספור עם ובלי האפשרות

הסקריפט הבא בונה שני מסמכים שמכילים את אותם שני פריטים. הראשון משתמש ברשימה ממוספרת, והשני משתמש ברשימה עם תבליטים. הוא משווה ביניהם פעמיים, פעם עם האפשרות כבויה ופעם עם האפשרות דלוקה, כך שתוכל לראות בדיוק מה משנה האפשרות.

import datetime
import aspose.words as aw

def build_list_document(bulleted: bool) -> aw.Document:
    """Create a two-item list, either numbered or bulleted."""
    doc = aw.Document()
    builder = aw.DocumentBuilder(doc=doc)
    if bulleted:
        builder.list_format.apply_bullet_default()
    else:
        builder.list_format.apply_number_default()
    builder.writeln("Item 1")
    builder.writeln("Item 2")
    builder.list_format.remove_numbers()
    return doc

def compare_lists(compare_list_definitions: bool) -> aw.Document:
    original = build_list_document(bulleted=False)
    edited = build_list_document(bulleted=True)

options = aw.comparing.CompareOptions()
    options.advanced_options.compare_list_definitions = compare_list_definitions

# compare() writes revisions into `original`; it returns nothing.
    original.compare(
        document=edited,
        author="Reviewer",
        date_time=datetime.datetime.now(),
        options=options,
    )
    return original

for flag in (False, True):
    result = compare_lists(flag)
    print(f"compare_list_definitions={flag}: {result.revisions.count} revision(s)")
    for revision in result.revisions:
        revision_type = aw.RevisionType(revision.revision_type).name
        text = revision.parent_node.get_text().strip()
        print(f"  {revision_type}: {text}")

result.save("compared-lists.docx")

הפעלת הסקריפט מדפיסה:

compare_list_definitions=False: 0 revision(s)
compare_list_definitions=True: 2 revision(s)
  FORMAT_CHANGE: Item 1
  FORMAT_CHANGE: Item 2

איך הקוד עובד

• build_list_document משתמש ב-DocumentBuilder.list_format כדי להתחיל רשימה ממוספרת או עם תבליטים ברירת מחדל, כותב שני פריטים, ואז קורא ל-remove_numbers() כך שכל פסקאות מאוחרות יותר אינן חלק מהרשימה.
• CompareOptions.advanced_options חושף את compare_list_definitions, שמוגדר כברירת מחדל ל-False.
• original.compare(...) משווה את original ל-edited ורושם את ההבדלים כגרסאות בתוך original. השיטה מחזירה None, ולכן יש לקרוא תמיד את התוצאות מהמסמך שעליו קראת את השיטה.
• parent_node של כל גרסה הוא פסקת הרשימה שהעיצוב שלה השתנה. revision_type הוא RevisionType.FORMAT_CHANGE עבור שינויי מספור ותבליטים.

זיהוי שינויי מספור בין שני קבצי Word

בזרימת עבודה אמיתית, אתה משווה שני קבצים קיימים, כגון שני גרסאות של חוזה. ההשוואות הללו בדרך כלל מכילות גם תיקונים אחרים, ולכן הסקריפט שלהלן משאיר רק את שינויי העיצוב היושבים על פסקאות ברשימה.

import datetime
import aspose.words as aw

original = aw.Document("contract-v1.docx")
edited = aw.Document("contract-v2.docx")

options = aw.comparing.CompareOptions()
options.advanced_options.compare_list_definitions = True

original.compare(edited, "Reviewer", datetime.datetime.now(), options)

# Keep only formatting revisions that sit on list paragraphs.
list_changes = [
    rev for rev in original.revisions
    if rev.revision_type == aw.RevisionType.FORMAT_CHANGE
    and rev.parent_node is not None
    and rev.parent_node.node_type == aw.NodeType.PARAGRAPH
    and rev.parent_node.as_paragraph().list_format.is_list_item
]

print(f"Total revisions: {original.revisions.count}")
print(f"Formatting changes on list paragraphs: {len(list_changes)}")
for rev in list_changes:
    print(f"  {rev.parent_node.get_text().strip()}")

original.save("contract-compared.docx")

בבדיקה שלנו, גרסה 2 של החוזה שינתה רשימה ממוספרת לתבליטים וגם הפכה משפט בלתי קשור לבולד. הפלט היה:

Total revisions: 5
Formatting changes on list paragraphs: 2
  Invoices are due in 30 days.
  Late fees apply after 45 days.

המסנן בוחר את שני פריטי הרשימה ומדלג על שינוי ההדגשה, מכיוון שהגרסה הזו נמצאת על הטקסט ולא על פסקת רשימה. יש לזכור שהוא תואם לכל שינוי עיצוב ברמת פסקה בפריט רשימה, כגון שינוי הזחה, ולא רק שינוי מספרים. בדוק את המסמך השמור אם אתה צריך להבדיל ביניהם.

סקור, קבל או דחה שינויים במספור

מאחר ששינויים במספור הם תיקוני פורמט רגילים, אתה מתמודד איתם באותו האופן כמו עם כל תיקון אחר:

• revisions.accept_all() מחיל את העיצוב של הרשימה הערוכה. בדוגמה הראשונה, שני הפריטים הופכים לנקודות.
• revisions.reject_all() משאיר את העיצוב המקורי, ולכן הפריטים נשארים ממוספרים 1. ו-2..
• שמירת המסמך כותבת את השינויים כמעקב שינויים, כך שהמבקרים יכולים לפתוח את הקובץ ב-Microsoft Word ולהחליט על כל שינוי בעצמם.

אתה יכול גם לקרוא ל‑accept() או reject() על אובייקטים של Revision בנפרד, לדוגמה רק על הפריטים ברשימת list_changes מהקטע הקודם.

מתי לזהות שינויי מספור

הפעל את האפשרות כאשר המספור של רשימה נושא משמעות עבור הסוקרים שלך. מסמכי משפט ומדיניות הם מקרה נפוץ: שינוי מספור של סעיפים מ-1. ל-(a) משנה את האופן שבו מסמכים אחרים מתייחסים אליהם, ולכן סוקר צריך לראות זאת. זה גם שימושי כאשר אתה מעביר מסמכים בין מערכות ורוצה לוודא שמספור הרשימה נשאר ללא שינוי לאחר ההעברה.

השאירו זאת כבוי כאשר אתם מתמקדים רק בניסוח. ביקורות תוכן, בדיקות תרגום והבדלים ברמת הטקסט קלים יותר לקריאה ללא שינויים בעיצוב משולבים.

דברים שיש לשים לב אליהם

• ignore_formatting מבטל את האפשרות. אם אתה מגדיר options.ignore_formatting = True, שינויים במספרים אינם מדווחים, אפילו עם compare_list_definitions = True.
• קבצים לא חייבים להכיל גרסאות לפני שאתה משווה אותם. אם אחד המסמכים כבר מכיל שינויים במעקב, compare מעלה RuntimeError שאומר שהמסמכים המושווים לא יכולים להכיל גרסאות. קבל או דחה את הגרסאות הקיימות תחילה. זה גם אומר שלא ניתן לבצע השוואה שנייה על מסמך שכבר מכיל את תוצאות הראשונה; טען מחדש את הקבצים בכל פעם.
• גרסאות אחרות עדיין מופיעות. טקסט שהוכנס או הוסר בפריט רשימה מדווח גם אם האפשרות מופעלת או כבויה, ולכן יש לבדוק את revision_type אם אתה צריך להפריד בין שינויים במספרים לשינויים בניסוח.

הצעדים הבאים

המאמר השוואת מסמכים בתיעוד Aspose.Words for Python מכסה את הגדרות ההשוואה האחרות, כולל גרנולריות, יעד ההשוואה, ואפשרויות ההתעלמות.

שאלות נפוצות

1. למה Aspose.Words לא מזהה שינויי מספור בעת השוואת קבצי Word? באופן ברירת מחדל, Aspose.Words פועל לפי Microsoft Word ומשאיר את הגדרות הרשימות, כגון סגנון המספור או תו הכדור, מחוץ להשוואה. רשימה שמשתנה ממספרים לכדורים לא תיצור שינויים אלא אם תפעיל את compare_list_definitions.

2. איך אני מזהה שינויי מספור ב-Python? צור CompareOptions, הגדר options.advanced_options.compare_list_definitions ל-True, והעבר את האפשרויות ל-Document.compare. כל פסקת רשימה שהמספור או התו המוביל שלה השתנו מקבלת תיקון FORMAT_CHANGE.

3. איזה סוג של גרסה נוצר כאשר שינוי המספור? כל פסקת רשימה מושפעת מקבלת גרסה מסוג RevisionType.FORMAT_CHANGE. קבלה של הגרסה מחילה את עיצוב הרשימה של הקובץ הערוך, ודחייה משאירה את המקור.

4. האם האפשרות עובדת יחד עם ignore_formatting?
   לא. כאשר CompareOptions.ignore_formatting הוא True, שינויים במספור אינם מדווחים, אפילו אם compare_list_definitions הוא True.

5. מה מחזירה Document.compare? כלום. היא כותבת את ההבדלים כ-revisions למסמך שעליו אתה קורא אותה, ולכן אתה קורא אותם מאוסף ה-revisions של המסמך.

6. איזו גרסה של Aspose.Words for Python הוסיפה אפשרות זו? המאפיין compare_list_definitions של AdvancedCompareOptions נוסף ב‑Aspose.Words for Python via .NET 26.9.

קבל רישיון חינמי ותמיכה

• רישיון זמני חינמי
• תיעוד
• הפניות API
• פורום התמיכה של Aspose.Words