[Python/Java] Markdown 表格文本转 CSV 文本

0 序

  • 用途1: DeepSeek/Kimi等GPT模型的 MarkDown 表格文本,转 CSV 文件数据
  • 用途2: 平时在笔记软件中编辑的 Markdown 表格文本数据,转 CSV 文件数据

1 Java 实现(源码)

  • Java 8 / 17

MarkdownTableToCsvConverter


import lombok.extern.slf4j.Slf4j;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Pattern;

/**
 * Markdown 表格 → CSV 转换器
 * <p>
 * 从 Markdown 文本中提取 GFM(GitHub Flavored Markdown) 表格,并转换为 CSV(RFC 4180) 文本。
 * 核心规则:
 * <pre>
 *  1) 表格识别:由「表头行 + 分隔行(| --- | :---: | 之类) + 其下连续含竖线的数据行」构成一个表格;
 *     文档中若存在多个表格,按出现顺序依次转换,各表格的 CSV 之间以一个空行分隔;
 *  2) 竖线转义:单元格内的 \| 视为字面竖线 '|',不会被当作列分隔符;
 *  3) 对齐分隔行(:--- / ---: / :---:) 仅用于识别表格,在 CSV 中无意义,直接丢弃;
 *  4) 列数对齐:数据行列数少于表头时右侧补空串,多于表头时截断(与 GFM 渲染行为一致);
 *  5) CSV 转义(RFC 4180):字段含 逗号/双引号/换行符 时,用双引号包裹且内部双引号翻倍;
 *  6) 行内标记(可选):可去除单元格内的 **加粗**、*斜体*、`代码`、[链接](url)、~~删除线~~ 等
 *     行内 Markdown 标记,仅保留纯文本;
 *  7) 围栏代码块(``` 或 ~~~)内的伪表格不会被误识别为表格。
 * </pre>
 *
 * @create-time 2026-11-10 11:30
 * @note
 *  简化说明:竖线转义仅支持 \|(GFM 表格中的标准转义写法),
 *  \\| 双反斜杠等罕见转义组合不保证与 GFM 渲染完全一致。
 *  使用示例:
 *  <pre>
 *    String csv = MarkdownTableToCsvConverter.convert(markdownText);        // 保留单元格原始文本
 *    String csv = MarkdownTableToCsvConverter.convert(markdownText, true);  // 去除行内 Markdown 标记
 *    Files.writeString(Paths.get("target/md2csv-demo-out.csv"), csv, StandardCharsets.UTF_8);  // 落盘为 CSV 文件
 *  </pre>
 */
@Slf4j
public final class MarkdownTableToCsvConverter {

    /** CSV 行分隔符:选用 \n(兼容性最好;若需严格 RFC 4180 的 \r\n 格式,改此处即可) */
    private static final String LINE_SEPARATOR = "\n";

    /**
     * 分隔行中单个「分隔单元格」的匹配模式:
     * 允许对齐冒号与空白,如 :--- / ---: / :---: / --- / -;至少一个 '-',不允许其他字符
     */
    private static final Pattern SEPARATOR_CELL_PATTERN = Pattern.compile("\\s*:?-+:?\\s*");

    // —— 以下正则用于【可选】去除单元格内的行内 Markdown 标记 ——

    /** 行内代码:`code` → code(最先处理,避免代码内容中的 * 等标记被后续正则误去除) */
    private static final Pattern INLINE_CODE_PATTERN = Pattern.compile("`([^`]+)`");

    /** 链接/图片:[text](url) 或 ![alt](url) → text/alt */
    private static final Pattern LINK_IMAGE_PATTERN = Pattern.compile("!?\\[([^\\]]*)]\\([^)]*\\)");

    /** 加粗:**bold** */
    private static final Pattern BOLD_PATTERN = Pattern.compile("\\*\\*(.+?)\\*\\*");

