student-skills

name	student-skills
description	Essential skills for college students: academic writing, data analysis, presentation design, research methodology, and study automation
version	1.0.0
author	Hermes Agent
license	MIT
platforms	["linux","macos","windows"]
metadata	{"hermes":{"tags":["student","academic","research","writing","analysis","education"],"related_skills":["office-mastery","powerpoint","research"]}}

Student Skills Toolkit

Comprehensive skills for college students covering academic writing, data analysis, presentations, research methodology, and study automation.

When to Use

Use this skill whenever you need to:

• Write academic papers, essays, and reports
• Analyze data for research projects and assignments
• Create professional presentations for class
• Conduct literature reviews and research
• Automate study tasks and organize notes
• Format documents according to academic standards
• Process research data and statistics

Academic Writing Skills

Paper Structure and Formatting

from docx import Document
from docx.shared import Pt, Inches
from docx.enum.text import WD_ALIGN_PARAGRAPH

def create_academic_paper():
    """Create properly formatted academic paper"""
    doc = Document()
    
    # Set default font
    style = doc.styles['Normal']
    font = style.font
    font.name = 'Times New Roman'
    font.size = Pt(12)
    
    # Title page
    title = doc.add_heading('Research Paper Title', 0)
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
    
    # Author info
    author = doc.add_paragraph()
    author.alignment = WD_ALIGN_PARAGRAPH.CENTER
    author.add_run('Student Name\n')
    author.add_run('University Name\n')
    author.add_run('Course Name\n')
    author.add_run(f'Date: {datetime.now().strftime("%B %d, %Y")}')
    
    # Abstract
    doc.add_heading('Abstract', level=1)
    abstract = doc.add_paragraph()
    abstract.add_run('This paper examines...').italic = True
    
    # Keywords
    keywords = doc.add_paragraph()
    keywords.add_run('Keywords: ').bold = True
    keywords.add_run('keyword1, keyword2, keyword3')
    
    # Main sections
    doc.add_heading('1. Introduction', level=1)
    doc.add_paragraph('Background and significance of the research...')
    
    doc.add_heading('2. Literature Review', level=1)
    doc.add_paragraph('Review of existing research...')
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    
    
    doc.add_heading(, level=)
    references = [
        ,
        ,
        
    ]
    
     ref  references:
        doc.add_paragraph(ref, style=)
    
     doc

Citation Management

import re
from collections import defaultdict

class CitationManager:
    """Manage academic citations and references"""
    
    def __init__(self):
        self.references = []
        self.citations = defaultdict(int)
    
    def add_reference(self, authors, year, title, source, **kwargs):
        """Add a reference to the manager"""
        ref = {
            'authors': authors,
            'year': year,
            'title': title,
            'source': source,
            **kwargs
        }
        self.references.append(ref)
        return len(self.references)
    
    def format_apa(self, ref):
        """Format reference in APA style"""
        authors = ref['authors']
        if len(authors) > 3:
            authors = f"{authors[0]} et al."
        elif len(authors) > 1:
            authors = ', '.join(authors[:-1]) + ', & ' + authors[-1]
        
        return f"{authors} ({ref[]}). . "
    
     ():
        
        authors = ref[]
         (authors) > :
            authors = 
        
         
    
     ():
        
        bibliography = []
         i, ref  (.references, ):
             style == :
                formatted = .format_apa(ref)
             style == :
                formatted = .format_mla(ref)
            
            bibliography.append()
        
         bibliography
    
     ():
        
        ref = .references[ref_id - ]
        authors = ref[]
        
         style == :
             (authors) > :
                 
             (authors) > :
                 
            :
                 
         style == :
             (authors) > :
                 
            :
                 

Data Analysis for Research

Statistical Analysis

import pandas as pd
import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
import seaborn as sns

