14、企业级表格｜AWS Textract 扫描件表格自动结构化

企业级表格｜AWS Textract 扫描件表格自动结构化

从发票到财报，Python实战PDF表格识别与跨页拼接

引言

财务部门的同事小王，每个月底都要面对一个让人头疼的场景：

客户发来30页的财务报表扫描件，里面密密麻麻全是数字表格。他需要把这些数据一个个敲进Excel，然后做汇总分析。一个季度下来，光是录入就耗费了整整3个工作日。

这不仅仅是"效率低"的问题------手动录入还伴随着肉眼可见的出错率。少一个小数点，多一个零，都可能让整个报表失真。

传统OCR工具（如Tesseract、普通扫描软件）能提取文字，但它们无法"理解"表格的结构。它们输出的是一堆散落的文字，完全丢失了行列关系。对业务系统来说，这样的输出毫无意义------因为你需要的是"第3行第2列的值"，而不是一堆坐标散落的文本。

AWS Textract 的出现，就是为了解决这个难题。它不是普通的OCR，而是一个智能文档处理（Intelligent Document Processing, IDP） 服务。它不仅能识别文字，还能自动理解文档中的表格结构（行列关系、合并单元格、表头） 和表单字段（键值对，如"发票号：INV-2025-001"） 。

在开始之前，先通过下面这张决策流程图，快速判断Textract是否适合你的业务场景：
财务报表/发票/合同
简单书信/纯文本
手写繁体古籍
<100页/月
>1000页/月 100-1000页/月
是
否
数据分析
报表存档
数据库
开始：我需要处理扫描件表格
文档类型是什么？
✓ Textract 首选
普通OCR足够
需要专用OCR
数据量有多大？
按量付费

约$0.015/页
考虑资源包

或企业折扣
表格是否跨页？
需要额外开发

跨页拼接逻辑
直接用TRP库

即可结构化
选用Textract + 后处理
识别后数据去向？
导出Pandas DataFrame
导出Excel
存入RDS/DynamoDB

本文将从Textract的核心能力讲起，逐步带你完成环境配置、Python调用、表格解析、跨页拼接、数据导出等全流程。全文所有关键流程均使用Mermaid图呈现，确保概念清晰、便于理解。

一、Textract核心能力：表格识别只是起点

1.1 为什么需要Textract？

在传统OCR的世界里，一个带表格的扫描件经过识别后，输出的是一堆带坐标的文字块。你得到的是一个"散落"的文本列表：

位置(100,200): 项目名称
位置(100,300): 笔记本电脑
位置(200,200): 单价
位置(200,300): 8999
位置(300,200): 数量
位置(300,300): 2

然后呢？你需要写大量代码去"猜"哪些文字属于同一行、哪些属于同一列。如果表格复杂一点（有合并单元格、多行表头），工作量直接翻倍。

Textract的突破在于 ：它直接输出结构化的表格数据------告诉你在第几行第几列是什么内容，哪些单元格是合并的，哪些是表头。这种从"文字"到"结构"的跃迁，正是企业级自动化处理的关键。[reference:0]

1.2 五大核心能力

Textract的能力远不止表格识别。它的功能矩阵可以概括为下图：
AWS Textract

核心能力
文字识别
印刷体高精度识别
手写体识别
多语言支持
表格解析
自动识别行列结构
合并单元格还原
表头识别
跨页表格
表单提取
键值对识别
如"姓名：张三"
复选框识别
单选/多选
智能查询
自然语言提问
"发票总额是多少？"
直接返回答案
文档结构感知
段落/标题/页眉
列表识别
阅读顺序还原

具体到每个功能：

（1）文字识别（Detect Document Text）

自动从扫描图像中识别和提取印刷文字。支持PDF、JPEG、PNG、TIFF等格式，可处理单页和多页文档。[reference:1]

（2）表格解析（Analyze Document -- Tables）

这是本文的核心关注点。Textract能够识别文档中的行列结构，自动重建表格关系，包括：

• 表格边界的检测
• 行和列的索引定位
• 单元格内容的提取
• 合并单元格（RowSpan/ColumnSpan）的还原
• 表头（COLUMN_HEADER）的识别

（3）表单字段提取（Analyze Document -- Forms）

自动识别键值对信息，例如"姓名：张三"、"发票号：INV-001"。这对于处理申请表、调查问卷、合同等非常有用。[reference:2]

（4）智能查询（Custom Queries）

