แยกข้อความจากเอกสาร Word ใน Python

การแยกข้อความจากเอกสาร Word มักดำเนินการในสถานการณ์ต่างๆ ตัวอย่างเช่น เพื่อวิเคราะห์ข้อความ เพื่อแยกส่วนเฉพาะของเอกสารและรวมเข้าด้วยกันเป็นเอกสารเดียว เป็นต้น ในบทความนี้ คุณจะได้เรียนรู้วิธีแยกข้อความจากเอกสาร Word โดยทางโปรแกรมใน Python นอกจากนี้ เราจะกล่าวถึงวิธีการแยกเนื้อหาระหว่างองค์ประกอบเฉพาะ เช่น ย่อหน้า ตาราง ฯลฯ แบบไดนามิก

Python Library เพื่อแยกข้อความจากเอกสาร Word
การแยกข้อความในเอกสาร Word
แยกข้อความจากเอกสาร Word

Python Library เพื่อแยกข้อความจากเอกสาร Word

Aspose.Words for Python เป็นไลบรารีอันทรงพลังที่ช่วยให้คุณสามารถสร้างเอกสาร MS Word ได้ตั้งแต่เริ่มต้น นอกจากนี้ ยังให้คุณจัดการเอกสาร Word ที่มีอยู่สำหรับการเข้ารหัส การแปลง การแยกข้อความ ฯลฯ เราจะใช้ไลบรารีนี้เพื่อแยกข้อความจากเอกสาร Word DOCX หรือ DOC คุณสามารถติดตั้งไลบรารีได้จาก PyPI โดยใช้คำสั่ง pip ต่อไปนี้

pip install aspose-words

การแยกข้อความในเอกสาร Word โดยใช้ Python

เอกสาร MS Word ประกอบด้วยองค์ประกอบต่างๆ ซึ่งรวมถึงย่อหน้า ตาราง รูปภาพ เป็นต้น ดังนั้นข้อกำหนดในการแยกข้อความจึงอาจแตกต่างกันไปในแต่ละสถานการณ์ ตัวอย่างเช่น คุณอาจต้องแยกข้อความระหว่างย่อหน้า ที่คั่นหน้า ความคิดเห็น ฯลฯ

องค์ประกอบแต่ละประเภทในเอกสาร Word จะแสดงเป็นโหนด ดังนั้นในการประมวลผลเอกสาร คุณจะต้องเล่นกับโหนด เรามาเริ่มกันและดูวิธีแยกข้อความจากเอกสาร Word ในสถานการณ์ต่างๆ

แยกข้อความจากเอกสาร Word ใน Python

ในส่วนนี้ เราจะใช้ Python text extractor สำหรับเอกสาร Word และขั้นตอนการทำงานของการแยกข้อความจะเป็นดังนี้:

ขั้นแรก เราจะกำหนดโหนดที่เราต้องการรวมไว้ในขั้นตอนการแยกข้อความ
จากนั้นเราจะแยกเนื้อหาระหว่างโหนดที่ระบุ (รวมถึงหรือไม่รวมโหนดเริ่มต้นและสิ้นสุด)
สุดท้าย เราจะใช้การโคลนของโหนดที่แยกออกมา เช่น เพื่อสร้างเอกสาร Word ใหม่ที่ประกอบด้วยเนื้อหาที่แยกออกมา

ตอนนี้มาเขียนเมธอดชื่อ extractcontent ซึ่งเราจะส่งโหนดและพารามิเตอร์อื่นๆ เพื่อดำเนินการแยกข้อความ วิธีนี้จะแยกวิเคราะห์เอกสารและโคลนโหนด ต่อไปนี้เป็นพารามิเตอร์ที่เราจะส่งผ่านไปยังวิธีนี้