    /** 加粗备选写法:__bold__ */
    private static final Pattern BOLD_ALT_PATTERN = Pattern.compile("__(.+?)__");

    /** 删除线:~~text~~ */
    private static final Pattern STRIKETHROUGH_PATTERN = Pattern.compile("~~(.+?)~~");

    /** 斜体:*italic*(放在加粗之后处理,保证 ***x*** 可正确退化) */
    private static final Pattern ITALIC_PATTERN = Pattern.compile("\\*(.+?)\\*");

    /** 纯静态工具类,禁止实例化 */
    private MarkdownTableToCsvConverter() {
        throw new UnsupportedOperationException("工具类不允许实例化");
    }

    /**
     * 将 Markdown 文本中的表格转换为 CSV 文本(保留单元格内的行内 Markdown 标记)
     *
     * @param markdownText 原始 Markdown 文本(可包含表格之外的普通文本,仅提取表格部分)
     * @return CSV 文本;输入为 null/空 或不含表格时返回空字符串
     */
    public static String convert(String markdownText) {
        return convert(markdownText, false);
    }

    /**
     * 将 Markdown 文本中的表格转换为 CSV 文本
     *
     * @param markdownText        原始 Markdown 文本
     * @param stripInlineMarkdown true = 去除单元格内的行内 Markdown 标记(加粗/斜体/代码/链接/删除线),仅保留纯文本
     * @return CSV 文本;输入为 null/空 或不含表格时返回空字符串
     */
    public static String convert(String markdownText, boolean stripInlineMarkdown) {
        // 边界保护:空输入直接返回,避免无意义的解析开销
        if (markdownText == null || markdownText.isEmpty()) {
            return "";
        }

        log.debug("convert-begin | stripInlineMarkdown={}\n{}", stripInlineMarkdown, markdownText);

        // 1. 按行扫描,提取文档中的所有 Markdown 表格(每个表格 = 若干行单元格)
        List<List<List<String>>> tables = extractTables(markdownText);

        // 2. 每个表格逐行转为 CSV;多个表格之间以一个空行分隔
        StringBuilder csv = new StringBuilder();
        for (List<List<String>> table : tables) {
            if (csv.length() > 0) {
                csv.append(LINE_SEPARATOR);// 表格之间的分隔空行
            }
            // 以表头列数为基准:数据行不足补空串、超出截断,保证 CSV 每行字段数一致(GFM 渲染行为)
            int columnCount = table.get(0).size();
            for (List<String> row : table) {
                csv.append(toCsvRow(normalizeRow(row, columnCount), stripInlineMarkdown)).append(LINE_SEPARATOR);
            }
        }

        log.debug("convert-end\n{}", csv);
        return csv.toString();
    }

    // ==================== 表格提取 ====================

    /**
     * 扫描 Markdown 文本,提取其中所有表格,三层结构:
     * tables.get(k).get(r).get(c) = 第 k 个表格的第 r 行的第 c 个单元格
     */
    private static List<List<List<String>>> extractTables(String markdownText) {
        // 注意:-1 保留尾部空行,使 split 行为与逐行读取一致
        String[] lines = markdownText.split("\\r?\\n", -1);
        List<List<List<String>>> tables = new ArrayList<>();
        // 记录各行是否已被上方表格吞并,防止「上一行刚作为上个表格的数据行,又被误判为新表格的表头」
        boolean[] consumed = new boolean[lines.length];
        // 是否处于 ``` / ~~~ 围栏代码块内:块内的 '|' 行一律不参与表格识别
        boolean inFence = false;

        for (int i = 0; i < lines.length; i++) {
            String line = lines[i];

            // 围栏代码块开关行(含闭合行),状态翻转后跳过
            if (isFenceStart(line)) {
                inFence = !inFence;
                consumed[i] = true;
                continue;
            }
            if (inFence) {
                continue;// 代码块内容不参与表格识别
            }

            // 表格入口判定:当前行是分隔行,且其上一行是未被消费的「含未转义竖线的行」——则上一行即表头
            if (isSeparatorLine(line) && i > 0 && !consumed[i - 1] && containsUnescapedPipe(lines[i - 1])) {
                List<List<String>> table = new ArrayList<>();
                table.add(splitCells(lines[i - 1]));// 表头行
                consumed[i] = true;

                // 自分隔行下一行起,向下吞并所有连续的数据行(遇空行/无竖线行/围栏行即终止)
                int j = i + 1;
                while (j < lines.length && !isFenceStart(lines[j]) && containsUnescapedPipe(lines[j])) {
                    // 罕见场景:数据区中再出现分隔行(如表格分段书写),跳过不输出分隔内容
                    if (isSeparatorLine(lines[j])) {
                        consumed[j] = true;
                        j++;
                        continue;
                    }
                    table.add(splitCells(lines[j]));
                    consumed[j] = true;
                    j++;
                }
                // 主循环跳到数据行结束处(外层 i++ 后从 j 继续扫描)
                i = j - 1;
                tables.add(table);
            }
        }
        return tables;
    }