这是Textract的独特功能------你可以用自然语言直接"问"文档问题，比如"这份合同的签约日期是哪天？"或者"发票总金额是多少？"，Textract会直接返回答案。[reference:3]

（5）文档结构感知

Textract不仅能识别文字，还能理解页面的布局------区分段落、标题、列表、页眉页脚，并以正确的阅读顺序输出。[reference:4]

1.3 与传统OCR的本质区别

AWS Textract
扫描件
文字检测
表格识别
键值对提取
结构感知
结构化JSON
直接可用数据
传统OCR
扫描件
文字检测
字符识别
散落文本+坐标
人工整理

简单来说：传统OCR给你"文字在哪里"，Textract给你"这些文字在表格的什么位置、它们之间有什么关系"。两者之间的差距，就是几天的手工整理工作和一键自动化的差距。

1.4 Textract的Block模型

理解Textract的输出，首先要理解它的核心概念------Block。

Textract将文档中的每个元素都表示为一个Block。Block的类型包括：

• PAGE：页面
• TABLE：表格
• CELL：单元格
• KEY_VALUE_SET：键值对
• WORD：单词
• LINE：文本行

这些Block通过Relationships（关系引用）相互连接。一个TABLE Block会指向其包含的所有CELL Block，每个CELL又指向其内部的WORD Block。理解这个层次结构，是正确解析Textract输出、提取表格数据的基础。[reference:5]

下面用Mermaid图展示Block模型的层次结构：
PAGE Block
TABLE Block
KEY_VALUE_SET Block
CELL Block
CELL Block
WORD Block
WORD Block
WORD Block
KEY Block
VALUE Block
WORD Block
WORD Block

每个Block都有唯一的ID，通过Relationships字段中的ChildIds和ParentIds来建立关联。解析时，你需要遍历这些关系来重建完整的表格或表单结构。

二、环境配置：AWS密钥、权限设置

2.1 前置条件

在使用Textract之前，你需要具备以下条件：

• 一个AWS账户（可注册免费试用）
• 基本的Python开发环境（Python 3.8+）
• 了解AWS IAM的基本概念

2.2 配置流程图

注册AWS账号
创建IAM用户
附加Textract权限策略

AmazonTextractFullAccess
创建访问密钥

Access Key + Secret Key
配置AWS CLI

或直接在代码中配置
创建S3存储桶

用于存放文档
验证权限

调用Textract测试API

2.3 详细配置步骤

步骤1：创建IAM用户并授予Textract权限

登录AWS Management Console，进入IAM服务：

1. 创建新用户（例如 textract-user）
2. 在"设置权限"页面，选择"直接附加现有策略"
3. 搜索并勾选 AmazonTextractFullAccess（完全访问权限）
4. 完成用户创建

如果需要处理存储在S3中的文档，还需要附加 AmazonS3ReadOnlyAccess 或更细粒度的S3权限。

步骤2：生成访问密钥

1. 进入IAM用户详情页
2. 选择"安全凭证"选项卡
3. 点击"创建访问密钥"
4. 选择"应用程序在AWS外部运行"场景
5. 保存 Access Key ID 和 Secret Access Key（注意：Secret Key只会显示一次）

步骤3：配置AWS凭证

有两种方式配置凭证：

方式一：使用AWS CLI配置（推荐）

# 安装AWS CLI
pip install awscli

# 配置凭证
aws configure
# 按提示输入：Access Key ID, Secret Access Key, 默认区域(如us-east-1), 默认输出格式(json)

配置完成后，boto3会自动从 ~/.aws/credentials 文件中读取凭证。

方式二：在代码中直接配置（仅适用于测试）

import boto3

textract = boto3.client(
    'textract',
    region_name='us-east-1',
    aws_access_key_id='YOUR_ACCESS_KEY',
    aws_secret_access_key='YOUR_SECRET_KEY'
)

⚠️ 安全提醒：永远不要将密钥硬编码在生产代码中。使用环境变量、AWS Secrets Manager或IAM角色是更安全的做法。

步骤4：创建S3存储桶（可选）

Textract支持两种文档输入方式：

• 直接传入文件字节流：适用于小文件（<5MB）和低延迟场景
• 通过S3传入文件路径：适用于大文件、多页PDF和异步处理场景

如果需要使用S3方式，创建一个存储桶：

aws s3 mb s3://your-textract-bucket-name --region us-east-1

2.4 验证环境配置

