编程部落

Python生成Markdown文件的完整指南

作者：

风君子

在

文章目录
  • Flutter是一个由Google开发的开源UI工具包，它可以让您在不同平台上创建高质量、美观的应用程序，而无需编写大量平台特定的代码。我将学习和深入研究Flutter的方方面面。从基础知识到高级技巧，从UI设计到性能优化，欢饮关注一起讨论学习，共同进入Flutter的精彩世界！ 以上就是Python生成Markdown文件的完整指南的详细内容，更多关于Python生成Markdown文件的资料请关注风君子博客其它相关文章！ 您可能感兴趣的文章: Python实现截图生成符合markdown的链接 Python3自动生成MySQL数据字典的markdown文本的实现 Python自动解析markdown中的图片并保存 基于Python开发一个现代化Markdown编辑器 Python 中 Markdown 库的使用教程从入门到实践
    • 目录
    • 一、基础方法：直接写入
      • 1. 简单文本写入
      • 2. 动态生成内容
      • 总结
      • 使用示例
    • 二、使用模板引擎生成
      • 1. 使用字符串模板
      • 2. 使用 Jinja2 模板引擎
      • 总结
      • 使用Jinja2生成
    • 三、使用专业库生成
      • 1. 使用 python-markdown 库（反向生成）
      • 2. 使用 mistune 库
    • 四、从数据结构生成
      • 1. 从JSON/YAML生成
      • 2. 从数据库生成文档
    • 五、高级功能：自动生成工具
      • 1. 从Python代码生成文档
    • 结束语

      def create_simple_markdown():
    """创建简单的Markdown文件"""
    
    content = """# 主标题

这是第一个段落。

## 二级标题

这是第二个段落。

### 三级标题

这是一个无序列表：
- 项目1
- 项目2
- 项目3

这是一个有序列表：
1. 第一项
2. 第二项
3. 第三项

**粗体文本** 和 *斜体文本*

`行内代码`

[链接文本](https://example.com)

![图片描述](image.jpg)
"""
    
    with open("simple_document.md", "w", encoding="utf-8") as f:
        f.write(content)
    
    print("Markdown文件已创建: simple_document.md")

# 使用
create_simple_markdown()


      def create_dynamic_markdown(data):
    """根据数据动态生成Markdown"""
    
    content = f"""# {data['title']}

**创建时间**: {data['date']}
**作者**: {data['author']}

## 概述
{data['overview']}

## 详细内容
{data['content']}

## 特性
"""
    
    # 添加列表
    for feature in data['features']:
        content += f"- {feature}n"
    
    content += f"""
## 代码示例
```python
{data['code_example']}


      with open("dynamic_document.md", "w", encoding="utf-8") as f:
    f.write(content)

print("动态Markdown文件已创建")


      data = {
‘title': ‘Python项目文档',
‘date': ‘2024-01-20',
‘author': ‘张三',
‘overview': ‘这是一个使用Python生成Markdown的示例项目。',
‘content': ‘详细说明了如何使用Python创建Markdown文件。',
‘features': [
‘自动生成文档',
‘支持多种格式',
‘可自定义模板',
‘易于扩展'
],
‘code_example': ‘print(“Hello, Markdown!”)',
‘summary': ‘这是一个非常有用的工具。'
}

create_dynamic_markdown(data)

      #python
from string import Template

class MarkdownTemplate:
    """Markdown模板生成器"""
    
    def __init__(self):
        self.templates = {
            'report': self._report_template(),
            'api_doc': self._api_doc_template(),
            'readme': self._readme_template(),
            'note': self._note_template()
        }
    
    def _report_template(self):
        """报告模板"""
        return Template("""# ${title}

## 基本信息
- **项目**: ${project}
- **日期**: ${date}
- **作者**: ${author}
- **版本**: ${version}

## 执行摘要
${summary}

## 详细内容
${content}

## 结果分析
${analysis}

## 结论
${conclusion}

## 建议
${recommendations}

## 附录
${appendix}
""")
    
    def _readme_template(self):
        """README模板"""
        return Template("""# ${project_name}