    /**
     * 判断一行文本是否为 GFM 表格的「分隔行」,例如:| --- | :---: | ---: |
     * 规则:去掉首尾可选竖线后,按竖线切分出的每一段都必须是 :--- / ---: / :---: / --- 形式
     */
    private static boolean isSeparatorLine(String line) {
        // 快速短路:不含竖线的行不会是分隔行(纯 ---------- / *** 之类属于水平线,需排除)
        if (!line.contains("|")) {
            return false;
        }
        String trimmed = line.trim();
        // 去掉行首可选竖线
        if (trimmed.startsWith("|")) {
            trimmed = trimmed.substring(1).trim();
        }
        // 去掉行尾可选竖线;若行尾是被转义的 \|,则该行必为数据行而非分隔行
        if (trimmed.endsWith("|")) {
            if (trimmed.endsWith("\\|")) {
                return false;
            }
            trimmed = trimmed.substring(0, trimmed.length() - 1).trim();
        }
        if (trimmed.isEmpty()) {
            return false;
        }
        // 每一段都必须是合法的分隔单元格(:---: / --- 之类)
        for (String part : trimmed.split("\\|", -1)) {
            if (!SEPARATOR_CELL_PATTERN.matcher(part).matches()) {
                return false;
            }
        }
        return true;
    }

    /**
     * 判断一行文本是否含有「未被转义的竖线」(\| 视为字面竖线,不算分隔符)
     * 用于区分表格行与普通文本行
     */
    private static boolean containsUnescapedPipe(String line) {
        for (int i = 0; i < line.length(); i++) {
            if (line.charAt(i) == '|') {
                // 统计竖线之前连续的反斜杠个数:奇数个 → 该竖线被转义,忽略;偶数个 → 未转义的分隔符
                int backslashes = 0;
                int k = i - 1;
                while (k >= 0 && line.charAt(k) == '\\') {
                    backslashes++;
                    k--;
                }
                if (backslashes % 2 == 0) {
                    return true;
                }
            }
        }
        return false;
    }

    /** 判断一行是否为 ``` 或 ~~~ 围栏代码块的开启/闭合行(允许缩进与语言后缀) */
    private static boolean isFenceStart(String line) {
        String trimmed = line.trim();
        return trimmed.startsWith("```") || trimmed.startsWith("~~~");
    }

    // ==================== 行解析与 CSV 输出 ====================

