一、实际应用场景描述（基于心理健康与创新能力视角）
在心理健康与创新能力研究中，"元认知（Metacognition）" 和 "思维可视化（Thinking Visualization）" 被认为是提升创造性问题解决能力的核心训练手段。
一个典型的现实场景：
你在做数据分析、写算法、或者推导一个数学公式。
你用计算器（或
"eval()" / NumPy）直接得到结果：
result = (a + b) * c / d # → 42.0
但你会发现：
- 你不知道这个结果是怎么来的
- 你看不到中间有没有可以简化的步骤
- 你无法回顾"当时是怎么想的"
从学习与创新的角度看，这带来三个问题：
1. 过程失忆（Process Amnesia）只记住结果，不记住推导路径，下次遇到类似问题还是从零开始。
2. 优化盲区传统计算器把"算对"作为唯一目标，从不问"有没有更优雅的算法"。
3. 元认知缺失你无法审视自己的思维过程，也就无法改进它——而元认知是创造力的基石。
本程序的目标是颠覆这一逻辑：
✅ 不只输出最终结果
✅ 保存全部演算草稿步骤
✅ 从计算过程的结构中，自动发现可简化、可重构、可创新的算法模式
✅ 把"计算"变成"算法发现的训练场"
二、引入痛点（中立、去情绪化）
1. 传统计算工具的隐含假设
隐含假设 在创新学习场景中的问题
结果 = 全部价值 丢失了过程性知识
最短路径最优 错过了发现更优算法的机会
黑盒计算即可 无法培养元认知与算法直觉
2. 创新能力视角的结构性问题
- 算法思维固化（Algorithmic Fixation）习惯了
"a + b * c" 的写法，永远不会发现
"(a + b) * c" 在某些场景下更优。
- 过程不可见 = 优化不可能如果你看不到中间步骤，就无法问"这一步能不能省略？"
- 学习的"黑盒依赖"长期使用黑盒计算器，会导致"会按按钮，但不会思考"。
3. 心理层面的代价
- 学习者形成"结果导向"的单一思维模式
- 创作者失去对"过程美感"的感知（如数学证明中的优雅性）
- 长期无法审视自己的思维路径 → 元认知发展受阻
三、核心逻辑讲解（心理模型 → 工程模型）
1️⃣ 核心心理模型：元认知训练（Metacognitive Training）
传统计算流程：
输入 → [黑盒] → 输出
本程序的计算流程：
输入 → [可观测的中间状态] → 输出
↓
过程记录
↓
模式识别（可简化？可重构？）
核心观点（Flavell, 1979）：
创造力不仅来自"产生想法"，更来自"审视自己怎么产生想法"的能力。
2️⃣ 工程化抽象
每个计算过程被建模为"演算树"：
ComputationNode:
- id: 节点唯一标识
- operation: 操作符（+, -, *, /, compose...）
- operands: 操作数列表
- result: 本节点计算结果
- children: 子节点（如果是复合运算）
- depth: 在演算树中的深度
- metadata: 额外信息（可优化标记等）
程序核心行为：
1. 表达式解析：将输入表达式解析为演算树
2. 逐步求值：按优先级逐步计算，记录每一步
3. 草稿保存：完整保存演算路径（可导出 / 可回放）
4. 模式识别：扫描演算树，发现可简化 / 可重构的模式
5. 创新建议：输出"这一步可以合并""这个分支可以剪枝"等算法优化提示
3️⃣ 可发现的优化模式（示例）
模式 原始写法 优化后 创新点
常数折叠
"(3 + 4) * x"
"7 * x" 编译期常量合并
冗余计算
"a * b + a * c"
"a * (b + c)" 提取公因子
幂等消除
"x * 1 + 0"
"x" 消除恒等元
重复子表达式 同个子表达式算两次 提取为变量 空间换时间
对称性利用 双向遍历 单向+对称性 复杂度减半
四、代码模块化实现（Python）
项目结构
scratch_calc/
├── README.md
├── requirements.txt
├── config.yaml
├── main.py
├── core/
│ ├── parser.py # 表达式解析器
│ ├── evaluator.py # 逐步求值引擎
│ ├── optimizer.py # 算法模式识别与优化建议
│ └── draft_store.py # 演算草稿持久化
└── utils/
├── logger.py
└── tree_viz.py # 演算树可视化
requirements.txt
pyyaml>=6.0
rich>=13.0.0
config.yaml
evaluation:
show_steps: true
detect_patterns: true
optimization:
enable_suggestions: true
min_saving_threshold: 0.1 # 最少节省 10% 计算量才建议
storage:
draft_path: "drafts.yaml"
core/parser.py
"""
表达式解析器
将字符串表达式解析为结构化的演算树
"""
import re
from typing import Dict, Any, List, Optional, Union
from utils.logger import setup_logger
logger = setup_logger("Parser")
class ComputationNode:
"""演算树中的一个节点"""
def __init__(
self,
node_id: str,
operation: str,
operands: List[Any],
depth: int = 0
):
self.id = node_id
self.operation = operation
self.operands = operands # 叶子节点存值，内部节点存子节点
self.result: Optional[float] = None
self.depth = depth
self.children: List['ComputationNode'] = []
self.optimization_hints: List[str] = []
def is_leaf(self) -> bool:
return not self.children
def to_dict(self) -> Dict[str, Any]:
return {
"id": self.id,
"operation": self.operation,
"operands": self.operands if self.is_leaf() else [c.id for c in self.children],
"result": self.result,
"depth": self.depth,
"is_leaf": self.is_leaf(),
"optimization_hints": self.optimization_hints
}
def parse_expression(expr: str) -> Optional[ComputationNode]:
"""
解析数学表达式，构建演算树
支持：+ - * / 和基础括号嵌套
这是一个教育级递归下降解析器（Recursive Descent Parser）
"""
expr = expr.strip().replace(" ", "")
if not expr:
return None
tokens = _tokenize(expr)
logger.debug(f"Tokenized: {tokens}")
pos = [0] # 用列表包装，使闭包可修改
root = _parse_additive(tokens, pos, depth=0, node_counter=[0])
logger.info(f"解析完成: {root.id}, 深度: {root.depth}")
return root
def _tokenize(expr: str) -> List[str]:
"""词法分析：将表达式拆分为 token 列表"""
tokens = []
i = 0
while i < len(expr):
if expr[i].isdigit() or (expr[i] == '.' and i + 1 < len(expr) and expr[i+1].isdigit()):
j = i
while j < len(expr) and (expr[j].isdigit() or expr[j] == '.'):
j += 1
tokens.append(expr[i:j])
i = j
elif expr[i] in '+-*/()':
tokens.append(expr[i])
i += 1
else:
raise ValueError(f"无法识别的字符: '{expr[i]}' at position {i}")
return tokens
def _parse_additive(tokens: list, pos: list, depth: int, node_counter: list) -> ComputationNode:
"""解析加减法层级"""
left = _parse_multiplicative(tokens, pos, depth, node_counter)
while pos[0] < len(tokens) and tokens[pos[0]] in ('+', '-'):
op = tokens[pos[0]]
pos[0] += 1
right = _parse_multiplicative(tokens, pos, depth, node_counter)
node = ComputationNode(
node_id=f"n{node_counter[0]}",
operation=op,
operands=[left.id, right.id],
depth=depth
)
node.children = [left, right]
node_counter[0] += 1
left = node
return left
def _parse_multiplicative(tokens: list, pos: list, depth: int, node_counter: list) -> ComputationNode:
"""解析乘除法层级"""
left = _parse_primary(tokens, pos, depth, node_counter)
while pos[0] < len(tokens) and tokens[pos[0]] in ('*', '/'):
op = tokens[pos[0]]
pos[0] += 1
right = _parse_primary(tokens, pos, depth, node_counter)
node = ComputationNode(
node_id=f"n{node_counter[0]}",
operation=op,
operands=[left.id, right.id],
depth=depth
)
node.children = [left, right]
node_counter[0] += 1
left = node
return left
def _parse_primary(tokens: list, pos: list, depth: int, node_counter: list) -> ComputationNode:
"""解析基本单元（数字 / 括号表达式）"""
if pos[0] >= len(tokens):
raise ValueError("表达式不完整")
token = tokens[pos[0]]
if token == '(':
pos[0] += 1 # 跳过 '('
node = _parse_additive(tokens, pos, depth + 1, node_counter)
if pos[0] >= len(tokens) or tokens[pos[0]] != ')':
raise ValueError("括号不匹配：缺少 ')'")
pos[0] += 1 # 跳过 ')'
return node
try:
value = float(token) if '.' in token else int(token)
except ValueError:
raise ValueError(f"无效的数字: '{token}'")
pos[0] += 1
node = ComputationNode(
node_id=f"n{node_counter[0]}",
operation="literal",
operands=[value],
depth=depth
)
node.result = float(value)
node_counter[0] += 1
return node
core/evaluator.py
"""
逐步求值引擎
按演算树的结构，逐步计算并记录每一步
"""
from typing import Dict, Any, List
from core.parser import ComputationNode
from utils.logger import setup_logger
logger = setup_logger("Evaluator")
class EvaluationStep:
"""单步求值记录"""
def __init__(self, node_id: str, description: str, result: float):
self.node_id = node_id
self.description = description
self.result = result
def to_dict(self):
return {
"node_id": self.node_id,
"description": self.description,
"result": self.result
}
class StepEvaluator:
"""逐步求值器"""
def __init__(self):
self.steps: List[EvaluationStep] = []
self.node_results: Dict[str, float] = {}
def evaluate(self, root: ComputationNode) -> float:
"""后序遍历演算树，逐步求值"""
result = self._eval_node(root)
logger.info(f"求值完成，共 {len(self.steps)} 步")
return result
def _eval_node(self, node: ComputationNode) -> float:
if node.is_leaf():
# 叶子节点：直接返回值
val = node.operands[0]
self.node_results[node.id] = val
self.steps.append(EvaluationStep(
node_id=node.id,
description=f"取值: {val}",
result=val
))
return val
# 递归求值子节点
child_results = []
for child in node.children:
r = self._eval_node(child)
child_results.append(r)
# 执行当前节点的运算
if node.operation == '+':
result = child_results[0] + child_results[1]
desc = f"{child_results[0]} + {child_results[1]} = {result}"
elif node.operation == '-':
result = child_results[0] - child_results[1]
desc = f"{child_results[0]} - {child_results[1]} = {result}"
elif node.operation == '*':
result = child_results[0] * child_results[1]
desc = f"{child_results[0]} × {child_results[1]} = {result}"
elif node.operation == '/':
if child_results[1] == 0:
raise ZeroDivisionError("除零错误")
result = child_results[0] / child_results[1]
desc = f"{child_results[0]} ÷ {child_results[1]} = {result}"
else:
raise ValueError(f"未知操作符: {node.operation}")
self.node_results[node.id] = result
node.result = result
self.steps.append(EvaluationStep(
node_id=node.id,
description=desc,
result=result
))
return result
def get_steps(self) -> List[Dict[str, Any]]:
return [s.to_dict() for s in self.steps]
core/optimizer.py
"""
算法模式识别与优化建议引擎
扫描演算树，发现可简化 / 可重构的模式
"""
from typing import Dict, Any, List
from core.parser import ComputationNode
from utils.logger import setup_logger
logger = setup_logger("Optimizer")
class OptimizationSuggestion:
"""单条优化建议"""
def __init__(self, node_id: str, pattern: str, description: str, savings_ratio: float):
self.node_id = node_id
self.pattern = pattern
self.description = description
self.savings_ratio = savings_ratio # 预期节省的计算比例
def to_dict(self):
return {
"node_id": self.node_id,
"pattern": self.pattern,
"description": self.description,
"savings_ratio": self.savings_ratio
}
class Optimizer:
"""演算树优化分析器"""
def __init__(self, min_savings: float = 0.1):
self.min_savings = min_savings
self.suggestions: List[OptimizationSuggestion] = []
def analyze(self, root: ComputationNode) -> List[OptimizationSuggestion]:
"""扫描演算树，生成优化建议"""
self.suggestions = []
self._scan(root)
# 按节省比例降序排列
self.suggestions.sort(key=lambda x: x.savings_ratio, reverse=True)
logger.info(f"分析完成，发现 {len(self.suggestions)} 条优化建议")
return self.suggestions
def _scan(self, node: ComputationNode):
"""递归扫描节点"""
if node.is_leaf():
return
# 检测模式
self._check_constant_folding(node)
self._check_identity_element(node)
self._check_common_factor(node)
self._check_redundant_computation(node)
# 递归扫描子节点
for child in node.children:
self._scan(child)
def _check_constant_folding(self, node: ComputationNode):
"""模式1：常数折叠 —— 子表达式全是常量，可提前计算"""
if node.operation in ('+', '-', '*', '/'):
all_const = all(
child.is_leaf() and child.operation == "literal"
for child in node.children
)
if all_const:
self.suggestions.append(OptimizationSuggestion(
node_id=node.id,
pattern="常数折叠（Constant Folding）",
description=(
f"节点 {node.id} 的操作数都是常量，"
"可在编译期/预处理期直接计算，运行时零开销"
),
savings_ratio=1.0 # 完全消除运行时计算
))
def _check_identity_element(self, node: ComputationNode):
"""模式2：恒等元消除 —— x * 1 = x, x + 0 = x"""
if node.operation == '*':
for i, child in enumerate(node.children):
if child.is_leaf() and child.operands[0] == 1:
other = node.children[1 - i]
self.suggestions.append(OptimizationSuggestion(
node_id=node.id,
pattern="恒等元消除（Identity Element）",
description=(
f"节点 {node.id}: 乘以 1 是冗余操作，"
f"可直接使用 {other.id} 的结果"
),
savings_ratio=0.5
))
elif node.operation == '+':
for i, child in enumerate(node.children):
if child.is_leaf() and child.operands[0] == 0:
other = node.children[1 - i]
self.suggestions.append(OptimizationSuggestion(
node_id=node.id,
pattern="恒等元消除（Identity Element）",
description=(
f"节点 {node.id}: 加 0 是冗余操作，"
f"可直接使用 {other.id} 的结果"
),
savings_ratio=0.5
))
def _check_common_factor(self, node: ComputationNode):
"""模式3：公因子提取 —— a*b + a*c = a*(b+c)"""
# 简化检测：当前节点是 +，子节点都是 *
if node.operation != '+':
return
if not all(c.operation == '*' for c in node.children):
return
# 提取每个乘法节点的因子
factor_sets = []
for child in node.children:
factors = set()
for f in child.children:
if f.is_leaf():
factors.add(f.operands[0])
factor_sets.append(factors)
# 查找公共因子
common = factor_sets[0]
for fs in factor_sets[1:]:
common = common & fs
if common:
self.suggestions.append(OptimizationSuggestion(
node_id=node.id,
pattern="公因子提取（Common Factor Extraction）",
description=(
f"节点 {node.id}: 检测到公共因子 {common}，"
f"可重构为 factor × (remaining_terms)"
),
savings_ratio=0.3
))
def _check_redundant_computation(self, node: ComputationNode):
"""模式4：重复子表达式 —— 同一子表达式被计算多次"""
# 遍历整棵树，收集所有子表达式的 result
expr_results = {}
self._collect_results(node, expr_results)
# 找出重复的 result
from collections import Counter
counts = Counter(expr_results.values())
for val, count in counts.items():
if count > 1:
nodes_with_val = [nid for nid, v in expr_results.items() if v == val]
self.suggestions.append(OptimizationSuggestion(
node_id=node.id,
pattern="重复子表达式（Redundant Sub-expression）",
description=(
f"值 {val} 被计算了 {count} 次"
f"（节点: {', '.join(nodes_with_val)}）。"
"可提取为临时变量，避免重复计算"
),
savings_ratio=(count - 1) / count
))
def _collect_results(self, node: ComputationNode, result_map: dict):
if node.result is not None:
result_map[node.id] = node.result
for child in node.children:
self._collect_results(child, result_map)
core/draft_store.py
"""
演算草稿持久化模块
将完整的演算过程保存为可回放、可审查的结构
"""
from pathlib import Path
import yaml
from typing import Dict, Any, List
from core.parser import ComputationNode
from core.evaluator import EvaluationStep
from core.optimizer import OptimizationSuggestion
from utils.logger import setup_logger
logger = setup_logger("DraftStore")
class Draft:
"""一次完整计算的草稿"""
def __init__(
self,
expression: str,
result: float,
steps: List[Dict[str, Any]],
tree: Dict[str, Any],
optimizations: List[Dict[str, Any]]
):
self.expression = expression
self.result = result
self.steps = steps
self.tree = tree
self.optimizations = optimizations
def to_dict(self):
return {
"expression": self.expression,
"result": self.result,
"steps": self.steps,
"tree": self.tree,
"optimizations": self.optimizations
}
class DraftStore:
"""草稿存储管理器"""
def __init__(self, path: str = "drafts.yaml"):
self.path = Path(path)
self.drafts: List[Draft] = []
def load(self):
if self.path.exists():
data = yaml.safe_load(self.path.read_text(encoding="utf-8")) or []
self.drafts = data
logger.info(f"加载 {len(self.drafts)} 份草稿")
def save_draft(self, draft: Draft):
self.drafts.append(draft.to_dict())
self._persist()
logger.info(f"草稿已保存: {draft.expression} = {draft.result}")
def _persist(self):
self.path.write_text(
yaml.dump(
self.drafts,
allow_unicode=True,
default_flow_style=False
),
encoding="utf-8"
)
def list_drafts(self) -> List[Dict[str, Any]]:
return [
{
"index": i,
"expression": d.get("expression", ""),
"result": d.get("result", 0)
}
for i, d in enumerate(self.drafts)
]
def get_draft(self, index: int) -> Optional[Dict[str, Any]]:
if 0 <= index < len(self.drafts):
return self.drafts[index]
return None
utils/tree_viz.py
"""
演算树可视化工具
用缩进结构展示计算过程
"""
from core.parser import ComputationNode
from utils.logger import setup_logger
logger = setup_logger("TreeViz")
def visualize_tree(root: ComputationNode, indent: int = 0) -> str:
"""将演算树渲染为可读的文本结构"""
prefix = " " * indent
lines = []
if root.is_leaf():
lines.append(f"{prefix}└─ [{root.id}] 值: {root.operands[0]}")
else:
op_symbol = {"+": "+", "-": "-", "*": "×", "/": "÷"}.get(root.operation, root.operation)
lines.append(f"{prefix}├─ [{root.id}] 操作: {op_symbol}")
for child in root.children:
lines.append(visualize_tree(child, indent + 1))
return "\n".join(lines)
utils/logger.py
from rich.logging import RichHandler
import logging
def setup_logger(name: str):
logger = logging.getLogger(name)
logger.setLevel(logging.INFO)
handler = RichHandler()
handler.setFormatter(logging.Formatter("%(message)s"))
logger.addHandler(handler)
return logger
main.py
"""
主程序入口
演示完整流程：解析 → 求值 → 优化分析 → 草稿保存
"""
import yaml
from pathlib import Path
from core.parser import parse_expression
from core.evaluator import StepEvaluator
from core.optimizer import Optimizer
from core.draft_store import DraftStore, Draft
from utils.tree_viz import visualize_tree
from utils.logger import setup_logger
from rich.console import Console
from rich.table import Table
from rich.panel import Panel
logger = setup_logger("Main")
console = Console()
def load_config(path: str = "config.yaml"):
return yaml.safe_load(Path(path).read_text(encoding="utf-8"))
def display_steps(steps: list):
"""展示逐步计算过程"""
console.print("\n[bold cyan]📝 演算步骤[/bold cyan]\n")
table = Table(show_header=True, header_style="bold magenta", box=None)
table.add_column("步骤", width=6, justify="center")
table.add_column("节点", style="yellow")
table.add_column("计算过程", style="white")
table.add_column("结果", justify="center", style="green")
for i, s in enumerate(steps, 1):
table.add_row(str(i), s["node_id"], s["description"], str(s["result"]))
console.print(table)
def display_optimizations(suggestions: list):
"""展示优化建议"""
if not suggestions:
console.print("\n[dim]未检测到可优化的模式[/dim]\n")
return
console.print("\n[bold cyan]⚡ 算法优化建议[/bold cyan]\n")
table = Table(show_header=True, header_style="bold magenta", box=None)
table.add_column("#", width=4, justify="center")
table.add_column("模式", style="yellow")
table.add_column("说明",
利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！
)
