职场汇报优先级工具，按重要紧急，领导关注度，难度排序，输出先做哪些工作的清单。

职场汇报优先级工具 - 智能工作规划系统

一、实际应用场景描述

张伟是一名互联网公司的产品经理，负责多个核心业务线的产品迭代。每周一上午，他都会面临这样的困境：

- 老板突然丢过来一个"紧急"需求，要求周三前完成汇报

- 运营部门催着要下周活动的产品方案

- 技术团队反馈上个版本还有几个bug需要修复

- 自己规划的季度 roadmap 还有几个重要功能待推进

- 下午还有两个跨部门会议要参加

到了周五，张伟发现自己忙得团团转，但老板最关心的核心指标提升方案还没做完，运营活动的方案也是仓促应付，技术债务越积越多。更糟糕的是，他花了大量时间在一些低价值的工作上，而真正影响业绩的关键任务却被拖延了。

他需要一套智能系统来帮助他：

1. 客观评估每个任务的真实优先级

2. 考虑领导的关注度和期望

3. 合理预估工作难度和时间投入

4. 输出清晰的工作执行清单

二、引入痛点

现代职场人的四大痛点

痛点 具体表现 后果

任务来源混乱 老板、同事、下属、客户多方同时提需求 工作节奏被打乱，重要任务被忽视

优先级判断主观 凭感觉判断"重要"和"紧急" 高价值工作被低价值工作挤占时间

领导关注度盲区 不清楚老板当前最关心什么 辛苦做的成果领导不买账

难度预估偏差 低估复杂任务时间，高估简单任务 计划完不成，频繁加班救火

传统解决方案的不足：

- ❌ 待办清单：只列任务，不排优先级

- ❌ 日历提醒：只管时间，不管重要性

- ❌ 领导口头沟通：信息易遗漏，难量化

- ❌ 个人直觉：受情绪影响，缺乏客观性

三、核心逻辑讲解

智能优先级决策框架（基于 Eisenhower Matrix + 加权评分）

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

│ 输入层 │

│ 任务列表 + 领导关注点 + 截止时间 + 难度评估 │

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

│

▼

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

│ 预处理层 │

│ 标准化任务属性 + 提取关键特征 + 权重校准 │

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

│

▼

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

│ 决策引擎 │

│ ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ │

│ │ 重要紧急评估 │ │ 领导关注度 │ │ 难度价值分析 │ │

│ │ (权重:35%) │ │ (权重:40%) │ │ (权重:25%) │ │

│ └─────────────┘ └─────────────┘ └─────────────┘ │

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

│

▼

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

│ 输出层 │

│ 优先级排序清单 + 执行建议 + 风险提示 + 时间分配 │

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

核心算法：多维加权评分公式

PriorityScore = W_1 \times IE_S + W_2 \times L_F + W_3 \times DV_R

其中：

- IE_S = 重要紧急得分 (Importance & Urgency Score) - 35%

- LF_S = 领导关注度得分 (Leadership Focus Score) - 40%

- DV_R = 难度价值比 (Difficulty-Value Ratio) - 25%

Eisenhower Matrix 四象限分类

紧急

↑

┌────────────┼────────────┐

│ │ │

重要 │ 第一象限 │ 第二象限 │

│ (立即做) │ (计划做) │

│ │ │

├────────────┼────────────┤

│ │ │

不重要│ 第三象限 │ 第四象限 │

│ (授权做) │ (不做) │

│ │ │

└────────────┼────────────┘

←──────────────→ 不重要

不紧急

四、代码模块化实现

项目结构

work_priority_tool/

├── main.py # 主程序入口

├── config.py # 配置文件

├── priority_engine.py # 优先级引擎核心模块

├── importance_urgency.py # 重要紧急评估模块

├── leadership_focus.py # 领导关注度模块

├── difficulty_value.py # 难度价值分析模块

├── task_models.py # 任务数据模型

├── utils.py # 工具函数

├── cli_interface.py # 命令行界面

└── README.md # 项目说明文档

1. config.py - 配置文件

"""

职场汇报优先级工具 - 配置文件

包含权重设置、评分阈值、任务类型定义等

"""

from dataclasses import dataclass, field

from typing import Dict, List, Any, Optional

from enum import Enum