    /**
     * 将一行 Markdown 表格文本切分为单元格列表,同时还原转义竖线:
     *  1) 遇未转义的 '|' 即为列分隔符;
     *  2) '\|' 还原为字面竖线 '|';
     *  3) 行首/行尾的可选竖线不产生空单元格(| a | b | 与 a | b 等价);
     *  4) 每个单元格去除首尾空白(与 GFM 渲染一致)。
     */
    private static List<String> splitCells(String line) {
        List<String> cells = new ArrayList<>();
        StringBuilder current = new StringBuilder();
        int n = line.length();
        // 行尾(trim 前)是否存在「未转义竖线」紧邻行尾的情况,用于判断是否移除末尾空单元格
        boolean trailingByPipe = line.trim().endsWith("|") && !line.trim().endsWith("\\|");

        for (int i = 0; i < n; i++) {
            char c = line.charAt(i);
            if (c == '\\' && i + 1 < n && line.charAt(i + 1) == '|') {
                // 转义竖线 \| → 字面竖线 |,并跳过下一个字符(该 | 不再作为分隔符)
                current.append('|');
                i++;
            } else if (c == '|') {
                // 未转义的竖线 = 列分隔符
                cells.add(current.toString());
                current.setLength(0);
            } else {
                current.append(c);
            }
        }
        // 收尾:追加最后一个单元格
        cells.add(current.toString());

        // 首尾可选竖线处理:行首/行尾的竖线会切分出多余的空单元格,按 GFM 语义移除
        String trimmed = line.trim();
        if (trimmed.startsWith("|") && !cells.isEmpty()) {
            cells.remove(0);
        }
        // 若行尾是「转义竖线 \|」,说明末尾单元格是真实数据,不能移除
        if (trailingByPipe && !cells.isEmpty()) {
            cells.remove(cells.size() - 1);
        }

        // 每个单元格去首尾空白(与 GFM 渲染行为一致)
        List<String> result = new ArrayList<>(cells.size());
        for (String cell : cells) {
            result.add(cell.trim());
        }
        return result;
    }

    /**
     * 将数据行的列数对齐到表头列数(与 GFM 渲染行为一致):
     * 少于表头 → 右侧补空串;多于表头 → 截断。
     * 保证输出的 CSV 每行字段数相同(CSV 消费方的常见假设)。
     */
    private static List<String> normalizeRow(List<String> row, int columnCount) {
        List<String> normalized = new ArrayList<>(row);
        while (normalized.size() < columnCount) {
            normalized.add("");// 列数不足 → 右侧补空串
        }
        if (normalized.size() > columnCount) {
            // 列数超出 → 截断到表头列数
            normalized = new ArrayList<>(normalized.subList(0, columnCount));
        }
        return normalized;
    }

    /**
     * 将一个表格行(单元格序列)序列化为一行 CSV 文本:
     *  1) 可选去除行内 Markdown 标记;
     *  2) 各字段按 RFC 4180 转义后以逗号拼接。
     */
    private static String toCsvRow(List<String> cells, boolean stripInlineMarkdown) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < cells.size(); i++) {
            if (i > 0) {
                sb.append(',');// 字段分隔符
            }
            String cell = cells.get(i);
            if (stripInlineMarkdown) {
                cell = stripInlineMarkdown(cell);
            }
            sb.append(escapeCsvField(cell));
        }
        return sb.toString();
    }

    /**
     * CSV 字段转义(RFC 4180):
     * 字段中包含 逗号 / 双引号 / 换行符 / 回车符 任一字符时,
     * 整个字段用双引号包裹,且字段内的双引号一律翻倍转义为 ""
     */
    private static String escapeCsvField(String cell) {
        if (cell.contains(",") || cell.contains("\"") || cell.contains("\n") || cell.contains("\r")) {
            return '"' + cell.replace("\"", "\"\"") + '"';
        }
        return cell;
    }

    /**
     * 去除单元格内的行内 Markdown 标记,仅保留纯文本。
     * 处理顺序:行内代码 → 链接/图片 → 加粗(两种写法) → 删除线 → 斜体
     * (代码最先处理,可避免代码内容中的星号等被后续正则误去除)
     */
    private static String stripInlineMarkdown(String cell) {
        String text = cell;
        text = INLINE_CODE_PATTERN.matcher(text).replaceAll("$1");// `code` → code
        text = LINK_IMAGE_PATTERN.matcher(text).replaceAll("$1");// [text](url) → text
        text = BOLD_PATTERN.matcher(text).replaceAll("$1");// **bold** → bold
        text = BOLD_ALT_PATTERN.matcher(text).replaceAll("$1");// __bold__ → bold
        text = STRIKETHROUGH_PATTERN.matcher(text).replaceAll("$1");// ~~x~~ → x
        text = ITALIC_PATTERN.matcher(text).replaceAll("$1");// *x* → x
        return text;
    }
}