运行以下Python代码验证配置是否正确：

import boto3

# 创建客户端
textract = boto3.client('textract', region_name='us-east-1')

# 列出所有可用的Textract操作（验证权限）
print(dir(textract))

# 如果以上代码没有报错，说明凭证配置正确
print("✅ Textract客户端初始化成功")

三、Python调用Textract：识别扫描件PDF表格

3.1 同步 vs 异步API选择

Textract提供两种API调用方式，你需要根据文档类型和处理场景来选择合适的模式：
单页图片

JPEG/PNG/TIFF
多页PDF

>1页
需要处理文档
文档类型?
同步API

AnalyzeDocument
异步API

StartDocumentAnalysis
结果立即返回

适合实时处理
异步处理流程:

1. 启动任务获取JobId

2. 轮询任务状态

3. 获取结果
   Done

选择建议：

• 同步API（AnalyzeDocument） ：适用于单页文档（图片格式），响应延迟低，结果直接在响应中返回。文件大小限制为5MB。
• 异步API（StartDocumentAnalysis + GetDocumentAnalysis） ：适用于多页PDF（最多3000页）、大文件（最大500MB），需要配合SNS或轮询获取结果。[reference:6]

本文主要处理扫描件PDF表格，因此使用异步API。

3.2 完整的PDF表格识别代码

下面是一个完整的Python脚本，演示如何使用Textract识别PDF中的表格：

import boto3
import time
import json
from typing import Dict, List, Any

class TextractPDFAnalyzer:
    """AWS Textract PDF分析器 - 支持异步处理"""
    
    def __init__(self, region_name: str = 'us-east-1'):
        """
        初始化Textract客户端
        :param region_name: AWS区域，建议选择与S3存储桶相同的区域
        """
        self.textract = boto3.client('textract', region_name=region_name)
        self.s3 = boto3.client('s3', region_name=region_name)
    
    def start_table_analysis(self, bucket: str, document_key: str) -> str:
        """
        启动异步表格分析任务
        :param bucket: S3存储桶名称
        :param document_key: S3中的文档路径
        :return: JobId（任务标识符）
        """
        try:
            response = self.textract.start_document_analysis(
                DocumentLocation={
                    'S3Object': {
                        'Bucket': bucket,
                        'Name': document_key
                    }
                },
                FeatureTypes=['TABLES', 'FORMS']  # 启用表格和表单识别
            )
            job_id = response['JobId']
            print(f"✅ 任务已启动，JobId: {job_id}")
            return job_id
        except Exception as e:
            print(f"❌ 启动任务失败: {e}")
            raise
    
    def wait_for_job_completion(self, job_id: str, max_wait_seconds: int = 300, 
                                poll_interval: int = 5) -> bool:
        """
        轮询等待任务完成
        :param job_id: 任务ID
        :param max_wait_seconds: 最大等待时间（秒）
        :param poll_interval: 轮询间隔（秒）
        :return: 是否成功完成
        """
        start_time = time.time()
        while time.time() - start_time < max_wait_seconds:
            response = self.textract.get_document_analysis(JobId=job_id)
            status = response['JobStatus']
            
            if status == 'SUCCEEDED':
                print(f"✅ 任务完成")
                return True
            elif status == 'FAILED':
                print(f"❌ 任务失败")
                return False
            else:
                print(f"⏳ 任务处理中... (状态: {status})")
                time.sleep(poll_interval)
        
        print(f"⚠️ 任务超时，请检查")
        return False
    
    def get_analysis_results(self, job_id: str) -> List[Dict[str, Any]]:
        """
        获取完整的分析结果
        :param job_id: 任务ID
        :return: Blocks列表（所有检测到的元素）
        """
        all_blocks = []
        next_token = None
        
        while True:
            if next_token:
                response = self.textract.get_document_analysis(
                    JobId=job_id,
                    NextToken=next_token
                )
            else:
                response = self.textract.get_document_analysis(JobId=job_id)
            
            all_blocks.extend(response.get('Blocks', []))
            next_token = response.get('NextToken')
            
            if not next_token:
                break
        
        print(f"✅ 共获取 {len(all_blocks)} 个Block")
        return all_blocks
    
    def process_pdf(self, bucket: str, document_key: str) -> List[Dict[str, Any]]:
        """
        一站式处理PDF：启动→等待→获取结果
        :param bucket: S3存储桶
        :param document_key: 文档路径
        :return: Blocks列表
        """
        job_id = self.start_table_analysis(bucket, document_key)
        
        if not self.wait_for_job_completion(job_id):
            return []
        
        return self.get_analysis_results(job_id)


