從 Word 文檔中提取文本通常在不同的場景中執(zhí)行。例如，分析文本，提取文檔的特定部分并將它們組合成單個文檔，等等。在本文中，您將學(xué)習(xí)如何在 Python 中以編程方式從 Word 文檔中提取文本。此外，我們將介紹如何動態(tài)提取段落、表格等特定元素之間的內(nèi)容。

Aspose.Words for . Python 最新下載

信息：如果您需要從 PowerPoint 演示文稿中獲取 Word 文檔，您可以使用 Aspose演示文稿到 Word 文檔轉(zhuǎn)換器。

從 Word 文檔中提取文本的 Python 庫

Aspose.Words for Python是一個強大的庫，可讓您從頭開始創(chuàng)建 MS Word 文檔。此外，它可以讓您操作現(xiàn)有的 Word 文檔進行加密、轉(zhuǎn)換、文本提取等。我們將使用這個庫從 Word DOCX 或 DOC 文檔中提取文本。您可以使用以下 pip 命令從PyPI安裝庫。

pip install aspose-words

使用 Python 在 Word 文檔中提取文本

MS Word 文檔由各種元素組成，包括段落、表格、圖像等。因此，文本提取的要求可能因一種情況而異。例如，您可能需要在段落、書簽、評論等之間提取文本。

Word 文檔中的每種類型的元素都表示為一個節(jié)點。因此，要處理文檔，您將不得不使用節(jié)點。那么讓我們開始看看如何在不同的場景下從 Word 文檔中提取文本。

在 Python 中從 Word 文檔中提取文本

在本節(jié)中，我們將為 Word 文檔實現(xiàn)一個 Python 文本提取器，文本提取的工作流程如下：

• 首先，我們將定義要包含在文本提取過程中的節(jié)點。
• 然后，我們將提取指定節(jié)點之間的內(nèi)容（包括或不包括開始和結(jié)束節(jié)點）。
• 最后，我們將使用提取節(jié)點的克隆，例如創(chuàng)建一個包含提取內(nèi)容的新 Word 文檔。

現(xiàn)在讓我們編寫一個名為extract_content的方法，我們將向該方法傳遞節(jié)點和一些其他參數(shù)來執(zhí)行文本提取。此方法將解析文檔并克隆節(jié)點。以下是我們將傳遞給此方法的參數(shù)。

1. StartNode 和 EndNode 分別作為內(nèi)容提取的起點和終點。這些可以是塊級（Paragraph 、 Table）或內(nèi)聯(lián)級（例如 Run、 FieldStart、 BookmarkStart 等）節(jié)點。
   1. 要傳遞一個字段，您應(yīng)該傳遞相應(yīng)的 FieldStart 對象。
   2. 要傳遞書簽，  應(yīng)傳遞BookmarkStart 和 BookmarkEnd節(jié)點。
   3. 對于評論，  應(yīng)使用CommentRangeStart 和 CommentRangeEnd節(jié)點。
2. IsInclusive定義標(biāo)記是否包含在提取中。如果此選項設(shè)置為 false 并且傳遞相同的節(jié)點或連續(xù)節(jié)點，則將返回一個空列表。

以下是extract_content方法的完整實現(xiàn)，該方法提取傳遞的節(jié)點之間的內(nèi)容。

def extract_content(startNode : aw.Node, endNode : aw.Node, isInclusive : bool):

# First, check that the nodes passed to this method are valid for use.
verify_parameter_nodes(startNode, endNode)

# Create a list to store the extracted nodes.
nodes = []

# If either marker is part of a comment, including the comment itself, we need to move the pointer
# forward to the Comment Node found after the CommentRangeEnd node.
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

# Keep a record of the original nodes passed to this method to split marker nodes if needed.
originalStartNode = startNode
originalEndNode = endNode

# Extract content based on block-level nodes (paragraphs and tables). Traverse through parent nodes to find them.
# We will split the first and last nodes' content, depending if the marker nodes are inline.
startNode = get_ancestor_in_body(startNode)
endNode = get_ancestor_in_body(endNode)

isExtracting = True
isStartingNode = True
# The current node we are extracting from the document.
currNode = startNode