MarkdownTableFormatConverterTest

import org.junit.Test;

import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

/**
 *
 * @version v1.0.0
 * @description
 * Markdown 表格 → CSV 端到端演示(临时验证程序,存放于 target 目录,不进入 src)
 * 生成 CSV 文件后直接从磁盘回读,验证落盘产物的真实内容
 * @create-time 2026/11/10 11:24
 * @update-time
 *
 */
public class MarkdownTableFormatConverterTest {
    @Test
    public void testMarkdownTableToCsv() throws IOException {
        // 模拟一段真实文档:含标题、表格(含中英文、逗号、双引号、转义竖线、对齐标记)
        String md = """
                ## 数据资产清单

                | 字段名 | 类型 | 说明 | 备注 |
                |--------|------|:----:|-----:|
                | user_id | BIGINT | 用户ID | 主键 |
                | tags | STRING | 标签集合 | a, b |
                | bio | STRING | 简介 | 他说: "你好" |
                """;
        // stripInlineMarkdown = true:去除行内标记,保留纯文本
        String csv = MarkdownTableToCsvConverter.convert(md, true);
        Path out = Paths.get("target/md2csv-demo-out.csv");
        Files.writeString(out, csv, StandardCharsets.UTF_8);
        System.out.println("CSV written: " + out.toAbsolutePath());
    }
}

output:

字段名,类型,说明,备注
user_id,BIGINT,用户ID,主键
tags,STRING,标签集合,"a, b"
bio,STRING,简介,"他说: ""你好"""

2 Python 实现(源码)

  • python 3

markdown_table_to_csv.py

import csv
import re

"""
@TongyiGPT : Python实现:将任意列的 Markdown 表格文本 转 CSV 文件输出 (提示词并非仅此1条,过程中有诸多调整细节,仅供参考)
"""

# 函数:正则判断文本是否是以 "| 文本列1 | 文本列2 | ... |" 格式 的 MarkDown 表格行(表头行、表头行与数据行的分隔行、数据行)
def is_markdown_table_line_format(text):
    # 正则判断是否为 Markdown 表格行
    # pattern = re.compile(r'^\|.*\|$')
    pattern = re.compile(r'^\s*\|.*\|\s*$')
    return bool(pattern.match(text))

# 函数: 判断文本是否为 Markdown 表格分隔行(非表头行、非数据行)
"""
is_markdown_table_seperator_line_format("|numer|text|") => False
is_markdown_table_seperator_line_format("|-----|-----|") => True
is_markdown_table_seperator_line_format("|1|world|") => False
is_markdown_table_seperator_line_format("|---|-xx--|") => False
"""
def is_markdown_table_seperator_line_format(markdown_table_line):
    # 转 markdown_table_line 为数组
    cells = [cell.strip() for cell in markdown_table_line.split('|') if cell.strip()]

    # 如果 cells 是空列表,则: bool(cells) 返回 False
    if bool(cells): # 若 cells 字符串数组不为空
        # 对 cells 字符串数组进行判断,如果 cells 数组内 cell 字符串 每个元素均以'-'字符串构成,则认定为分隔行
        for cell in cells:
            if not all(char == '-' for char in cell):
                return False
        return True
    else: # 若 cells 字符串数组为空
        return False