class TaskType(Enum):

"""任务类型枚举"""

STRATEGIC = "strategic" # 战略级任务

OPERATIONAL = "operational" # 运营级任务

TECHNICAL = "technical" # 技术级任务

ADMINISTRATIVE = "admin" # 行政级任务

EMERGENCY = "emergency" # 紧急任务

MEETING = "meeting" # 会议类任务

class PriorityLevel(Enum):

"""优先级等级枚举"""

CRITICAL = "critical" # 极重要

HIGH = "high" # 高重要

MEDIUM = "medium" # 中等重要

LOW = "low" # 低重要

DEFERRED = "deferred" # 可延期

@dataclass

class ScoringWeights:

"""评分权重配置"""

importance_urgency_weight: float = 0.35 # 重要紧急权重

leadership_focus_weight: float = 0.40 # 领导关注权重

difficulty_value_weight: float = 0.25 # 难度价值权重

def validate(self) -> bool:

"""验证权重和为1"""

total = (self.importance_urgency_weight +

self.leadership_focus_weight +

self.difficulty_value_weight)

return abs(total - 1.0) < 0.001

@dataclass

class PriorityThresholds:

"""优先级阈值配置"""

critical_min: float = 80.0 # 极重要最低分

high_min: float = 65.0 # 重要最低分

medium_min: float = 45.0 # 中等最低分

low_min: float = 25.0 # 低重要最低分

deferred_max: float = 25.0 # 可延期最高分

@dataclass

class TimeEstimationFactors:

"""时间估算因子配置"""

strategic_task_multiplier: float = 1.5 # 战略任务时间乘数

emergency_task_multiplier: float = 0.8 # 紧急任务时间乘数

technical_complexity_base: float = 2.0 # 技术复杂度基数

meeting_overhead_percent: float = 0.25 # 会议开销百分比

@dataclass

class LeadershipFocusKeywords:

"""领导关注关键词配置"""

business_impact: List[str] = field(default_factory=lambda: [

"营收", "利润", "增长", "转化", "DAU", "GMV",

"ROI", "市场份额", "核心竞争力", "战略目标"

])

urgent_deliverables: List[str] = field(default_factory=lambda: [

"本周", "下周", "月底", "季度", "deadline",

"截止", "汇报", "演示", "评审", "验收"

])

stakeholder_requests: List[str] = field(default_factory=lambda: [

"老板", "CEO", "总监", "VP", "投资人",

"董事会", "大客户", "重要合作方"

])

# 全局配置实例

SCORING_WEIGHTS = ScoringWeights()

PRIORITY_THRESHOLDS = PriorityThresholds()

TIME_FACTORS = TimeEstimationFactors()

FOCUS_KEYWORDS = LeadershipFocusKeywords()

# 任务类型基础分配置

TASK_TYPE_BASE_SCORES = {

TaskType.STRATEGIC: {"importance": 9, "urgency": 6, "value": 9},

TaskType.EMERGENCY: {"importance": 7, "urgency": 10, "value": 6},

TaskType.OPERATIONAL: {"importance": 6, "urgency": 7, "value": 7},

TaskType.TECHNICAL: {"importance": 5, "urgency": 5, "value": 8},

TaskType.MEETING: {"importance": 4, "urgency": 6, "value": 4},

TaskType.ADMINISTRATIVE: {"importance": 3, "urgency": 4, "value": 3}

}

# 难度等级映射

DIFFICULTY_LEVELS = {

1: {"name": "很简单", "time_factor": 0.5, "risk": "低"},

2: {"name": "简单", "time_factor": 0.8, "risk": "低"},

3: {"name": "中等", "time_factor": 1.0, "risk": "中"},

4: {"name": "困难", "time_factor": 1.5, "risk": "高"},

5: {"name": "很困难", "time_factor": 2.0, "risk": "很高"}

}

# 预估时间配置（小时）

ESTIMATED_TIME_RANGES = {

TaskType.STRATEGIC: (8, 40),

TaskType.EMERGENCY: (2, 16),

TaskType.OPERATIONAL: (4, 24),

TaskType.TECHNICAL: (6, 32),

TaskType.MEETING: (1, 4),

TaskType.ADMINISTRATIVE: (1, 8)

}

class ConfigValidator:

"""配置验证器"""

@staticmethod

def validate_all():

"""验证所有配置"""

errors = []

if not SCORING_WEIGHTS.validate():

errors.append("权重配置无效，总和必须为1.0")

weight_sum = (SCORING_WEIGHTS.importance_urgency_weight +

SCORING_WEIGHTS.leadership_focus_weight +

SCORING_WEIGHTS.difficulty_value_weight)

if abs(weight_sum - 1.0) > 0.001:

errors.append(f"权重总和错误: {weight_sum}")

if PRIORITY_THRESHOLDS.critical_min <= PRIORITY_THRESHOLDS.high_min:

errors.append("Critical阈值必须大于High阈值")

return errors if errors else None

2. task_models.py - 任务数据模型

"""

任务数据模型模块

定义任务相关的数据结构

"""

from dataclasses import dataclass, field

from datetime import datetime, timedelta

from typing import Optional, List, Dict, Any, Union

from enum import Enum

import uuid

from config import TaskType, PriorityLevel, DIFFICULTY_LEVELS

@dataclass

class TaskDependency:

"""任务依赖关系"""

dependency_id: str

dependency_type: str = "finish_to_start" # finish_to_start, start_to_start, etc.

lag_hours: int = 0 # 滞后时间

@dataclass

class Stakeholder:

"""干系人信息"""

name: str

role: str # boss, peer, subordinate, client, other

influence_level: int = 5 # 影响力 1-10

interest_level: int = 5 # 关注度 1-10

@dataclass

class Task:

"""

工作任务数据类

包含任务的所有关键属性和元数据

"""

task_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])

title: str = "" # 任务标题

description: str = "" # 任务描述

task_type: Union[TaskType, str] = TaskType.OPERATIONAL

# 重要紧急相关

business_impact: int = 5 # 业务影响 1-10

urgency_level: int = 5 # 紧急程度 1-10

deadline: Optional[datetime] = None # 截止时间

is_milestone: bool = False # 是否为里程碑任务

# 领导关注相关

requested_by: str = "" # 需求提出者

stakeholder_list: List[Stakeholder] = field(default_factory=list)

alignment_with_goals: int = 5 # 与目标对齐度 1-10

visibility_level: int = 5 # 可见度 1-10

# 难度价值相关

difficulty_level: int = 3 # 难度等级 1-5

estimated_hours: float = 8.0 # 预估工时

actual_value_score: int = 5 # 实际价值评分 1-10

learning_potential: int = 3 # 学习潜力 1-10

# 依赖和状态

dependencies: List[TaskDependency] = field(default_factory=list)

tags: List[str] = field(default_factory=list)

created_at: datetime = field(default_factory=datetime.now)

status: str = "pending" # pending, in_progress, completed, blocked

def __post_init__(self):

"""初始化后处理"""

# 标准化任务类型

if isinstance(self.task_type, str):

self.task_type = TaskType(self.task_type.lower())

# 确保数值在有效范围内

self.business_impact = max(1, min(10, self.business_impact))

self.urgency_level = max(1, min(10, self.urgency_level))

self.difficulty_level = max(1, min(5, self.difficulty_level))

self.estimated_hours = max(0.5, self.estimated_hours)

self.actual_value_score = max(1, min(10, self.actual_value_score))

self.alignment_with_goals = max(1, min(10, self.alignment_with_goals))

self.visibility_level = max(1, min(10, self.visibility_level))

self.learning_potential = max(1, min(10, self.learning_potential))

def to_dict(self) -> Dict[str, Any]:

"""转换为字典格式"""

return {

"task_id": self.task_id,

"title": self.title,

"description": self.description,

"task_type": self.task_type.value,

"business_impact": self.business_impact,

"urgency_level": self.urgency_level,

"deadline": self.deadline.isoformat() if self.deadline else None,

"is_milestone": self.is_milestone,

"requested_by": self.requested_by,

"stakeholders": [

{

"name": s.name,

"role": s.role,

"influence": s.influence_level,

"interest": s.interest_level

} for s in self.stakeholder_list

],

"alignment_with_goals": self.alignment_with_goals,

"visibility_level": self.visibility_level,

"difficulty_level": self.difficulty_level,

"estimated_hours": self.estimated_hours,

"actual_value_score": self.actual_value_score,

"learning_potential": self.learning_potential,

"dependencies": [

{"id": d.dependency_id, "type": d.dependency_type, "lag": d.lag_hours}

for d in self.dependencies

],

"tags": self.tags,

"created_at": self.created_at.isoformat(),

"status": self.status

}

