一、实际应用场景描述基于心理健康与创新能力视角在心理健康与创新能力研究中元认知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) * x7 * x 编译期常量合并冗余计算a * b a * ca * (b c) 提取公因子幂等消除x * 1 0x 消除恒等元重复子表达式 同个子表达式算两次 提取为变量 空间换时间对称性利用 双向遍历 单向对称性 复杂度减半四、代码模块化实现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.txtpyyaml6.0rich13.0.0config.yamlevaluation:show_steps: truedetect_patterns: trueoptimization:enable_suggestions: truemin_saving_threshold: 0.1 # 最少节省 10% 计算量才建议storage:draft_path: drafts.yamlcore/parser.py表达式解析器将字符串表达式解析为结构化的演算树import refrom typing import Dict, Any, List, Optional, Unionfrom utils.logger import setup_loggerlogger setup_logger(Parser)class ComputationNode:演算树中的一个节点def __init__(self,node_id: str,operation: str,operands: List[Any],depth: int 0):self.id node_idself.operation operationself.operands operands # 叶子节点存值内部节点存子节点self.result: Optional[float] Noneself.depth depthself.children: List[ComputationNode] []self.optimization_hints: List[str] []def is_leaf(self) - bool:return not self.childrendef 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 Parserexpr expr.strip().replace( , )if not expr:return Nonetokens _tokenize(expr)logger.debug(fTokenized: {tokens})pos [0] # 用列表包装使闭包可修改root _parse_additive(tokens, pos, depth0, node_counter[0])logger.info(f解析完成: {root.id}, 深度: {root.depth})return rootdef _tokenize(expr: str) - List[str]:词法分析将表达式拆分为 token 列表tokens []i 0while i len(expr):if expr[i].isdigit() or (expr[i] . and i 1 len(expr) and expr[i1].isdigit()):j iwhile j len(expr) and (expr[j].isdigit() or expr[j] .):j 1tokens.append(expr[i:j])i jelif expr[i] in -*/():tokens.append(expr[i])i 1else:raise ValueError(f无法识别的字符: {expr[i]} at position {i})return tokensdef _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] 1right _parse_multiplicative(tokens, pos, depth, node_counter)node ComputationNode(node_idfn{node_counter[0]},operationop,operands[left.id, right.id],depthdepth)node.children [left, right]node_counter[0] 1left nodereturn leftdef _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] 1right _parse_primary(tokens, pos, depth, node_counter)node ComputationNode(node_idfn{node_counter[0]},operationop,operands[left.id, right.id],depthdepth)node.children [left, right]node_counter[0] 1left nodereturn leftdef _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 nodetry:value float(token) if . in token else int(token)except ValueError:raise ValueError(f无效的数字: {token})pos[0] 1node ComputationNode(node_idfn{node_counter[0]},operationliteral,operands[value],depthdepth)node.result float(value)node_counter[0] 1return nodecore/evaluator.py逐步求值引擎按演算树的结构逐步计算并记录每一步from typing import Dict, Any, Listfrom core.parser import ComputationNodefrom utils.logger import setup_loggerlogger setup_logger(Evaluator)class EvaluationStep:单步求值记录def __init__(self, node_id: str, description: str, result: float):self.node_id node_idself.description descriptionself.result resultdef 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 resultdef _eval_node(self, node: ComputationNode) - float:if node.is_leaf():# 叶子节点直接返回值val node.operands[0]self.node_results[node.id] valself.steps.append(EvaluationStep(node_idnode.id,descriptionf取值: {val},resultval))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] resultnode.result resultself.steps.append(EvaluationStep(node_idnode.id,descriptiondesc,resultresult))return resultdef get_steps(self) - List[Dict[str, Any]]:return [s.to_dict() for s in self.steps]core/optimizer.py算法模式识别与优化建议引擎扫描演算树发现可简化 / 可重构的模式from typing import Dict, Any, Listfrom core.parser import ComputationNodefrom utils.logger import setup_loggerlogger setup_logger(Optimizer)class OptimizationSuggestion:单条优化建议def __init__(self, node_id: str, pattern: str, description: str, savings_ratio: float):self.node_id node_idself.pattern patternself.description descriptionself.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_savingsself.suggestions: List[OptimizationSuggestion] []def analyze(self, root: ComputationNode) - List[OptimizationSuggestion]:扫描演算树生成优化建议self.suggestions []self._scan(root)# 按节省比例降序排列self.suggestions.sort(keylambda x: x.savings_ratio, reverseTrue)logger.info(f分析完成发现 {len(self.suggestions)} 条优化建议)return self.suggestionsdef _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 literalfor child in node.children)if all_const:self.suggestions.append(OptimizationSuggestion(node_idnode.id,pattern常数折叠Constant Folding,description(f节点 {node.id} 的操作数都是常量可在编译期/预处理期直接计算运行时零开销),savings_ratio1.0 # 完全消除运行时计算))def _check_identity_element(self, node: ComputationNode):模式2恒等元消除 —— x * 1 x, x 0 xif 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_idnode.id,pattern恒等元消除Identity Element,description(f节点 {node.id}: 乘以 1 是冗余操作f可直接使用 {other.id} 的结果),savings_ratio0.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_idnode.id,pattern恒等元消除Identity Element,description(f节点 {node.id}: 加 0 是冗余操作f可直接使用 {other.id} 的结果),savings_ratio0.5))def _check_common_factor(self, node: ComputationNode):模式3公因子提取 —— a*b a*c a*(bc)# 简化检测当前节点是 子节点都是 *if node.operation ! :returnif 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 fsif common:self.suggestions.append(OptimizationSuggestion(node_idnode.id,pattern公因子提取Common Factor Extraction,description(f节点 {node.id}: 检测到公共因子 {common}f可重构为 factor × (remaining_terms)),savings_ratio0.3))def _check_redundant_computation(self, node: ComputationNode):模式4重复子表达式 —— 同一子表达式被计算多次# 遍历整棵树收集所有子表达式的 resultexpr_results {}self._collect_results(node, expr_results)# 找出重复的 resultfrom collections import Countercounts 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_idnode.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.resultfor child in node.children:self._collect_results(child, result_map)core/draft_store.py演算草稿持久化模块将完整的演算过程保存为可回放、可审查的结构from pathlib import Pathimport yamlfrom typing import Dict, Any, Listfrom core.parser import ComputationNodefrom core.evaluator import EvaluationStepfrom core.optimizer import OptimizationSuggestionfrom utils.logger import setup_loggerlogger 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 expressionself.result resultself.steps stepsself.tree treeself.optimizations optimizationsdef 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(encodingutf-8)) or []self.drafts datalogger.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_unicodeTrue,default_flow_styleFalse),encodingutf-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 Noneutils/tree_viz.py演算树可视化工具用缩进结构展示计算过程from core.parser import ComputationNodefrom utils.logger import setup_loggerlogger setup_logger(TreeViz)def visualize_tree(root: ComputationNode, indent: int 0) - str:将演算树渲染为可读的文本结构prefix * indentlines []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.pyfrom rich.logging import RichHandlerimport loggingdef setup_logger(name: str):logger logging.getLogger(name)logger.setLevel(logging.INFO)handler RichHandler()handler.setFormatter(logging.Formatter(%(message)s))logger.addHandler(handler)return loggermain.py主程序入口演示完整流程解析 → 求值 → 优化分析 → 草稿保存import yamlfrom pathlib import Pathfrom core.parser import parse_expressionfrom core.evaluator import StepEvaluatorfrom core.optimizer import Optimizerfrom core.draft_store import DraftStore, Draftfrom utils.tree_viz import visualize_treefrom utils.logger import setup_loggerfrom rich.console import Consolefrom rich.table import Tablefrom rich.panel import Panellogger setup_logger(Main)console Console()def load_config(path: str config.yaml):return yaml.safe_load(Path(path).read_text(encodingutf-8))def display_steps(steps: list):展示逐步计算过程console.print(\n[bold cyan] 演算步骤[/bold cyan]\n)table Table(show_headerTrue, header_stylebold magenta, boxNone)table.add_column(步骤, width6, justifycenter)table.add_column(节点, styleyellow)table.add_column(计算过程, stylewhite)table.add_column(结果, justifycenter, stylegreen)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)returnconsole.print(\n[bold cyan]⚡ 算法优化建议[/bold cyan]\n)table Table(show_headerTrue, header_stylebold magenta, boxNone)table.add_column(#, width4, justifycenter)table.add_column(模式, styleyellow)table.add_column(说明,利用AI解决实际问题如果你觉得这个工具好用欢迎关注长安牧笛