# 使用示例
if __name__ == "__main__":
    # 配置参数
    S3_BUCKET = "your-textract-bucket"
    PDF_KEY = "invoices/monthly_report.pdf"
    
    # 创建分析器
    analyzer = TextractPDFAnalyzer(region_name='us-east-1')
    
    # 处理PDF
    blocks = analyzer.process_pdf(S3_BUCKET, PDF_KEY)
    
    # 打印Block类型统计
    block_types = {}
    for block in blocks:
        block_type = block['BlockType']
        block_types[block_type] = block_types.get(block_type, 0) + 1
    
    print("\n📊 Block类型统计:")
    for btype, count in block_types.items():
        print(f"  {btype}: {count}")

3.3 理解Textract的输出结构

Textract返回的响应中，最关键的部分是 Blocks 数组。每个Block都有以下字段：

字段	说明	示例
BlockType	块类型	"TABLE", "CELL", "WORD", "PAGE"
Id	唯一标识符	"1a2b3c4d"
Confidence	置信度（0-100）	99.5
Geometry	边界框位置信息	多边形坐标
Relationships	与其他Block的关系	ChildIds, ParentIds

对于TABLE Block ，它包含一个Relationships字段，指向其所有子CELL。对于CELL Block，它包含：

• RowIndex：行索引（从1开始）
• ColumnIndex：列索引（从1开始）
• RowSpan：行合并跨度（默认为1）
• ColumnSpan：列合并跨度（默认为1）
• EntityTypes：实体类型，如["COLUMN_HEADER"]表示表头单元格

这些信息是重建表格的关键。[reference:7]

四、高级处理：跨页表格拼接、合并单元格还原

4.1 表格解析的挑战

在实际业务中，表格不会总是"乖乖地"待在一页之内。跨页表格的处理是Textract解析中最常见的痛点：
常见问题
表头跨页重复
每页开头都有表头
合并单元格
RowSpan/ColumnSpan > 1
跨页表格
同一表格分布在多页
空白单元格
没有文字内容
需要识别并去除重复
影响后续行列定位
需要按逻辑拼接
需要保留位置

Textract的限制：Textract的异步API是逐页返回结果的，它不会自动告诉你"第2页的表格是第1页表格的延续"。跨页表格的拼接逻辑需要自己实现。此外，官方TRP库虽然能解析单页表格，但对跨页场景的支持有限。[reference:8]

4.2 完整的表格解析器（支持合并单元格）

下面是一个完整的表格解析类，能够处理Textract返回的Blocks，重建表格结构，包括合并单元格：

from typing import List, Dict, Any, Optional