def add_stakeholder(self, name: str, role: str, influence: int = 5, interest: int = 5):

"""添加干系人"""

self.stakeholder_list.append(Stakeholder(

name=name, role=role, influence_level=influence, interest_level=interest

))

def set_deadline(self, days_from_now: int):

"""设置截止时间"""

self.deadline = datetime.now() + timedelta(days=days_from_now)

def get_difficulty_info(self) -> Dict[str, Any]:

"""获取难度相关信息"""

diff_config = DIFFICULTY_LEVELS.get(self.difficulty_level, DIFFICULTY_LEVELS[3])

return {

"level": self.difficulty_level,

"name": diff_config["name"],

"time_factor": diff_config["time_factor"],

"risk": diff_config["risk"]

}

@dataclass

class PriorityResult:

"""

优先级计算结果类

包含任务的优先级评分和详细分析

"""

task_id: str

task_title: str

overall_score: float = 0.0

priority_level: PriorityLevel = PriorityLevel.MEDIUM

# 各项得分

importance_urgency_score: float = 0.0

leadership_focus_score: float = 0.0

difficulty_value_score: float = 0.0

# 详细分析

analysis_details: Dict[str, Any] = field(default_factory=dict)

strengths: List[str] = field(default_factory=list)

risks: List[str] = field(default_factory=list)

recommendations: List[str] = field(default_factory=list)

# 执行建议

suggested_order: int = 0 # 建议执行顺序

optimal_start_time: Optional[datetime] = None

time_allocation_percent: float = 0.0 # 建议时间分配百分比

def to_dict(self) -> Dict[str, Any]:

"""转换为字典格式"""

return {

"task_id": self.task_id,

"task_title": self.task_title,

"overall_score": round(self.overall_score, 2),

"priority_level": self.priority_level.value,

"scores": {

"importance_urgency": round(self.importance_urgency_score, 2),

"leadership_focus": round(self.leadership_focus_score, 2),

"difficulty_value": round(self.difficulty_value_score, 2)

},

"analysis": self.analysis_details,

"strengths": self.strengths,

"risks": self.risks,

"recommendations": self.recommendations,

"execution_plan": {

"suggested_order": self.suggested_order,

"optimal_start": self.optimal_start_time.isoformat() if self.optimal_start_time else None,

"time_allocation_percent": round(self.time_allocation_percent, 1)

}

}

@dataclass

class WorkPlan:

"""

工作计划类

包含多个任务的优先级排序和执行计划

"""

plan_id: str = field(default_factory=lambda: str(uuid.uuid4())[:8])

created_at: datetime = field(default_factory=datetime.now)

task_results: List[PriorityResult] = field(default_factory=list)

total_estimated_hours: float = 0.0

available_hours: float = 40.0 # 可用工时（默认一周）

def add_result(self, result: PriorityResult):

"""添加优先级结果"""

self.task_results.append(result)

self._sort_by_priority()

def _sort_by_priority(self):

"""按优先级排序"""

priority_order = {

PriorityLevel.CRITICAL: 0,

PriorityLevel.HIGH: 1,

PriorityLevel.MEDIUM: 2,

PriorityLevel.LOW: 3,

PriorityLevel.DEFERRED: 4

}

self.task_results.sort(key=lambda x: (priority_order[x.priority_level], -x.overall_score))

# 更新执行顺序

for i, result in enumerate(self.task_results, 1):

result.suggested_order = i

def get_critical_tasks(self) -> List[PriorityResult]:

"""获取极重要任务"""

return [r for r in self.task_results if r.priority_level == PriorityLevel.CRITICAL]

def get_high_priority_tasks(self) -> List[PriorityResult]:

"""获取高重要任务"""

return [r for r in self.task_results if r.priority_level == PriorityLevel.HIGH]

def calculate_time_allocation(self):

"""计算时间分配"""

total_score = sum(r.overall_score for r in self.task_results if r.priority_level != PriorityLevel.DEFERRED)

