钦州市网站建设_网站建设公司_外包开发_seo优化

我将为您开发一个学生学习效率分析系统，能够分析作业完成时间模式，识别效率低谷期，并提供个性化的时间管理建议。

项目结构

study_efficiency_analyzer/

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

├── data_collector.py # 数据收集模块

├── analyzer.py # 数据分析模块

├── visualizer.py # 数据可视化模块

├── advisor.py # 建议生成模块

├── models.py # 数据模型

├── utils.py # 工具函数

├── config.py # 配置文件

├── student_data.csv # 学生数据文件

├── requirements.txt # 依赖包

├── README.md # 项目说明

└── knowledge_cards.md # 核心知识点卡片

1. requirements.txt

pandas>=1.3.0

numpy>=1.21.0

matplotlib>=3.5.0

seaborn>=0.11.0

plotly>=5.0.0

scikit-learn>=1.1.0

datetime

collections

statistics

2. config.py - 配置文件

"""

学习效率分析系统配置文件

"""

# 时间段定义

TIME_PERIODS = {

"early_morning": {"start": 5, "end": 9, "name": "清晨时段"},

"morning": {"start": 9, "end": 12, "name": "上午时段"},

"afternoon": {"start": 12, "end": 18, "name": "下午时段"},

"evening": {"start": 18, "end": 22, "name": "晚上时段"},

"night": {"start": 22, "end": 5, "name": "深夜时段"}

}

# 效率等级定义

EFFICIENCY_LEVELS = {

"high": {"threshold": 0.8, "name": "高效率", "color": "#28a745"},

"medium": {"threshold": 0.6, "name": "中等效率", "color": "#ffc107"},

"low": {"threshold": 0.4, "name": "低效率", "color": "#fd7e14"},

"very_low": {"threshold": 0.0, "name": "极低效率", "color": "#dc3545"}

}

# 学科分类

SUBJECTS = {

"math": "数学",

"chinese": "语文",

"english": "英语",

"science": "科学",

"social": "社会",

"other": "其他"

}

# 分析参数

ANALYSIS_CONFIG = {

"min_data_days": 7, # 最少需要的数据天数

"efficiency_threshold": 0.6, # 效率阈值

"fatigue_detection_hours": 3, # 疲劳检测时长(小时)

"recommendation_count": 5 # 建议数量

}

# 可视化配置

VISUALIZATION_CONFIG = {

"figure_size": (12, 8),

"dpi": 300,

"style": "seaborn-v0_8",

"color_palette": ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd"]

}

3. models.py - 数据模型

"""

数据模型定义

使用dataclass定义数据结构

"""

from dataclasses import dataclass, field

from typing import List, Dict, Optional

from datetime import datetime, time

from enum import Enum

class SubjectType(Enum):

"""学科类型枚举"""

MATH = "math"

CHINESE = "chinese"

ENGLISH = "english"

SCIENCE = "science"

SOCIAL = "social"

OTHER = "other"

class EfficiencyLevel(Enum):

"""效率等级枚举"""

VERY_LOW = "very_low"

LOW = "low"

MEDIUM = "medium"

HIGH = "high"

@dataclass

class StudyRecord:

"""学习记录数据类"""

date: str # 日期 YYYY-MM-DD

start_time: str # 开始时间 HH:MM

end_time: str # 结束时间 HH:MM

subject: str # 学科

duration_minutes: int # 持续时间(分钟)

efficiency_score: Optional[float] = None # 效率评分(0-1)

notes: str = "" # 备注

def __post_init__(self):

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

if self.efficiency_score is None:

self.efficiency_score = self._calculate_default_efficiency()

def _calculate_default_efficiency(self) -> float:

"""计算默认效率分数"""

# 基于时间段和持续时间的简单效率估算

start_hour = int(self.start_time.split(':')[0])

duration_hours = self.duration_minutes / 60

# 基础效率

base_efficiency = 0.7

# 时间段调整

if 9 <= start_hour <= 11: # 上午高效时段

base_efficiency += 0.15

elif 14 <= start_hour <= 16: # 下午中等时段

base_efficiency += 0.05

elif 19 <= start_hour <= 21: # 晚上良好时段

base_efficiency += 0.1

elif start_hour < 7 or start_hour > 22: # 深夜低效时段

base_efficiency -= 0.2

# 持续时间调整 (过长会降低效率)

if duration_hours > 3:

base_efficiency -= (duration_hours - 3) * 0.1

return max(0.1, min(1.0, base_efficiency))

@dataclass

class DailyAnalysis:

"""每日分析结果"""

date: str

total_study_time: int # 总学习时间(分钟)

average_efficiency: float # 平均效率

subject_times: Dict[str, int] # 各学科时间分布