class TextractTableParser:
    """
    Textract表格解析器
    支持：合并单元格还原、表头识别、跨页表格拼接
    """
    
    def __init__(self, blocks: List[Dict[str, Any]]):
        """
        初始化解析器
        :param blocks: Textract返回的Blocks列表
        """
        # 建立Block ID到Block的映射，便于快速查找
        self.blocks_map = {block['Id']: block for block in blocks}
        self.tables = []
    
    def _get_cell_text(self, cell_block: Dict[str, Any]) -> str:
        """
        获取单元格中的完整文本
        :param cell_block: CELL类型的Block
        :return: 单元格内所有文字拼接
        """
        text_parts = []
        
        # 遍历CELL的CHILD关系，找到WORD Block
        for rel in cell_block.get('Relationships', []):
            if rel['Type'] == 'CHILD':
                for child_id in rel.get('Ids', []):
                    child_block = self.blocks_map.get(child_id)
                    if child_block and child_block['BlockType'] == 'WORD':
                        text_parts.append(child_block.get('Text', ''))
        
        return ' '.join(text_parts)
    
    def extract_table_from_page(self, page_block: Dict[str, Any]) -> List[List[Dict[str, Any]]]:
        """
        从单页中提取表格（仅限单页内）
        返回二维数组，每个元素是单元格信息字典
        """
        tables_on_page = []
        
        # 查找该页下的所有TABLE Block
        for rel in page_block.get('Relationships', []):
            if rel['Type'] == 'CHILD':
                for child_id in rel.get('Ids', []):
                    child_block = self.blocks_map.get(child_id)
                    if child_block and child_block['BlockType'] == 'TABLE':
                        table = self._parse_table_block(child_block)
                        if table:
                            tables_on_page.append(table)
        
        return tables_on_page
    
    def _parse_table_block(self, table_block: Dict[str, Any]) -> Optional[List[List[str]]]:
        """
        解析单个TABLE Block，返回二维文本数组
        自动处理合并单元格
        """
        cells: Dict[tuple, Dict[str, Any]] = {}
        max_row, max_col = 0, 0
        
        # 收集所有CELL
        for rel in table_block.get('Relationships', []):
            if rel['Type'] == 'CHILD':
                for cell_id in rel.get('Ids', []):
                    cell = self.blocks_map.get(cell_id)
                    if cell and cell['BlockType'] == 'CELL':
                        row = cell.get('RowIndex', 0)
                        col = cell.get('ColumnIndex', 0)
                        max_row = max(max_row, row)
                        max_col = max(max_col, col)
                        
                        text = self._get_cell_text(cell)
                        row_span = cell.get('RowSpan', 1)
                        col_span = cell.get('ColumnSpan', 1)
                        is_header = 'COLUMN_HEADER' in cell.get('EntityTypes', [])
                        
                        cells[(row, col)] = {
                            'text': text,
                            'row_span': row_span,
                            'col_span': col_span,
                            'is_header': is_header
                        }
        
        if not cells:
            return None
        
        # 构建二维表格数组（处理合并单元格）
        # 先创建占位矩阵
        table = [['' for _ in range(max_col)] for _ in range(max_row)]
        
        # 填充单元格，处理合并占位
        used_cells = set()
        for (row, col), cell_info in cells.items():
            # 调整索引从0开始
            r, c = row - 1, col - 1
            
            # 如果这个位置已经被之前的合并单元格占用，跳过
            if (r, c) in used_cells:
                continue
            
            # 填充主单元格
            table[r][c] = cell_info['text']
            used_cells.add((r, c))
            
            # 标记合并单元格占用的其他位置
            row_span = cell_info['row_span']
            col_span = cell_info['col_span']
            for dr in range(row_span):
                for dc in range(col_span):
                    if dr == 0 and dc == 0:
                        continue
                    nr, nc = r + dr, c + dc
                    if nr < max_row and nc < max_col:
                        # 合并区域内的单元格标记为已占用，内容留空或复制
                        used_cells.add((nr, nc))
                        # 可选：将主单元格内容复制到合并区域
                        # table[nr][nc] = cell_info['text']
        
        return table
    
    def get_all_tables(self) -> List[List[List[str]]]:
        """
        提取文档中所有表格
        :return: 表格列表，每个表格是二维字符串数组
        """
        all_tables = []
        
        for block_id, block in self.blocks_map.items():
            if block['BlockType'] == 'TABLE':
                table = self._parse_table_block(block)
                if table:
                    all_tables.append(table)
        
        return all_tables
    
    def get_tables_by_page(self) -> Dict[int, List[List[List[str]]]]:
        """
        按页码获取表格
        :return: {页码: [表格1, 表格2, ...]}
        """
        page_tables = {}
        
        for block_id, block in self.blocks_map.items():
            if block['BlockType'] == 'PAGE':
                page_num = block.get('Page', 1)
                tables = self.extract_table_from_page(block)
                if tables:
                    page_tables[page_num] = tables
        
        return page_tables
    
    def merge_across_pages(self, page_tables: Dict[int, List[List[List[str]]]]) -> List[List[str]]:
        """
        跨页表格拼接（简易版本）
        假设：同一列结构不变，跨页表格按行顺序拼接
        需要根据实际业务逻辑定制
        """
        merged_table = []
        
        for page_num in sorted(page_tables.keys()):
            for table in page_tables[page_num]:
                # 跳过表头重复（可选：根据内容相似度判断）
                if merged_table and self._is_header_row(table[0]):
                    # 如果是表头行且已存在，跳过
                    continue
                merged_table.extend(table)
        
        return merged_table
    
    def _is_header_row(self, row: List[str]) -> bool:
        """判断是否为表头行（简单启发式）"""
        if not row:
            return False
        # 表头通常包含"日期"、"金额"、"编号"等关键词
        header_keywords = ['日期', '金额', '编号', '名称', '数量', '单价', '合计']
        row_text = ' '.join(row).lower()
        for kw in header_keywords:
            if kw in row_text:
                return True
        return False


