Plataforma E-learning para Focus Prevention

import pandas as pd
import numpy as np
from typing import Dict, List, Optional

class DataProcessor:
    """
    A class for processing and analyzing data.
    """
    
    def __init__(self, data_path: str):
        """
        Initialize the DataProcessor with a data file.
        
        Args:
            data_path: Path to the data file
        """
        self.data_path = data_path
        self.data = self._load_data()
        
    def _load_data(self) -> pd.DataFrame:
        """
        Load data from the specified path.
        
        Returns:
            DataFrame containing the loaded data
        """
        try:
            return pd.read_csv(self.data_path)
        except Exception as e:
            print(f"Error loading data: {e}")
            return pd.DataFrame()
            
    def clean_data(self) -> pd.DataFrame:
        """
        Clean the data by removing duplicates and handling missing values.
        
        Returns:
            Cleaned DataFrame
        """
        # Remove duplicates
        self.data = self.data.drop_duplicates()
        
        # Handle missing values
        for column in self.data.columns:
            if self.data[column].dtype == np.number:
                self.data[column].fillna(self.data[column].median(), inplace=True)
            else:
                self.data[column].fillna(self.data[column].mode()[0], inplace=True)
                
        return self.data
        
    def analyze_data(self) -> Dict[str, any]:
        """
        Perform basic analysis on the data.
        
        Returns:
            Dictionary containing analysis results
        """
        results = {
            "row_count": len(self.data),
            "column_count": len(self.data.columns),
            "summary_stats": self.data.describe().to_dict(),
            "missing_values": self.data.isnull().sum().to_dict()
        }
        
        return results
        
    def filter_data(self, conditions: Dict[str, any]) -> pd.DataFrame:
        """
        Filter data based on specified conditions.
        
        Args:
            conditions: Dictionary of column-value pairs to filter by
            
        Returns:
            Filtered DataFrame
        """
        filtered_data = self.data.copy()
        
        for column, value in conditions.items():
            if column in filtered_data.columns:
                filtered_data = filtered_data[filtered_data[column] == value]
                
        return filtered_data

# Example usage
if __name__ == "__main__":
    processor = DataProcessor("data.csv")
    cleaned_data = processor.clean_data()
    analysis_results = processor.analyze_data()
    
    print(f"Data has {analysis_results['row_count']} rows and {analysis_results['column_count']} columns")
    
    # Filter data example
    filtered = processor.filter_data({"category": "A"})
    print(f"Filtered data has {len(filtered)} rows")