代码：用pyhon生成word/wps蓝墨云班题库

import os, pythoncom, win32com.client as win32

# ---------------------- 工具函数 ----------------------
def get_or_add_style(doc, name):
    try:
        return doc.Styles(name)
    except:
        return doc.Styles.Add(Name=name, Type=1)  # 1=段落样式

# ---------------------- 主程序 ----------------------
pythoncom.CoInitialize()
try:
    app = win32.Dispatch("Word.Application")
except:
    app = win32.Dispatch("Kwps.Application")
app.Visible = True
doc = app.Documents.Add()

# Word 常数
wdCollapseEnd = 0
wdStory = 6
wdWord9TableBehavior = 1
wdAutoFitContent = 1
wdFormatDocumentDefault = 12

# ---------- 1. 建立基础样式（匹配附件模板格式） ----------
def make_styles():
    # 题型标题（如【单选题】）
    s = get_or_add_style(doc, "题型标题")
    s.Font.NameFarEast = s.Font.Name = "黑体"
    s.Font.Size = 12
    s.Font.Bold = True
    pf = s.ParagraphFormat
    pf.SpaceBefore = 6
    pf.SpaceAfter = 3
    pf.Alignment = 0

    # 题干/选项/解析样式
    s = get_or_add_style(doc, "题目内容")
    s.Font.NameFarEast = s.Font.Name = "宋体"
    s.Font.Size = 10.5
    pf = s.ParagraphFormat
    pf.FirstLineIndent = 0
    pf.LineSpacingRule = 3
    pf.LineSpacing = 1.25
    pf.Alignment = 0

    # 选项样式
    s = get_or_add_style(doc, "选项")
    s.Font.NameFarEast = s.Font.Name = "宋体"
    s.Font.Size = 10.5
    pf = s.ParagraphFormat
    pf.FirstLineIndent = 0
    pf.LineSpacingRule = 3
    pf.LineSpacing = 1.25
    pf.Alignment = 0

    # 备注样式（所属章、难度等）
    s = get_or_add_style(doc, "备注")
    s.Font.NameFarEast = s.Font.Name = "宋体"
    s.Font.Size = 10.5
    pf = s.ParagraphFormat
    pf.SpaceBefore = 3
    pf.SpaceAfter = 6
    pf.Alignment = 0

make_styles()

# ---------- 2. 辅助函数：写入题目 ----------
rng = doc.Range()
rng.Collapse(wdCollapseEnd)

def write_style(style, text, newline=True):
    rng.Style = style
    rng.Text = text
    if newline:
        rng.InsertParagraphAfter()
    rng.Collapse(wdCollapseEnd)

def add_single_choice(no, score, question, option_a, option_b, option_c, option_d, correct, chapter, difficulty, analysis="", knowledge=""):
    """添加单选题"""
    write_style(doc.Styles("题型标题"), f"【单选题】（{score}分）")
    write_style(doc.Styles("题目内容"), f"{no}. {question}({correct})")
    write_style(doc.Styles("选项"), f"A、{option_a}")
    write_style(doc.Styles("选项"), f"B、{option_b}")
    write_style(doc.Styles("选项"), f"C、{option_c}")
    write_style(doc.Styles("选项"), f"D、{option_d}")
    write_style(doc.Styles("备注"), f"所属章：{chapter}")
    write_style(doc.Styles("备注"), f"难度：{difficulty}")
    if analysis:
        write_style(doc.Styles("备注"), f"解析：{analysis}")
    if knowledge:
        write_style(doc.Styles("备注"), f"知识点：{knowledge}")
    rng.InsertParagraphAfter()

def add_multi_choice(no, score, question, option_a, option_b, option_c, option_d, correct, chapter, difficulty, analysis="", knowledge=""):
    """添加多选题"""
    write_style(doc.Styles("题型标题"), f"【多选题】（{score}分）")
    write_style(doc.Styles("题目内容"), f"{no}. {question}({correct})")
    write_style(doc.Styles("选项"), f"A、{option_a}")
    write_style(doc.Styles("选项"), f"B、{option_b}")
    write_style(doc.Styles("选项"), f"C、{option_c}")
    write_style(doc.Styles("选项"), f"D、{option_d}")
    write_style(doc.Styles("备注"), f"所属章：{chapter}")
    write_style(doc.Styles("备注"), f"难度：{difficulty}")
    if analysis:
        write_style(doc.Styles("备注"), f"解析：{analysis}")
    if knowledge:
        write_style(doc.Styles("备注"), f"知识点：{knowledge}")
    rng.InsertParagraphAfter()

def add_fill_blank(no, score_per, question, answers, case_sensitive, order_sensitive, chapter, difficulty, analysis="", knowledge=""):
    """添加填空题"""
    write_style(doc.Styles("题型标题"), f"【填空题】（每空{score_per}分）")
    write_style(doc.Styles("题目内容"), f"{no}. {question}")
    write_style(doc.Styles("备注"), f"判分时答案内字母区分大小写：{case_sensitive}")
    write_style(doc.Styles("备注"), f"判分时区分多个空的先后顺序：{order_sensitive}")
    write_style(doc.Styles("备注"), f"所属章：{chapter}")
    write_style(doc.Styles("备注"), f"难度：{difficulty}")
    if analysis:
        write_style(doc.Styles("备注"), f"解析：{analysis}")
    if knowledge:
        write_style(doc.Styles("备注"), f"知识点：{knowledge}")
    rng.InsertParagraphAfter()