# 使用示例
def parse_textract_tables(blocks: List[Dict[str, Any]]) -> None:
    """解析并打印Textract识别出的表格"""
    parser = TextractTableParser(blocks)
    
    # 方式1：按页码获取
    tables_by_page = parser.get_tables_by_page()
    for page_num, tables in tables_by_page.items():
        print(f"\n📄 第 {page_num} 页，共 {len(tables)} 个表格")
        for idx, table in enumerate(tables):
            print(f"  表格 {idx+1}:")
            for row in table:
                print(f"    {row}")
    
    # 方式2：获取所有表格
    all_tables = parser.get_all_tables()
    print(f"\n📊 文档中共有 {len(all_tables)} 个表格")
    
    # 方式3：跨页拼接（如果需要）
    merged = parser.merge_across_pages(tables_by_page)
    if merged:
        print("\n🔗 跨页拼接后的表格:")
        for row in merged:
            print(f"  {row}")

4.3 跨页表格拼接的实战技巧

跨页表格拼接是Textract使用中最复杂的部分。以下是一些实战建议：

策略1：基于表头匹配

• 提取第一页表格的表头行
• 后续页面如果检测到相似度极高的表头，说明是新表格的开始，而不是延续

策略2：基于内容连续性

• 检查上一页最后一行和下一页第一行是否有逻辑关联
• 例如，金额列是否继续累加、序号是否连续

策略3：使用TRP库辅助

虽然TRP官方库对跨页表格支持有限，但它可以极大地简化单页内的表格解析，推荐在生产环境中使用。[reference:9]

安装TRP库：

pip install amazon-textract-response-parser

使用TRP简化解析：

from trp import Document

# 加载Textract响应
doc = Document(response)

for page in doc.pages:
    for table in page.tables:
        for row in table.rows:
            row_text = [cell.text for cell in row.cells]
            print(" | ".join(row_text))

五、输出转换：JSON结果→Pandas DataFrame→Excel

5.1 转换流程图

Textract JSON响应
Blocks解析
提取表格数据
转换为Pandas DataFrame
数据验证/清洗
导出Excel
存入数据库
发送到API

5.2 完整的数据导出脚本

import pandas as pd
from typing import List, Dict, Any
import json

class TextractToExcel:
    """将Textract表格结果导出为Excel"""
    
    def __init__(self, blocks: List[Dict[str, Any]]):
        self.parser = TextractTableParser(blocks)
    
    def tables_to_dataframes(self) -> List[pd.DataFrame]:
        """
        将提取的表格转换为Pandas DataFrame列表
        """
        all_tables = self.parser.get_all_tables()
        dataframes = []
        
        for idx, table in enumerate(all_tables):
            if not table:
                continue
            
            # 第一行作为列名（表头）
            if len(table) > 0:
                headers = table[0]
                data = table[1:] if len(table) > 1 else []
                
                # 清理列名（处理空列名）
                clean_headers = []
                for i, h in enumerate(headers):
                    if not h or h.strip() == '':
                        clean_headers.append(f'Column_{i+1}')
                    else:
                        clean_headers.append(h.strip())
                
                df = pd.DataFrame(data, columns=clean_headers)
            else:
                df = pd.DataFrame(table)
            
            # 添加元数据
            df.attrs['table_index'] = idx
            dataframes.append(df)
        
        return dataframes
    
    def export_to_excel(self, output_path: str, sheet_name_prefix: str = 'Table') -> None:
        """
        导出所有表格到Excel，每个表格单独一个Sheet
        :param output_path: 输出Excel文件路径
        :param sheet_name_prefix: Sheet名称前缀
        """
        dataframes = self.tables_to_dataframes()
        
        if not dataframes:
            print("⚠️ 未找到表格数据")
            return
        
        with pd.ExcelWriter(output_path, engine='openpyxl') as writer:
            for idx, df in enumerate(dataframes):
                sheet_name = f"{sheet_name_prefix}_{idx + 1}"
                # Excel sheet名称不能超过31个字符
                sheet_name = sheet_name[:31]
                df.to_excel(writer, sheet_name=sheet_name, index=False)
                print(f"✅ 已写入 Sheet: {sheet_name} ({df.shape[0]}行 x {df.shape[1]}列)")
        
        print(f"\n📁 表格已导出至: {output_path}")
    
    def export_to_json(self, output_path: str) -> None:
        """
        导出表格为JSON格式（保留完整结构）
        """
        all_tables = self.parser.get_all_tables()
        
        output_data = {
            'tables': [],
            'metadata': {
                'total_tables': len(all_tables)
            }
        }
        
        for idx, table in enumerate(all_tables):
            if not table:
                continue
            
            # 转换为字典格式
            headers = table[0] if table else []
            rows = []
            for row in table[1:]:
                row_dict = {}
                for i, cell in enumerate(row):
                    if i < len(headers):
                        key = headers[i] if headers[i] else f'col_{i+1}'
                        row_dict[key] = cell
                    else:
                        row_dict[f'col_{i+1}'] = cell
                rows.append(row_dict)
            
            output_data['tables'].append({
                'index': idx,
                'headers': headers,
                'rows': rows,
                'raw_data': table  # 保留原始二维数组
            })
        
        with open(output_path, 'w', encoding='utf-8') as f:
            json.dump(output_data, f, ensure_ascii=False, indent=2)
        
        print(f"✅ 已导出JSON至: {output_path}")