StartNode และ EndNode เป็นจุดเริ่มต้นและจุดสิ้นสุดสำหรับการแยกเนื้อหา ตามลำดับ สิ่งเหล่านี้สามารถเป็นได้ทั้งโหนดระดับบล็อก (ย่อหน้า ตาราง) หรือระดับอินไลน์ (เช่น Run, FieldStart, BookmarkStart เป็นต้น)
1. ในการส่งฟิลด์ คุณควรส่งวัตถุ FieldStart ที่สอดคล้องกัน
2. ในการส่งผ่านบุ๊กมาร์ก ควรผ่านโหนด BookmarkStart และ BookmarkEnd
3. สำหรับความคิดเห็น ควรใช้โหนด CommentRangeStart และ CommentRangeEnd
IsInclusive กำหนดว่าเครื่องหมายรวมอยู่ในการแยกหรือไม่ หากตั้งค่าตัวเลือกนี้เป็น False และโหนดเดียวกันหรือโหนดที่ต่อเนื่องกันจะถูกส่งกลับ รายการว่างจะถูกส่งกลับ

ต่อไปนี้เป็นการนำเมธอด extractcontent ไปใช้งานโดยสมบูรณ์ซึ่งจะแยกเนื้อหาระหว่างโหนดที่ส่งผ่าน

def extract_content(startNode : aw.Node, endNode : aw.Node, isInclusive : bool):
    
    # ขั้นแรก ตรวจสอบว่าโหนดที่ส่งผ่านไปยังเมธอดนี้ถูกต้องสำหรับการใช้งาน
    verify_parameter_nodes(startNode, endNode)

    # สร้างรายการเพื่อจัดเก็บโหนดที่แยกออกมา
    nodes = []

    # หากตัวทำเครื่องหมายเป็นส่วนหนึ่งของความคิดเห็น รวมถึงความคิดเห็นด้วย เราจำเป็นต้องเลื่อนตัวชี้
    # ส่งต่อไปยังโหนดความคิดเห็นที่พบหลังจากโหนด CommentRangeEnd
    if (endNode.node_type == aw.NodeType.COMMENT_RANGE_END and isInclusive) :
        
        node = find_next_node(aw.NodeType.COMMENT, endNode.next_sibling)
        if (node != None) :
            endNode = node

    # เก็บบันทึกโหนดดั้งเดิมที่ส่งผ่านไปยังวิธีนี้เพื่อแยกโหนดเครื่องหมายหากจำเป็น
    originalStartNode = startNode
    originalEndNode = endNode

    # แยกเนื้อหาตามโหนดระดับบล็อก (ย่อหน้าและตาราง) สำรวจผ่านโหนดหลักเพื่อค้นหา
    # เราจะแบ่งเนื้อหาของโหนดแรกและโหนดสุดท้าย ขึ้นอยู่กับว่าโหนดเครื่องหมายอยู่ในบรรทัดหรือไม่
    startNode = get_ancestor_in_body(startNode)
    endNode = get_ancestor_in_body(endNode)

    isExtracting = True
    isStartingNode = True
    # โหนดปัจจุบันที่เรากำลังแยกออกจากเอกสาร
    currNode = startNode

    # เริ่มแยกเนื้อหา ประมวลผลโหนดระดับบล็อกทั้งหมดและแยกโหนดแรกโดยเฉพาะ
    # และโหนดสุดท้ายเมื่อจำเป็น ดังนั้นการจัดรูปแบบย่อหน้าจึงยังคงอยู่
    # วิธีการนี้ซับซ้อนกว่าตัวแยกข้อมูลทั่วไปเล็กน้อยเนื่องจากเราต้องแยกส่วน
    # ในการแยกโดยใช้โหนดแบบอินไลน์ ฟิลด์ บุ๊กมาร์ก ฯลฯ เพื่อให้มีประโยชน์
    while (isExtracting) :
        
        # โคลนโหนดปัจจุบันและโหนดย่อยเพื่อรับสำเนา
        cloneNode = currNode.clone(True)
        isEndingNode = currNode == endNode

        if (isStartingNode or isEndingNode) :
            
            # เราจำเป็นต้องประมวลผลเครื่องหมายแต่ละรายการแยกกัน ดังนั้นส่งต่อไปยังวิธีอื่นแทน
            # ควรดำเนินการสิ้นสุดในตอนแรกเพื่อเก็บดัชนีโหนด
            if (isEndingNode) :
                # !isStartingNode: อย่าเพิ่มโหนดสองครั้งหากเครื่องหมายเป็นโหนดเดียวกัน
                process_marker(cloneNode, nodes, originalEndNode, currNode, isInclusive, False, not isStartingNode, False)
                isExtracting = False

            # เงื่อนไขต้องแยกออกจากกันเนื่องจากเครื่องหมายเริ่มต้นและสิ้นสุดของระดับบล็อก อาจเป็นโหนดเดียวกัน
            if (isStartingNode) :
                process_marker(cloneNode, nodes, originalStartNode, currNode, isInclusive, True, True, False)
                isStartingNode = False
            
        else :
            # โหนดไม่ใช่เครื่องหมายเริ่มต้นหรือจุดสิ้นสุด เพียงเพิ่มสำเนาลงในรายการ
            nodes.append(cloneNode)

        # ย้ายไปยังโหนดถัดไปและแตกไฟล์ หากโหนดถัดไปไม่มี
        # เนื้อหาที่เหลืออยู่ในส่วนอื่น
        if (currNode.next_sibling == None and isExtracting) :
            # ย้ายไปยังส่วนถัดไป
            nextSection = currNode.get_ancestor(aw.NodeType.SECTION).next_sibling.as_section()
            currNode = nextSection.body.first_child
            
        else :
            # ย้ายไปยังโหนดถัดไปในเนื้อหา
            currNode = currNode.next_sibling
            
    # เพื่อความเข้ากันได้กับโหมดที่มีบุ๊กมาร์กแบบอินไลน์ ให้เพิ่มย่อหน้าถัดไป (ว่าง)
    if (isInclusive and originalEndNode == endNode and not originalEndNode.is_composite) :
        include_next_paragraph(endNode, nodes)

    # ส่งกลับโหนดระหว่างเครื่องหมายโหนด
    return nodes

