[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) 或  → 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
本文作者:
千千寰宇
本文链接: https://www.cnblogs.com/johnnyzen
关于博文:评论和私信会在第一时间回复,或直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
日常交流:大数据与软件开发-QQ交流群: 774386015 【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力!
本文链接: https://www.cnblogs.com/johnnyzen
关于博文:评论和私信会在第一时间回复,或直接私信我。
版权声明:本博客所有文章除特别声明外,均采用 BY-NC-SA 许可协议。转载请注明出处!
日常交流:大数据与软件开发-QQ交流群: 774386015 【入群二维码】参见左下角。您的支持、鼓励是博主技术写作的重要动力!

浙公网安备 33010602011771号