# 完整工作流示例
def complete_workflow(bucket: str, document_key: str, output_excel: str):
    """
    完整的PDF表格处理工作流
    """
    print("=" * 60)
    print("🚀 AWS Textract 表格处理工作流")
    print("=" * 60)
    
    # 步骤1：启动Textract任务
    print("\n📤 步骤1: 上传文档到S3并启动Textract...")
    analyzer = TextractPDFAnalyzer()
    blocks = analyzer.process_pdf(bucket, document_key)
    
    if not blocks:
        print("❌ 处理失败")
        return
    
    # 步骤2：解析表格
    print("\n🔍 步骤2: 解析表格结构...")
    parser = TextractTableParser(blocks)
    
    tables_by_page = parser.get_tables_by_page()
    print(f"   发现 {len(tables_by_page)} 页包含表格")
    
    for page_num, tables in tables_by_page.items():
        print(f"     第{page_num}页: {len(tables)}个表格")
    
    # 步骤3：跨页拼接（如果需要）
    print("\n🔗 步骤3: 跨页表格拼接...")
    merged_table = parser.merge_across_pages(tables_by_page)
    if merged_table:
        print(f"   跨页拼接后表格: {len(merged_table)}行")
    
    # 步骤4：导出Excel
    print("\n📊 步骤4: 导出到Excel...")
    exporter = TextractToExcel(blocks)
    exporter.export_to_excel(output_excel)
    
    print("\n✅ 工作流完成!")


# 调用示例
if __name__ == "__main__":
    complete_workflow(
        bucket="your-textract-bucket",
        document_key="financial_report.pdf",
        output_excel="financial_tables.xlsx"
    )

六、适用场景：财务报表、合同、票据的企业级处理

6.1 行业应用全景图

Textract

企业级应用场景
金融服务
贷款申请自动审批
银行对账单处理
股票交易记录提取
财务会计
发票信息批量提取
费用报销自动化
财务三表结构化
保险行业
理赔申请单处理
保单信息录入
事故报告分析
法律合规
合同关键条款提取
法律文书数字化
合规性审查
医疗健康
病历电子化
保险理赔单
诊断报告提取
物流零售
采购订单处理
发货单自动录入
供应商发票核对

6.2 场景一：财务报表处理

痛点：上市公司的年报、季报动辄上百页，包含大量财务三表（资产负债表、利润表、现金流量表）。审计和投资分析需要将这些表格数据提取出来进行横向/纵向对比分析。

Textract解决方案：

• 批量处理PDF年报，自动识别表格边界
• 提取每个单元格的数值和文字
• 与历史数据对比，自动标记异常变动

6.3 场景二：发票批量处理

痛点：企业每月可能收到成百上千张供应商发票，财务人员需要逐个录入发票号、金额、税额、开票日期。

Textract解决方案：

• Textract的AnalyzeExpense专用API专为发票和收据优化
• 自动识别发票中的关键字段
• 可与ERP系统集成，实现发票自动过账[reference:10]

6.4 场景三：合同文本分析

痛点：合同扫描件通常包含复杂的键值对信息（如"签约日期：2025-03-15"、"甲方：XX公司"），手动提取耗时且容易遗漏。

Textract解决方案：

• 使用Forms功能自动识别键值对
• 结合Amazon Comprehend进行实体识别
• 支持批量合同的关键条款提取[reference:11]

6.5 场景四：政府/医疗表格电子化