# Begin extracting content. Process all block-level nodes and specifically split the first
# and last nodes when needed, so paragraph formatting is retained.
# Method is a little more complicated than a regular extractor as we need to factor
# in extracting using inline nodes, fields, bookmarks, etc. to make it useful.
while (isExtracting) :

# Clone the current node and its children to obtain a copy.
cloneNode = currNode.clone(True)
isEndingNode = currNode == endNode

if (isStartingNode or isEndingNode) :

# We need to process each marker separately, so pass it off to a separate method instead.
# End should be processed at first to keep node indexes.
if (isEndingNode) :
# !isStartingNode: don't add the node twice if the markers are the same node.
process_marker(cloneNode, nodes, originalEndNode, currNode, isInclusive, False, not isStartingNode, False)
isExtracting = False

# Conditional needs to be separate as the block level start and end markers, maybe the same node.
if (isStartingNode) :
process_marker(cloneNode, nodes, originalStartNode, currNode, isInclusive, True, True, False)
isStartingNode = False

else :
# Node is not a start or end marker, simply add the copy to the list.
nodes.append(cloneNode)

# Move to the next node and extract it. If the next node is None,
# the rest of the content is found in a different section.
if (currNode.next_sibling == None and isExtracting) :
# Move to the next section.
nextSection = currNode.get_ancestor(aw.NodeType.SECTION).next_sibling.as_section()
currNode = nextSection.body.first_child

else :
# Move to the next node in the body.
currNode = currNode.next_sibling

# For compatibility with mode with inline bookmarks, add the next paragraph (empty).
if (isInclusive and originalEndNode == endNode and not originalEndNode.is_composite) :
include_next_paragraph(endNode, nodes)

# Return the nodes between the node markers.
return nodes

extract_content方法還需要一些輔助方法來完成文本提取操作，如下所示。

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

# The order in which these checks are done is important.
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")

# Check the end node is after the start node in the DOM tree.
# First, check if they are in different sections, then if they're not,
# check their position in the body of the same section.
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):

# Test if the node is a descendant of a Paragraph or Table node and is not a paragraph
# or a table a paragraph inside a comment class that is decent of a paragraph is possible.
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 we are dealing with a block-level node, see if it should be included and add it to the list.
if node == block_level_ancestor:
if can_add and is_inclusive:
nodes.append(clone_node)
return

# cloneNode is a clone of blockLevelNode. If node != blockLevelNode, blockLevelAncestor
# is the node's ancestor that means it is a composite node.
assert clone_node.is_composite

# If a marker is a FieldStart node check if it's to be included or not.
# We assume for simplicity that the FieldStart and FieldEnd appear in the same paragraph.
if node.node_type == aw.NodeType.FIELD_START:
# If the marker is a start node and is not included, skip to the end of the field.
# If the marker is an end node and is to be included, then move to the end field so the field will not be removed.
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

# Support a case if the marker node is on the third level of the document body or lower.
node_branch = fill_self_and_parents(node, block_level_ancestor)

# Process the corresponding node in our cloned node by index.
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)

# After processing, the composite node may become empty if it has doesn't include it.
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:

# Move to the first child to include paragraphs without content.
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()
# Remove the first paragraph from the empty document.
dst_doc.first_section.body.remove_all_children()

# Import each node from the list into the new document. Keep the original formatting of the node.
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

現(xiàn)在我們準(zhǔn)備好使用這些方法并從 Word 文檔中提取文本。

在 Word 文檔中的段落之間提取文本

讓我們看看如何在 Word DOCX 文檔的兩個段落之間提取內(nèi)容。以下是在 Python 中執(zhí)行此操作的步驟。

• 首先，使用Document類加載 Word 文檔。
• 使用Document.first_section.body.get_child(NodeType.PARAGRAPH, int, boolean).as_paragraph()方法將開始和結(jié)束段落的引用獲取到兩個對象中。
• 調(diào)用extract_content(startPara, endPara, True)方法將節(jié)點提取到對象中.
• 調(diào)用generate_document(Document, extractNodes)輔助方法來創(chuàng)建包含提取內(nèi)容的文檔。
• 最后，使用Document.save(string)方法保存返回的文檔。