def add_judge(no, score, question, correct, chapter, difficulty, analysis="", knowledge=""):
    """添加判断题"""
    write_style(doc.Styles("题型标题"), f"【判断题】（{score}分）")
    write_style(doc.Styles("题目内容"), f"{no}. {question}({correct})")
    write_style(doc.Styles("备注"), f"所属章：{chapter}")
    write_style(doc.Styles("备注"), f"难度：{difficulty}")
    if analysis:
        write_style(doc.Styles("备注"), f"解析：{analysis}")
    if knowledge:
        write_style(doc.Styles("备注"), f"知识点：{knowledge}")
    rng.InsertParagraphAfter()

# ---------- 3. 第5章 题库内容 ----------
chapter = "第5章 Python变量模型与容器操作"

# 单选题（5道）
add_single_choice(
    no=1,
    score=2,
    question="Python中执行a=10时，以下描述正确的是",
    option_a="a直接存储10，与C语言变量存储方式一致",
    option_b="先构造值为10的整数对象，再将a与该对象绑定",
    option_c="a是指针，直接指向内存地址0x10",
    option_d="10会被存储在栈内存中，a存储栈地址",
    correct="B",
    chapter=chapter,
    difficulty="简单",
    analysis="Python变量本质是引用，执行a=10时先在堆内存创建整数对象10，再将变量名a（栈中）与对象绑定；C语言中变量直接存储值，二者存储模型不同",
    knowledge="Python变量模型、与C语言变量模型对比"
)

add_single_choice(
    no=2,
    score=2,
    question="Python中执行a=10; b=a后，再执行a+=5，b的值会是",
    option_a="5",
    option_b="10",
    option_c="15",
    option_d="报错",
    correct="B",
    chapter=chapter,
    difficulty="简单",
    analysis="a=10时a绑定整数对象10，b=a是将b与同一对象绑定；a+=5时，因整数是不可变对象，会创建新对象15并重新绑定a，原对象10的引用计数减1，b仍绑定10",
    knowledge="不可变对象、变量重绑定"
)

add_single_choice(
    no=3,
    score=3,
    question="以下哪种类型的对象是可变对象",
    option_a="int（整数）",
    option_b="str（字符串）",
    option_c="list（列表）",
    option_d="tuple（元组）",
    correct="C",
    chapter=chapter,
    difficulty="一般",
    analysis="Python中列表、字典、集合是可变对象，支持增删改内容；整数、字符串、元组是不可变对象，修改内容会创建新对象或报错",
    knowledge="可变类型与不可变类型"
)

add_single_choice(
    no=4,
    score=3,
    question="关于浅拷贝与深拷贝的描述，正确的是",
    option_a="浅拷贝会拷贝对象的深层结构",
    option_b="深拷贝仅拷贝对象的表层结构",
    option_c="浅拷贝对嵌套列表的内层列表仅复制引用",
    option_d="深拷贝不会复制对象的表层结构",
    correct="C",
    chapter=chapter,
    difficulty="一般",
    analysis="拷贝均会复制表层结构；浅拷贝对深层嵌套结构仅复制引用，不创建新对象；深拷贝会递归复制所有层级结构，创建完全独立的新对象",
    knowledge="浅拷贝与深拷贝"
)

add_single_choice(
    no=5,
    score=4,
    question="以下哪种对象不能作为字典的键",
    option_a="int（整数）",
    option_b="str（字符串）",
    option_c="list（列表）",
    option_d="tuple（元组）",
    correct="C",
    chapter=chapter,
    difficulty="困难",
    analysis="字典的键需可哈希，不可变对象（整数、字符串、元组）均为可哈希类型；列表是可变对象，不可哈希，不能作为字典的键",
    knowledge="不可变与可哈希、字典操作"
)

# 多选题（3道）
add_multi_choice(
    no=1,
    score=4,
    question="Python与C语言的变量模型差异包括",
    option_a="Python变量是引用，C语言变量是直接存储值",
    option_b="Python对象存储在堆内存，C语言基本类型存储在栈内存",
    option_c="Python变量无需声明类型，C语言变量必须声明类型",
    option_d="Python与C语言的变量都可直接修改存储的值",
    correct="ABC",
    chapter=chapter,
    difficulty="一般",
    analysis="Python变量是对堆内存对象的引用，无需声明类型；C语言基本类型变量直接在栈内存存储值，必须声明类型；Python不可变对象无法直接修改值，需创建新对象",
    knowledge="Python变量模型与C语言变量模型对比"
)