วิธีตัวช่วยบางอย่างจำเป็นต้องใช้โดยวิธี extractcontent เพื่อดำเนินการแยกข้อความให้สำเร็จ ซึ่งแสดงไว้ด้านล่าง

def verify_parameter_nodes(start_node: aw.Node, end_node: aw.Node):

    # ลำดับในการตรวจสอบเหล่านี้มีความสำคัญ
    if start_node is None:
        raise ValueError("Start node cannot be None")
    if end_node is None:
        raise ValueError("End node cannot be None")

    if start_node.document != end_node.document:
        raise ValueError("Start node and end node must belong to the same document")

    if start_node.get_ancestor(aw.NodeType.BODY) is None or end_node.get_ancestor(aw.NodeType.BODY) is None:
        raise ValueError("Start node and end node must be a child or descendant of a body")

    # ตรวจสอบว่าโหนดสิ้นสุดอยู่หลังโหนดเริ่มต้นในแผนผัง DOM
    # ขั้นแรก ให้ตรวจสอบว่าพวกเขาอยู่ในส่วนต่างๆ หรือไม่ จากนั้นหากไม่ใช่
    # ตรวจสอบตำแหน่งของพวกเขาในเนื้อหาของส่วนเดียวกัน
    start_section = start_node.get_ancestor(aw.NodeType.SECTION).as_section()
    end_section = end_node.get_ancestor(aw.NodeType.SECTION).as_section()

    start_index = start_section.parent_node.index_of(start_section)
    end_index = end_section.parent_node.index_of(end_section)

    if start_index == end_index:

        if (start_section.body.index_of(get_ancestor_in_body(start_node)) >
            end_section.body.index_of(get_ancestor_in_body(end_node))):
            raise ValueError("The end node must be after the start node in the body")

    elif start_index > end_index:
        raise ValueError("The section of end node must be after the section start node")

 