痛点：大量表单包含手写填写内容（如申请表、体检报告），传统OCR对手写识别率低。

Textract解决方案：

• Textract支持手写文字识别
• 可与人工审核(A2I)结合，对低置信度的内容进行人工确认
• 满足HIPAA等合规要求[reference:12]

七、成本与性能实测（每千页价格）

7.1 定价模型详解

Textract采用按页计费的定价模式，根据使用的功能不同，每页价格有所差异。[reference:13][reference:14]
Textract定价分层
基础文本检测

$0.0015/页
表格提取

$0.015/页
表单提取

$0.05/页
智能查询

+$0.015/页
完整分析

≈$0.08/页

具体定价：

功能	每页价格	每千页价格	说明
文本检测 (Text Detection)	$0.0015	$1.50	仅提取文字，无结构
表格提取 (Table)	$0.015	$15.00	识别表格结构
表单提取 (Form)	$0.05	$50.00	识别键值对
智能查询 (Query)	$0.015	$15.00	附加功能
完整分析 (Tables+Forms)	约$0.065	约$65	同时开启多特征
完整分析+查询	约$0.08	约$80	全功能开启

价格说明：

• 以上价格为标准按需定价（截至2026年）
• 月处理量超过100万页后，单价降至约$0.0006/页[reference:15]
• 新AWS用户可享受3个月免费套餐：每月最多1000页（Text任务）或100页（Form/Table任务）[reference:16]

7.2 成本估算示例

假设某企业需要处理以下文档：

文档类型	月处理量	所需功能	估算月成本
供应商发票	500页	Tables + Forms	500 × 0.065 = 32.50
财务年报	200页	Tables	200 × 0.015 = 3.00
合同扫描件	100页	Forms	100 × 0.05 = 5.00
合计	800页	-	约$40.50/月

7.3 性能实测数据

根据实际测试，Textract的处理性能如下：

文档类型	页数	处理时间	平均每页耗时
单页发票（图片）	1页	约2-3秒	2-3秒
10页PDF（纯文字）	10页	约20-30秒	2-3秒
50页PDF（含表格）	50页	约2-3分钟	约3秒/页
300页PDF（复杂布局）	300页	约15-20分钟	约3-4秒/页

Textract处理速度约2.9秒/页，与竞品相当，批量处理的优势在于无需人工干预。[reference:17]

7.4 成本优化建议

1. 按需使用：只在需要时调用，无最低消费
2. 精准选择功能：如果只需要表格，不要开启Forms功能
3. 利用免费额度：试用期充分利用每月1000页的免费额度
4. 批量处理：合并小文档，减少API调用开销
5. 考虑混合方案：高频场景购买资源包，低频场景按量付费[reference:18]

八、总结与最佳实践

8.1 Textract vs 传统OCR方案

对比维度	传统OCR	AWS Textract
表格结构识别	❌ 无法识别	✅ 自动识别行列、合并单元格
键值对提取	❌ 无法提取	✅ 自动识别"字段：值"
手写文字	⚠️ 识别率低	✅ 支持手写识别
跨页表格	❌ 需手动拼接	⚠️ 需后处理拼接
大规模处理	⚠️ 需自建队列	✅ 异步+自动扩展
定价	一次性买断或按量	按页计费

8.2 核心要点回顾

核心要点
Textract不是OCR

而是智能文档理解
理解Block模型

是解析的关键
跨页表格拼接

需要自行实现
TRP库可简化

单页内解析
按功能计费

精准选择省成本

1. Textract的本质：不是普通OCR，而是能够理解文档结构（表格、表单、布局）的智能服务
2. Block模型：掌握PAGE→TABLE→CELL→WORD的层次关系，是正确解析输出的前提
3. 跨页表格：Textract不会自动拼接跨页表格，需要根据业务逻辑自行实现
4. TRP库 ：使用amazon-textract-response-parser可以大幅简化单页内的解析工作
5. 成本控制：按需开启功能（TABLES/FORMS/QUERIES），精准选择才能控制预算

8.3 下一步建议

• 深入学习 ：阅读AWS Textract官方文档，了解更多高级功能如AnalyzeExpense、AnalyzeID
• 自动化集成：将Textract与AWS Lambda、SQS、Step Functions结合，构建全自动的文档处理流水线
• 人工智能结合：将Textract提取的文本与Amazon Bedrock/Claude结合，实现智能文档摘要和问答

---