pandas-reimplementation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 style=\"text-align:center\">COMP20270 OOP in Python, Assignment 2: MyDataFrame<br>Brian Manning</h1>\n",
    "\n",
    "___\n",
    "## MySeries Class\n",
    "- This class is used to create an indexed series stored as a dict\n",
    "___\n",
    "- It has methods to do the following:\n",
    "    1. __min__: Calculate the minimum value in the series\n",
    "    2. __max__: Calculate the maximum value in the series\n",
    "    3. __mean__: Calculate the mean of the series\n",
    "    3. __print__: Prints the value of the series\n",
    "    3. __item_at_ind__: Prints the value at a certain indice\n",
    "\n",
    "- It has the following properties:\n",
    "    1. __s_dict__: This is a dictionary which stores the inputted series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MySeries():\n",
    "    def __init__(self, s_dict, **kwargs):\n",
    "        # check if the inputted dictionary is a dictionary\n",
    "        if isinstance(s_dict, dict):\n",
    "            self.s_dict = s_dict\n",
    "        # if it isnt a dictionary, check if its a list - if not itll be invalid\n",
    "        elif isinstance(s_dict, list):\n",
    "            # check if an index is passed, if not add index\n",
    "            if 'index' not in kwargs:\n",
    "                self.s_dict = dict(zip(range(len(s_dict)), s_dict))\n",
    "            # check if the index passed was a list\n",
    "            elif isinstance(kwargs.get('index'), list):\n",
    "                # check if the length of the index matches the length of the series\n",
    "                if len(kwargs.get('index')) == len(s_dict):\n",
    "                    self.s_dict = dict(zip(kwargs.get('index'), s_dict))\n",
    "                else:\n",
    "                    raise ValueError(\"Index must be the same length as the series.\")\n",
    "            else:\n",
    "                raise ValueError(\"Index must be of type list.\")\n",
    "        else:\n",
    "            raise ValueError(\"Incorrect input to MySeries class.\\nYou must input either a list or a dictionary.\")\n",
    "\n",
    "    def min(self):\n",
    "        # min function returns the key for the mimum number value\n",
    "        # if the series is of strings it returns the letter closest to the start of the alphabet\n",
    "        try:\n",
    "            min_val = min(self.s_dict, key=self.s_dict.get)\n",
    "            return self.s_dict[min_val]\n",
    "        except:\n",
    "            print(\"Could not calculate the minimum of the given values\")\n",
    "    \n",
    "    def max(self):\n",
    "        # max function returns the maximum number value\n",
    "        # if the series is of strings it returns the letter furthest from the start of the alphabet\n",
    "        try:\n",
    "            max_val = max(self.s_dict, key=self.s_dict.get)\n",
    "            return self.s_dict[max_val]\n",
    "        except:\n",
    "            print(\"Could not calculate the maximum of the given values\")\n",
    "    \n",
    "    def mean(self):\n",
    "        # mean function calculates the mean average of the series\n",
    "        # if the series is of strings it raises an error\n",
    "        try:\n",
    "            mean_value = float(sum(self.s_dict.values()))/len(self.s_dict)\n",
    "            return mean_value\n",
    "        except:\n",
    "            raise ValueError(\"Could not calculate the mean of the given values.\")\n",
    "    \n",
    "    def print(self):\n",
    "        for key in self.s_dict.keys():\n",
    "            key_value = self.s_dict[key]\n",
    "            max_len_key = max(len(str(v)) for v in self.s_dict.keys())\n",
    "            max_len_val = max(len(str(v)) for v in self.s_dict.values())\n",
    "            # tries to print as integer, if it cant it prints as normal string\n",
    "            # allows for number formatting\n",
    "            try:\n",
    "                print(\"{0:>{1}}\".format(key,max_len_key), '\\t', \"{:.1f}\".format(key_value))\n",
    "            except:\n",
    "                print(\"{0:>{1}}\".format(key,max_len_key), '\\t',\"{0:>{1}}\".format(key_value,max_len_val))\n",
    "\n",
    "    def item_at_ind(self, key):\n",
    "        # check if key exists, if not show what keys exist\n",
    "        if key in self.s_dict.keys():\n",
    "            print(self.s_dict[key])\n",
    "        else:\n",
    "            print(f\"\\'{key}\\' not in index.\\n\")\n",
    "            print(f\"The following keys may be used:\\n{self.s_dict.keys()}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div class=\"alert alert-block alert-success\"><h2 style=\"text-align:center\">MySeries - Sample 1</h2></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms3 = MySeries([1,2,1], index = ['a','b','c'])\n",
    "ms3.s_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Minimum value:',ms3.min())\n",
    "print('Maximum value:',ms3.max())\n",
    "print('Mean value:',ms3.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms3.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms3.item_at_ind('c')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div class=\"alert alert-block alert-success\"><h2 style=\"text-align:center\">MySeries - Sample 2</h2></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms4 = MySeries([4,5,6])\n",
    "ms4.s_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Minimum value:',ms4.min())\n",
    "print('Maximum value:',ms4.max())\n",
    "print('Mean value:',ms4.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ms4.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div class=\"alert alert-block alert-success\"><h2 style=\"text-align:center\">MySeries - Sample 3</h2></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'b': 1, 'a': 0, 'c': 2}\n",
    "s2 = MySeries(d)\n",
    "s2.s_dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('Minimum value:',s2.min())\n",
    "print('Maximum value:',s2.max())\n",
    "print('Mean value:   ',s2.mean())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "s2.print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## MyDataFrame Class\n",
    "- This class is used to create a basic data frame, with columns from the MySeries class\n",
    "___\n",
    "- It has methods to do the following:\n",
    "    1. __min__: Calculate the minimum value of each of the series\n",
    "    2. __max__: Calculate the maximum value of each of the series\n",
    "    3. __mean__: Calculate the mean of each of the series\n",
    "    3. __print__: Prints the value of the data frame, based on the sorting\n",
    "    3. __sort_values__: Sorts the values in ascending order for the given row, takes optional reverse_val parameter which will reverse the sorting if it is equal to True (default False)\n",
    "    3. ____repr____: Calls the print function, returns empty string (to replicate pandas)\n",
    "    3. ____calculate__: Calculates either min, max, or mean of the dataframe based on the type passed\n",
    "    3. ____calc_max_len__: Calculates the maximum length in a column, to be used when printing\n",
    "\n",
    "\n",
    "- It has the following properties:\n",
    "    1. __dict__: This is a dictionary which stores the inputted series\n",
    "    1. __index__: Stores the row headings of the data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import operator\n",
    "\n",
    "class MyDataFrame():\n",
    "    def __init__(self, d, **kwargs):\n",
    "        # check if the argument passed is a dictionary\n",
    "        if not isinstance(d, dict):\n",
    "            raise ValueError('Error input not dict')\n",
    "        else:\n",
    "            self.dict = {}\n",
    "            # check if index provided nad\n",
    "            if 'index' not in kwargs:\n",
    "                for key in d.keys():\n",
    "                    self.dict[key] = MySeries(d[key])\n",
    "                self.index = range(len(self.dict)-1)\n",
    "            if isinstance(kwargs.get('index'), list):\n",
    "                if len(kwargs.get('index')) == len(next(iter(d.values()))):\n",
    "                    self.index = kwargs.get('index')\n",
    "                    for key in d.keys():\n",
    "                        self.dict[key] = MySeries(d[key], index=self.index)\n",
    "                else:\n",
    "                    raise ValueError('Index inputted not of same length')\n",
    "    \n",
    "    # added this to replicate how pandas implements it when you only say the instance variable name\n",
    "    # returns blank string as repr must return string\n",
    "    def __repr__(self):\n",
    "        self.print()\n",
    "        return ''\n",
    "        \n",
    "    def print(self, calculation=None):\n",
    "        count_key, count_index = 0, 0\n",
    "        max_col_len = {}\n",
    "        # check if the keys have been sorted\n",
    "        # loop through rows \n",
    "        for i in range(1, len(self.index)+2):\n",
    "            # loop through each col heading (key)\n",
    "            for key in self.dict.keys():\n",
    "                if count_key == 0:\n",
    "                    # prints the empty space at the start and the first column heading\n",
    "                    count_key = 1\n",
    "                    max_col_len[key] = self.__calc_max_len(key)\n",
    "                    print(\"\\t\",\"{0:>{1}}\".format(key, max_col_len[key]), sep=\"\", end= \"\\t\")\n",
    "                elif i == 1:\n",
    "                    # prints the rest of the column headings\n",
    "                    max_col_len[key] = self.__calc_max_len(key)\n",
    "                    count_key += 1\n",
    "                    print(\"{0:>{1}}\".format(key, max_col_len[key]), end=\"\\t\")\n",
    "                elif i > 1 and count_index == 1:\n",
    "                    # prints the row headings\n",
    "                    print()\n",
    "                    row_name = self.index[i-2]\n",
    "                    print(self.index[i-2], end=\"\\t\")\n",
    "                    print(\"{0:>{1}}\".format(self.dict[key].s_dict[row_name], max_col_len[key]),sep=\"\", end=\"\\t\")\n",
    "                    count_index += 1             \n",
    "                else:\n",
    "                    # prints the data\n",
    "                    print(\"{0:>{1}}\".format(self.dict[key].s_dict[row_name], max_col_len[key]),sep=\"\", end=\"\\t\")\n",
    "            count_index = 1\n",
    "        count_index = 0\n",
    "        \n",
    "    def sort_values(self, column_head, reverse_val=False):\n",
    "        # changes the order of column headings to reflect input\n",
    "        self.index = sorted(self.dict[column_head].s_dict ,  key=self.dict[column_head].s_dict.get, reverse=reverse_val)\n",
    "    \n",
    "    def min(self):\n",
    "        self.__calculate('min')\n",
    "    \n",
    "    def max(self):\n",
    "        self.__calculate('max')\n",
    "    \n",
    "    def mean(self):\n",
    "        self.__calculate('mean')\n",
    "    \n",
    "    # prevent access to calculate as it uses methodcaller\n",
    "    def __calculate(self, type):\n",
    "        max_len_key = len(max(self.dict, key=len))\n",
    "        for key in self.dict.keys():\n",
    "            try:\n",
    "                # note: operator.methodcaller is being used here as the for loop is the same for each min, max, mean\n",
    "                # used to prevent code duplication in each method \n",
    "                value = operator.methodcaller(type)(self.dict[key])\n",
    "                print(\"{0:>{1}}\".format(key, max_len_key), \"{:>11}\".format(\"{:.2f}\".format(value)))\n",
    "            except:\n",
    "                # used so that the other calculations are printed\n",
    "                # when the calculations are done on a MySeries instance they raise an error\n",
    "                pass\n",
    "    \n",
    "    def __calc_max_len(self, key):\n",
    "        # used to calculate the maximum of either the values in a column or the key of that column\n",
    "        # to be used for table formatting in the print function above\n",
    "        max_temp = max(len(str(v)) for v in self.dict[key].s_dict.values())\n",
    "        return max(max_temp, len(key))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div class=\"alert alert-block alert-success\"><h2 style=\"text-align:center\">Dataframe - Sample 1</h2></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = { 'Sun Hours' : [ 4.5 , 4.0 , 5.1 , 5 ],\n",
    "'Max Temp' : [ 19.6 , 19.1 , 19.6 , 20.0 ],\n",
    "'Min Temp' : [ 12.7 , 12.5 , 13.3 , 12.1 ],\n",
    "'Rain (mm)' : [ 82 , 109 , 65 , 76 ],\n",
    "'Rain Days' : [ 13 , 20 , 10 , 9.7 ]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df1 = MyDataFrame(d)\n",
    "df1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = MyDataFrame(d, index = ['Clare', 'Galway','Dublin', 'Wexford'])\n",
    "df2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2.sort_values('Rain (mm)')\n",
    "df2.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "<div class=\"alert alert-block alert-success\"><h2 style=\"text-align:center\">Dateframe - Sample 2</h2></div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films = {'Rank': [112,62,41,172,230,176],\n",
    "        'Release Year': [1973,1980,1960,2015,1976,1996],\n",
    "        'IMDB Rating': [8.3,8.4,8.5,8.1,8.1,8.1],\n",
    "        'Time (minutes)': [129,146,109,118,120,98],\n",
    "        'Main Genre': ['Comedy','Horror','Horror','Drama','Drama','Drama']}\n",
    "f_names = ['Sting','Shining', 'Psycho','Room','Rocky','Fargo']\n",
    "\n",
    "films_df =  MyDataFrame(films, index = f_names) \n",
    "films_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.sort_values('Release Year')\n",
    "films_df.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.sort_values('Release Year',reverse_val=True)\n",
    "films_df.print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "films_df.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}