def find_next_node(node_type: aw.NodeType, from_node: aw.Node):

    if from_node is None or from_node.node_type == node_type:
        return from_node

    if from_node.is_composite:

        node = find_next_node(node_type, from_node.as_composite_node().first_child)
        if node is not None:
            return node

    return find_next_node(node_type, from_node.next_sibling)

 
def is_inline(node: aw.Node):

    # ทดสอบว่าโหนดนั้นสืบทอดมาจากโหนดย่อหน้าหรือตารางและไม่ใช่ย่อหน้าหรือไม่
    # หรือตารางย่อหน้าในคลาสความคิดเห็นที่เหมาะสมของย่อหน้าก็เป็นไปได้
    return ((node.get_ancestor(aw.NodeType.PARAGRAPH) is not None or node.get_ancestor(aw.NodeType.TABLE) is not None) and
            not (node.node_type == aw.NodeType.PARAGRAPH or node.node_type == aw.NodeType.TABLE))

 
def process_marker(clone_node: aw.Node, nodes, node: aw.Node, block_level_ancestor: aw.Node,
    is_inclusive: bool, is_start_marker: bool, can_add: bool, force_add: bool):

    # หากเรากำลังจัดการกับโหนดระดับบล็อก ให้ดูว่าควรรวมและเพิ่มลงในรายการหรือไม่
    if node == block_level_ancestor:
        if can_add and is_inclusive:
            nodes.append(clone_node)
        return

    # cloneNode เป็นโคลนของ blockLevelNode ถ้าโหนด != blockLevelNode, blockLevelAncestor
    # เป็นบรรพบุรุษของโหนดซึ่งหมายความว่าเป็นโหนดคอมโพสิต
    assert clone_node.is_composite

    # หากเครื่องหมายเป็นโหนด FieldStart ให้ตรวจสอบว่าจำเป็นต้องรวมหรือไม่
    # เราถือว่า FieldStart และ FieldEnd ปรากฏในย่อหน้าเดียวกันเพื่อความง่าย
    if node.node_type == aw.NodeType.FIELD_START:
        # ถ้าเครื่องหมายเป็นโหนดเริ่มต้นและไม่ได้รวมอยู่ ให้ข้ามไปที่จุดสิ้นสุดของฟิลด์
        # หากเครื่องหมายเป็นโหนดสิ้นสุดและจะรวมอยู่ด้วย ให้ย้ายไปยังฟิลด์สิ้นสุดเพื่อไม่ให้ฟิลด์ถูกลบออก
        if is_start_marker and not is_inclusive or not is_start_marker and is_inclusive:
            while node.next_sibling is not None and node.node_type != aw.NodeType.FIELD_END:
                node = node.next_sibling

    # รองรับกรณีและปัญหาหากโหนดเครื่องหมายอยู่ที่ระดับที่สามของเนื้อหาเอกสารหรือต่ำกว่า
    node_branch = fill_self_and_parents(node, block_level_ancestor)

    # ประมวลผลโหนดที่เกี่ยวข้องในโหนดโคลนของเราตามดัชนี
    current_clone_node = clone_node
   for i in range(len(node_branch) - 1, -1):

        current_node = node_branch[i]
        node_index = current_node.parent_node.index_of(current_node)
        current_clone_node = current_clone_node.as_composite_node.child_nodes[node_index]

        remove_nodes_outside_of_range(current_clone_node, is_inclusive or (i > 0), is_start_marker)

    # หลังจากการประมวลผล โหนดคอมโพสิตอาจว่างเปล่าหากไม่ได้รวมไว้
    if can_add and (force_add or clone_node.as_composite_node().has_child_nodes):
        nodes.append(clone_node)

 