if total_score == 0:

return

for result in self.task_results:

if result.priority_level != PriorityLevel.DEFERRED:

result.time_allocation_percent = (result.overall_score / total_score) * 100

# 按优先级分配可用时间

allocated_hours = 0

for result in self.task_results:

if result.priority_level != PriorityLevel.DEFERRED:

allocated_hours += result.time_allocation_percent / 100 * self.available_hours

self.total_estimated_hours = allocated_hours

def get_execution_timeline(self, working_hours_per_day: int = 8) -> List[Dict[str, Any]]:

"""生成执行时间线"""

timeline = []

current_day = 1

remaining_hours = self.available_hours

for result in self.task_results:

if result.priority_level == PriorityLevel.DEFERRED:

continue

allocated_hours = result.time_allocation_percent / 100 * self.available_hours

days_needed = int(allocated_hours / working_hours_per_day)

if allocated_hours % working_hours_per_day > 0:

days_needed += 1

timeline_entry = {

"order": result.suggested_order,

"task_title": result.task_title,

"priority": result.priority_level.value,

"allocated_hours": round(allocated_hours, 1),

"days_needed": days_needed,

"start_day": current_day,

"end_day": current_day + days_needed - 1,

"completion_deadline": (datetime.now() + timedelta(days=current_day + days_needed - 1)).strftime("%Y-%m-%d")

}

timeline.append(timeline_entry)

current_day += days_needed

remaining_hours -= allocated_hours

return timeline

3. importance_urgency.py - 重要紧急评估模块

"""

重要紧急评估模块

基于Eisenhower Matrix理论，评估任务的重要性和紧急程度

"""

from dataclasses import dataclass, field

from typing import Dict, Any, List, Tuple

from datetime import datetime, timedelta

from task_models import Task, PriorityLevel

from config import (

TaskType, TASK_TYPE_BASE_SCORES, PRIORITY_THRESHOLDS,

TIME_FACTORS, FOCUS_KEYWORDS

)

@dataclass

class ImportanceUrgencyScores:

"""重要紧急评分结果"""

importance_score: float = 0.0

urgency_score: float = 0.0

combined_score: float = 0.0

quadrant: str = ""

analysis_details: Dict[str, Any] = field(default_factory=dict)

class ImportanceUrgencyAnalyzer:

"""

重要紧急分析器

核心逻辑：

1. 重要性评估：基于业务影响、目标对齐度、任务类型

2. 紧急性评估：基于截止时间、依赖关系、外部压力

3. 象限分类：结合重要性和紧急性进行分类

"""

def __init__(self):

"""初始化分析器"""

self.base_scores = TASK_TYPE_BASE_SCORES

self.thresholds = PRIORITY_THRESHOLDS

self.time_factors = TIME_FACTORS

def analyze(

self,

task: Task

) -> Tuple[float, ImportanceUrgencyScores]:

"""

分析任务的重要紧急程度

Args:

task: 任务对象

Returns:

Tuple[综合得分, 详细评分结果]

"""

# 1. 计算重要性得分

importance_score = self._calculate_importance(task)

# 2. 计算紧急性得分

urgency_score = self._calculate_urgency(task)

# 3. 计算综合得分

combined_score = (importance_score * 0.6 + urgency_score * 0.4)

# 4. 确定象限分类

quadrant = self._determine_quadrant(importance_score, urgency_score)

# 5. 生成详细分析

analysis = self._generate_analysis(

task, importance_score, urgency_score, quadrant

)

scores = ImportanceUrgencyScores(

importance_score=importance_score,

urgency_score=urgency_score,

combined_score=combined_score,

quadrant=quadrant,

analysis_details=analysis

)

return combined_score, scores

def _calculate_importance(self, task: Task) -> float:

"""

计算重要性得分 (0-100)

评估维度：

- 业务影响 (30%)

- 任务类型基础重要性 (25%)

- 与目标对齐度 (25%)

- 里程碑属性 (20%)

"""

score = 0.0

# 业务影响得分 (30%)

impact_score = (task.business_impact / 10) * 100 * 0.30

score += impact_score

# 任务类型基础重要性 (25%)

type_base = self.base_scores.get(task.task_type, self.base_scores[TaskType.OPERATIONAL])

type_importance = t

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