def analyze_research_data(data_file):
    """Comprehensive data analysis for research"""
    
    # Load data
    df = pd.read_csv(data_file)
    
    # Basic statistics
    print("📊 数据基本统计:")
    print(df.describe())
    
    # Check for missing values
    print("\n🔍 缺失值检查:")
    missing = df.isnull().sum()
    print(missing[missing > 0])
    
    # Correlation analysis
    print("\n📈 相关性分析:")
    numeric_df = df.select_dtypes(include=[np.number])
    correlation = numeric_df.corr()
    
    # Visualization
    plt.figure(figsize=(12, 8))
    
    # Correlation heatmap
    plt.subplot(2, 2, 1)
    sns.heatmap(correlation, annot=True, cmap='coolwarm', center=0)
    plt.title('Correlation Matrix')
    
    # Distribution plots
    plt.subplot(2, 2, 2)
    for col in numeric_df.columns[:3]:
        sns.kdeplot(data=df, x=col, label=col)
    plt.title()
    plt.legend()
    
    
    plt.subplot(, , )
    numeric_df.boxplot()
    plt.title()
    plt.xticks(rotation=)
    
    
     (numeric_df.columns) >= :
        plt.subplot(, , )
        plt.scatter(numeric_df.iloc[:, ], numeric_df.iloc[:, ], alpha=)
        plt.xlabel(numeric_df.columns[])
        plt.ylabel(numeric_df.columns[])
        plt.title()
    
    plt.tight_layout()
    plt.savefig(, dpi=, bbox_inches=)
    plt.show()
    
     df, correlation

 ():
    
    
    
    _, p1 = stats.shapiro(group1)
    _, p2 = stats.shapiro(group2)
    
     p1 > alpha  p2 > alpha:
        
        t_stat, p_value = stats.ttest_ind(group1, group2)
        test_type = 
    :
        
        t_stat, p_value = stats.mannwhitneyu(group1, group2)
        test_type = 
    
     {
        : test_type,
        : t_stat,
        : p_value,
        : p_value < alpha
    }

Survey Data Analysis

def analyze_survey_data(survey_file):
    """Analyze survey/questionnaire data"""
    
    df = pd.read_excel(survey_file)
    
    results = {}
    
    # Demographic analysis
    print("👥 人口统计学分析:")
    demographic_cols = ['gender', 'age_group', 'education']
    for col in demographic_cols:
        if col in df.columns:
            counts = df[col].value_counts()
            print(f"\n{col}:")
            print(counts)
            results[col] = counts
    
    # Likert scale analysis
    print("\n📊 李克特量表分析:")
    likert_cols = [col for col in df.columns if 'q' in col.lower()]
    
    for col in likert_cols:
        mean = df[col].mean()
        std = df[col].std()
        print(f"{col}: Mean = {mean:.2f}, SD = {std:.2f}")
        results[col] = {'mean': mean, 'std': std}
    
    # Reliability analysis (Cronbach's alpha)
    if len(likert_cols) > 1:
        likert_data = df[likert_cols]
        n_items = len(likert_cols)
        item_vars = likert_data.var().sum()
        total_var = likert_data.sum(axis=1).var()
        
        cronbach_alpha = (n_items / (n_items - )) * ( - item_vars / total_var)
        ()
        results[] = cronbach_alpha
    
     results

Research Methodology

Literature Review Matrix

def create_literature_review():
    """Create literature review matrix"""
    
    wb = openpyxl.Workbook()
    ws = wb.active
    ws.title = '文献综述'
    
    # Headers
    headers = ['作者', '年份', '标题', '研究方法', '主要发现', '局限性', '相关度']
    for col, header in enumerate(headers, 1):
        cell = ws.cell(row=1, column=col, value=header)
        cell.font = Font(bold=True, color='FFFFFF')
        cell.fill = PatternFill(start_color='4472C4', end_color='4472C4', fill_type='solid')
    
    # Sample literature entries
    literature = [
        ['Smith et al.', 2020, 'Study Title 1', 'Quantitative', 'Finding 1', 'Small sample', 'High'],
        ['Johnson', 2021, 'Study Title 2', 'Qualitative', 'Finding 2', 'Limited scope', 'Medium'],
        ['Williams & Brown', 2022, 'Study Title 3', 'Mixed methods', 'Finding 3', 'Time constraint', 'High']
    ]
    
    for row_idx, entry in enumerate(literature, 2):
         col_idx, value  (entry, ):
            ws.cell(row=row_idx, column=col_idx, value=value)
    
    
     col  (, ):
        ws.column_dimensions[get_column_letter(col)].width = 
    
    wb.save()
     

Research Proposal Template