${badges}

${description}

## ✨ 特性
${features}

## 🚀 快速开始

### 安装
```bash
${install_command}
```

### 使用示例
```python
${usage_example}
```

## 📖 文档
${documentation}

## 🤝 贡献
${contributing}

## 📄 许可证
${license}

## 📞 联系方式
${contact}
""")
    
    def _api_doc_template(self):
        """API文档模板"""
        return Template("""# ${api_name} API 文档

## 概述
${overview}

## 认证
${authentication}

## 端点

### ${endpoint_name}
**URL**: `${url}`

**方法**: ${method}

**参数**:
${parameters}

**响应**:
```json
${response_example}
```

**错误码**:
${error_codes}

## 使用示例
${usage_examples}
""")
    
    def generate(self, template_name, data, output_file=None):
        """生成Markdown文件"""
        if template_name not in self.templates:
            raise ValueError(f"模板不存在: {template_name}")
        
        template = self.templates[template_name]
        content = template.safe_substitute(data)
        
        if output_file:
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(content)
            print(f"Markdown文件已生成: {output_file}")
        
        return content

# 使用示例
md_generator = MarkdownTemplate()

# 生成报告
report_data = {
    'title': '季度项目报告',
    'project': '数据分析平台',
    'date': '2024-Q1',
    'author': '张三',
    'version': '1.0.0',
    'summary': '本季度项目进展顺利，完成了主要功能开发。',
    'content': '详细开发了数据导入、处理和可视化模块。',
    'analysis': '性能提升了30%，用户满意度达到95%。',
    'conclusion': '项目按计划推进，达到预期目标。',
    'recommendations': '建议增加AI分析功能。',
    'appendix': '详见附件文档。'
}

report_md = md_generator.generate('report', report_data, '季度报告.md')

# 生成README
readme_data = {
    'project_name': 'Awesome Project',
    'badges': '[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)]',
    'description': '一个非常棒的项目，用于演示Markdown生成。',
    'features': '- 功能一n- 功能二n- 功能三',
    'install_command': 'pip install awesome-project',
    'usage_example': 'from awesome import Awesomenobj = Awesome()nobj.do_something()',
    'documentation': '详见 [文档网站](https://docs.example.com)',
    'contributing': '欢迎提交PR！',
    'license': 'MIT License',
    'contact': '邮箱: contact@example.com'
}

readme_md = md_generator.generate('readme', readme_data, 'README.md')


      from jinja2 import Template, Environment, FileSystemLoader
import os

class JinjaMarkdownGenerator:
    """使用Jinja2生成Markdown"""
    
    def __init__(self, template_dir="templates"):
        self.env = Environment(
            loader=FileSystemLoader(template_dir),
            trim_blocks=True,
            lstrip_blocks=True,
            keep_trailing_newline=True
        )
    
    def generate_from_template(self, template_name, context, output_file):
        """从模板生成Markdown"""
        template = self.env.get_template(template_name)
        content = template.render(**context)
        
        with open(output_file, "w", encoding="utf-8") as f:
            f.write(content)
        
        print(f"Markdown文件已生成: {output_file}")
        return content

# 创建模板目录和文件
os.makedirs("templates", exist_ok=True)

# 创建report模板 (templates/report.md.j2)
report_template_content = """# {{ title }}

## 项目信息
- **项目名称**: {{ project_name }}
- **版本**: v{{ version }}
- **生成时间**: {{ generated_at }}

## 概述
{{ overview }}

## 详细分析
{% for section in sections %}
### {{ section.title }}
{{ section.content }}

{% if section.items %}
**关键点**:
{% for item in section.items %}
- {{ item }}
{% endfor %}
{% endif %}

{% endfor %}

## 数据统计
| 指标 | 数值 | 状态 |
|------|------|------|
{% for metric in metrics %}
| {{ metric.name }} | {{ metric.value }} | {{ metric.status }} |
{% endfor %}