以下代碼示例展示了如何在 Python 中提取 Word 文檔中第 7 段和第 11 段之間的文本。

# Load document.
doc = aw.Document("Extract content.docx")

# Define starting and ending paragraphs.
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()

# Extract the content between these paragraphs in the document. Include these markers in the extraction.
extractedNodes = extract_content(startPara, endPara, True)

# Generate document containing extracted content.
dstDoc = generate_document(doc, extractedNodes)

# Save document.
dstDoc.save("extract_content_between_paragraphs.docx")

在 Word 文檔中不同類型的節(jié)點之間提取文本

您還可以在不同類型的節(jié)點之間提取內(nèi)容。為了演示，讓我們提取段落和表格之間的內(nèi)容并將其保存到新的 Word 文檔中。以下是執(zhí)行此操作的步驟。

• 使用Document類加載 Word 文檔。
• 使用Document.first_section.body.get_child(NodeType, int, boolean)方法將起始節(jié)點和結(jié)束節(jié)點引用到兩個對象中。
• 調(diào)用extract_content(startPara, endPara, True)方法將節(jié)點提取到對象中。
• 調(diào)用generate_document(Document, extractNodes)輔助方法來創(chuàng)建包含提取內(nèi)容的文檔。
• 使用Document.save(string)方法保存返回的文檔。

以下代碼示例展示了如何在 Python 中提取段落和表格之間的文本。

# Load document
doc = aw.Document("Extract content.docx")

# Define starting and ending nodes.
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()

# Extract the content between these nodes in the document. Include these markers in the extraction.
extracted_nodes = extract_content(start_para, end_table, True)

# Generate document containing extracted content.
dstDoc = generate_document(doc, extractedNodes)

# Save document.
dstDoc.save("extract_content_between_nodes.docx")

根據(jù)樣式提取段落之間的文本

現(xiàn)在讓我們看看如何根據(jù)樣式提取段落之間的內(nèi)容。為了演示，我們將提取 Word 文檔中第一個“標(biāo)題 1”和第一個“標(biāo)題 3”之間的內(nèi)容。以下步驟演示了如何在 Python 中實現(xiàn)此目的。

• 首先，使用Document類加載 Word 文檔。
• 然后，使用paragraphs_by_style_name(Document, “Heading 1”)輔助方法將段落提取到一個對象中。
• 使用paragraphs_by_style_name(Document, “Heading 3”)輔助方法將段落提取到另一個對象中。
• 調(diào)用extract_content(startPara, endPara, True)方法并將兩個段落數(shù)組中的第一個元素作為第一個和第二個參數(shù)傳遞。
• 調(diào)用generate_document(Document, extractNodes)輔助方法來創(chuàng)建包含提取內(nèi)容的文檔。
• 最后，使用Document.save(string)方法保存返回的文檔。

以下代碼示例展示了如何根據(jù)樣式提取段落之間的內(nèi)容。

# Load document
doc = aw.Document("Extract content.docx")

# Gather a list of the paragraphs using the respective heading styles.
parasStyleHeading1 = paragraphs_by_style_name(doc, "Heading 1")
parasStyleHeading3 = paragraphs_by_style_name(doc, "Heading 3")

# Use the first instance of the paragraphs with those styles.
startPara1 = parasStyleHeading1[0]
endPara1 = parasStyleHeading3[0]

# Extract the content between these nodes in the document. Don't include these markers in the extraction.
extractedNodes = extract_content(startPara1, endPara1, False)

# Generate document containing extracted content.
dstDoc = generate_document(doc, extractedNodes)

# Save document.
dstDoc.save("extract_content_between_paragraphs_based_on-Styles.docx")

結(jié)論

在本文中，您學(xué)習(xí)了如何使用 Python 從 MS Word 文檔中提取文本。此外，您還了解了如何以編程方式在 Word 文檔中相似或不同類型的節(jié)點之間提取內(nèi)容。因此，您可以在 Python 中構(gòu)建自己的 MS Word 文本提取器。此外，您可以使用文檔探索 Aspose.Words for Python 的其他功能 。如果您有任何問題，請隨時告訴我們。

歡迎下載|體驗更多Aspose產(chǎn)品