Upptäck ändringar i numrering när du jämför Word‑filer i Python

När du jämför två Word‑filer och den enda skillnaden är hur en lista är numrerad, till exempel att klausuler som var 1. och 2. nu är a. och b., eller att en numrerad lista har blivit en punktlista, rapporterar Aspose.Words inga skillnader som standard. Den här handledningen visar hur du upptäcker förändringar i numrering när du jämför Word‑filer i Python. Den förklarar också hur du granskar, accepterar eller förkastar de förändringar som den hittar.

Viktiga slutsatser

• Som standard ger en ändring av en listas numreringsstil eller punkttecken inga revisioner när du jämför Word‑filer.
• Om du sätter options.advanced_options.compare_list_definitions = True rapporteras varje påverkad listparagraf som en FORMAT_CHANGE‑revision.
• Textändringar i listobjekt rapporteras oavsett. Alternativet lägger bara till ändringar i numrering och punkttecken ovanpå.
• ignore_formatting=True döljer numreringsändringar även när alternativet är aktiverat.

Varför nummerändringar inte visas som standard

Numrering och punktlistor i Word kommer från en listdefinition. Den beskriver hur varje listnivå ser ut: nummerformatet (1., a., i.), punkttecknet och relaterad formatering. När du jämför dokument, Aspose.Words följer Microsoft Word som standard och utesluter listdefinitioner från jämförelsen. Så om endast numreringen ändrades ser jämförelsen inget att rapportera.

Alternativet compare_list_definitions har ingen motsvarighet i Word. Det talar Aspose.Words att inkludera listdefinitioner i jämförelsen. Här är vad vi såg när vi jämförde två‑objektslistor i version 26.9:

Den sista raden spelar roll i praktiken. Att slå på alternativet skapar inte extra revisioner för listor som är identiska i båda filerna.

Förutsättningar

Du behöver Aspose.Words for Python via .NET 26.9 eller senare. Installera eller uppgradera den från PyPI:

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

Utan en licens kör Aspose.Words i utvärderingsläge med begränsningar. En tillfällig licens tar bort dem medan du testar.

Se skillnaden: Numrering förändras med och utan alternativet

Följande skript skapar två dokument som innehåller samma två objekt. Det första använder en numrerad lista och det andra en punktlista. Det jämför dem två gånger, en gång med alternativet avstängt och en gång med det påslaget, så att du kan se exakt vad alternativet ändrar.

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

När skriptet körs skrivs:

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

Så fungerar koden

• build_list_document använder DocumentBuilder.list_format för att starta en standardnumrerad eller punktlista, skriver två objekt och anropar sedan remove_numbers() så att efterföljande stycken inte är en del av listan.
• CompareOptions.advanced_options exponerar compare_list_definitions, som har standardvärdet False.
• original.compare(...) jämför original med edited och registrerar skillnaderna som revisioner i original. Metoden returnerar None, så läs alltid resultaten från dokumentet du anropade den på.
• Varje revisions parent_node är liststycket vars formatering ändrades. revision_type är RevisionType.FORMAT_CHANGE för nummer- och punktändringar.

Upptäck numreringsändringar mellan två Word-filer

I ett verkligt arbetsflöde jämför du två befintliga filer, till exempel två versioner av ett kontrakt. Dessa jämförelser innehåller vanligtvis också andra revisioner, så skriptet nedan behåller endast formateringsändringarna som finns på listparagrafer.

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

I vårt test ändrade version 2 av kontraktet en numrerad lista till punkter och gjorde även en orelaterad mening fetstil. Utdata var:

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

Filtret plockar ut de två listobjekten och hoppar över den fetstilade ändringen, eftersom den revisionen sitter på text snarare än på ett listavsnitt. Tänk på att den matchar alla formateringsändringar på paragrafnivå i ett listobjekt, såsom en ändrad indragning, inte bara numrering. Kontrollera det sparade dokumentet om du behöver skilja dem åt.

