用 Python 编写一个"自我否定记录 × 触发事件标注 × 避坑清单生成" 的心理效能工具。

内容严格保持中立、去营销化、可复现，不推荐任何商业产品，不引流。

一、实际应用场景描述（Scene）

在心理健康与创新能力课程中，有一个被反复验证的心理规律：

自我否定（Self-Negation）是创新者最大的隐性精力消耗源

典型应用场景包括：

- 程序员写完代码后反复自我怀疑："这方案是不是太蠢了？"

- 设计师产出方案后内心否定："这配色简直灾难"

- 创业者在推进项目时持续自我攻击："我根本不适合干这个"

- 研究者在论文被拒后陷入螺旋："我完全没有学术能力"

这些场景的共同点是：

不是能力问题，而是大脑在"习惯性否定自己"

这种自我否定往往：

- 与真实能力脱钩

- 在特定场景下反复触发

- 消耗大量认知资源

二、引入痛点（Pain Points）

1️⃣ 自我否定是"隐形税"

大多数人对内耗的认知是模糊的：

- "今天状态不好"

- "我可能真的不行"

- "算了，先刷会儿手机"

但无法回答：

- 今天否定了自己几次？

- 分别由什么事件触发？

- 有哪些是重复出现的模式？

2️⃣ 触发事件未被结构化记录

即使偶尔意识到"我又在否定自己"，也因为：

- 没有记录

- 没有分类

- 没有回顾

导致同样的坑反复踩、反复内耗。

3️⃣ 精力被无效消耗，创新空间被挤压

心理学研究表明：

- 自我否定消耗的工作记忆资源，与复杂认知任务高度重叠

- 内耗越多，留给创造性思考的"心理带宽"越少

不是没时间创新，而是没精力创新。

三、核心逻辑讲解（Core Logic）

1️⃣ 基本假设

自我否定不是性格缺陷，而是可被观察、记录、规避的可管理事件

2️⃣ 核心建模思路

将每天的自我否定抽象为：

触发事件

↓

自我否定反应

↓

记录（时间 + 事件 + 否定内容 + 强度）

↓

聚合分析 → 识别模式

↓

生成个性化避坑清单

3️⃣ 否定事件分类体系

类别 典型触发事件

社交比较 看到同龄人成果

完美主义 产出未达预期

不确定性焦虑 面对模糊需求

外部批评 收到负面反馈

身体疲惫 熬夜后状态差

拖延自责 未按时完成任务

4️⃣ 避坑清单生成逻辑

IF 某类触发事件出现 ≥ N 次：

→ 生成一条避坑规则

→ 附带应对建议

IF 某时段内否定频率异常高：

→ 标记为"高危时段"

→ 建议调整日程安排

四、程序设计与代码实现（Python）

1️⃣ 项目结构

self_negation_tracker/

│

├── README.md

├── requirements.txt

├── main.py

├── models.py

├── recorder.py

├── analyzer.py

├── data/

│ └── records.json

└── docs/

└── knowledge_cards.md

2️⃣ 数据模型（models.py）

# models.py

from dataclasses import dataclass

from datetime import datetime

from typing import Optional

from enum import Enum

class TriggerCategory(Enum):

"""自我否定的触发事件类别"""

SOCIAL_COMPARISON = "社交比较"

PERFECTIONISM = "完美主义"

UNCERTAINTY = "不确定性焦虑"

EXTERNAL_CRITICISM = "外部批评"

PHYSICAL_FATIGUE = "身体疲惫"

PROCRASTINATION = "拖延自责"

OTHER = "其他"

@dataclass

class NegationEvent:

"""单次自我否定记录"""

id: str

timestamp: str # ISO 格式时间戳

trigger_event: str # 触发事件描述（用户填写）

trigger_category: TriggerCategory # 事件分类

negative_thought: str # 自我否定的具体内容

intensity: int # 否定强度（1-10）

context_note: Optional[str] = None # 附加上下文

def to_dict(self):

return {

"id": self.id,

"timestamp": self.timestamp,

"trigger_event": self.trigger_event,

"trigger_category": self.trigger_category.value,

"negative_thought": self.negative_thought,

"intensity": self.intensity,

"context_note": self.context_note,

}

3️⃣ 事件记录模块（recorder.py）

# recorder.py

import json

from datetime import datetime

from typing import List

from models import NegationEvent, TriggerCategory

class NegationRecorder:

"""自我否定事件的记录器"""

def __init__(self, storage_path: str = "data/records.json"):

self.storage_path = storage_path

self.records: List[NegationEvent] = []

self._load()

def _load(self):

"""从文件加载已有记录"""

try:

with open(self.storage_path, "r", encoding="utf-8") as f:

data = json.load(f)

for item in data:

self.records.append(

NegationEvent(

id=item["id"],

timestamp=item["timestamp"],

trigger_event=item["trigger_event"],

trigger_category=TriggerCategory(

item["trigger_category"]

),

negative_thought=item["negative_thought"],

intensity=item["intensity"],

context_note=item.get("context_note"),

)

)

except (FileNotFoundError, json.JSONDecodeError):

self.records = []

def add_event(

self,

trigger_event: str,

trigger_category: TriggerCategory,

negative_thought: str,

intensity: int,

context_note: str = None,

) -> NegationEvent:

"""记录一次自我否定事件"""

event = NegationEvent(

id=f"neg_{len(self.records) + 1}",

timestamp=datetime.now().isoformat(),

trigger_event=trigger_event,

trigger_category=trigger_category,

negative_thought=negative_thought,

intensity=intensity,

context_note=context_note,

)

self.records.append(event)

self._save()

return event

def _save(self):

"""持久化到文件"""

with open(self.storage_path, "w", encoding="utf-8") as f:

json.dump(

[r.to_dict() for r in self.records],

f,

indent=2,

ensure_ascii=False,

)

def get_all(self) -> List[NegationEvent]:

return self.records

4️⃣ 分析与避坑清单生成模块（analyzer.py）

# analyzer.py

from typing import List, Dict

from collections import defaultdict, Counter

from models import NegationEvent, TriggerCategory

class NegationAnalyzer:

"""分析自我否定模式，生成避坑清单"""

def __init__(self, events: List[NegationEvent]):

self.events = events

def frequency_by_category(self) -> Dict[str, int]:

"""按触发类别统计出现次数"""

counter = Counter()

for e in self.events:

counter[e.trigger_category.value] += 1

return dict(counter)

def avg_intensity_by_category(self) -> Dict[str, float]:

"""按类别计算平均否定强度"""

buckets = defaultdict(list)

for e in self.events:

buckets[e.trigger_category.value].append(e.intensity)

return {

k: round(sum(v) / len(v), 2)

for k, v in buckets.items()

}

def hourly_distribution(self) -> Dict[int, int]:

"""按小时统计否定事件分布"""

dist = defaultdict(int)

for e in self.events:

hour = int(e.timestamp.split("T")[1].split(":")[0])

dist[hour] += 1

return dict(dist)

def generate_avoidance_checklist(self, min_occurrences: int = 2) -> List[Dict]:

"""

生成个性化避坑清单

出现 >= min_occurrences 的触发类别，生成一条避坑规则

"""

freq = self.frequency_by_category()

checklist = []

# 避坑规则映射

avoidance_rules = {

TriggerCategory.SOCIAL_COMPARISON.value: {

"trigger": "社交比较",

"rule": "看到他人成果时，先记录自己的进展再浏览",

"action": "关闭社交平台推送，设定每周固定浏览时间",

},

TriggerCategory.PERFECTIONISM.value: {

"trigger": "完美主义",

"rule": "产出第一版时明确标记为'草稿'，禁止自我审查",

"action": "设定'完成 > 完美'的阶段性目标",

},

TriggerCategory.UNCERTAINTY.value: {

"trigger": "不确定性焦虑",

"rule": "面对模糊需求时，先列出3个可行方向再深入",

"action": "用'探索期'框架替代'必须一次做对'心态",

},

TriggerCategory.EXTERNAL_CRITICISM.value: {

"trigger": "外部批评",

"rule": "收到负面反馈后，先区分'事实'与'观点'",

"action": "建立反馈分类标准：可行动 / 不可行动",

},

TriggerCategory.PHYSICAL_FATIGUE.value: {

"trigger": "身体疲惫",

"rule": "疲惫状态下不做自我评价，只做机械性任务",

"action": "设定'低能量时段'的专属任务清单",

},

TriggerCategory.PROCRASTINATION.value: {

"trigger": "拖延自责",

"rule": "拖延时问自己：'我在害怕什么？'而非'我为什么不做？'",

"action": "将任务拆解为5分钟可完成的微步骤",

},

}

for category, count in freq.items():

if count >= min_occurrences:

rule = avoidance_rules.get(category, {})

checklist.append(

{

"category": category,

"occurrences": count,

"rule": rule.get("rule", "保持觉察，记录模式"),

"suggested_action": rule.get(

"action", "持续观察此类触发事件"

),

}

)

# 按出现次数降序排列

checklist.sort(key=lambda x: x["occurrences"], reverse=True)

return checklist

5️⃣ 主程序（main.py）

# main.py

import json

from models import TriggerCategory

from recorder import NegationRecorder

from analyzer import NegationAnalyzer

# 初始化记录器