## 代码示例
```{{ code_language }}
{{ code_example }}


      with open(“templates/report.md.j2”, “w”, encoding=“utf-8”) as f:
f.write(report_template_content)

      generator = JinjaMarkdownGenerator(“templates”)

context = {
‘title': ‘项目分析报告',
‘project_name': ‘数据分析系统',
‘version': ‘1.2.0',
‘generated_at': ‘2024-01-20 10:30:00',
‘overview': ‘本报告分析了系统的运行情况和性能指标。',
‘sections': [
{
‘title': ‘性能分析',
‘content': ‘系统性能良好，响应时间在预期范围内。',
‘items': [‘平均响应时间: 200ms', ‘吞吐量: 1000 req/s', ‘错误率: 0.1%']
},
{
‘title': ‘用户分析',
‘content': ‘用户活跃度持续增长。',
‘items': [‘日活用户: 10,000', ‘月活用户: 50,000', ‘用户留存率: 85%']
}
],
‘metrics': [
{‘name': ‘CPU使用率', ‘value': ‘45%', ‘status': ‘正常'},
{‘name': ‘内存使用率', ‘value': ‘60%', ‘status': ‘正常'},
{‘name': ‘磁盘空间', ‘value': ‘75%', ‘status': ‘警告'},
{‘name': ‘网络延迟', ‘value': ‘50ms', ‘status': ‘优秀'}
],
‘code_language': ‘python',
‘code_example': ‘def analyze_data(data):n return process(data)',
‘summary': ‘系统运行稳定，建议关注磁盘空间使用情况。'
}

generator.generate_from_template(
‘report.md.j2',
context,
‘项目分析报告.md'
)

      #python
import markdown
from markdown.extensions.toc import TocExtension
from markdown.extensions.codehilite import CodeHiliteExtension
from markdown.extensions.tables import TableExtension

class MarkdownGenerator:
    """高级Markdown生成器"""
    
    def __init__(self):
        self.elements = []
    
    def add_title(self, text, level=1):
        """添加标题"""
        prefix = '#' * level
        self.elements.append(f"{prefix} {text}n")
        return self
    
    def add_paragraph(self, text):
        """添加段落"""
        self.elements.append(f"{text}nn")
        return self
    
    def add_list(self, items, ordered=False):
        """添加列表"""
        for i, item in enumerate(items):
            if ordered:
                self.elements.append(f"{i+1}. {item}n")
            else:
                self.elements.append(f"- {item}n")
        self.elements.append("n")
        return self
    
    def add_code_block(self, code, language=""):
        """添加代码块"""
        self.elements.append(f"```{language}n
      n```nn")
        return self
    
    def add_table(self, headers, rows):
        """添加表格"""
        # 表头
        header_row = "| " + " | ".join(headers) + " |"
        separator = "| " + " | ".join(["---"] * len(headers)) + " |"
        
        self.elements.append(header_row + "n")
        self.elements.append(separator + "n")
        
        # 数据行
        for row in rows:
            row_str = "| " + " | ".join(str(cell) for cell in row) + " |"
            self.elements.append(row_str + "n")
        
        self.elements.append("n")
        return self
    
    def add_blockquote(self, text):
        """添加引用"""
        lines = text.split('n')
        for line in lines:
            self.elements.append(f"> {line}n")
        self.elements.append("n")
        return self
    
    def add_horizontal_rule(self):
        """添加水平线"""
        self.elements.append("---nn")
        return self
    
    def add_link(self, text, url):
        """添加链接"""
        self.elements.append(f"[{text}]({url})nn")
        return self
    
    def add_image(self, alt_text, url, title=""):
        """添加图片"""
        if title:
            self.elements.append(f'![{alt_text}]({url} "{title}")nn')
        else:
            self.elements.append(f'![{alt_text}]({url})nn')
        return self
    
    def generate(self, output_file=None):
        """生成Markdown内容"""
        content = "".join(self.elements)
        
        if output_file:
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(content)
            print(f"Markdown文件已生成: {output_file}")
        
        return content

# 使用示例
md = MarkdownGenerator()

md.add_title("Python学习笔记", level=1)
md.add_paragraph("这是我的Python学习笔记，记录了一些重要的概念和示例。")
md.add_horizontal_rule()

md.add_title("基本语法", level=2)
md.add_paragraph("Python的基本语法非常简洁。")

md.add_title("数据类型", level=3)
md.add_list([
    "整数 (int)",
    "浮点数 (float)",
    "字符串 (str)",
    "列表 (list)",
    "字典 (dict)"
])

md.add_title("代码示例", level=2)
md.add_code_block("def hello(name):n    print(f'Hello, {name}!')nnhello('World')", "python")

md.add_title("数据结构对比", level=2)
md.add_table(
    ["数据结构", "可变性", "有序性", "示例"],
    [
        ["列表", "可变", "有序", "[1, 2, 3]"],
        ["元组", "不可变", "有序", "(1, 2, 3)"],
        ["集合", "可变", "无序", "{1, 2, 3}"],
        ["字典", "可变", "有序(3.7+)", "{'a': 1, 'b': 2}"]
    ]
)

md.add_blockquote("Python之禅：优美胜于丑陋，明了胜于晦涩。")

md.add_title("参考资源", level=2)
md.add_link("Python官方文档", "https://docs.python.org")
md.add_image("Python Logo", "https://www.python.org/static/img/python-logo.png", "Python官方Logo")

# 生成文件
content = md.generate("学习笔记.md")


      import mistune

class MarkdownRenderer(mistune.HTMLRenderer):
    """自定义Markdown渲染器（可用于反向生成）"""
    
    def __init__(self, escape=True):
        super().__init__(escape)
        self.output = []
    
    def text(self, text):
        self.output.append(text)
        return text
    
    def paragraph(self, text):
        self.output.append(f"n{text}n")
        return f"<p>{text}</p>"
    
    def generate_markdown(self):
        """获取生成的Markdown内容"""
        return "".join(self.output)

# 使用mistune解析并生成
def convert_to_markdown(html_content):
    """将HTML转换为Markdown（简单示例）"""
    # 注意：mistune主要是HTML转Markdown，这里展示反向思路
    pass


      import json
import yaml
from typing import Dict, List, Any

class DataToMarkdown:
    """从数据结构生成Markdown"""
    
    def __init__(self, indent_size=2):
        self.indent_size = indent_size
        self.indent_char = ' '
    
    def from_json(self, json_file: str, output_file: str = None) -> str:
        """从JSON文件生成Markdown"""
        with open(json_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
        
        return self._generate_from_dict(data, output_file)
    
    def from_yaml(self, yaml_file: str, output_file: str = None) -> str:
        """从YAML文件生成Markdown"""
        with open(yaml_file, 'r', encoding='utf-8') as f:
            data = yaml.safe_load(f)
        
        return self._generate_from_dict(data, output_file)
    
    def from_dict(self, data: Dict, output_file: str = None) -> str:
        """从字典生成Markdown"""
        return self._generate_from_dict(data, output_file)
    
    def _generate_from_dict(self, data: Dict, output_file: str = None) -> str:
        """从字典生成Markdown内容"""
        lines = []
        
        def process_value(key, value, level=0):
            indent = self.indent_char * self.indent_size * level
            
            if isinstance(value, dict):
                # 标题
                lines.append(f"{indent}# {' '.join(key.split('_')).title()}n")
                
                # 处理字典的键值对
                for k, v in value.items():
                    if isinstance(v, (dict, list)):
                        process_value(k, v, level + 1)
                    else:
                        lines.append(f"{indent}- **{k.replace('_', ' ').title()}**: {v}n")
                lines.append("n")
            
            elif isinstance(value, list):
                # 列表标题
                lines.append(f"{indent}## {' '.join(key.split('_')).title()}n")
                
                for item in value:
                    if isinstance(item, dict):
                        lines.append(f"{indent}###n")
                        for k, v in item.items():
                            lines.append(f"{indent}- **{k.replace('_', ' ').title()}**: {v}n")
                    else:
                        lines.append(f"{indent}- {item}n")
                lines.append("n")
            
            else:
                # 简单键值对
                lines.append(f"{indent}- **{key.replace('_', ' ').title()}**: {value}n")
        
        # 开始处理
        if isinstance(data, dict):
            # 添加主标题
            title = data.get('title', 'Document')
            lines.append(f"# {title}nn")
            
            # 处理其他内容
            for key, value in data.items():
                if key != 'title':
                    process_value(key, value)
        else:
            lines.append("# Documentnn")
            process_value('content', data)
        
        # 合并所有行
        content = ''.join(lines)
        
        # 写入文件
        if output_file:
            with open(output_file, 'w', encoding='utf-8') as f:
                f.write(content)
            print(f"Markdown文件已生成: {output_file}")
        
        return content

# 使用示例
json_data = {
    "title": "API 配置文档",
    "metadata": {
        "version": "1.0.0",
        "author": "张三",
        "created_at": "2024-01-20"
    },
    "endpoints": [
        {
            "name": "获取用户信息",
            "method": "GET",
            "path": "/api/users/{id}",
            "description": "根据用户ID获取用户信息",
            "parameters": [
                {"name": "id", "type": "integer", "required": True}
            ],
            "responses": [
                {"code": 200, "description": "成功"},
                {"code": 404, "description": "用户不存在"}
            ]
        },
        {
            "name": "创建用户",
            "method": "POST",
            "path": "/api/users",
            "description": "创建新用户",
            "parameters": [
                {"name": "username", "type": "string", "required": True},
                {"name": "email", "type": "string", "required": True}
            ],
            "responses": [
                {"code": 201, "description": "用户创建成功"},
                {"code": 400, "description": "参数错误"}
            ]
        }
    ],
    "authentication": {
        "type": "JWT",
        "description": "需要在请求头中添加Authorization: Bearer <token>"
    }
}

# 从字典生成
converter = DataToMarkdown()
markdown_content = converter.from_dict(json_data, "api_docs.md")

# 或者从JSON文件生成
with open("config.json", "w", encoding="utf-8") as f:
    json.dump(json_data, f, ensure_ascii=False, indent=2)

converter.from_json("config.json", "api_docs_from_json.md")


      import sqlite3
import mysql.connector
from typing import List, Dict

class DatabaseToMarkdown:
    """从数据库生成Markdown文档"""
    
    def __init__(self, db_type='sqlite', **kwargs):
        self.db_type = db_type
        self.connection_params = kwargs
        
    def connect(self):
        """连接到数据库"""
        if self.db_type == 'sqlite':
            self.conn = sqlite3.connect(self.connection_params.get('database'))
        elif self.db_type == 'mysql':
            self.conn = mysql.connector.connect(**self.connection_params)
        else:
            raise ValueError(f"不支持的数据库类型: {self.db_type}")
        
        return self.conn
    
    def generate_schema_doc(self, output_file: str = None) -> str:
        """生成数据库模式文档"""
        self.connect()
        cursor = self.conn.cursor()
        
        lines = ["# 数据库模式文档nn"]
        
        # 获取所有表
        if self.db_type == 'sqlite':
            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
            tables = [row[0] for row in cursor.fetchall()]
        elif self.db_type == 'mysql':
            cursor.execute("SHOW TABLES;")
            tables = [row[0] for row in cursor.fetchall()]
        
        for table in tables:
            if table.startswith('sqlite_'):
                continue
            
            lines.append(f"## 表: `{table}`nn")
            
            # 获取表结构
            if self.db_type == 'sqlite':
                cursor.execute(f"PRAGMA table_info({table});")
                columns = cursor.fetchall()
                
                # 表头
                lines.append("| 字段名 | 类型 | 是否为空 | 默认值 | 主键 |n")
                lines.append("|--------|------|----------|--------|------|n")
                
                for col in columns:
                    col_id, name, type_, notnull, default, pk = col
                    lines.append(f"| {name} | {type_} | {'NOT NULL' if notnull else ''} | {default if default else ''} | {'✓' if pk else ''} |n")
            
            elif self.db_type == 'mysql':
                cursor.execute(f"DESCRIBE {table};")
                columns = cursor.fetchall()
                
                lines.append("| 字段名 | 类型 | 是否为空 | 键 | 默认值 | 额外 |n")
                lines.append("|--------|------|----------|----|--------|------|n")
                
                for col in columns:
                    lines.append(f"| {col[0]} | {col[1]} | {col[2]} | {col[3]} | {col[4]} | {col[5]} |n")
            
            lines.append("n")
            
            # 获取索引信息
            if self.db_type == 'sqlite':
                cursor.execute(f"PRAGMA index_list({table});")
                indexes = cursor.fetchall()
                
                if indexes:
                    lines.append("### 索引nn")
                    for idx in indexes:
                        idx_id, idx_name, unique = idx
                        lines.append(f"- **{idx_name}** ({'唯一' if unique else '非唯一'})n")
                    lines.append("n")
            
            # 获取外键信息
            if self.db_type == 'sqlite':
                cursor.execute(f"PRAGMA foreign_key_list({table});")
                foreign_keys = cursor.fetchall()
                
                if foreign_keys:
                    lines.append("### 外键约束nn")
                    for fk in foreign_keys:
                        lines.append(f"- 从 `{fk[3]}` 到 `{fk[2]}.{fk[4]}`n")
                    lines.append("n")
        
        # 关闭连接
        cursor.close()
        self.conn.close()
        
        content = "".join(lines)
        
        if output_file:
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(content)
            print(f"数据库文档已生成: {output_file}")
        
        return content
    
    def generate_data_dictionary(self, output_file: str = None) -> str:
        """生成数据字典"""
        self.connect()
        cursor = self.conn.cursor()
        
        lines = ["# 数据字典nn"]
        
        # 获取所有表
        if self.db_type == 'sqlite':
            cursor.execute("SELECT name FROM sqlite_master WHERE type='table';")
            tables = [row[0] for row in cursor.fetchall()]
        elif self.db_type == 'mysql':
            cursor.execute("SHOW TABLES;")
            tables = [row[0] for row in cursor.fetchall()]
        
        for table in tables:
            if table.startswith('sqlite_'):
                continue
            
            lines.append(f"## `{table}`nn")
            lines.append("### 描述nn[填写表描述]nn")
            
            lines.append("### 字段说明nn")
            lines.append("| 字段名 | 数据类型 | 描述 | 示例 | 约束 |n")
            lines.append("|--------|----------|------|------|------|n")
            
            # 获取字段信息
            if self.db_type == 'sqlite':
                cursor.execute(f"PRAGMA table_info({table});")
                columns = cursor.fetchall()
                
                for col in columns:
                    col_id, name, type_, notnull, default, pk = col
                    constraints = []
                    if pk:
                        constraints.append("主键")
                    if notnull:
                        constraints.append("非空")
                    if default:
                        constraints.append(f"默认值: {default}")
                    
                    lines.append(f"| {name} | {type_} | [填写描述] | [填写示例] | {', '.join(constraints)} |n")
            
            elif self.db_type == 'mysql':
                cursor.execute(f"DESCRIBE {table};")
                columns = cursor.fetchall()
                
                for col in columns:
                    name, type_, nullable, key, default, extra = col
                    constraints = []
                    if key == 'PRI':
                        constraints.append("主键")
                    if key == 'UNI':
                        constraints.append("唯一")
                    if nullable == 'NO':
                        constraints.append("非空")
                    if default:
                        constraints.append(f"默认值: {default}")
                    if extra:
                        constraints.append(extra)
                    
                    lines.append(f"| {name} | {type_} | [填写描述] | [填写示例] | {', '.join(constraints)} |n")
            
            lines.append("n### 业务规则nn[填写业务规则]nn")
            lines.append("### 使用示例nn```sqlnSELECT * FROM {table} LIMIT 5;n```nn")
            lines.append("---nn")
        
        cursor.close()
        self.conn.close()
        
        content = "".join(lines)
        
        if output_file:
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(content)
            print(f"数据字典已生成: {output_file}")
        
        return content

# 使用示例
# 创建测试数据库
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()

cursor.execute("""
CREATE TABLE users (
    id INTEGER PRIMARY KEY,
    username TEXT NOT NULL UNIQUE,
    email TEXT NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
""")

cursor.execute("""
CREATE TABLE posts (
    id INTEGER PRIMARY KEY,
    user_id INTEGER,
    title TEXT NOT NULL,
    content TEXT,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (user_id) REFERENCES users(id)
);
""")

conn.commit()
conn.close()

# 生成文档
doc_gen = DatabaseToMarkdown(db_type='sqlite', database=":memory:")
schema_doc = doc_gen.generate_schema_doc("数据库模式.md")
data_dict = doc_gen.generate_data_dictionary("数据字典.md")


      import ast
import inspect
from typing import List, Dict, Any
import os

class PythonToMarkdown:
    """从Python代码生成Markdown文档"""
    
    def __init__(self):
        self.imports = []
        self.classes = []
        self.functions = []
    
    def analyze_file(self, filepath: str):
        """分析Python文件"""
        with open(filepath, 'r', encoding='utf-8') as f:
            content = f.read()
        
        tree = ast.parse(content)
        
        for node in ast.walk(tree):
            if isinstance(node, ast.Import):
                for alias in node.names:
                    self.imports.append(alias.name)
            elif isinstance(node, ast.ImportFrom):
                for alias in node.names:
                    self.imports.append(f"{node.module}.{alias.name}")
            elif isinstance(node, ast.ClassDef):
                class_info = self._extract_class_info(node)
                self.classes.append(class_info)
            elif isinstance(node, ast.FunctionDef):
                # 排除类中的方法
                if not self._is_method(node):
                    func_info = self._extract_function_info(node)
                    self.functions.append(func_info)
    
    def _is_method(self, node: ast.FunctionDef) -> bool:
        """检查是否是类方法"""
        parent = node.parent if hasattr(node, 'parent') else None
        return isinstance(parent, ast.ClassDef)
    
    def _extract_class_info(self, node: ast.ClassDef) -> Dict:
        """提取类信息"""
        class_info = {
            'name': node.name,
            'docstring': ast.get_docstring(node),
            'methods': [],
            'bases': [ast.unparse(base) for base in node.bases]
        }
        
        # 提取方法
        for item in node.body:
            if isinstance(item, ast.FunctionDef):
                method_info = self._extract_function_info(item)
                class_info['methods'].append(method_info)
        
        return class_info
    
    def _extract_function_info(self, node: ast.FunctionDef) -> Dict:
        """提取函数信息"""
        func_info = {
            'name': node.name,
            'docstring': ast.get_docstring(node),
            'args': self._extract_arguments(node.args),
            'returns': ast.unparse(node.returns) if node.returns else None,
            'decorators': [ast.unparse(decorator) for decorator in node.decorator_list]
        }
        return func_info
    
    def _extract_arguments(self, args: ast.arguments) -> List[Dict]:
        """提取参数信息"""
        arguments = []
        
        # 位置参数
        for arg in args.args:
            arguments.append({
                'name': arg.arg,
                'type': arg.annotation,
                'default': None
            })
        
        # 默认参数
        for i, default in enumerate(args.defaults):
            idx = len(args.args) - len(args.defaults) + i
            arguments[idx]['default'] = ast.unparse(default)
        
        # 可变参数
        if args.vararg:
            arguments.append({
                'name': f"*{args.vararg.arg}",
                'type': args.vararg.annotation,
                'default': None
            })
        
        # 关键字参数
        for kwonlyarg in args.kwonlyargs:
            arguments.append({
                'name': kwonlyarg.arg,
                'type': kwonlyarg.annotation,
                'default': None
            })
        
        # 关键字默认值
        for i, default in enumerate(args.kw_defaults):
            if default:
                arguments[len(args.args) + (1 if args.vararg else 0) + i]['default'] = ast.unparse(default)
        
        # 关键字可变参数
        if args.kwarg:
            arguments.append({
                'name': f"**{args.kwarg.arg}",
                'type': args.kwarg.annotation,
                'default': None
            })
        
        return arguments
    
    def generate_documentation(self, output_file: str = None) -> str:
        """生成文档"""
        lines = ["# API 文档nn"]
        
        # 导入部分
        if self.imports:
            lines.append("## 导入nn")
            lines.append("```pythonn")
            for imp in sorted(set(self.imports)):
                if '.' in imp:
                    module, name = imp.rsplit('.', 1)
                    lines.append(f"from {module} import {name}n")
                else:
                    lines.append(f"import {imp}n")
            lines.append("```nn")
        
        # 函数部分
        if self.functions:
            lines.append("## 函数nn")
            for func in self.functions:
                lines.append(f"### `{func['name']}`nn")
                
                if func['docstring']:
                    lines.append(f"{func['docstring']}nn")
                
                # 函数签名
                arg_strs = []
                for arg in func['args']:
                    arg_str = arg['name']
                    if arg['type']:
                        arg_str += f": {ast.unparse(arg['type'])}"
                    if arg['default']:
                        arg_str += f" = {arg['default']}"
                    arg_strs.append(arg_str)
                
                signature = f"def {func['name']}({', '.join(arg_strs)})"
                if func['returns']:
                    signature += f" -> {func['returns']}"
                
                lines.append(f"```pythonn{signature}n```nn")
        
        # 类部分
        if self.classes:
            lines.append("## 类nn")
            for cls in self.classes:
                lines.append(f"### `{cls['name']}`nn")
                
                if cls['bases']:
                    lines.append(f"**继承自**: {', '.join(cls['bases'])}nn")
                
                if cls['docstring']:
                    lines.append(f"{cls['docstring']}nn")
                
                # 类的方法
                if cls['methods']:
                    lines.append("#### 方法nn")
                    for method in cls['methods']:
                        lines.append(f"##### `{method['name']}`nn")
                        
                        if method['docstring']:
                            lines.append(f"{method['docstring']}nn")
        
        content = "".join(lines)
        
        if output_file:
            with open(output_file, "w", encoding="utf-8") as f:
                f.write(content)
            print(f"API文档已生成: {output_file}")
        
        return content