def remove_nodes_outside_of_range(marker_node: aw.Node, is_inclusive: bool, is_start_marker: bool):

    is_processing = True
    is_removing = is_start_marker
    next_node = marker_node.parent_node.first_child

    while is_processing and next_node is not None:

        current_node = next_node
        is_skip = False

        if current_node == marker_node:
            if is_start_marker:
                is_processing = False
                if is_inclusive:
                    is_removing = False
            else:
                is_removing = True
                if is_inclusive:
                    is_skip = True

        next_node = next_node.next_sibling
        if is_removing and not is_skip:
            current_node.remove()

 
def fill_self_and_parents(node: aw.Node, till_node: aw.Node):

    nodes = []
    current_node = node

    while current_node != till_node:
        nodes.append(current_node)
        current_node = current_node.parent_node

    return nodes

 
def include_next_paragraph(node: aw.Node, nodes):

    paragraph = find_next_node(aw.NodeType.PARAGRAPH, node.next_sibling).as_paragraph()
    if paragraph is not None:

        # ย้ายไปที่ลูกคนแรกเพื่อรวมย่อหน้าโดยไม่มีเนื้อหา
        marker_node = paragraph.first_child if paragraph.has_child_nodes else paragraph
        root_node = get_ancestor_in_body(paragraph)

        process_marker(root_node.clone(True), nodes, marker_node, root_node,
            marker_node == paragraph, False, True, True)

 
def get_ancestor_in_body(start_node: aw.Node):

    while start_node.parent_node.node_type != aw.NodeType.BODY:
        start_node = start_node.parent_node
    return start_node
def generate_document(src_doc: aw.Document, nodes):

    dst_doc = aw.Document()
    # ลบย่อหน้าแรกออกจากเอกสารเปล่า
    dst_doc.first_section.body.remove_all_children()

    # นำเข้าแต่ละโหนดจากรายการไปยังเอกสารใหม่ รักษารูปแบบเดิมของโหนด
    importer = aw.NodeImporter(src_doc, dst_doc, aw.ImportFormatMode.KEEP_SOURCE_FORMATTING)

   for node in nodes:
        import_node = importer.import_node(node, True)
        dst_doc.first_section.body.append_child(import_node)

    return dst_doc

 
def paragraphs_by_style_name(doc: aw.Document, style_name: str):

    paragraphs_with_style = []
    paragraphs = doc.get_child_nodes(aw.NodeType.PARAGRAPH, True)

   for paragraph in paragraphs:
        paragraph = paragraph.as_paragraph()
        if paragraph.paragraph_format.style.name == style_name:
            paragraphs_with_style.append(paragraph)

    return paragraphs_with_style

ตอนนี้เราพร้อมที่จะใช้วิธีการเหล่านี้และดึงข้อความจากเอกสาร Word แล้ว

แยกข้อความระหว่างย่อหน้าในเอกสาร Word

มาดูวิธีการแยกเนื้อหาระหว่างสองย่อหน้าในเอกสาร Word DOCX ต่อไปนี้เป็นขั้นตอนในการดำเนินการนี้ใน Python

