学生党知识点动画卡片，看图比背书快。
学生党知识点动画卡片生成器 - 看图比背书快
一、实际应用场景描述
在期末复习季，学生们常常面临这样的困境：面对厚厚的教材和密密麻麻的文字笔记，明明花了大量时间背诵，却总是记不住重点；翻开书什么都知道，合上书大脑一片空白。传统的死记硬背效率低下，而视觉记忆研究表明，图文结合的信息留存率比纯文字高出65%。
本程序专为大学生设计，能够将枯燥的知识点（如历史事件时间线、生物细胞结构、数学公式推导、英语单词词根等）自动转换为生动的动画卡片。学生只需输入知识点文本，程序即可生成包含动态图示、关键词高亮、逻辑流程的可视化动画，让复杂的概念"一目了然"。无论是考前突击还是日常预习，都能显著提升记忆效率。
目标用户：中学生、大学生、考研党、考证族
使用场景：宿舍复习、图书馆自习、碎片化学习（课间/通勤）
核心价值：将抽象知识转化为视觉记忆锚点，实现"一眼记住一个知识点"
二、引入痛点
1. 视觉疲劳：长时间阅读文字导致注意力涣散，记忆效率下降
2. 抽象难懂：理科公式、历史脉络等抽象概念难以通过文字想象
3. 重点模糊：笔记冗长繁杂，抓不住核心考点，复习效率低
4. 被动接收：传统学习方式缺乏互动，知识留存率低
5. 时间紧迫：考前复习时间有限，需要快速掌握大量知识点
三、核心逻辑讲解
程序采用"知识解析→视觉映射→动画生成→卡片合成"四层架构：
1. 知识解析层：
- 接收用户输入的知识点文本（支持Markdown格式）
- 使用NLP技术提取关键词、逻辑关系（因果/并列/递进）
- 识别知识点类型（概念定义/流程步骤/对比分析/公式推导）
2. 视觉映射层：
- 根据知识点类型匹配视觉模板（思维导图/流程图/对比表格/动态图解）
- 关键词自动高亮配色（遵循色彩心理学原理）
- 抽象概念转具象图标（使用矢量图标库）
3. 动画生成层：
- 入场动画：元素按顺序淡入，引导视线聚焦
- 强调动画：关键词脉冲闪烁、重点内容放大缩小
- 转场动画：逻辑衔接处平滑过渡，保持思维连贯性
- 退出动画：知识点总结后优雅收尾
4. 卡片合成层：
- 自动适配手机竖屏比例（9:16）
- 添加学习进度提示（如"第3个知识点/共10个"）
- 生成配套语音朗读（可选）
- 输出GIF/MP4格式，支持一键导入Anki等记忆软件
四、代码模块化实现
项目结构
knowledge_card_generator/
├── main.py # 主程序入口
├── config.py # 配置文件
├── modules/
│ ├── knowledge_parser.py # 知识点解析模块
│ ├── visual_mapper.py # 视觉映射模块
│ ├── animation_engine.py # 动画引擎模块
│ ├── card_composer.py # 卡片合成模块
│ └── utils.py # 工具函数
├── templates/ # 视觉模板
│ ├── concept_template.svg # 概念定义模板
│ ├── flowchart_template.svg # 流程图模板
│ ├── comparison_template.svg # 对比表格模板
│ └── formula_template.svg # 公式推导模板
├── assets/ # 静态资源
│ ├── icons/ # 矢量图标库
│ ├── fonts/ # 字体文件
│ └── colors/ # 配色方案
├── output/ # 输出目录
└── requirements.txt # 依赖清单
核心代码实现
1. config.py - 配置文件
"""
配置文件：存储程序运行所需参数和资源路径
"""
import os
# 基础配置
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
OUTPUT_DIR = os.path.join(BASE_DIR, "output")
TEMPLATES_DIR = os.path.join(BASE_DIR, "templates")
ASSETS_DIR = os.path.join(BASE_DIR, "assets")
# 卡片配置
CARD_RESOLUTION = (720, 1280) # 竖屏分辨率
CARD_DURATION = 8 # 单张卡片动画时长（秒）
FPS = 24 # 帧率
BACKGROUND_COLOR = "#F5F5F5" # 背景色
# 知识点类型映射
KNOWLEDGE_TYPES = {
"concept": "概念定义",
"flowchart": "流程步骤",
"comparison": "对比分析",
"formula": "公式推导",
"timeline": "时间线",
"classification": "分类体系"
}
# 配色方案（基于色彩心理学）
COLOR_SCHEMES = {
"default": {
"primary": "#2196F3", # 蓝色-信任/专注
"secondary": "#4CAF50", # 绿色-成长/记忆
"accent": "#FF9800", # 橙色-活力/提醒
"text": "#333333", # 主文本
"highlight": "#E91E63" # 高亮色
},
"science": {
"primary": "#3F51B5", # 靛蓝-理性
"secondary": "#009688", # 青色-科技
"accent": "#FF5722", # 深橙-能量
"text": "#212121",
"highlight": "#FFC107"
},
"humanity": {
"primary": "#795548", # 棕色-人文
"secondary": "#8BC34A", # 浅绿-希望
"accent": "#FF4081", # 粉红-情感
"text": "#424242",
"highlight": "#CDDC39"
}
}
# 动画配置
ANIMATION_CONFIG = {
"entry_duration": 0.5, # 入场动画时长
"emphasis_duration": 1.0, # 强调动画时长
"transition_delay": 0.3, # 元素间延迟
"pulse_count": 3, # 脉冲次数
"zoom_scale": 1.2 # 放大倍数
}
2. modules/knowledge_parser.py - 知识点解析模块
"""
知识点解析模块：解析用户输入的知识文本，提取结构化信息
支持多种知识点类型和Markdown格式
"""
import re
from typing import Dict, List, Tuple, Optional
from dataclasses import dataclass
@dataclass
class KnowledgePoint:
"""知识点数据结构"""
raw_text: str # 原始文本
title: str # 标题
k_type: str # 知识点类型
keywords: List[str] # 关键词列表
logic_relations: List[Tuple[str, str, str]] # 逻辑关系 (主体, 关系, 客体)
steps: List[str] # 步骤列表（适用于流程类）
comparisons: List[Tuple[str, str]] # 对比项 (项目1, 项目2)
formulas: List[str] # 公式列表
summary: str # 总结句
class KnowledgeParser:
"""知识点解析器类"""
def __init__(self):
# 知识点类型识别规则
self.type_patterns = {
"concept": [
r"是[什么什么]", r"指[的是]", r"定义为", r"含义[是]",
r"所谓[的]?(.+?)[，是]"
],
"flowchart": [
r"步骤[：:]", r"流程[：:]", r"首先.*其次.*最后",
r"第一步.*第二步.*第三步", r"过程[：:]"
],
"comparison": [
r"区别[：:]", r"差异[：:]", r"对比[：:]", r"不同[在于]",
r"相似[之处]?[：:]", r"比较[：:]"
],
"formula": [
r"[A-Z]+[\+\-\*\/=]", r"公式[：:]", r"定律[：:]",
r"定理[：:]", r"表达式[：:]"
],
"timeline": [
r"(\d{3,4})年[，：]", r"世纪[：:]", r"时期[：:]",
r"年代[：:]", r"先后[顺序]?[：:]"
],
"classification": [
r"分类[：:]", r"类型[：:]", r"种类[：:]", r"分为[：:]",
r"包括[：:]", r"属于[：:]"
]
}
# 停用词（过滤无意义词汇）
self.stop_words = {"的", "了", "是", "在", "和", "与", "或", "及", "等"}
def parse(self, text: str) -> KnowledgePoint:
"""
解析知识点文本，返回结构化数据
参数:
text: 用户输入的知识点文本（支持Markdown）
返回:
KnowledgePoint对象
"""
# 预处理：移除Markdown标记，保留纯文本
clean_text = self._preprocess_markdown(text)
# 提取标题（第一行非空文本）
lines = clean_text.strip().split('\n')
title = lines[0].strip() if lines else "未命名知识点"
# 识别知识点类型
k_type = self._detect_knowledge_type(clean_text)
# 提取关键词
keywords = self._extract_keywords(clean_text)
# 解析逻辑关系
logic_relations = self._parse_logic_relations(clean_text, k_type)
# 根据类型提取特定结构
steps = self._extract_steps(clean_text) if k_type == "flowchart" else []
comparisons = self._extract_comparisons(clean_text) if k_type == "comparison" else []
formulas = self._extract_formulas(clean_text) if k_type == "formula" else []
# 生成总结句
summary = self._generate_summary(clean_text, title, k_type)
return KnowledgePoint(
raw_text=text,
title=title,
k_type=k_type,
keywords=keywords,
logic_relations=logic_relations,
steps=steps,
comparisons=comparisons,
formulas=formulas,
summary=summary
)
def _preprocess_markdown(self, text: str) -> str:
"""预处理Markdown文本，移除格式标记"""
# 移除标题标记
text = re.sub(r'^#{1,6}\s+', '', text, flags=re.MULTILINE)
# 移除加粗/斜体标记
text = re.sub(r'[*_]{1,2}(.+?)[*_]{1,2}', r'\1', text)
# 移除代码块标记
text = re.sub(r'```.*?```', '', text, flags=re.DOTALL)
# 移除链接标记
text = re.sub(r'\[(.+?)\]\(.+?\)', r'\1', text)
return text.strip()
def _detect_knowledge_type(self, text: str) -> str:
"""识别知识点类型"""
scores = {k_type: 0 for k_type in self.type_patterns}
for k_type, patterns in self.type_patterns.items():
for pattern in patterns:
if re.search(pattern, text):
scores[k_type] += 1
# 返回得分最高的类型，默认"concept"
max_score = max(scores.values())
if max_score == 0:
return "concept"
for k_type, score in scores.items():
if score == max_score:
return k_type
def _extract_keywords(self, text: str) -> List[str]:
"""提取关键词（名词短语）"""
# 简单分词（实际应用中可使用jieba等分词库）
words = re.findall(r'[\u4e00-\u9fa5]{2,}|[a-zA-Z]{2,}', text)
# 过滤停用词和短词
keywords = [w for w in words if w not in self.stop_words and len(w) >= 2]
# 去重并保留前10个高频词
unique_keywords = list(dict.fromkeys(keywords))[:10]
return unique_keywords
def _parse_logic_relations(self, text: str, k_type: str) -> List[Tuple[str, str, str]]:
"""解析文本中的逻辑关系"""
relations = []
if k_type == "concept":
# 概念定义关系：A是B
matches = re.findall(r'([^，。是]+?)\s*是\s*([^，。]+)', text)
for m in matches:
relations.append((m[0].strip(), "是", m[1].strip()))
elif k_type == "flowchart":
# 流程顺序关系
steps = re.split(r'[;；。\n]', text)
for i in range(len(steps)-1):
step1 = steps[i].strip()
step2 = steps[i+1].strip()
if step1 and step2:
relations.append((step1, "→", step2))
elif k_type == "comparison":
# 对比关系
matches = re.findall(r'([^与和与和对比]+?)\s*(?:与|和|跟)\s*([^的的区别]+)', text)
for m in matches:
relations.append((m[0].strip(), "vs", m[1].strip()))
return relations[:5] # 最多返回5组关系
def _extract_steps(self, text: str) -> List[str]:
"""提取流程步骤"""
steps = []
# 匹配数字序号
numbered = re.findall(r'(?:第)?(\d+)[、.．]\s*(.+?)(?=(?:第\d+[、.．])|$)', text, re.DOTALL)
if numbered:
steps = [s[1].strip() for s in numbered]
else:
# 匹配"首先/其次/最后"模式
sequence_words = ["首先", "其次", "然后", "接着", "随后", "最后", "最终"]
for word in sequence_words:
match = re.search(f'{word}[，：]?\s*(.+?)(?={"|".join(sequence_words)}|$)', text)
if match:
steps.append(match.group(1).strip())
return [s for s in steps if s][:6] # 最多6步
def _extract_comparisons(self, text: str) -> List[Tuple[str, str]]:
"""提取对比项"""
comparisons = []
# 匹配"A...B..."对比结构
pattern = r'([^与和与和对比]+?)\s*(?:与|和|跟|相比)\s*([^的的区别]+?)\s*(?:的)?(?:区别|不同|差异)'
matches = re.findall(pattern, text)
comparisons.extend([(m[0].strip(), m[1].strip()) for m in matches])
return comparisons[:3] # 最多3组对比
def _extract_formulas(self, text: str) -> List[str]:
"""提取公式"""
formulas = []
# 匹配数学表达式
math_pattern = r'[A-Za-z]+\s*=\s*[^，。；\n]+'
formulas = re.findall(math_pattern, text)
# 匹配带运算符的表达式
operator_pattern = r'[A-Za-z0-9]+\s*[\+\-\*\/]\s*[A-Za-z0-9]+\s*=\s*.+'
formulas.extend(re.findall(operator_pattern, text))
return list(set(formulas))[:3] # 去重，最多3个公式
def _generate_summary(self, text: str, title: str, k_type: str) -> str:
"""生成知识点总结句"""
# 简单策略：取第一句非标题的句子
sentences = re.split(r'[。！？]', text)
for s in sentences:
s = s.strip()
if s and s != title and len(s) > 10:
return s + "。"
# 备选：拼接关键词
keywords = self._extract_keywords(text)[:3]
if keywords:
return f"{title}的核心要点包括{keywords[0]}、{keywords[1]}和{keywords[2]}。"
return f"掌握{title}的关键信息，有助于理解相关知识体系。"
3. modules/visual_mapper.py - 视觉映射模块
"""
视觉映射模块：将解析后的知识点转换为视觉元素
包括布局设计、图标匹配、配色方案选择
"""
from typing import Dict, List, Tuple, Any
from dataclasses import dataclass
from PIL import Image, ImageDraw, ImageFont
import os
@dataclass
class VisualElement:
"""视觉元素数据结构"""
element_type: str # 元素类型：text/image/shape/arrow
content: Any # 内容（文本/图片路径/形状参数）
position: Tuple[int, int] # 位置 (x, y)
size: Tuple[int, int] # 尺寸 (宽, 高)
color: str # 颜色
animation_type: str # 动画类型：fade_in/zoom/pulse/slide
class VisualMapper:
"""视觉映射器类"""
def __init__(self, config: Dict):
"""
初始化视觉映射器
参数:
config: 配置字典
"""
self.config = config
self.resolution = config["CARD_RESOLUTION"]
self.color_schemes = config["COLOR_SCHEMES"]
self.templates_dir = config["TEMPLATES_DIR"]
self.assets_dir = config["ASSETS_DIR"]
def map_to_visuals(self, knowledge_point: 'KnowledgePoint') -> List[VisualElement]:
"""
将知识点映射为视觉元素列表
参数:
knowledge_point: 解析后的知识点对象
返回:
视觉元素列表
"""
# 根据知识点类型选择模板和配色
template = self._select_template(knowledge_point.k_type)
color_scheme = self._select_color_scheme(knowledge_point.k_type)
# 根据类型生成不同布局
if knowledge_point.k_type == "concept":
return self._create_concept_layout(knowledge_point, template, color_scheme)
elif knowledge_point.k_type == "flowchart":
return self._create_flowchart_layout(knowledge_point, template, color_scheme)
elif knowledge_point.k_type == "comparison":
return self._create_comparison_layout(knowledge_point, template, color_scheme)
elif knowledge_point.k_type == "formula":
return self._create_formula_layout(knowledge_point, template, color_scheme)
else:
return self._create_default_layout(knowledge_point, template, color_scheme)
def _select_template(self, k_type: str) -> str:
"""选择对应的视觉模板"""
template_map = {
"concept": "concept_template.svg",
"flowchart": "flowchart_template.svg",
"comparison": "comparison_template.svg",
"formula": "formula_template.svg",
"timeline": "timeline_template.svg",
"classification": "classification_template.svg"
}
return template_map.get(k_type, "concept_template.svg")
def _select_color_scheme(self, k_type: str) -> Dict[str, str]:
"""根据知识点类型选择配色方案"""
scheme_map = {
"concept": "default",
"flowchart": "default",
"comparison": "humanity",
"formula": "science",
"timeline": "humanity",
"classification": "default"
}
scheme_name = scheme_map.get(k_type, "default")
return self.color_schemes[scheme_name]
def _create_concept_layout(self, kp: 'KnowledgePoint', template: str,
colors: Dict[str, str]) -> List[VisualElement]:
"""创建概念定义的视觉布局"""
elements = []
width, height = self.resolution
margin = 80
# 1. 标题
title_y = margin
elements.append(VisualElement(
element_type="text",
content=kp.title,
position=(margin, title_y),
size=(width - 2*margin, 80),
color=colors["primary"],
animation_type="slide_down"
))
# 2. 定义句
definition_y = title_y + 100
elements.append(VisualElement(
element_type="text",
content=f"定义：{kp.summary}",
position=(margin, definition_y),
size=(width - 2*margin, 120),
color=colors["text"],
animation_type="fade_in"
))
# 3. 关键词云
keyword_y = definition_y + 150
keyword_x = margin
for i, keyword in enumerate(kp.keywords[:5]):
elements.append(VisualElement(
element_type="text",
content=keyword,
position=(keyword_x, keyword_y),
size=(150, 50),
color=colors["secondary"] if i % 2 == 0 else colors["accent"],
animation_type="pop_in"
))
keyword_x += 160
# 4. 核心关系图
if kp.logic_relations:
relation_y = keyword_y + 80
for i, (subj, rel, obj) in enumerate(kp.logic_relations[:2]):
# 主体
elements.append(VisualElement(
element_type="text",
content=subj,
position=(margin, relation_y),
size=(200, 50),
color=colors["primary"],
animation_type="fade_in"
))
# 关系箭头
elements.append(VisualElement(
element_type="shape",
content="arrow_right",
position=(margin + 220, relation_y + 15),
size=(60, 20),
color=colors["accent"],
animation_type="draw_line"
))
# 客体
elements.append(VisualElement(
element_type="text",
content=obj,
position=(margin + 290, relation_y),
size=(200, 50),
color=colors["secondary"],
animation_type="fade_in"
))
relation_y += 70
return elements
def _create_flowchart_layout(self, kp: 'KnowledgePoint', template: str,
colors: Dict[str, str]) -> List[VisualElement]:
"""创建流程步骤的视觉布局"""
elements = []
width, height = self.resolution
margin = 60
step_width = width - 2*margin
step_height = 100
# 1. 标题
elements.append(VisualElement(
element_type="text",
content=f"📋 {kp.title}",
position=(margin, margin),
size=(step_width, 70),
color=colors["primary"],
animation_type="slide_down"
))
# 2. 流程步骤
start_y = margin + 100
for i, step in enumerate(kp.steps[:5]):
y_pos = start_y + i * (step_height + 20)
# 步骤框
elements.append(VisualElement(
element_type="shape",
content="rounded_rect",
position=(margin, y_pos),
size=(step_width, step_height),
color=colors["primary"] if i == 0 else colors["secondary"],
animation_type="slide_right"
))
# 步骤编号
elements.append(VisualElement(
element_type="text",
content=f"Step {i+1}",
position=(margin + 20, y_pos + 10),
size=(60, 30),
color="#FFFFFF",
animation_type="fade_in"
))
# 步骤内容
elements.append(VisualElement(
element_type="text",
content=step[:20] + "..." if len(step) > 20 else step,
position=(margin + 90, y_pos + 25),
size=(step_width - 110, 50),
color="#FFFFFF",
animation_type="fade_in"
))
# 连接箭头
if i < len(kp.steps) - 1:
elements.append(VisualElement(
element_type="shape",
content="arrow_down",
position=(width//2 - 15, y_pos + step_height),
size=(30, 30),
color=colors["accent"],
animation_type="draw_line"
))
return elements
def _create_comparison_layout(self, kp: 'KnowledgePoint', template: str,
colors: Dict[str, str]) -> List[VisualElement]:
"""创建对比分析的视觉布局"""
elements = []
width, height = self.resolution
margin = 40
col_width = (width - 3*margin) // 2
row_height = 80
# 1. 标题
elements.append(VisualElement(
element_type="text",
content=f"⚖️ {kp.title}",
position=(margin, margin),
size=(width - 2*margin, 70),
color=colors["primary"],
animation_type="slide_down"
))
# 2. 表头
headers = ["对比维度", "项目A", "项目B"]
header_colors = [colors["primary"], colors["secondary"], colors["accent"]]
for i, (header, h_color) in enumerate(zip(headers, header_colors)):
x_pos = margin + i * (col_width + margin)
elements.append(VisualElement(
element_type="shape",
content="rect",
positi
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！