企业官网建设流程全解析

一、实际应用场景描述（基于心理健康与创新能力视角）

在心理健康与创新能力研究中，"认知负荷理论（Cognitive Load Theory）" 和 "支架式教学（Scaffolding）" 表明：一次性呈现过多信息会触发认知过载，反而抑制深度学习与创新思维。

一个典型的现实场景：

你加入了一个新项目，或者开始学习一门新技术。

团队或教程把所有资源一次性丢给你：

- 完整代码库

- 全部文档

- 设计稿、API 文档、数据库 schema……

结果往往是：

- 信息过载 → 不知从何入手

- 直接看最终方案 → 跳过了"探索—试错—顿悟"的过程

- 习惯了"抄答案"，而非"想答案"

心理学研究表明：

- 顿悟（Insight） 发生在信息逐步呈现、思维逐步推进的过程中

- 认知留白（Cognitive White Space） 是创造性联想的必要条件

- 一次性获取全部资源 = 剥夺了"自主发现"的心理满足感

本程序的目标是颠覆这一逻辑：

✅ 不一次性释放所有资源

✅ 按阶段、按条件逐步开放素材

✅ 用"信息不对称"倒逼分步思考

✅ 每一阶段只给"刚好够"的材料，留出思考空间

二、引入痛点（中立、去情绪化）

1. 传统打包/分发工具的隐含假设

隐含假设 在创新学习场景中的问题

信息越全越好 认知过载，降低学习效率

一步到位最高效 跳过了探索阶段，削弱创新能力

用户自己会分步 缺乏外部约束时，大多数人直接看答案

2. 创新能力视角的结构性问题

- 认知过载（Cognitive Overload）工作记忆容量有限（约 7±2 个信息单元），超载会导致"浅层处理"。

- 探索动机缺失当"终局答案"触手可及时，大脑会走认知捷径，跳过发散思维阶段。

- 习得性依赖长期接受"完整打包"的资源，会丧失"从碎片中构建整体"的能力。

3. 心理层面的代价

- 学习者陷入"收藏—从未打开"的恶性循环

- 创作者养成"看别人怎么做"而非"自己想怎么做"的习惯

- 团队中新成员"知其然不知其所以然"，难以独立创新

三、核心逻辑讲解（心理模型 → 工程模型）

1️⃣ 核心心理模型：最近发展区（ZPD）+ 支架式教学

能力水平

^

| ┌─────────────┐

| │ 独立创新区 │

| ┌─────────┤ │

| │ 支架区 │ ZPD │

| 当前水平 ────────┘ │

| │

└────────────────────────────────────→ 时间/阶段

核心思想：

在用户当前能力水平之上，只提供"刚好够得着"的下一层信息，逐步撤除支架。

2️⃣ 工程化抽象

每个项目被建模为"分阶段资源树"：

Project:

- id: 项目唯一标识

- name: 项目名称

- stages: 阶段列表

- stage_1:

name: "需求理解"

unlock_condition: "start" # 初始开放

resources: [需求文档.md, 用户画像.pdf]

next_stage_hint: "完成需求分析后解锁下一阶段"

- stage_2:

name: "方案设计"

unlock_condition: "stage_1.completed"

resources: [竞品分析.md, 技术选型指南.pdf]

next_stage_hint: "设计方案评审通过后解锁"

- stage_3:

name: "执行落地"

unlock_condition: "stage_2.completed"

resources: [完整代码库.zip, 部署文档.md]

程序核心行为：

1. 初始化时只开放第一阶段资源

2. 用户完成当前阶段后，手动或自动触发解锁

3. 每个阶段只暴露"必要且刚好够用"的素材

4. 记录用户的思考路径（可选）

3️⃣ 解锁机制设计

def check_unlock(stage, project_state):

if stage.unlock_condition == "start":

return True

if stage.unlock_condition == "previous.completed":

return project_state[f"stage_{stage.index-1}_done"] == True

if stage.unlock_condition.startswith("score>="):

threshold = float(stage.unlock_condition.split(">=")[1])

return project_state["current_score"] >= threshold

return False

设计理念：

不是"藏起来让你找"，而是"按时机给你需要的"。

类似游戏中的技能树解锁机制，但应用于学习与创新场景。

四、代码模块化实现（Python）

项目结构