ขั้นแรก ให้โหลดเอกสาร Word โดยใช้คลาส Document
รับการอ้างอิงของย่อหน้าเริ่มต้นและสิ้นสุดเป็นสองวัตถุโดยใช้เมธอด Document.firstsection.body.getchild(NodeType.PARAGRAPH, int, boolean).asparagraph()
เรียกใช้เมธอด extractcontent (startPara, endPara, True) เพื่อแยกโหนดออกเป็นวัตถุ
เรียกใช้เมธอดตัวช่วยที่ถูกสร้างขึ้น (Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
สุดท้าย บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(string)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีแยกข้อความระหว่างย่อหน้าที่ 7 และ 11 ในเอกสาร Word ใน Python

# โหลดเอกสาร
doc = aw.Document("Extract content.docx")

# กำหนดย่อหน้าเริ่มต้นและสิ้นสุด
startPara = doc.first_section.body.get_child(aw.NodeType.PARAGRAPH, 6, True).as_paragraph()
endPara = doc.first_section.body.get_child(aw.NodeType.PARAGRAPH, 10, True).as_paragraph()

# แยกเนื้อหาระหว่างย่อหน้าเหล่านี้ในเอกสาร รวมเครื่องหมายเหล่านี้ในการแยก
extractedNodes = extract_content(startPara, endPara, True)

# สร้างเอกสารที่มีเนื้อหาที่แยกออกมา
dstDoc = generate_document(doc, extractedNodes)

# บันทึกเอกสาร
dstDoc.save("extract_content_between_paragraphs.docx")

แยกข้อความระหว่างโหนดประเภทต่างๆ ในเอกสาร Word

คุณยังสามารถแยกเนื้อหาระหว่างโหนดประเภทต่างๆ สำหรับการสาธิต ลองแยกเนื้อหาระหว่างย่อหน้าและตารางแล้วบันทึกลงในเอกสาร Word ใหม่ ต่อไปนี้เป็นขั้นตอนในการดำเนินการนี้

โหลดเอกสาร Word โดยใช้คลาส Document
รับการอ้างอิงของโหนดเริ่มต้นและสิ้นสุดเป็นสองวัตถุโดยใช้เมธอด Document.firstsection.body.getchild(NodeType, int, boolean)
เรียกใช้เมธอด extractcontent (startPara, endPara, True) เพื่อแยกโหนดออกเป็นวัตถุ
เรียกใช้เมธอดตัวช่วยที่ถูกสร้างขึ้น (Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(string)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการแยกข้อความระหว่างย่อหน้าและตารางใน Python

# โหลดเอกสาร
doc = aw.Document("Extract content.docx")

# กำหนดโหนดเริ่มต้นและสิ้นสุด
start_para = doc.last_section.get_child(aw.NodeType.PARAGRAPH, 2, True).as_paragraph()
end_table = doc.last_section.get_child(aw.NodeType.TABLE, 0, True).as_table()

# แยกเนื้อหาระหว่างโหนดเหล่านี้ในเอกสาร รวมเครื่องหมายเหล่านี้ในการแยก
extracted_nodes = extract_content(start_para, end_table, True)

# สร้างเอกสารที่มีเนื้อหาที่แยกออกมา
dstDoc = generate_document(doc, extractedNodes)

# บันทึกเอกสาร
dstDoc.save("extract_content_between_nodes.docx")

แยกข้อความระหว่างย่อหน้าตามสไตล์

มาดูวิธีแยกเนื้อหาระหว่างย่อหน้าตามสไตล์กัน สำหรับการสาธิต เราจะแยกเนื้อหาระหว่าง “หัวเรื่อง 1” แรกและ “หัวเรื่อง 3” แรกในเอกสาร Word ขั้นตอนต่อไปนี้จะสาธิตวิธีทำให้สำเร็จใน Python

ขั้นแรก ให้โหลดเอกสาร Word โดยใช้คลาส Document
จากนั้น แยกย่อหน้าลงในวัตถุโดยใช้วิธีการช่วยของ paragraphsbystylename(Document, “Heading 1”)
แยกย่อหน้าลงในวัตถุอื่นโดยใช้วิธีการช่วยของ paragraphsbystylename(Document, “Heading 3”)
โทร extractcontent (startPara, endPara, True) วิธีการและส่งองค์ประกอบแรกในอาร์เรย์ย่อหน้าทั้งสองเป็นพารามิเตอร์ที่หนึ่งและสอง
เรียกใช้เมธอดตัวช่วยที่ถูกสร้างขึ้น (Document, extractedNodes) เพื่อสร้างเอกสารที่ประกอบด้วยเนื้อหาที่แยกออกมา
สุดท้าย บันทึกเอกสารที่ส่งคืนโดยใช้เมธอด Document.save(string)

ตัวอย่างโค้ดต่อไปนี้แสดงวิธีการแยกเนื้อหาระหว่างย่อหน้าตามสไตล์

# โหลดเอกสาร
doc = aw.Document("Extract content.docx")

# รวบรวมรายการของย่อหน้าโดยใช้รูปแบบหัวเรื่องที่เกี่ยวข้อง
parasStyleHeading1 = paragraphs_by_style_name(doc, "Heading 1")
parasStyleHeading3 = paragraphs_by_style_name(doc, "Heading 3")

# ใช้ตัวอย่างแรกของย่อหน้ากับสไตล์เหล่านั้น
startPara1 = parasStyleHeading1[0]
endPara1 = parasStyleHeading3[0]

# แยกเนื้อหาระหว่างโหนดเหล่านี้ในเอกสาร อย่ารวมเครื่องหมายเหล่านี้ในการแยก
extractedNodes = extract_content(startPara1, endPara1, False)

# สร้างเอกสารที่มีเนื้อหาที่แยกออกมา
dstDoc = generate_document(doc, extractedNodes)

# บันทึกเอกสาร
dstDoc.save("extract_content_between_paragraphs_based_on-Styles.docx")

อ่านเพิ่มเติม

คุณสามารถสำรวจสถานการณ์อื่นๆ ในการแยกข้อความจากเอกสาร Word โดยใช้บทความคู่มือ this

รับใบอนุญาต API ฟรี

คุณสามารถรับ ใบอนุญาตชั่วคราว เพื่อใช้ Aspose.Words for Python ได้โดยไม่มีข้อจำกัดในการประเมิน

บทสรุป

ในบทความนี้ คุณได้เรียนรู้วิธีแยกข้อความจากเอกสาร MS Word โดยใช้ Python นอกจากนี้ คุณได้เห็นวิธีแยกเนื้อหาระหว่างโหนดประเภทเดียวกันหรือต่างชนิดกันในเอกสาร Word โดยทางโปรแกรม ดังนั้น คุณสามารถสร้างตัวแยกข้อความ MS Word ของคุณเองใน Python นอกจากนี้ คุณสามารถสำรวจคุณสมบัติอื่นๆ ของ Aspose.Words for Python โดยใช้ เอกสารประกอบ ในกรณีที่คุณมีคำถามใดๆ โปรดแจ้งให้เราทราบผ่านทาง ฟอรัม ของเรา

ดูสิ่งนี้ด้วย

ข้อมูล: หากคุณต้องการรับเอกสาร Word จากงานนำเสนอ PowerPoint คุณสามารถใช้ตัวแปลง Aspose Presentation to Word Document ได้

Python Library เพื่อแยกข้อความจากเอกสาร Word#

การแยกข้อความในเอกสาร Word โดยใช้ Python#

แยกข้อความจากเอกสาร Word ใน Python#

แยกข้อความระหว่างย่อหน้าในเอกสาร Word#

แยกข้อความระหว่างโหนดประเภทต่างๆ ในเอกสาร Word#

แยกข้อความระหว่างย่อหน้าตามสไตล์#

อ่านเพิ่มเติม#

รับใบอนุญาต API ฟรี#

บทสรุป#

ดูสิ่งนี้ด้วย#

Python Library เพื่อแยกข้อความจากเอกสาร Word

การแยกข้อความในเอกสาร Word โดยใช้ Python

แยกข้อความจากเอกสาร Word ใน Python

แยกข้อความระหว่างย่อหน้าในเอกสาร Word

แยกข้อความระหว่างโหนดประเภทต่างๆ ในเอกสาร Word

แยกข้อความระหว่างย่อหน้าตามสไตล์

อ่านเพิ่มเติม

รับใบอนุญาต API ฟรี

บทสรุป

ดูสิ่งนี้ด้วย