# 使用示例
# 创建一个示例Python文件
sample_code = '''
"""示例模块"""

import os
from typing import List, Optional

def greet(name: str, greeting: str = "Hello") -> str:
    """生成问候语
    
    Args:
        name: 姓名
        greeting: 问候语，默认为'Hello'
    
    Returns:
        完整的问候字符串
    """
    return f"{greeting}, {name}!"

class Calculator:
    """计算器类"""
    
    def __init__(self, precision: int = 2):
        """初始化计算器
        
        Args:
            precision: 计算精度
        """
        self.precision = precision
    
    def add(self, a: float, b: float) -> float:
        """加法运算"""
        return round(a + b, self.precision)
    
    def multiply(self, a: float, b: float) -> float:
        """乘法运算"""
        return round(a * b, self.precision)
'''

with open("sample_module.py", "w", encoding="utf-8") as f:

      Flutter是一个由Google开发的开源UI工具包，它可以让您在不同平台上创建高质量、美观的应用程序，而无需编写大量平台特定的代码。我将学习和深入研究Flutter的方方面面。从基础知识到高级技巧，从UI设计到性能优化，欢饮关注一起讨论学习，共同进入Flutter的精彩世界！

      以上就是Python生成Markdown文件的完整指南的详细内容，更多关于Python生成Markdown文件的资料请关注风君子博客其它相关文章！

      您可能感兴趣的文章:

      • Python实现截图生成符合markdown的链接
      • Python3自动生成MySQL数据字典的markdown文本的实现
      • Python自动解析markdown中的图片并保存
      • 基于Python开发一个现代化Markdown编辑器
      • Python 中 Markdown 库的使用教程从入门到实践

      更多文章

      站内搜索

      标签云

      iphone 三星 信用卡 信贷 华为 小米 微软 快科技 手机 投资理财 支付宝 特斯拉 理财知识 电脑 科技 程序 股票 芯片 苹果 贷款 路由器 银行 银行卡 额度

      热门文章

      友情链接