staged_resource/

├── README.md

├── requirements.txt

├── config.yaml

├── main.py

├── core/

│ ├── project_loader.py # 项目数据加载

│ ├── stage_manager.py # 阶段管理与解锁逻辑

│ ├── resource_viewer.py # 资源展示与访问

│ └── progress_tracker.py # 进度追踪

└── utils/

├── logger.py

└── file_utils.py

requirements.txt

pyyaml>=6.0

rich>=13.0.0

config.yaml

project:

data_path: "projects.yaml"

state_path: "progress.yaml"

display:

show_hints: true

show_locked: false # 是否展示锁定阶段的占位信息

core/project_loader.py

"""

项目数据加载模块

读取项目配置，解析阶段与资源结构

"""

from pathlib import Path

import yaml

from typing import Dict, List, Any, Optional

from utils.logger import setup_logger

logger = setup_logger("ProjectLoader")

class Resource:

"""单个资源文件的描述"""

def __init__(self, data: Dict[str, Any]):

self.name = data["name"]

self.path = data.get("path", "")

self.type = data.get("type", "file")

self.description = data.get("description", "")

def to_dict(self):

return {

"name": self.name,

"path": self.path,

"type": self.type,

"description": self.description

}

class Stage:

"""项目的一个阶段"""

def __init__(self, index: int, data: Dict[str, Any]):

self.index = index

self.name = data["name"]

self.unlock_condition = data["unlock_condition"]

self.hint = data.get("next_stage_hint", "")

self.resources = [Resource(r) for r in data.get("resources", [])]

def to_dict(self):

return {

"index": self.index,

"name": self.name,

"unlock_condition": self.unlock_condition,

"hint": self.hint,

"resources": [r.to_dict() for r in self.resources]

}

class Project:

"""完整项目定义"""

def __init__(self, data: Dict[str, Any]):

self.id = data["id"]

self.name = data["name"]

self.description = data.get("description", "")

self.stages: List[Stage] = []

for i, s in enumerate(data.get("stages", []), 1):

self.stages.append(Stage(i, s))

def to_dict(self):

return {

"id": self.id,

"name": self.name,

"description": self.description,

"stages": [s.to_dict() for s in self.stages]

}

def load_projects(path: str) -> List[Project]:

"""从 YAML 加载项目列表"""

p = Path(path)

if not p.exists():

logger.error(f"项目文件不存在: {path}")

return []

raw = yaml.safe_load(p.read_text(encoding="utf-8")) or []

projects = [Project(item) for item in raw]

logger.info(f"加载项目 {len(projects)} 个")

return projects

core/stage_manager.py

"""

阶段管理器

核心模块：控制每个阶段的锁定/解锁状态

"""

from typing import Dict, Any, Optional

from core.project_loader import Project, Stage

from utils.logger import setup_logger

logger = setup_logger("StageManager")

class StageManager:

"""管理项目的阶段解锁逻辑"""

def __init__(self, project: Project, state: Dict[str, Any]):

self.project = project

self.state = state

def get_stage_key(self, stage_index: int) -> str:

return f"{self.project.id}_stage_{stage_index}_done"

def is_stage_completed(self, stage_index: int) -> bool:

return self.state.get(self.get_stage_key(stage_index), False)

def mark_stage_completed(self, stage_index: int):

self.state[self.get_stage_key(stage_index)] = True

logger.info(

f"[{self.project.name}] 阶段 {stage_index} 已标记为完成"

)

def is_stage_unlocked(self, stage: Stage) -> bool:

"""判断阶段是否满足解锁条件"""

cond = stage.unlock_condition.strip()

# 无条件（初始阶段）

if cond in ("start", "true", "always"):

return True

# 前一阶段完成

if cond == "previous.completed":

if stage.index <= 1:

return True

return self.is_stage_completed(stage.index - 1)

# 分数阈值

if cond.startswith("score>="):

try:

threshold = float(cond.split(">=")[1])

current_score = self.state.get("current_score", 0.0)

return current_score >= threshold

except (ValueError, IndexError):

logger.warning(f"无法解析解锁条件: {cond}")

return False

# 自定义条件（可扩展）

logger.warning(f"未知的解锁条件: {cond}")

return False

def get_visible_stages(self) -> list:

"""获取当前用户可见的阶段（已解锁的）"""

visible = []

for s in self.project.stages:

if self.is_stage_unlocked(s):

visible.append({

**s.to_dict(),

"completed": self.is_stage_completed(s.index),

"locked": False

})

else:

visible.append({

"index": s.index,

"name": s.name,

"completed": False,

"locked": True,

"hint": s.hint

})

return visible

def advance(self, stage_index: int) -> Dict[str, Any]:

"""

用户请求推进到下一阶段

返回操作结果（成功/失败/需要条件）

"""

if stage_index < 1 or stage_index > len(self.project.stages):

return {"ok": False, "msg": "无效阶段编号"}

stage = self.project.stages[stage_index - 1]

if not self.is_stage_unlocked(stage):

return {

"ok": False,

"msg": f"阶段 '{stage.name}' 尚未解锁",

"hint": stage.hint

}

# 标记当前阶段完成并解锁下一阶段

self.mark_stage_completed(stage.index)

next_index = stage.index + 1

if next_index <= len(self.project.stages):

next_stage = self.project.stages[next_index - 1]

return {

"ok": True,

"msg": f"阶段 '{stage.name}' 完成！",

"next_stage": next_stage.name,

"next_hint": next_stage.hint,

"auto_unlocked": self.is_stage_unlocked(next_stage)

}

else:

return {

"ok": True,

"msg": f"🎉 所有阶段已完成！项目 '{self.project.name}' 结束。",

"next_stage": None

}

core/resource_viewer.py

"""

资源展示模块

按阶段呈现可用的资源列表

"""

from rich.console import Console

from rich.table import Table

from core.project_loader import Project, Stage

from core.stage_manager import StageManager

from utils.logger import setup_logger

logger = setup_logger("ResourceViewer")

console = Console()

def show_stage_resources(manager: StageManager, stage_index: int):

"""展示指定阶段可用的资源"""

if stage_index < 1 or stage_index > len(manager.project.stages):

console.print("[red]无效阶段编号[/red]")

return

stage = manager.project.stages[stage_index - 1]

if not manager.is_stage_unlocked(stage):

console.print(

f"[yellow]⚠ 阶段 '{stage.name}' 尚未解锁[/yellow]"

)

if stage.hint:

console.print(f"[dim]提示: {stage.hint}[/dim]")

return

console.print(f"\n[bold cyan]📂 阶段: {stage.name}[/bold cyan]")

console.print(f"[dim]{'─' * 50}[/dim]")

if not stage.resources:

console.print(" [dim]本阶段暂无资源[/dim]")

return

table = Table(show_header=True, header_style="bold magenta", box=None)

table.add_column("#", width=4, justify="center")

table.add_column("资源名称", style="green")

table.add_column("类型", justify="center", style="yellow")

table.add_column("说明", style="white")

for i, r in enumerate(stage.resources, 1):

table.add_row(str(i), r.name, r.type, r.description)

console.print(table)

# 显示推进提示

completed = manager.is_stage_completed(stage.index)

if not completed:

console.print(

f"\n[dim]完成本阶段后，运行 'advance {stage.index}' "

f"解锁下一阶段[/dim]"

)

else:

console.print(

f"\n[green]✓ 本阶段已完成[/green]"

)

def show_project_overview(manager: StageManager):

"""展示项目全貌（仅显示已解锁阶段）"""

console.print(

f"\n[bold cyan]📋 项目: {manager.project.name}[/bold cyan]"

)

if manager.project.description:

console.print(f"[dim]{manager.project.description}[/dim]\n")

visible = manager.get_visible_stages()

table = Table(show_header=True, header_style="bold magenta", box=None)

table.add_column("阶段", width=6, justify="center")

table.add_column("名称", style="green")

table.add_column("状态", justify="center")

table.add_column("提示", style="dim")

for s in visible:

if s["locked"]:

status = "[red]🔒 锁定[/red]"

hint = s.get("hint", "")

elif s["completed"]:

status = "[green]✓ 已完成[/green]"

hint = ""

else:

status = "[yellow]进行中[/yellow]"

hint = s.get("hint", "")

table.add_row(

str(s["index"]),

s["name"],

status,

hint[:60] if hint else ""

)

console.print(table)

console.print()

core/progress_tracker.py