Granska, acceptera eller avvisa numreringsändringar

Eftersom numreringsändringar är vanliga formatändringar hanterar du dem på samma sätt som alla andra revisioner:

• revisions.accept_all() tillämpar den redigerade listformateringen. I det första exemplet blir båda objekten punktlistor.
• revisions.reject_all() behåller den ursprungliga formateringen, så objekten förblir numrerade 1. och 2..
• Att spara dokumentet skriver revisionerna som spårade ändringar, så granskare kan öppna filen i Microsoft Word och själva besluta om varje ändring.

Du kan också anropa accept() eller reject() på enskilda Revision‑objekt, till exempel endast på objekten i list_changes‑listan från föregående avsnitt.

När du ska upptäcka numreringsändringar

Aktivera alternativet när numreringen av en lista har betydelse för dina granskare. Juridiska och policydokument är ett vanligt exempel: att omnumrera klausuler från 1. till (a) ändrar hur andra dokument refererar till dem, så en granskare behöver se det. Det är också användbart när du migrerar dokument mellan system och vill bekräfta att listnumreringen överlevde flytten oförändrad.

Lämna det av när du bara bryr dig om formuleringen. Innehållsgranskningar, översättningskontroller och textnivå-diffar är lättare att läsa utan att formateringsrevisioner blandas in.

Saker att hålla utkik efter

• ignore_formatting åsidosätter alternativet. Om du sätter options.ignore_formatting = True rapporteras inte nummerändringar, även med compare_list_definitions = True.
• Filer får inte innehålla revisioner innan du jämför dem. Om något av dokumenten redan har spårade ändringar, kastar compare ett RuntimeError som säger att jämförda dokument inte får ha revisioner. Acceptera eller förkasta befintliga revisioner först. Detta innebär också att du inte kan köra en andra jämförelse på ett dokument som redan innehåller resultaten från den första; ladda om filerna varje gång.
• Andra revisioner visas fortfarande. Infogad eller raderad text i ett listobjekt rapporteras oavsett om alternativet är på eller av, så kontrollera revision_type om du behöver skilja på nummerändringar och textändringar.

Nästa steg

Artikeln Compare Documents i Aspose.Words for Python-dokumentationen täcker de andra jämförelsinställningarna, inklusive granularitet, jämförelsesmålet och ignoreringsalternativen.

FAQs

1. Varför upptäcker inte Aspose.Words ändringar i numrering när man jämför Word-filer? Som standard följer Aspose.Words Microsoft Word och lämnar listdefinitioner, såsom numreringsstil eller punkttecken, utanför jämförelsen. En lista som ändras från siffror till punkter ger inga revisioner om du inte aktiverar compare_list_definitions.

2. Hur upptäcker jag numreringsändringar i Python? Skapa CompareOptions, sätt options.advanced_options.compare_list_definitions till True och skicka alternativen till Document.compare. Varje listparagraf vars numrering eller punkt har ändrats får en FORMAT_CHANGE-revision.

3. Vilken typ av revision skapar en numreringsändring? Varje påverkad listparagraf får en revision av typen RevisionType.FORMAT_CHANGE. Att acceptera den tillämpar den redigerade filens listformatering, och att avvisa den behåller originalet.

4. Fungerar alternativet tillsammans med ignore_formatting? Nej. När CompareOptions.ignore_formatting är True, rapporteras inte nummerändringar, även om compare_list_definitions är True.

5. Vad returnerar Document.compare? Ingenting. Den skriver skillnaderna som revisioner i dokumentet du anropar den på, så läser du dem från dokumentets revisions-samling.

6. Vilken version av Aspose.Words for Python lade till detta alternativ? Egenskapen compare_list_definitions i AdvancedCompareOptions lades till i Aspose.Words for Python via .NET 26.9.

Få en gratis licens och support

• Gratis tillfällig licens
• Dokumentation
• API-referens
• Aspose.Words Supportforum