add_multi_choice(
    no=2,
    score=4,
    question="以下关于不可变对象的描述正确的有",
    option_a="对象内容不可直接修改",
    option_b="修改不可变对象会创建新对象",
    option_c="元组是不可变对象，修改其元素会报错",
    option_d="不可变对象一定是可哈希的",
    correct="ABCD",
    chapter=chapter,
    difficulty="一般",
    analysis="不可变对象的核心是内容不可直接修改，修改操作会生成新对象（如整数、字符串）或报错（如元组）；不可变对象均支持哈希，可作为字典键和集合元素",
    knowledge="不可变类型的对象、不可变与可哈希"
)

add_multi_choice(
    no=3,
    score=5,
    question="以下属于Python四大容器的常用操作有",
    option_a="列表：append()添加元素、pop()删除元素",
    option_b="字典：keys()获取键、get()获取值",
    option_c="集合：add()添加元素、remove()删除元素",
    option_d="元组：insert()插入元素、sort()排序",
    correct="ABC",
    chapter=chapter,
    difficulty="困难",
    analysis="列表、字典、集合、元组是Python四大容器；元组是不可变对象，不支持insert()、sort()等修改操作；ABC选项分别是三大可变容器的合法操作",
    knowledge="四大容器的增删改查操作"
)

# 填空题（3道）
add_fill_blank(
    no=1,
    score_per=2,
    question="Python中执行b=a时，本质是将b与【答案1】进行重绑定；可变对象与不可变对象的核心区别是【答案2】是否可直接修改",
    answers=["a所绑定的对象", "对象的内容"],
    case_sensitive="否",
    order_sensitive="是",
    chapter=chapter,
    difficulty="简单",
    analysis="b=a不会创建新对象，仅增加原对象的引用计数；可变对象支持内容直接修改，不可变对象不支持",
    knowledge="变量重绑定、可变与不可变对象"
)

add_fill_blank(
    no=2,
    score_per=3,
    question="字典的键和集合的元素需要具备【答案1】特性，便于快速检索；不可变对象要作为字典键，除自身不可变外，其【答案2】也必须不可变",
    answers=["可哈希", "深层结构"],
    case_sensitive="否",
    order_sensitive="是",
    chapter=chapter,
    difficulty="一般",
    analysis="可哈希特性是字典和集合快速查找的基础；若不可变对象包含可变深层结构（如嵌套列表的元组），仍不可作为字典键",
    knowledge="不可变与可哈希、字典操作"
)

add_fill_blank(
    no=3,
    score_per=3,
    question="生成器解析式相比列表解析式更省内存，其原因是生成器解析式【答案1】，而列表解析式会【答案2】",
    answers=["按需生成元素（不一次性加载到内存）", "一次性生成所有元素并存储在内存"],
    case_sensitive="否",
    order_sensitive="是",
    chapter=chapter,
    difficulty="困难",
    analysis="生成器解析式返回生成器对象，元素仅在迭代时生成；列表解析式直接返回列表，所有元素提前占用内存",
    knowledge="生成器解析式、列表解析式"
)

# 判断题（5道）
add_judge(
    no=1,
    score=2,
    question="Python中变量不可修改，修改变量本质是重新绑定对象（对/错）",
    correct="错",
    chapter=chapter,
    difficulty="简单",
    analysis="Python变量永远可变（可重新绑定），不可变的是对象的内容，而非变量本身",
    knowledge="可变与不可变对象的定义"
)

add_judge(
    no=2,
    score=2,
    question="浅拷贝和深拷贝都会复制对象的表层结构（对/错）",
    correct="对",
    chapter=chapter,
    difficulty="一般",
    analysis="浅拷贝和深拷贝的核心差异在深层结构，表层结构均会被复制生成新的引用",
    knowledge="浅拷贝与深拷贝"
)

add_judge(
    no=3,
    score=2,
    question="Python中的整数对象10和字符串对象'10'都是不可变对象（对/错）",
    correct="对",
    chapter=chapter,
    difficulty="简单",
    analysis="整数、字符串、元组均属于不可变对象，修改其内容会创建新对象",
    knowledge="不可变类型的对象"
)

add_judge(
    no=4,
    score=3,
    question="元组是不可变对象，因此元组中嵌套的列表也无法修改（对/错）",
    correct="错",
    chapter=chapter,
    difficulty="一般",
    analysis="元组的不可变仅指元组本身的元素引用不可变，嵌套的列表是可变对象，其内容可通过列表方法修改",
    knowledge="不可变对象、嵌套结构"
)

add_judge(
    no=5,
    score=3,
    question="可迭代对象包含迭代器，迭代器包含生成器（对/错）",
    correct="对",
    chapter=chapter,
    difficulty="困难",
    analysis="生成器是特殊的迭代器，迭代器是特殊的可迭代对象，三者是包含关系",
    knowledge="可迭代对象、迭代器、生成器"
)

# ---------- 保存文档 ----------
save_path = os.path.join(os.path.expanduser("~"), "Desktop", "第5章Python变量模型与容器操作题库.docx")
doc.SaveAs(save_path, FileFormat=wdFormatDocumentDefault)
print("题库文档已生成：", save_path)

pythoncom.CoUninitialize()