# 函数:解析 Markdown 表格文本
# def parse_markdown_table(markdown_table):
#     lines = markdown_table.split('\n')
#     headers = [header.strip() for header in lines[0].split('|') if header.strip()]
#     rows = []
#     for line in lines[2:]:
#         cells = [cell.strip() for cell in line.split('|') if cell.strip()]
#         if cells:
#             rows.append(cells)
#     return headers, rows

def parse_markdown_table(markdown_table):
    # step1 按行分割 markdown 文本
    lines = markdown_table.split('\n')
    # print("lines-v1:\n", lines)
    
    # step2 遍历并去除所有的空行(仅含有''、' '、\t制表符的文本行)
    lines = [line for line in lines if line.strip()]
    # print("lines-v2:\n", lines)

    # step3 解析 header | 前置条件: 第1行必须是表头行
    header_line = lines[0]
    headers = [header.strip() for header in header_line.split('|') if header.strip()]
    print(0, " | ", is_markdown_table_line_format(header_line) , " | ", is_markdown_table_seperator_line_format(header_line) , " | ", header_line)

    # step4 解析数据行 | 建议: 第3行及后续行是数据行
    lines = lines[2:] # 截取第3行及后续行
    rows = []
    for i, line in enumerate(lines):
        print(i+1, " | ", is_markdown_table_line_format(line) , " | ", is_markdown_table_seperator_line_format(line) , " | ", line)
        if is_markdown_table_line_format(line): # 判断是否为 Markdown 表格行(表头行、分隔行、数据行)
            if not is_markdown_table_seperator_line_format(line): # 判断是否为 Markdown 分隔行 (非分隔行,则即:数据行)
                # print(i+1, " : ", is_markdown_table_seperator_line_format(line) , " : ", line)
                # print(i+1, " : ", is_markdown_table_line_format(line) , ": ", line)
                cells = [cell.strip() for cell in line.split('|') if cell.strip()]
                if cells:
                    rows.append(cells);

    # step5 调试、打印解析后的数据
    # print("headers:\n", headers)
    # print("rows:\n", rows)
    return headers, rows

# 新增函数:将解析后的数据写入 CSV 文件
def write_csv(headers, rows, filename):
    # 为避免 Windows 系统 Excel 打开 utf-8 的 CSV 文件时中文显示乱码,在生成文件时添加 BOM 标记
    # with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
    with open(filename, 'w', newline='', encoding='utf-8-sig') as csvfile:
        writer = csv.writer(csvfile)
        writer.writerow(headers)
        writer.writerows(rows)


def main():
    # step1 提供Markdown表格
    ## 方式1: 人工指定的 Markdown 表格文本
    # markdown_table = """
    # | 项目名称(projectName) | URL(url) | Star数(starCount) | Fork数(forkCount) |
    # |-----------------------|----------|-------------------|-------------------|
    # | Joplin | https://github.com/laurent22/joplin | 47559 | 5170 |
    # | Standard Notes | https://github.com/standardnotes/app | 5525 | 437 |
    # """

    ## 方式2: 从指定文件路径读取文本内容
    markdown_file_path = 'C:\\Users\\xxxxxx\\Desktop\\input.md'
    # with open(markdown_file_path, 'r', encoding='utf-8') as file:
    #     markdown_table = file.read()
    markdown_table = open(markdown_file_path, 'r', encoding='utf-8').read()

    print("markdown_file_content:\n", markdown_table, "\n")


    # step2 解析Markdown表格
    headers, rows = parse_markdown_table(markdown_table)

    # step3 将解析后的数据写入CSV文件
    output_dir = 'C:\\Users\\408675\\Desktop\\output.csv';
    write_csv(headers, rows, output_dir)
    print(f"CSV文件已生成到: {output_dir}")


if __name__ == "__main__":
    main()

X 参考文献

  • 通义灵码
  • Kimi GPT
posted @ 2025-02-08 11:50  千千寰宇  阅读(2)  评论(0)    收藏  举报