def create_research_proposal():
    """Create research proposal document"""
    
    doc = Document()
    
    # Title
    title = doc.add_heading('研究计划书', 0)
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
    
    # Basic info
    doc.add_heading('一、基本信息', level=1)
    info_table = doc.add_table(rows=5, cols=2)
    info_table.style = 'Table Grid'
    
    info_data = [
        ['研究题目', '填写研究题目'],
        ['研究者', '姓名、学号、专业'],
        ['指导教师', '教师姓名、职称'],
        ['研究时间', '开始日期 - 结束日期'],
        ['研究类型', '实验研究/调查研究/文献研究等']
    ]
    
    for row_idx, (label, value) in enumerate(info_data):
        info_table.rows[row_idx].cells[0].text = label
        info_table.rows[row_idx].cells[1].text = value
    
    # Research background
    doc.add_heading('二、研究背景与意义', level=1)
    doc.add_paragraph('1. 研究背景')
    doc.add_paragraph('描述研究领域的现状和问题...')
    doc.add_paragraph('2. 研究意义')
    doc.add_paragraph('理论意义和实践意义...')
    
    # Literature review
    doc.add_heading('三、文献综述', level=1)
    doc.add_paragraph('1. 国内研究现状')
    doc.add_paragraph('2. 国外研究现状')
    doc.add_paragraph('3. 文献评述')
    
    # Research design
    doc.add_heading('四、研究设计', level=)
    doc.add_paragraph()
    doc.add_paragraph()
    doc.add_paragraph()
    doc.add_paragraph()
    
    
    doc.add_heading(, level=)
    timeline_table = doc.add_table(rows=, cols=)
    timeline_table.style = 
    
    timeline_data = [
        [, , ],
        [, , ],
        [, , ],
        [, , ],
        [, , ]
    ]
    
     row_idx, row_data  (timeline_data):
         col_idx, value  (row_data):
            timeline_table.rows[row_idx].cells[col_idx].text = value
    
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    doc.add_paragraph()
    doc.add_paragraph()
    
    
    doc.add_heading(, level=)
    doc.add_paragraph()
    
    doc.save()
     

Study Automation

Flashcard Generator

def create_flashcards(content_file):
    """Create study flashcards from content"""
    
    with open(content_file, 'r', encoding='utf-8') as f:
        content = f.read()
    
    # Parse content into Q&A pairs
    lines = content.strip().split('\n')
    flashcards = []
    
    current_question = None
    current_answer = []
    
    for line in lines:
        if line.startswith('Q:'):
            if current_question and current_answer:
                flashcards.append({
                    'question': current_question,
                    'answer': '\n'.join(current_answer)
                })
            current_question = line[2:].strip()
            current_answer = []
        elif line.startswith('A:'):
            current_answer.append(line[2:].strip())
        elif current_question:
            current_answer.append(line)
    
    # Add last card
    if current_question and current_answer:
        flashcards.append({
            'question': current_question,
            'answer': '\n'.join(current_answer)
        })
    
    # Create Anki-compatible file
    with open('flashcards.txt', 'w', encoding='utf-8') as f:
        for card in flashcards:
            f.write()
    
    
    html_content = 
    
     i, card  (flashcards, ):
        html_content += 
    
    html_content += 
    
     (, , encoding=)  f:
        f.write(html_content)
    
     flashcards

 ():
    
    
    schedule = {}
    today = datetime.now().date()
    
     subject, exam_date  exam_dates.items():
        exam_date = datetime.strptime(exam_date, ).date()
        days_until_exam = (exam_date - today).days
        
         days_until_exam <= :
            schedule[subject] = 
            
        
        
        total_hours = days_until_exam * study_hours_per_day
        topics_count =   
        
        schedule[subject] = {
            : exam_date,
            : days_until_exam,
            : total_hours,
            : total_hours / topics_count,
            : []
        }
        
        
         day  (days_until_exam):
            date = today + timedelta(days=day)
            topics_per_day = topics_count / days_until_exam
            
            schedule[subject][].append({
                : date,
                : (topics_per_day, ),
                : study_hours_per_day
            })
    
     schedule

Note-Taking System

class CornellNotes:
    """Implement Cornell note-taking system"""
    
    def __init__(self, subject):
        self.subject = subject
        self.notes = []
        self.cues = []
        self.summary = ""
    
    def add_note(self, content, page=None):
        """Add a note with optional page reference"""
        note = {
            'content': content,
            'page': page,
            'timestamp': datetime.now()
        }
        self.notes.append(note)
    
    def add_cue(self, cue):
        """Add a cue/question for review"""
        self.cues.append(cue)
    
    def set_summary(self, summary):
        """Set summary for the notes"""
        self.summary = summary
    
    def export_to_word(self):
        """Export Cornell notes to Word document"""
        doc = Document()
        
        # Title
        title = doc.add_heading(f'Cornell Notes: {self.subject}', 0)
        title.alignment = WD_ALIGN_PARAGRAPH.CENTER
        
        # Create Cornell notes layout
        table = doc.add_table(rows=1, cols=2)
        table.style = 'Table Grid'
        
        
        left_cell = table.rows[].cells[]
        left_cell.text = 
         cue  .cues:
            left_cell.text += 
        
        
        right_cell = table.rows[].cells[]
        right_cell.text = 
         note  .notes:
            page_ref =   note[]  
            right_cell.text += 
        
        
        doc.add_heading(, level=)
        doc.add_paragraph(.summary)
        
        
        filename = 
        doc.save(filename)
         filename