recorder = NegationRecorder()

# ============================================

# 模拟录入今天的自我否定事件

# 实际使用时，这里可以替换为交互式输入

# ============================================

recorder.add_event(

trigger_event="看到同事升职的消息",

trigger_category=TriggerCategory.SOCIAL_COMPARISON,

negative_thought="我做得完全不够，我是个失败者",

intensity=7,

context_note="刷了半小时朋友圈，情绪低落",

)

recorder.add_event(

trigger_event="代码 review 收到修改意见",

trigger_category=TriggerCategory.EXTERNAL_CRITICISM,

negative_thought="我连基本的东西都写不好",

intensity=5,

context_note="其实只是风格问题，不是逻辑错误",

)

recorder.add_event(

trigger_event="凌晨两点还在改需求",

trigger_category=TriggerCategory.PHYSICAL_FATIGUE,

negative_thought="别人都能扛住，只有我不行",

intensity=6,

context_note="已经连续加班一周",

)

recorder.add_event(

trigger_event="看到同事升职的消息（又来了）",

trigger_category=TriggerCategory.SOCIAL_COMPARISON,

negative_thought="我永远追不上别人",

intensity=8,

context_note="今天第二次被这个触发",

)

# ============================================

# 分析 & 生成避坑清单

# ============================================

events = recorder.get_all()

analyzer = NegationAnalyzer(events)

report = {

"total_negation_events": len(events),

"frequency_by_category": analyzer.frequency_by_category(),

"avg_intensity_by_category": analyzer.avg_intensity_by_category(),

"hourly_distribution": analyzer.hourly_distribution(),

"avoidance_checklist": analyzer.generate_avoidance_checklist(

min_occurrences=2

),

}

print("📊 自我否定分析报告：")

print(json.dumps(report, indent=2, ensure_ascii=False))

6️⃣ 运行输出示例

{

"total_negation_events": 4,

"frequency_by_category": {

"社交比较": 2,

"外部批评": 1,

"身体疲惫": 1

},

"avg_intensity_by_category": {

"社交比较": 7.5,

"外部批评": 5.0,

"身体疲惫": 6.0

},

"hourly_distribution": {

"14": 2,

"2": 1,

"15": 1

},

"avoidance_checklist": [

{

"category": "社交比较",

"occurrences": 2,

"rule": "看到他人成果时，先记录自己的进展再浏览",

"suggested_action": "关闭社交平台推送，设定每周固定浏览时间"

}

]

}

五、README 文件与使用说明（README.md）

# Self-Negation Tracker

一个用于记录自我否定时刻、识别触发模式、生成个性化避坑清单的 Python 工具。

目标是减少内耗，把精力留给真正的创新思考。

## 功能

- 记录每次自我否定事件（触发事件 + 否定内容 + 强度）

- 自动按类别统计出现频率

- 按小时分析否定事件的时间分布

- 自动生成个性化避坑清单

## 使用方式

bash

python main.py

## 触发类别说明

| 类别 | 说明 |

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

| 社交比较 | 看到他人成果产生自我怀疑 |

| 完美主义 | 产出未达预期而否定自己 |

| 不确定性焦虑 | 面对模糊场景时恐慌 |

| 外部批评 | 收到负面反馈后崩溃 |

| 身体疲惫 | 疲劳状态下自我评价骤降 |

| 拖延自责 | 未按时完成任务的自责循环 |

## 适用人群

- 开发者

- 创作者

- 创业者

- 任何想减少内耗、保护创新能力的人

六、核心知识点卡片（Knowledge Cards）

## 知识点卡片

### 1️⃣ 自我否定与认知资源

- 自我否定消耗的工作记忆与创造性思维高度重叠

- 内耗是创新的"隐性竞争对手"

### 2️⃣ 情绪标记（Emotional Tagging）

- 将情绪事件结构化记录

- 是认知行为疗法（CBT）的核心技术之一

### 3️⃣ 模式识别 > 意志力强撑

- 识别触发模式比"告诉自己别想太多"更有效

- 避坑清单是外部化的自我管理能力

### 4️⃣ Python 工程实践

- Enum 约束分类，防止数据污染

- JSON 持久化实现轻量级数据管理

- Counter 简化频率统计

七、总结（Conclusion）

这个程序的核心不是"正能量鸡汤"，而是做一个冷静的观察者：

把自我否定从"感受"变成"数据"，从"情绪漩涡"变成"可管理的事件"

它通过三个步骤实现这一目标：

1. 记录 — 将模糊的内耗显性化

2. 分析 — 识别重复出现的触发模式

3. 规避 — 生成可执行的避坑清单

最终目的只有一个：

把省下来的认知资源，全部投入到你真正想创造的东西上。

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