time_periods: Dict[str, int] # 各时段时间分布

low_efficiency_periods: List[Dict] # 低效率时段

recommendations: List[str] # 建议列表

@dataclass

class StudentProfile:

"""学生档案"""

name: str

grade: str

study_records: List[StudyRecord] = field(default_factory=list)

analysis_results: List[DailyAnalysis] = field(default_factory=list)

def add_record(self, record: StudyRecord):

"""添加学习记录"""

self.study_records.append(record)

def get_recent_records(self, days: int = 7) -> List[StudyRecord]:

"""获取最近N天的记录"""

# 这里简化处理，实际应该按日期筛选

return self.study_records[-days:] if len(self.study_records) >= days else self.study_records

4. data_collector.py - 数据收集模块

"""

数据收集模块

负责收集和管理学生的学习数据

"""

import pandas as pd

import json

from datetime import datetime, timedelta

from typing import List, Dict, Optional

from .models import StudyRecord, StudentProfile

from .utils import TimeUtils, ValidationUtils

class DataCollector:

"""数据收集器类"""

def __init__(self, data_file: str = "student_data.csv"):

self.data_file = data_file

self.student_profiles: Dict[str, StudentProfile] = {}

self.load_data()

def load_data(self):

"""从文件加载数据"""

try:

df = pd.read_csv(self.data_file)

self._process_dataframe(df)

print(f"成功加载 {len(self.student_profiles)} 个学生的数据")

except FileNotFoundError:

print(f"数据文件 {self.data_file} 不存在，将创建新文件")

self._create_sample_data()

except Exception as e:

print(f"加载数据失败: {e}")

self._create_sample_data()

def _process_dataframe(self, df: pd.DataFrame):

"""处理DataFrame数据"""

for _, row in df.iterrows():

student_name = row.get('student_name', '未知学生')

if student_name not in self.student_profiles:

self.student_profiles[student_name] = StudentProfile(

name=student_name,

grade=row.get('grade', '未知年级')

)

# 创建学习记录

record = StudyRecord(

date=row['date'],

start_time=row['start_time'],

end_time=row['end_time'],

subject=row['subject'],

duration_minutes=int(row['duration_minutes']),

efficiency_score=float(row.get('efficiency_score', 0.5)),

notes=row.get('notes', '')

)

self.student_profiles[student_name].add_record(record)

def _create_sample_data(self):

"""创建示例数据"""

sample_data = [

# 学生1：小明的学习记录

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-15', 'start_time': '09:00', 'end_time': '10:30',

'subject': 'math', 'duration_minutes': 90, 'efficiency_score': 0.8, 'notes': '状态不错'

},

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-15', 'start_time': '14:00', 'end_time': '15:30',

'subject': 'english', 'duration_minutes': 90, 'efficiency_score': 0.6, 'notes': ''

},

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-15', 'start_time': '19:00', 'end_time': '21:00',

'subject': 'chinese', 'duration_minutes': 120, 'efficiency_score': 0.7, 'notes': '有点累'

},

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-16', 'start_time': '08:30', 'end_time': '10:00',

'subject': 'science', 'duration_minutes': 90, 'efficiency_score': 0.85, 'notes': '早上效率高'

},

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-16', 'start_time': '15:00', 'end_time': '17:00',

'subject': 'math', 'duration_minutes': 120, 'efficiency_score': 0.5, 'notes': '下午犯困'

},

{

'student_name': '小明',

'grade': '初二',

'date': '2024-01-16', 'start_time': '22:00', 'end_time': '23:30',

'subject': 'english', 'duration_minutes': 90, 'efficiency_score': 0.4, 'notes': '太晚了，效率低'

},

# 学生2：小红的学习记录

{

'student_name': '小红',

'grade': '初三',

'date': '2024-01-15', 'start_time': '07:00', 'end_time': '08:30',

'subject': 'english', 'duration_minutes': 90, 'efficiency_score': 0.9, 'notes': '晨读效果好'

},

{

'student_name': '小红',

'grade': '初三',

'date': '2024-01-15', 'start_time': '10:00', 'end_time': '12:00',

'subject': 'math', 'duration_minutes': 120, 'efficiency_score': 0.75, 'notes': ''

},

{

'student_name': '小红',

'grade': '初三',

'date': '2024-01-15', 'start_time': '20:00', 'end_time': '21:30',

'subject': 'science', 'duration_minutes': 90, 'efficiency_score': 0.8, 'notes': '晚上专注'

}

]

df = pd.DataFrame(sample_data)

df.to_csv(self.data_file, index=False, encoding='utf-8-sig')

self._process_dataframe(df)

print("已创建示例数据")

def add_study_record(self, student_name: str, record: StudyRecord) -> bool:

"""添加学习记录"""

try:

if student_name not in self.student_profiles:

self.student_profiles[student_name] = StudentProfile(

name=student_name,

grade="未知年级"

)

self.student_profiles[student_name].add_record(record)

self._save_data()

return True

except Exception as e:

print(f"添加记录失败: {e}")

return False

def interactive_add_record(self):

"""交互式添加学习记录"""

print("\n=== 添加学习记录 ===")

student_name = input("学生姓名: ").strip()

if not student_name:

print("学生姓名不能为空")

return

# 获取日期

date_input = input("日期 (YYYY-MM-DD，回车使用今天): ").strip()

if not date_input:

date_input = datetime.now().strftime("%Y-%m-%d")

# 验证日期格式

if not ValidationUtils.validate_date(date_input):

print("日期格式错误，请使用 YYYY-MM-DD 格式")

return

# 获取时间

start_time = input("开始时间 (HH:MM): ").strip()

end_time = input("结束时间 (HH:MM): ").strip()

if not ValidationUtils.validate_time(start_time) or not ValidationUtils.validate_time(end_time):

print("时间格式错误，请使用 HH:MM 格式")

return

# 获取学科

print("可选学科:", ", ".join(["math", "chinese", "english", "science", "social", "other"]))

subject = input("学科: ").strip()

# 获取备注

notes = input("备注 (可选): ").strip()

# 计算持续时间

try:

start_dt = datetime.strptime(f"{date_input} {start_time}", "%Y-%m-%d %H:%M")

end_dt = datetime.strptime(f"{date_input} {end_time}", "%Y-%m-%d %H:%M")

if end_dt <= start_dt:

print("结束时间必须晚于开始时间")

return

duration_minutes = int((end_dt - start_dt).total_seconds() / 60)

# 创建记录

record = StudyRecord(

date=date_input,

start_time=start_time,

end_time=end_time,

subject=subject,

duration_minutes=duration_minutes,

notes=notes

)

if self.add_study_record(student_name, record):

print("✅ 记录添加成功！")

else:

print("❌ 记录添加失败")

except ValueError as e:

print(f"时间计算错误: {e}")

def _save_data(self):

"""保存数据到文件"""

try:

records = []

for profile in self.student_profiles.values():

for record in profile.study_records:

records.append({

'student_name': profile.name,

'grade': profile.grade,

'date': record.date,

'start_time': record.start_time,

'end_time': record.end_time,

'subject': record.subject,

'duration_minutes': record.duration_minutes,

'efficiency_score': record.efficiency_score,

'notes': record.notes

})

df = pd.DataFrame(records)

df.to_csv(self.data_file, index=False, encoding='utf-8-sig')

except Exception as e:

print(f"保存数据失败: {e}")

def get_student_names(self) -> List[str]:

"""获取所有学生姓名"""

return list(self.student_profiles.keys())

def get_student_profile(self, student_name: str) -> Optional[StudentProfile]:

"""获取学生档案"""

return self.student_profiles.get(student_name)

def get_all_profiles(self) -> Dict[str, StudentProfile]:

"""获取所有学生档案"""

return self.student_profiles

5. analyzer.py - 数据分析模块

"""

数据分析模块

负责分析学习数据的模式和效率

"""

import pandas as pd

import numpy as np

from datetime import datetime, time

from typing import List, Dict, Tuple

from collections import defaultdict, Counter

from .models import StudyRecord, DailyAnalysis, EfficiencyLevel

from .config import TIME_PERIODS, EFFICIENCY_LEVELS, ANALYSIS_CONFIG

from .utils import TimeUtils, StatisticsUtils

class EfficiencyAnalyzer:

"""效率分析器类"""

def __init__(self):

self.time_period_mapping = self._create_time_period_mapping()

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

"""创建小时到时间段的映射"""

mapping = {}

for period_name, period_info in TIME_PERIODS.items():

start = period_info["start"]

end = period_info["end"]

if start <= end: # 正常时段

for hour in range(start, end):

mapping[hour] = period_name

else: # 跨日时段（如深夜）

for hour in range(start, 24):

mapping[hour] = period_name

for hour in range(0, end):

mapping[hour] = period_name

return mapping

def analyze_student_efficiency(self, student_profile) -> List[DailyAnalysis]:

"""分析学生学习效率"""

analyses = []

# 按日期分组记录

daily_records = self._group_by_date(student_profile.study_records)

for date, records in daily_records.items():

analysis = self._analyze_daily_data(date, records)

analyses.append(analysis)

# 按日期排序

analyses.sort(key=lambda x: x.date)

return analyses

def _group_by_date(self, records: List[StudyRecord]) -> Dict[str, List[StudyRecord]]:

"""按日期分组记录"""

daily_groups = defaultdict(list)

for record in records:

daily_groups[record.date].append(record)

return dict(daily_groups)

def _analyze_daily_data(self, date: str, records: List[StudyRecord]) -> DailyAnalysis:

"""分析单日数据"""

# 计算总学习时间

total_time = sum(record.duration_minutes for record in records)

# 计算平均效率

avg_efficiency = np.mean([record.efficiency_score for record in records])

# 学科时间分布

subject_times = defaultdict(int)

for record in records:

subject_times[record.subject] += record.duration_minutes

# 时段时间分布

time_periods = defaultdict(int)

low_efficiency_periods = []

for record in records:

# 获取主要时段

main_period = self._get_main_time_period(record.start_time)

time_periods[main_period] += record.duration_minutes

# 检查是否为低效率时段

if record.efficiency_score < ANALYSIS_CONFIG["efficiency_threshold"]:

low_efficiency_periods.append({

"time": f"{record.start_time}-{record.end_time}",

"subject": record.subject,

"efficiency": record.efficiency_score,

"duration": record.duration_minutes

})

# 生成建议

recommendations = self._generate_recommendations(

records, total_time, avg_efficiency, low_efficiency_periods

)

return DailyAnalysis(

date=date,

total_study_time=total_time,

average_efficiency=avg_efficiency,

subject_times=dict(subject_times),

time_periods=dict(time_periods),

low_efficiency_periods=low_efficiency_periods,

recommendations=recommendations

)

def _get_main_time_period(self, start_time: str) -> str:

"""获取开始时间所在的主要时段"""

hour = int(start_time.split(':')[0])

return self.time_period_mapping.get(hour, "unknown")

def _generate_recommendations(self, records: List[StudyRecord],

total_time: int, avg_efficiency: float,

low_efficiency_periods: List[Dict]) -> List[str]:

"""生成个性化建议"""

recommendations = []

# 基于总学习时间的建议

if total_time < 120: # 少于2小时

recommendations.append("📚 建议增加每日学习时间，至少保证2-3小时的有效学习")

elif total_time > 480: # 超过8小时

recommendations.append("⏰ 学习时间过长可能导致疲劳，建议适当休息，提高效率")

# 基于平均效率的建议

if avg_efficiency < 0.5:

recommendations.append("🎯 整体学习效率偏低，建议优化学习方法，保持专注")

elif avg_efficiency > 0.8:

recommendations.append("🌟 学习效率很高！继续保持这种良好的学习状态")

# 基于低效率时段的建议

if low_efficiency_periods:

late_night_sessions = [p for p in low_efficiency_periods

if self._get_main_time_period(p["time"].split('-')[0]) == "night"]

if late_night_sessions:

recommendations.append("🌙 避免在深夜学习，这会严重影响效率和健康")

long_sessions = [p for p in low_efficiency_periods if p["duration"] > 180]

if long_sessions:

recommendations.append("⏳ 单次学习时间过长容易疲劳，建议采用番茄工作法，25-45分钟为一个学习单元")

# 基于学科分布的建讱

subject_times = defaultdict(int)

for record in records:

subject_times[record.subject] += record.duration_minutes

if subject_times:

max_subject = max(subject_times.items(), key=lambda x: x[1])

if max_subject[1] > total_time * 0.6: # 某一学科占比超过60%

recommendations.append(f"⚖️ {max_subject[0]}学科投入时间较多，注意平衡各科学习")

# 通用建议

recommendations.extend([

"💡 建议制定详细的学习计划，合理分配各时段任务",

"🏃 学习间隙适当运动，有助于保持大脑活力",

"📝 及时复习巩固，避免临时抱佛脚",

"😴 保证充足睡眠，早睡早起有利于学习效率提升"

])

return recommendations[:ANALYSIS_CONFIG["recommendation_count"]]

def identify_efficiency_patterns(self, student_profile) -> Dict:

"""识别学习效率模式"""

if len(student_profile.study_records) < ANALYSIS_CONFIG["min_data_days"]:

return {"error": f"需要至少{ANALYSIS_CONFIG['min_data_days']}天的数据才能进行有效分析"}

records = student_profile.study_records

# 时段效率分析

period_efficiency = self._analyze_period_efficiency(records)

# 学科效率分析

subject_efficiency = self._analyze_subject_efficiency(records)

# 时间长度效率分析

duration_efficiency = self._analyze_duration_efficiency(records)

# 疲劳模式分析

fatigue_patterns = self._analyze_fatigue_patterns(records)

return {

"period_efficiency": period_efficiency,

"subject_efficiency": subject_efficiency,

"duration_efficiency": duration_efficiency,

关注我，有更多实用程序等着你！