def create_simple_markdown():
    """創(chuàng)建簡(jiǎn)單的Markdown文件"""
    
    content = """# 主標(biāo)題

這是第一個(gè)段落。

## 二級(jí)標(biāo)題

這是第二個(gè)段落。

### 三級(jí)標(biāo)題

這是一個(gè)無(wú)序列表：
- 項(xiàng)目1
- 項(xiàng)目2
- 項(xiàng)目3

這是一個(gè)有序列表：
1. 第一項(xiàng)
2. 第二項(xiàng)
3. 第三項(xiàng)

**粗體文本** 和 *斜體文本*

`行內(nèi)代碼`

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

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

# 使用
create_simple_markdown()

def create_dynamic_markdown(data):
    """根據(jù)數(shù)據(jù)動(dòng)態(tài)生成Markdown"""
    
    content = f"""# {data['title']}

**創(chuàng)建時(shí)間**: {data['date']}
**作者**: {data['author']}

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

## 詳細(xì)內(nèi)容
{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("動(dòng)態(tài)Markdown文件已創(chuàng)建")

data = {
‘title': ‘Python項(xiàng)目文檔',
‘date': ‘2024-01-20',
‘a(chǎn)uthor': ‘張三',
‘overview': ‘這是一個(gè)使用Python生成Markdown的示例項(xiàng)目。',
‘content': ‘詳細(xì)說(shuō)明了如何使用Python創(chuàng)建Markdown文件。',
‘features': [
‘自動(dòng)生成文檔',
‘支持多種格式',
‘可自定義模板',
‘易于擴(kuò)展'
],
‘code_example': ‘print(“Hello, Markdown!”)',
‘summary': ‘這是一個(gè)非常有用的工具。'
}

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):
        """報(bào)告模板"""
        return Template("""# ${title}

## 基本信息
- **項(xiàng)目**: ${project}
- **日期**: ${date}
- **作者**: ${author}
- **版本**: ${version}

## 執(zhí)行摘要
${summary}

## 詳細(xì)內(nèi)容
${content}

## 結(jié)果分析
${analysis}

## 結(jié)論
${conclusion}

## 建議
${recommendations}

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

${badges}

${description}

## ? 特性
${features}

## ?? 快速開(kāi)始

### 安裝
\`\`\`bash
${install_command}
\`\`\`

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

## ?? 文檔
${documentation}

## ?? 貢獻(xiàn)
${contributing}

## ?? 許可證
${license}

## ?? 聯(lián)系方式
${contact}
""")
    
    def _api_doc_template(self):
        """API文檔模板"""
        return Template("""# ${api_name} API 文檔

## 概述
${overview}

## 認(rèn)證
${authentication}

## 端點(diǎn)

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

**方法**: ${method}

**參數(shù)**:
${parameters}

**響應(yīng)**:
\`\`\`json
${response_example}
\`\`\`

**錯(cuò)誤碼**:
${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()

# 生成報(bào)告
report_data = {
    'title': '季度項(xiàng)目報(bào)告',
    'project': '數(shù)據(jù)分析平臺(tái)',
    'date': '2024-Q1',
    'author': '張三',
    'version': '1.0.0',
    'summary': '本季度項(xiàng)目進(jìn)展順利，完成了主要功能開(kāi)發(fā)。',
    'content': '詳細(xì)開(kāi)發(fā)了數(shù)據(jù)導(dǎo)入、處理和可視化模塊。',
    'analysis': '性能提升了30%，用戶滿意度達(dá)到95%。',
    'conclusion': '項(xiàng)目按計(jì)劃推進(jìn)，達(dá)到預(yù)期目標(biāo)。',
    'recommendations': '建議增加AI分析功能。',
    'appendix': '詳見(jiàn)附件文檔。'
}

report_md = md_generator.generate('report', report_data, '季度報(bào)告.md')

# 生成README
readme_data = {
    'project_name': 'Awesome Project',
    'badges': '[![Python Version](https://img.shields.io/badge/python-3.8+-blue.svg)]',
    'description': '一個(gè)非常棒的項(xiàng)目，用于演示Markdown生成。',
    'features': '- 功能一\n- 功能二\n- 功能三',
    'install_command': 'pip install awesome-project',
    'usage_example': 'from awesome import Awesome\nobj = Awesome()\nobj.do_something()',
    'documentation': '詳見(jiàn) [文檔網(wǎng)站](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

# 創(chuàng)建模板目錄和文件
os.makedirs("templates", exist_ok=True)

# 創(chuàng)建report模板 (templates/report.md.j2)
report_template_content = """# {{ title }}

## 項(xiàng)目信息
- **項(xiàng)目名稱**: {{ project_name }}
- **版本**: v{{ version }}
- **生成時(shí)間**: {{ generated_at }}

## 概述
{{ overview }}

## 詳細(xì)分析
{% for section in sections %}
### {{ section.title }}
{{ section.content }}

{% if section.items %}
**關(guān)鍵點(diǎn)**:
{% for item in section.items %}
- {{ item }}
{% endfor %}
{% endif %}

{% endfor %}

## 數(shù)據(jù)統(tǒng)計(jì)
| 指標(biāo) | 數(shù)值 | 狀態(tài) |
|------|------|------|
{% 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': ‘項(xiàng)目分析報(bào)告',
‘project_name': ‘?dāng)?shù)據(jù)分析系統(tǒng)',
‘version': ‘1.2.0',
‘generated_at': ‘2024-01-20 10:30:00',
‘overview': ‘本報(bào)告分析了系統(tǒng)的運(yùn)行情況和性能指標(biāo)。',
‘sections': [
{
‘title': ‘性能分析',
‘content': ‘系統(tǒng)性能良好，響應(yīng)時(shí)間在預(yù)期范圍內(nèi)。',
‘items': [‘平均響應(yīng)時(shí)間: 200ms', ‘吞吐量: 1000 req/s', ‘錯(cuò)誤率: 0.1%']
},
{
‘title': ‘用戶分析',
‘content': ‘用戶活躍度持續(xù)增長(zhǎng)。',
‘items': [‘日活用戶: 10,000', ‘月活用戶: 50,000', ‘用戶留存率: 85%']
}
],
‘metrics': [
{‘name': ‘CPU使用率', ‘value': ‘45%', ‘status': ‘正常'},
{‘name': ‘內(nèi)存使用率', ‘value': ‘60%', ‘status': ‘正常'},
{‘name': ‘磁盤(pán)空間', ‘value': ‘75%', ‘status': ‘警告'},
{‘name': ‘網(wǎng)絡(luò)延遲', ‘value': ‘50ms', ‘status': ‘優(yōu)秀'}
],
‘code_language': ‘python',
‘code_example': ‘def analyze_data(data):\n return process(data)',
‘summary': ‘系統(tǒng)運(yùn)行穩(wěn)定，建議關(guān)注磁盤(pán)空間使用情況。'
}

