Appearance
OpenClaw 教学管理平台
教学管理平台是OpenClaw教育解决方案的管理中心，为教育机构提供全面的教学资源管理、课程设计、教学分析和决策支持功能。
平台概述
教学管理平台基于数据分析和AI技术，能够：
- 统一管理教学资源和课程
- 辅助教师设计优质课程
- 分析教学效果和学生表现
- 提供数据驱动的教学决策支持
核心功能
1. 教学资源管理
功能描述
集中管理各类教学资源，包括课件、视频、练习题、参考资料等，支持资源的上传、分类、检索和共享。
技术实现
python
from typing import Dict, List, Optional
from datetime import datetime
import hashlib
class TeachingResourceManager:
def __init__(self, config: Dict):
self.config = config
self.resource_uploader = ResourceUploader()
self.resource_classifier = ResourceClassifier()
self.resource_indexer = ResourceIndexer()
self.resource_searcher = ResourceSearcher()
self.permission_manager = PermissionManager()
self.version_manager = VersionManager()
async def upload_resource(
self,
teacher_id: str,
resource_data: Dict
) -> Dict:
uploaded = await self.resource_uploader.upload(resource_data)
classification = await self.resource_classifier.classify(
uploaded
)
indexed = await self.resource_indexer.index(
uploaded,
classification
)
permissions = await self.permission_manager.set_permissions(
indexed['resource_id'],
resource_data.get('permissions', {})
)
return {
'resource_id': indexed['resource_id'],
'teacher_id': teacher_id,
'file_info': uploaded['file_info'],
'classification': classification,
'permissions': permissions,
'uploaded_at': datetime.now().isoformat()
}
async def search_resources(
self,
query: str,
filters: Optional[Dict] = None
) -> Dict:
search_results = await self.resource_searcher.search(
query,
filters
)
filtered_results = self.filter_by_permissions(
search_results,
filters.get('user_id')
)
return {
'query': query,
'total': len(filtered_results),
'results': filtered_results,
'searched_at': datetime.now().isoformat()
}
async def update_resource(
self,
resource_id: str,
updates: Dict
) -> Dict:
version_info = await self.version_manager.create_version(
resource_id,
updates
)
updated = await self.resource_indexer.update(
resource_id,
updates
)
return {
'resource_id': resource_id,
'version': version_info['version'],
'updated_at': datetime.now().isoformat()
}
def filter_by_permissions(
self,
results: List[Dict],
user_id: Optional[str]
) -> List[Dict]:
if not user_id:
return []
return [
result for result in results
if self.check_permission(result, user_id)
]
def check_permission(self, resource: Dict, user_id: str) -> bool:
permissions = resource.get('permissions', {})
if permissions.get('public', False):
return True
if user_id in permissions.get('allowed_users', []):
return True
return False
class ResourceUploader:
def __init__(self):
self.storage = StorageService()
self.file_validator = FileValidator()
async def upload(self, resource_data: Dict) -> Dict:
file_data = resource_data.get('file')
validation = await self.file_validator.validate(file_data)
if not validation['is_valid']:
raise ValueError(f"Invalid file: {validation['error']}")
file_info = await self.storage.store(file_data)
metadata = self.extract_metadata(resource_data)
return {
'file_info': file_info,
'metadata': metadata,
'uploaded_at': datetime.now().isoformat()
}
def extract_metadata(self, resource_data: Dict) -> Dict:
return {
'title': resource_data.get('title'),
'description': resource_data.get('description'),
'subject': resource_data.get('subject'),
'grade_level': resource_data.get('grade_level'),
'tags': resource_data.get('tags', []),
'author': resource_data.get('author')
}
class FileValidator:
async def validate(self, file_data: Dict) -> Dict:
allowed_types = [
'application/pdf',
'application/vnd.ms-powerpoint',
'application/vnd.openxmlformats-officedocument.presentationml.presentation',
'video/mp4',
'video/avi',
'image/jpeg',
'image/png'
]
file_type = file_data.get('type')
file_size = file_data.get('size', 0)
max_size = 100 * 1024 * 1024
if file_type not in allowed_types:
return {
'is_valid': False,
'error': f'File type {file_type} not allowed'
}
if file_size > max_size:
return {
'is_valid': False,
'error': f'File size exceeds limit of {max_size} bytes'
}
return {'is_valid': True}
class StorageService:
def __init__(self):
self.storage_path = '/storage/resources'
async def store(self, file_data: Dict) -> Dict:
file_hash = self.calculate_hash(file_data)
file_path = f"{self.storage_path}/{file_hash}"
return {
'file_id': file_hash,
'file_path': file_path,
'size': file_data.get('size'),
'type': file_data.get('type'),
'stored_at': datetime.now().isoformat()
}
def calculate_hash(self, file_data: Dict) -> str:
content = file_data.get('content', '')
return hashlib.sha256(content.encode()).hexdigest()
class ResourceClassifier:
def __init__(self):
self.type_classifier = TypeClassifier()
self.subject_classifier = SubjectClassifier()
self.difficulty_estimator = DifficultyEstimator()
async def classify(self, resource: Dict) -> Dict:
resource_type = await self.type_classifier.classify(
resource
)
subject = await self.subject_classifier.classify(
resource
)
difficulty = await self.difficulty_estimator.estimate(
resource
)
return {
'type': resource_type,
'subject': subject,
'difficulty': difficulty,
'classified_at': datetime.now().isoformat()
}
class TypeClassifier:
async def classify(self, resource: Dict) -> str:
file_type = resource['file_info']['type']
type_mapping = {
'application/pdf': 'document',
'application/vnd.ms-powerpoint': 'presentation',
'application/vnd.openxmlformats-officedocument.presentationml.presentation': 'presentation',
'video/mp4': 'video',
'video/avi': 'video',
'image/jpeg': 'image',
'image/png': 'image'
}
return type_mapping.get(file_type, 'other')
class SubjectClassifier:
def __init__(self):
self.subject_keywords = {
'mathematics': ['数学', '函数', '方程', '几何', '代数'],
'physics': ['物理', '力学', '电学', '光学', '热学'],
'chemistry': ['化学', '元素', '反应', '分子', '原子'],
'language': ['语文', '英语', '写作', '语法', '词汇'],
'history': ['历史', '朝代', '事件', '人物', '文化'],
'geography': ['地理', '地形', '气候', '国家', '城市']
}
async def classify(self, resource: Dict) -> str:
metadata = resource['metadata']
title = metadata.get('title', '')
description = metadata.get('description', '')
tags = metadata.get('tags', [])
text = f"{title} {description} {' '.join(tags)}"
scores = {}
for subject, keywords in self.subject_keywords.items():
score = sum(1 for keyword in keywords if keyword in text)
scores[subject] = score
if not scores or max(scores.values()) == 0:
return 'general'
return max(scores, key=scores.get)
class DifficultyEstimator:
async def estimate(self, resource: Dict) -> str:
metadata = resource['metadata']
grade_level = metadata.get('grade_level')
if grade_level:
if grade_level <= 6:
return 'elementary'
elif grade_level <= 9:
return 'intermediate'
else:
return 'advanced'
return 'intermediate'
class ResourceIndexer:
def __init__(self):
self.elasticsearch_client = ElasticsearchClient()
async def index(
self,
resource: Dict,
classification: Dict
) -> Dict:
resource_id = self.generate_resource_id(resource)
document = {
'resource_id': resource_id,
'title': resource['metadata']['title'],
'description': resource['metadata']['description'],
'subject': classification['subject'],
'type': classification['type'],
'difficulty': classification['difficulty'],
'grade_level': resource['metadata']['grade_level'],
'tags': resource['metadata']['tags'],
'author': resource['metadata']['author'],
'file_path': resource['file_info']['file_path'],
'indexed_at': datetime.now().isoformat()
}
await self.elasticsearch_client.index(
index='teaching_resources',
id=resource_id,
body=document
)
return {
'resource_id': resource_id,
'indexed': True
}
def generate_resource_id(self, resource: Dict) -> str:
import uuid
return str(uuid.uuid4())
async def update(
self,
resource_id: str,
updates: Dict
) -> Dict:
await self.elasticsearch_client.update(
index='teaching_resources',
id=resource_id,
body={'doc': updates}
)
return {
'resource_id': resource_id,
'updated': True
}
class ElasticsearchClient:
async def index(self, index: str, id: str, body: Dict) -> None:
pass
async def update(self, index: str, id: str, body: Dict) -> None:
pass
class ResourceSearcher:
def __init__(self):
self.elasticsearch_client = ElasticsearchClient()
async def search(
self,
query: str,
filters: Optional[Dict] = None
) -> List[Dict]:
search_body = self.build_search_body(query, filters)
results = await self.elasticsearch_client.search(
index='teaching_resources',
body=search_body
)
return self.format_results(results)
def build_search_body(self, query: str, filters: Optional[Dict]) -> Dict:
body = {
'query': {
'bool': {
'must': [
{
'multi_match': {
'query': query,
'fields': ['title^2', 'description', 'tags']
}
}
]
}
}
}
if filters:
if filters.get('subject'):
body['query']['bool']['filter'] = [
{'term': {'subject': filters['subject']}}
]
if filters.get('type'):
if 'filter' not in body['query']['bool']:
body['query']['bool']['filter'] = []
body['query']['bool']['filter'].append(
{'term': {'type': filters['type']}}
)
return body
def format_results(self, results: Dict) -> List[Dict]:
hits = results.get('hits', {}).get('hits', [])
return [
{
'resource_id': hit['_id'],
'score': hit['_score'],
**hit['_source']
}
for hit in hits
]
class PermissionManager:
def __init__(self):
self.permission_store = PermissionStore()
async def set_permissions(
self,
resource_id: str,
permissions: Dict
) -> Dict:
default_permissions = {
'public': False,
'allowed_users': [],
'allowed_groups': []
}
final_permissions = {**default_permissions, **permissions}
await self.permission_store.save(
resource_id,
final_permissions
)
return final_permissions
class PermissionStore:
async def save(self, resource_id: str, permissions: Dict) -> None:
pass
class VersionManager:
def __init__(self):
self.version_store = VersionStore()
async def create_version(
self,
resource_id: str,
updates: Dict
) -> Dict:
current_version = await self.get_current_version(resource_id)
new_version = current_version + 1
version_info = {
'resource_id': resource_id,
'version': new_version,
'updates': updates,
'created_at': datetime.now().isoformat()
}
await self.version_store.save(version_info)
return version_info
async def get_current_version(self, resource_id: str) -> int:
return 0
class VersionStore:
async def save(self, version_info: Dict) -> None:
pass2. 课程设计助手
功能描述
帮助教师设计高质量的课程，包括课程大纲制定、教学目标设定、教学活动安排和评估方式设计。
技术实现
python
from typing import Dict, List, Optional
from datetime import datetime
class CourseDesignAssistant:
def __init__(self, config: Dict):
self.config = config
self.outline_generator = OutlineGenerator()
self.objective_setter = ObjectiveSetter()
self.activity_planner = ActivityPlanner()
self.assessment_designer = AssessmentDesigner()
self.resource_recommender = ResourceRecommender()
async def design_course(
self,
teacher_id: str,
course_requirements: Dict
) -> Dict:
outline = await self.outline_generator.generate(
course_requirements
)
objectives = await self.objective_setter.set(
outline,
course_requirements
)
activities = await self.activity_planner.plan(
outline,
objectives
)
assessments = await self.assessment_designer.design(
objectives,
activities
)
resources = await self.resource_recommender.recommend(
outline,
objectives,
activities
)
return {
'teacher_id': teacher_id,
'course_outline': outline,
'learning_objectives': objectives,
'teaching_activities': activities,
'assessments': assessments,
'recommended_resources': resources,
'designed_at': datetime.now().isoformat()
}
class OutlineGenerator:
def __init__(self):
self.llm_client = LLMClient()
self.knowledge_graph = KnowledgeGraph()
async def generate(self, requirements: Dict) -> Dict:
subject = requirements['subject']
grade_level = requirements['grade_level']
duration = requirements.get('duration', 16)
topics = await self.knowledge_graph.get_topics(
subject,
grade_level
)
organized_topics = self.organize_topics(topics, duration)
modules = self.create_modules(organized_topics)
return {
'subject': subject,
'grade_level': grade_level,
'duration': duration,
'modules': modules,
'total_hours': self.calculate_total_hours(modules)
}
def organize_topics(self, topics: List[Dict], duration: int) -> List[List[Dict]]:
organized = []
weeks = duration
topics_per_week = max(1, len(topics) // weeks)
for i in range(0, len(topics), topics_per_week):
week_topics = topics[i:i + topics_per_week]
organized.append(week_topics)
return organized
def create_modules(self, organized_topics: List[List[Dict]]) -> List[Dict]:
modules = []
for week_num, topics in enumerate(organized_topics, 1):
module = {
'week': week_num,
'title': f'第{week_num}周',
'topics': topics,
'hours': sum(t.get('hours', 2) for t in topics)
}
modules.append(module)
return modules
def calculate_total_hours(self, modules: List[Dict]) -> int:
return sum(m['hours'] for m in modules)
class KnowledgeGraph:
async def get_topics(self, subject: str, grade_level: int) -> List[Dict]:
return [
{'id': 't1', 'name': '基础概念', 'hours': 2},
{'id': 't2', 'name': '核心原理', 'hours': 3},
{'id': 't3', 'name': '实际应用', 'hours': 2}
]
class ObjectiveSetter:
def __init__(self):
self.llm_client = LLMClient()
self.blooms_taxonomy = BloomsTaxonomy()
async def set(
self,
outline: Dict,
requirements: Dict
) -> List[Dict]:
objectives = []
for module in outline['modules']:
module_objectives = await self.generate_module_objectives(
module,
requirements
)
objectives.extend(module_objectives)
return objectives
async def generate_module_objectives(
self,
module: Dict,
requirements: Dict
) -> List[Dict]:
topics = module['topics']
prompt = f"""
为以下课程模块设计学习目标：
学科：{requirements['subject']}
年级：{requirements['grade_level']}
模块主题：{module['title']}
包含主题：{', '.join([t['name'] for t in topics])}
请设计3-5个学习目标，涵盖不同认知层次（记忆、理解、应用、分析、评价、创造）。
"""
response = await self.llm_client.generate(prompt)
objectives = self.parse_objectives(response)
return objectives
def parse_objectives(self, response: str) -> List[Dict]:
lines = response.split('\n')
objectives = []
for line in lines:
if line.strip() and not line.startswith('#'):
objective = {
'id': f"obj_{len(objectives) + 1}",
'description': line.strip(),
'level': self.classify_level(line)
}
objectives.append(objective)
return objectives
def classify_level(self, objective: str) -> str:
level_keywords = {
'remember': ['记住', '回忆', '识别', '列举'],
'understand': ['理解', '解释', '说明', '总结'],
'apply': ['应用', '使用', '执行', '实施'],
'analyze': ['分析', '比较', '区分', '组织'],
'evaluate': ['评价', '判断', '评估', '批评'],
'create': ['创造', '设计', '构建', '产生']
}
for level, keywords in level_keywords.items():
if any(keyword in objective for keyword in keywords):
return level
return 'understand'
class BloomsTaxonomy:
def get_levels(self) -> List[str]:
return [
'remember',
'understand',
'apply',
'analyze',
'evaluate',
'create'
]
class ActivityPlanner:
def __init__(self):
self.llm_client = LLMClient()
self.activity_templates = ActivityTemplates()
async def plan(
self,
outline: Dict,
objectives: List[Dict]
) -> List[Dict]:
activities = []
for module in outline['modules']:
module_activities = await self.plan_module_activities(
module,
objectives
)
activities.extend(module_activities)
return activities
async def plan_module_activities(
self,
module: Dict,
objectives: List[Dict]
) -> List[Dict]:
module_objectives = [
obj for obj in objectives
if obj.get('module') == module['week']
]
prompt = f"""
为以下课程模块设计教学活动：
模块：{module['title']}
主题：{', '.join([t['name'] for t in module['topics']])}
学习目标：{len(module_objectives)}个
请设计3-4个教学活动，包括：
1. 导入活动（5-10分钟）
2. 主要活动（20-30分钟）
3. 练习活动（15-20分钟）
4. 总结活动（5-10分钟）
"""
response = await self.llm_client.generate(prompt)
activities = self.parse_activities(response, module)
return activities
def parse_activities(self, response: str, module: Dict) -> List[Dict]:
activity_types = ['导入', '主要', '练习', '总结']
activities = []
for i, activity_type in enumerate(activity_types):
activity = {
'id': f"act_{module['week']}_{i + 1}",
'module': module['week'],
'type': activity_type,
'title': f"{activity_type}活动",
'description': f"{activity_type}活动描述",
'duration': 20,
'methods': ['讲解', '讨论', '练习']
}
activities.append(activity)
return activities
class ActivityTemplates:
def get_template(self, activity_type: str) -> Dict:
templates = {
'导入': {
'duration': 10,
'methods': ['提问', '案例分析', '视频引入']
},
'主要': {
'duration': 30,
'methods': ['讲授', '演示', '小组讨论']
},
'练习': {
'duration': 20,
'methods': ['个人练习', '小组合作', '游戏']
},
'总结': {
'duration': 10,
'methods': ['回顾', '提问', '布置作业']
}
}
return templates.get(activity_type, {})
class AssessmentDesigner:
def __init__(self):
self.llm_client = LLMClient()
self.question_generator = QuestionGenerator()
async def design(
self,
objectives: List[Dict],
activities: List[Dict]
) -> List[Dict]:
assessments = []
assessment_types = ['formative', 'summative']
for assessment_type in assessment_types:
assessment = await self.design_assessment(
assessment_type,
objectives,
activities
)
assessments.append(assessment)
return assessments
async def design_assessment(
self,
assessment_type: str,
objectives: List[Dict],
activities: List[Dict]
) -> Dict:
if assessment_type == 'formative':
return await self.design_formative_assessment(
objectives,
activities
)
else:
return await self.design_summative_assessment(
objectives,
activities
)
async def design_formative_assessment(
self,
objectives: List[Dict],
activities: List[Dict]
) -> Dict:
questions = []
for objective in objectives[:3]:
question = await self.question_generator.generate(
objective,
'short_answer'
)
questions.append(question)
return {
'id': 'formative_1',
'type': 'formative',
'title': '形成性评估',
'questions': questions,
'duration': 15,
'weight': 0.3
}
async def design_summative_assessment(
self,
objectives: List[Dict],
activities: List[Dict]
) -> Dict:
questions = []
for objective in objectives:
question_type = self.select_question_type(objective['level'])
question = await self.question_generator.generate(
objective,
question_type
)
questions.append(question)
return {
'id': 'summative_1',
'type': 'summative',
'title': '总结性评估',
'questions': questions,
'duration': 60,
'weight': 0.7
}
def select_question_type(self, level: str) -> str:
type_mapping = {
'remember': 'multiple_choice',
'understand': 'multiple_choice',
'apply': 'short_answer',
'analyze': 'short_answer',
'evaluate': 'essay',
'create': 'essay'
}
return type_mapping.get(level, 'short_answer')
class QuestionGenerator:
def __init__(self):
self.llm_client = LLMClient()
async def generate(
self,
objective: Dict,
question_type: str
) -> Dict:
prompt = f"""
根据以下学习目标生成一道{question_type}题目：
学习目标：{objective['description']}
认知层次：{objective['level']}
请生成：
1. 题目描述
2. 正确答案
3. 评分标准
"""
response = await self.llm_client.generate(prompt)
question = self.parse_question(response, question_type)
return {
'id': f"q_{objective['id']}",
'objective_id': objective['id'],
'type': question_type,
**question
}
def parse_question(self, response: str, question_type: str) -> Dict:
return {
'question': response,
'correct_answer': '示例答案',
'points': 10
}
class ResourceRecommender:
def __init__(self):
self.resource_searcher = ResourceSearcher()
self.relevance_calculator = RelevanceCalculator()
async def recommend(
self,
outline: Dict,
objectives: List[Dict],
activities: List[Dict]
) -> List[Dict]:
recommendations = []
for module in outline['modules']:
module_resources = await self.recommend_module_resources(
module,
objectives,
activities
)
recommendations.extend(module_resources)
return recommendations
async def recommend_module_resources(
self,
module: Dict,
objectives: List[Dict],
activities: List[Dict]
) -> List[Dict]:
topics = [t['name'] for t in module['topics']]
query = ' '.join(topics)
search_results = await self.resource_searcher.search(
query,
{'subject': outline['subject']}
)
ranked = self.rank_by_relevance(
search_results,
module
)
return ranked[:5]
def rank_by_relevance(
self,
resources: List[Dict],
module: Dict
) -> List[Dict]:
for resource in resources:
relevance = self.calculate_relevance(resource, module)
resource['relevance_score'] = relevance
return sorted(
resources,
key=lambda x: x['relevance_score'],
reverse=True
)
def calculate_relevance(self, resource: Dict, module: Dict) -> float:
base_score = resource.get('score', 0.5)
difficulty_match = 1.0 if resource.get('difficulty') == 'intermediate' else 0.7
return base_score * difficulty_match3. 教学分析系统
功能描述
分析教学数据，评估教学效果，识别教学问题，提供改进建议。
技术实现
python
from typing import Dict, List, Optional
from datetime import datetime, timedelta
import numpy as np
class TeachingAnalyticsSystem:
def __init__(self, config: Dict):
self.config = config
self.data_collector = DataCollector()
self.effectiveness_analyzer = EffectivenessAnalyzer()
self.student_performance_analyzer = StudentPerformanceAnalyzer()
self.teaching_pattern_analyzer = TeachingPatternAnalyzer()
self.recommendation_engine = RecommendationEngine()
async def analyze_teaching(
self,
teacher_id: str,
course_id: str,
time_period: Optional[Dict] = None
) -> Dict:
teaching_data = await self.data_collector.collect(
teacher_id,
course_id,
time_period
)
effectiveness = await self.effectiveness_analyzer.analyze(
teaching_data
)
student_performance = await self.student_performance_analyzer.analyze(
teaching_data
)
teaching_patterns = await self.teaching_pattern_analyzer.analyze(
teaching_data
)
recommendations = await self.recommendation_engine.generate(
effectiveness,
student_performance,
teaching_patterns
)
return {
'teacher_id': teacher_id,
'course_id': course_id,
'time_period': time_period,
'effectiveness': effectiveness,
'student_performance': student_performance,
'teaching_patterns': teaching_patterns,
'recommendations': recommendations,
'analyzed_at': datetime.now().isoformat()
}
class DataCollector:
async def collect(
self,
teacher_id: str,
course_id: str,
time_period: Optional[Dict]
) -> Dict:
return {
'attendance_data': [],
'assessment_data': [],
'engagement_data': [],
'feedback_data': []
}
class EffectivenessAnalyzer:
async def analyze(self, data: Dict) -> Dict:
return {
'overall_effectiveness': 0.85,
'attendance_rate': 0.92,
'completion_rate': 0.88,
'student_satisfaction': 0.87
}
class StudentPerformanceAnalyzer:
async def analyze(self, data: Dict) -> Dict:
return {
'average_score': 82.5,
'score_distribution': {
'excellent': 0.25,
'good': 0.45,
'average': 0.20,
'below_average': 0.10
},
'improvement_rate': 0.12
}
class TeachingPatternAnalyzer:
async def analyze(self, data: Dict) -> Dict:
return {
'preferred_methods': ['lecture', 'discussion'],
'activity_diversity': 0.75,
'pacing': 'appropriate'
}
class RecommendationEngine:
async def generate(
self,
effectiveness: Dict,
student_performance: Dict,
teaching_patterns: Dict
) -> List[str]:
recommendations = []
if effectiveness['student_satisfaction'] < 0.8:
recommendations.append("增加互动环节，提高学生参与度")
if student_performance['improvement_rate'] < 0.1:
recommendations.append("调整教学节奏，确保学生充分理解")
if teaching_patterns['activity_diversity'] < 0.7:
recommendations.append("丰富教学活动形式，增加多样性")
return recommendations系统架构
javascript
const teachingManagementPlatformArchitecture = {
layers: {
presentationLayer: {
components: ['教师工作台', '课程设计器', '资源管理器', '分析仪表盘'],
technologies: ['React', 'Vue.js', 'Ant Design', 'ECharts']
},
serviceLayer: {
components: ['资源服务', '课程服务', '分析服务', '推荐服务'],
technologies: ['Node.js', 'Python', 'FastAPI']
},
aiLayer: {
components: ['内容分析', '智能推荐', '模式识别', '预测模型'],
technologies: ['BERT', 'GPT', 'TensorFlow', 'PyTorch']
},
dataLayer: {
components: ['资源数据库', '课程数据库', '教学数据库', '分析数据库'],
technologies: ['PostgreSQL', 'MongoDB', 'Redis', 'Elasticsearch']
}
}
};最后更新时间：2026-03-10
教学管理平台通过AI驱动的资源管理、课程设计和教学分析功能，为教师提供全面的教学支持，提升教学质量和效率。