"""

进度追踪模块

持久化用户的阶段完成状态

"""

from pathlib import Path

import yaml

from typing import Dict, Any

from utils.logger import setup_logger

logger = setup_logger("ProgressTracker")

class ProgressTracker:

def __init__(self, path: str = "progress.yaml"):

self.path = Path(path)

self.state: Dict[str, Any] = {}

def load(self):

if self.path.exists():

self.state = yaml.safe_load(

self.path.read_text(encoding="utf-8")

) or {}

logger.info(f"加载进度: {len(self.state)} 条记录")

return self.state

def save(self):

self.path.write_text(

yaml.dump(self.state, allow_unicode=True, default_flow_style=False),

encoding="utf-8"

)

logger.debug("进度已保存")

def get(self, key: str, default: Any = None) -> Any:

return self.state.get(key, default)

def set(self, key: str, value: Any):

self.state[key] = value

self.save()

utils/file_utils.py

"""文件工具：检查资源文件是否存在"""

from pathlib import Path

def check_resource_exists(path: str) -> bool:

return Path(path).exists()

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.project_loader import load_projects

from core.stage_manager import StageManager

from core.resource_viewer import show_project_overview, show_stage_resources

from core.progress_tracker import ProgressTracker

from utils.logger import setup_logger

logger = setup_logger("Main")

def load_config(path: str = "config.yaml"):

return yaml.safe_load(Path(path).read_text(encoding="utf-8"))

def main():

config = load_config()

# 加载项目

projects = load_projects(config["project"]["data_path"])

if not projects:

logger.warning("无可用项目，请检查 projects.yaml")

return

# 加载进度

tracker = ProgressTracker(config["project"]["state_path"])

state = tracker.load()

# 使用第一个项目做演示

project = projects[0]

manager = StageManager(project, state)

# 展示项目概览

show_project_overview(manager)

# 展示第一阶段资源

show_stage_resources(manager, 1)

# 模拟推进到下一阶段

console = __import__("rich.console").Console()

console.print("\n[dim]─" * 50)

console.print("[bold]模拟: 完成阶段 1，推进到阶段 2...[/bold]\n")

result = manager.advance(1)

if result["ok"]:

console.print(f"[green]{result['msg']}[/green]")

if result.get("next_stage"):

console.print(f"[cyan]下一阶段: {result['next_stage']}[/cyan]")

console.print(f"[dim]{result.get('next_hint', '')}[/dim]")

tracker.save()

# 展示新阶段资源

show_stage_resources(manager, 2)

else:

console.print(f"[red]{result['msg']}[/red]")

logger.info("演示完成")

if __name__ == "__main__":

main()

projects.yaml（示例数据）

- id: "proj_001"

name: "设计一个智能推荐系统"

description: "从零开始设计一个小型推荐系统，分阶段获取资源"

stages:

- name: "阶段一：需求与场景理解"

unlock_condition: "start"

next_stage_hint: "完成需求分析文档后解锁"

resources:

- name: "用户画像模板.md"

path: "resources/proj_001/stage1/persona.md"

type: "markdown"

description: "目标用户的基本属性与行为特征模板"

- name: "需求分析框架.pdf"

path: "resources/proj_001/stage1/requirements.pdf"

type: "pdf"

description: "结构化需求梳理方法"

- name: "阶段二：方案设计"

unlock_condition: "previous.completed"

next_stage_hint: "方案评审通过后解锁"

resources:

- name: "竞品分析案例.md"

path: "resources/proj_001/stage2/competitors.md"

type: "markdown"

description: "三个主流方案的优缺点对比"

- name: "技术选型决策树.pdf"

path: "resources/proj_001/stage2/tech_choice.pdf"

type: "pdf"

description: "基于场景的技术选型框架"

- name: "阶段三：执行落地"

unlock_condition: "previous.completed"

next_stage_hint: "全部资源已开放"

resources:

- name: "完整代码库"

path: "resources/proj_001/stage3/code.zip"

type: "archive"

description: "推荐系统完整实现（Python）"

- name: "部署与运维指南.md"

path: "resources/proj_001/stage3/deploy.md"

type: "markdown"

description: "从开发到上线的完整流程"

五、README.md

# Staged Resource — 分阶段资源开放工具

## 是什么