generator.generate_from_template(
‘report.md.j2',
context,
‘項(xiàng)目分析報(bào)告.md'
)

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

class MarkdownGenerator:
    """高級(jí)Markdown生成器"""
    
    def __init__(self):
        self.elements = []
    
    def add_title(self, text, level=1):
        """添加標(biāo)題"""
        prefix = '#' * level
        self.elements.append(f"{prefix} {text}\n")
        return self
    
    def add_paragraph(self, text):
        """添加段落"""
        self.elements.append(f"{text}\n\n")
        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[code]\n```\n\n")
        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")
        
        # 數(shù)據(jù)行
        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("---\n\n")
        return self
    
    def add_link(self, text, url):
        """添加鏈接"""
        self.elements.append(f"[{text}]({url})\n\n")
        return self
    
    def add_image(self, alt_text, url, title=""):
        """添加圖片"""
        if title:
            self.elements.append(f'![{alt_text}]({url} "{title}")\n\n')
        else:
            self.elements.append(f'![{alt_text}]({url})\n\n')
        return self
    
    def generate(self, output_file=None):
        """生成Markdown內(nèi)容"""
        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學(xué)習(xí)筆記", level=1)
md.add_paragraph("這是我的Python學(xué)習(xí)筆記，記錄了一些重要的概念和示例。")
md.add_horizontal_rule()

md.add_title("基本語(yǔ)法", level=2)
md.add_paragraph("Python的基本語(yǔ)法非常簡(jiǎn)潔。")

md.add_title("數(shù)據(jù)類型", level=3)
md.add_list([
    "整數(shù) (int)",
    "浮點(diǎn)數(shù) (float)",
    "字符串 (str)",
    "列表 (list)",
    "字典 (dict)"
])

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

md.add_title("數(shù)據(jù)結(jié)構(gòu)對(duì)比", level=2)
md.add_table(
    ["數(shù)據(jù)結(jié)構(gòu)", "可變性", "有序性", "示例"],
    [
        ["列表", "可變", "有序", "[1, 2, 3]"],
        ["元組", "不可變", "有序", "(1, 2, 3)"],
        ["集合", "可變", "無(wú)序", "{1, 2, 3}"],
        ["字典", "可變", "有序(3.7+)", "{'a': 1, 'b': 2}"]
    ]
)

md.add_blockquote("Python之禪：優(yōu)美勝于丑陋，明了勝于晦澀。")

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("學(xué)習(xí)筆記.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內(nèi)容"""
        return "".join(self.output)

# 使用mistune解析并生成
def convert_to_markdown(html_content):
    """將HTML轉(zhuǎn)換為Markdown（簡(jiǎn)單示例）"""
    # 注意：mistune主要是HTML轉(zhuǎn)Markdown，這里展示反向思路
    pass

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

class DataToMarkdown:
    """從數(shù)據(jù)結(jié)構(gòu)生成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內(nèi)容"""
        lines = []
        
        def process_value(key, value, level=0):
            indent = self.indent_char * self.indent_size * level
            
            if isinstance(value, dict):
                # 標(biāo)題
                lines.append(f"{indent}# {' '.join(key.split('_')).title()}\n")
                
                # 處理字典的鍵值對(duì)
                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):
                # 列表標(biāo)題
                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:
                # 簡(jiǎn)單鍵值對(duì)
                lines.append(f"{indent}- **{key.replace('_', ' ').title()}**: {value}\n")
        
        # 開(kāi)始處理
        if isinstance(data, dict):
            # 添加主標(biāo)題
            title = data.get('title', 'Document')
            lines.append(f"# {title}\n\n")
            
            # 處理其他內(nèi)容
            for key, value in data.items():
                if key != 'title':
                    process_value(key, value)
        else:
            lines.append("# Document\n\n")
            process_value('content', data)
        
        # 合并所有行
        content = ''.join(lines)
        
        # 寫(xiě)入文件
        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": "根據(jù)用戶ID獲取用戶信息",
            "parameters": [
                {"name": "id", "type": "integer", "required": True}
            ],
            "responses": [
                {"code": 200, "description": "成功"},
                {"code": 404, "description": "用戶不存在"}
            ]
        },
        {
            "name": "創(chuàng)建用戶",
            "method": "POST",
            "path": "/api/users",
            "description": "創(chuàng)建新用戶",
            "parameters": [
                {"name": "username", "type": "string", "required": True},
                {"name": "email", "type": "string", "required": True}
            ],
            "responses": [
                {"code": 201, "description": "用戶創(chuàng)建成功"},
                {"code": 400, "description": "參數(shù)錯(cuò)誤"}
            ]
        }
    ],
    "authentication": {
        "type": "JWT",
        "description": "需要在請(qǐng)求頭中添加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:
    """從數(shù)據(jù)庫(kù)生成Markdown文檔"""
    
    def __init__(self, db_type='sqlite', **kwargs):
        self.db_type = db_type
        self.connection_params = kwargs
        
    def connect(self):
        """連接到數(shù)據(jù)庫(kù)"""
        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"不支持的數(shù)據(jù)庫(kù)類型: {self.db_type}")
        
        return self.conn
    
    def generate_schema_doc(self, output_file: str = None) -> str:
        """生成數(shù)據(jù)庫(kù)模式文檔"""
        self.connect()
        cursor = self.conn.cursor()
        
        lines = ["# 數(shù)據(jù)庫(kù)模式文檔\n\n"]
        
        # 獲取所有表
        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}`\n\n")
            
            # 獲取表結(jié)構(gòu)
            if self.db_type == 'sqlite':
                cursor.execute(f"PRAGMA table_info({table});")
                columns = cursor.fetchall()
                
                # 表頭
                lines.append("| 字段名 | 類型 | 是否為空 | 默認(rèn)值 | 主鍵 |\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("| 字段名 | 類型 | 是否為空 | 鍵 | 默認(rèn)值 | 額外 |\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("### 索引\n\n")
                    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("### 外鍵約束\n\n")
                    for fk in foreign_keys:
                        lines.append(f"- 從 `{fk[3]}` 到 `{fk[2]}.{fk[4]}`\n")
                    lines.append("\n")
        
        # 關(guā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"數(shù)據(jù)庫(kù)文檔已生成: {output_file}")
        
        return content
    
    def generate_data_dictionary(self, output_file: str = None) -> str:
        """生成數(shù)據(jù)字典"""
        self.connect()
        cursor = self.conn.cursor()
        
        lines = ["# 數(shù)據(jù)字典\n\n"]
        
        # 獲取所有表
        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}`\n\n")
            lines.append("### 描述\n\n[填寫(xiě)表描述]\n\n")
            
            lines.append("### 字段說(shuō)明\n\n")
            lines.append("| 字段名 | 數(shù)據(jù)類型 | 描述 | 示例 | 約束 |\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"默認(rèn)值: {default}")
                    
                    lines.append(f"| {name} | {type_} | [填寫(xiě)描述] | [填寫(xiě)示例] | {', '.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"默認(rèn)值: {default}")
                    if extra:
                        constraints.append(extra)
                    
                    lines.append(f"| {name} | {type_} | [填寫(xiě)描述] | [填寫(xiě)示例] | {', '.join(constraints)} |\n")
            
            lines.append("\n### 業(yè)務(wù)規(guī)則\n\n[填寫(xiě)業(yè)務(wù)規(guī)則]\n\n")
            lines.append("### 使用示例\n\n```sql\nSELECT * FROM {table} LIMIT 5;\n```\n\n")
            lines.append("---\n\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"數(shù)據(jù)字典已生成: {output_file}")
        
        return content

# 使用示例
# 創(chuàng)建測(cè)試數(shù)據(jù)庫(kù)
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("數(shù)據(jù)庫(kù)模式.md")
data_dict = doc_gen.generate_data_dictionary("數(shù)據(jù)字典.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:
        """提取函數(shù)信息"""
        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]:
        """提取參數(shù)信息"""
        arguments = []
        
        # 位置參數(shù)
        for arg in args.args:
            arguments.append({
                'name': arg.arg,
                'type': arg.annotation,
                'default': None
            })
        
        # 默認(rèn)參數(shù)
        for i, default in enumerate(args.defaults):
            idx = len(args.args) - len(args.defaults) + i
            arguments[idx]['default'] = ast.unparse(default)
        
        # 可變參數(shù)
        if args.vararg:
            arguments.append({
                'name': f"*{args.vararg.arg}",
                'type': args.vararg.annotation,
                'default': None
            })
        
        # 關(guān)鍵字參數(shù)
        for kwonlyarg in args.kwonlyargs:
            arguments.append({
                'name': kwonlyarg.arg,
                'type': kwonlyarg.annotation,
                'default': None
            })
        
        # 關(guān)鍵字默認(rèn)值
        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)
        
        # 關(guān)鍵字可變參數(shù)
        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 文檔\n\n"]
        
        # 導(dǎo)入部分
        if self.imports:
            lines.append("## 導(dǎo)入\n\n")
            lines.append("```python\n")
            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("```\n\n")
        
        # 函數(shù)部分
        if self.functions:
            lines.append("## 函數(shù)\n\n")
            for func in self.functions:
                lines.append(f"### `{func['name']}`\n\n")
                
                if func['docstring']:
                    lines.append(f"{func['docstring']}\n\n")
                
                # 函數(shù)簽名
                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"```python\n{signature}\n```\n\n")
        
        # 類部分
        if self.classes:
            lines.append("## 類\n\n")
            for cls in self.classes:
                lines.append(f"### `{cls['name']}`\n\n")
                
                if cls['bases']:
                    lines.append(f"**繼承自**: {', '.join(cls['bases'])}\n\n")
                
                if cls['docstring']:
                    lines.append(f"{cls['docstring']}\n\n")
                
                # 類的方法
                if cls['methods']:
                    lines.append("#### 方法\n\n")
                    for method in cls['methods']:
                        lines.append(f"##### `{method['name']}`\n\n")
                        
                        if method['docstring']:
                            lines.append(f"{method['docstring']}\n\n")
        
        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

# 使用示例
# 創(chuàng)建一個(gè)示例Python文件
sample_code = '''
"""示例模塊"""

import os
from typing import List, Optional

def greet(name: str, greeting: str = "Hello") -> str:
    """生成問(wèn)候語(yǔ)
    
    Args:
        name: 姓名
        greeting: 問(wèn)候語(yǔ)，默認(rèn)為'Hello'
    
    Returns:
        完整的問(wèn)候字符串
    """
    return f"{greeting}, {name}!"

class Calculator:
    """計(jì)算器類"""
    
    def __init__(self, precision: int = 2):
        """初始化計(jì)算器
        
        Args:
            precision: 計(jì)算精度
        """
        self.precision = precision
    
    def add(self, a: float, b: float) -> float:
        """加法運(yùn)算"""
        return round(a + b, self.precision)
    
    def multiply(self, a: float, b: float) -> float:
        """乘法運(yùn)算"""
        return round(a * b, self.precision)
'''

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