Academic Tools

Plagiarism Checker (Basic)

def check_similarity(text1, text2):
    """Basic text similarity check"""
    
    from sklearn.feature_extraction.text import TfidfVectorizer
    from sklearn.metrics.pairwise import cosine_similarity
    
    # Create TF-IDF vectors
    vectorizer = TfidfVectorizer()
    tfidf_matrix = vectorizer.fit_transform([text1, text2])
    
    # Calculate cosine similarity
    similarity = cosine_similarity(tfidf_matrix[0:1], tfidf_matrix[1:2])[0][0]
    
    return {
        'similarity_score': similarity,
        'similarity_percentage': similarity * 100,
        'is_similar': similarity > 0.8  # Threshold for plagiarism
    }

def extract_text_from_docx(docx_file):
    """Extract text from Word document"""
    doc = Document(docx_file)
    text = []
    for paragraph in doc.paragraphs:
        text.append(paragraph.text)
    return '\n'.join(text)

Grade Calculator

def calculate_gpa(grades, credits):
    """Calculate GPA from grades and credits"""
    
    # Grade point mapping
    grade_points = {
        'A+': 4.0, 'A': 4.0, 'A-': 3.7,
        'B+': 3.3, 'B': 3.0, 'B-': 2.7,
        'C+': 2.3, 'C': 2.0, 'C-': 1.7,
        'D+': 1.3, 'D': 1.0, 'D-': 0.7,
        'F': 0.0
    }
    
    total_points = 0
    total_credits = 0
    
    for grade, credit in zip(grades, credits):
        if grade in grade_points:
            total_points += grade_points[grade] * credit
            total_credits += credit
    
    if total_credits == 0:
        return 0.0
    
    gpa = total_points / total_credits
    return round(gpa, 2)

def predict_gpa(current_gpa, current_credits, target_gpa, remaining_credits):
    """Predict needed GPA for remaining courses"""
    
    current_points = current_gpa * current_credits
    target_points = target_gpa * (current_credits + remaining_credits)
    needed_points = target_points - current_points
    needed_gpa = needed_points / remaining_credits
    
     {
        : current_gpa,
        : target_gpa,
        : (needed_gpa, ),
        : needed_gpa <= 
    }

Dependencies

Critical: Always use python3 -m pip instead of pip3 to avoid installing to the wrong Python version. See office-mastery skill's references/python-env-pitfalls.md for details.

# Core academic libraries
python3 -m pip install python-docx openpyxl python-pptx PyPDF2 pdfplumber

# Data analysis
python3 -m pip install pandas numpy scipy matplotlib seaborn scikit-learn

# Report generation
python3 -m pip install reportlab

# Additional tools
python3 -m pip install python-dateutil openpyxl

Best Practices for Students

1. Start early - Begin assignments and research well before deadlines
2. Use version control - Track changes in your documents
3. Backup regularly - Save copies in multiple locations
4. Follow citation styles - Use APA, MLA, or Chicago consistently
5. Proofread carefully - Check for grammar and spelling errors
6. Use academic databases - Access scholarly articles through library
7. Organize files systematically - Create clear folder structures
8. Automate repetitive tasks - Use scripts for data processing
9. Collaborate effectively - Use cloud tools for group projects
10. Seek feedback - Ask professors and peers for reviews

Common Academic Formats

APA Style (7th Edition)

• Title page with running head
• Abstract (150-250 words)
• Main body with headings
• References in alphabetical order
• In-text citations: (Author, Year)

MLA Style (9th Edition)

• No title page (unless required)
• Header with name, instructor, course, date
• Works Cited page
• In-text citations: (Author Page)

Chicago Style

• Title page
• Footnotes or endnotes
• Bibliography
• In-text citations with superscript numbers

This comprehensive toolkit provides everything students need for academic success, from writing papers to analyzing data and creating presentations.