一个基于心理健康与创新理论的 Python 工具，用于：

- 将项目资源拆分为多个阶段

- 按条件逐步开放素材，而非一次性释放全部

- 用"信息不对称"倒逼分步思考与创新

## 核心思想

> 不是"给你全部，你自己分步骤"，

> 而是"只给你当前需要的，逼你先想清楚"。

## 安装

bash

python -m venv .venv

source .venv/bin/activate

pip install -r requirements.txt

## 使用

bash

python main.py

## 项目配置格式

编辑 `projects.yaml`，按阶段组织资源：

yaml

- id: "proj_001"name: "项目名称"description: "项目说明"stages:

- name: "阶段一名称"unlock_condition: "start"next_stage_hint: "解锁提示"resources:

- name: "资源名称"path: "文件路径"type: "file类型"description: "资源说明"

### 解锁条件（unlock_condition）

| 值 | 含义 |

|----|------|

| `start` | 初始即开放 |

| `previous.completed` | 前一阶段完成后自动解锁 |

| `score>=8.0` | 当前评分达到阈值后解锁 |

## 进度管理

用户进度自动保存在 `progress.yaml`，包括：

- 各阶段完成状态

- 当前评分（可选）

## 模块说明

| 模块 | 职责 |

|----|----|

| core/project_loader.py | 项目与阶段数据加载 |

| core/stage_manager.py | 解锁条件判断与阶段推进 |

| core/resource_viewer.py | 资源列表展示 |

| core/progress_tracker.py | 进度持久化 |

## 许可

MIT License

六、核心知识点卡片（去营销、中立）

┌──────────────────────────────────────────────────────┐

│ 知识点 #1：Cognitive Load Theory（认知负荷理论） │

├──────────────────────────────────────────────────────┤

│ 工作记忆容量有限（~7±2 个信息单元） │

│ 一次性呈现过多信息 → 认知过载 → 浅层处理 │

│ 分阶段呈现 → 降低内在负荷 → 释放认知带宽给创新 │

└──────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────┐

│ 知识点 #2：ZPD（最近发展区） │

├──────────────────────────────────────────────────────┤

│ Vygotsky 提出的核心概念 │

│ 学习者在"现有水平"与"潜在水平"之间的区域 │

│ 外部支架（Scaffolding）应落在 ZPD 内 │

│ 本程序将"下一阶段资源"作为支架，刚好落在 ZPD │

└──────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────┐

│ 知识点 #3：Scaffolding（支架式教学） │

├──────────────────────────────────────────────────────┤

│ 临时支持结构，帮助学习者完成"凭自己做不到"的任务 │

│ 关键特征： │

│ - 临时性（逐步撤除） │

│ - 适应性（匹配当前能力） │

│ - 指向性（引导而非告知答案） │

└──────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────┐

│ 知识点 #4：Information Gap（信息缺口） │

├──────────────────────────────────────────────────────┤

│ 心理学中的"信息缺口理论" │

│ 适度的信息不对称 → 激发好奇心 → 驱动探索行为 │

│ 本程序刻意制造"可控的信息缺口" │

│ 类比：游戏中的迷雾机制（Fog of War） │

└──────────────────────────────────────────────────────┘

┌──────────────────────────────────────────────────────┐

│ 知识点 #5：State Machine（状态机） │

├──────────────────────────────────────────────────────┤

│ 阶段推进本质上是有限状态机 │

│ 状态 = 当前阶段 + 完成标志 │

│ 转移条件 = unlock_condition │

│ 工程价值：清晰、可审计、可持久化 │

└──────────────────────────────────────────────────────┘

七、总结（中立、工程视角）

传统打包/分发工具的核心假设是"信息越完整越好"，这在确定性的"交付场景"中成立，但在"学习与创新场景"中是一种认知误区。

本方案做了三件不同的事：

1. 翻转信息释放策略：从"一次性全给"变为"按需分阶段开放"

2. 引入解锁机制：用状态机管理认知支架的投放节奏

3. 保留思考空间：每个阶段只给"刚好够"的素材，留白给创新

从工程角度看，这是一个轻量级、数据驱动、状态可持久化的系统；

从心理角度看，它通过控制信息暴露节奏，保护了学习者的认知带宽和探索动机，符合支架式教学与最近发展区的核心原则。

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！