exam.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e589a6e4",
   "metadata": {},
   "source": [
    "# Programming with Python Course Exam: NR Gilfillan"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56bec7a5",
   "metadata": {},
   "source": [
    "The following code has been written to fulfill the requirements for the course Assessment/Exam. Comments will be made inside the code as well as markdowns before specific sections of the code. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9da72dfb",
   "metadata": {},
   "source": [
    "The following section installs all of the required packages. This code was written on a Windows 10 computer. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6355399c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: pandas in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (1.3.2)\n",
      "Requirement already satisfied: python-dateutil>=2.7.3 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from pandas) (2.8.2)\n",
      "Requirement already satisfied: numpy>=1.17.3 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from pandas) (1.21.2)\n",
      "Requirement already satisfied: pytz>=2017.3 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from pandas) (2021.1)\n",
      "Requirement already satisfied: six>=1.5 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from python-dateutil>=2.7.3->pandas) (1.16.0)\n",
      "Requirement already satisfied: numpy in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (1.21.2)\n",
      "Requirement already satisfied: sqlalchemy in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (1.4.23)\n",
      "Requirement already satisfied: greenlet!=0.4.17 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from sqlalchemy) (1.1.1)\n",
      "Collecting matplotlib\n",
      "  Downloading matplotlib-3.4.3-cp39-cp39-win_amd64.whl (7.1 MB)\n",
      "Collecting pillow>=6.2.0\n",
      "  Downloading Pillow-8.3.1-1-cp39-cp39-win_amd64.whl (3.2 MB)\n",
      "Requirement already satisfied: python-dateutil>=2.7 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from matplotlib) (2.8.2)\n",
      "Collecting cycler>=0.10\n",
      "  Using cached cycler-0.10.0-py2.py3-none-any.whl (6.5 kB)\n",
      "Requirement already satisfied: pyparsing>=2.2.1 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from matplotlib) (2.4.7)\n",
      "Collecting kiwisolver>=1.0.1\n",
      "  Downloading kiwisolver-1.3.1-cp39-cp39-win_amd64.whl (51 kB)\n",
      "Requirement already satisfied: numpy>=1.16 in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from matplotlib) (1.21.2)\n",
      "Requirement already satisfied: six in c:\\users\\natha\\anaconda3\\envs\\exam\\lib\\site-packages (from cycler>=0.10->matplotlib) (1.16.0)\n",
      "Installing collected packages: pillow, kiwisolver, cycler, matplotlib\n",
      "Successfully installed cycler-0.10.0 kiwisolver-1.3.1 matplotlib-3.4.3 pillow-8.3.1\n"
     ]
    }
   ],
   "source": [
    "!pip install pandas\n",
    "!pip install numpy\n",
    "!pip install sqlalchemy\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "daf8f5d6",
   "metadata": {},
   "source": [
    "Setup/import the packages to be used"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "id": "269924e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "import sqlite3\n",
    "from sqlite3 import Error\n",
    "from sqlalchemy import create_engine"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d20f8340",
   "metadata": {},
   "source": [
    "The following section will set up the function and classes to be used in the project"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "41f91ef0",
   "metadata": {},
   "outputs": [],
   "source": [
    "#SQL create connection function\n",
    "def create_connection(db_file):\n",
    "    \"\"\" create a database connection to a SQLite database \"\"\"\n",
    "    conn = None\n",
    "    try:\n",
    "        conn = sqlite3.connect(db_file)\n",
    "        print(\"Successful connection/creation of SQL database, SQL version: \" + sqlite3.version)\n",
    "    except Error as e:\n",
    "        print(e)\n",
    "    finally:\n",
    "        if conn:\n",
    "            conn.close()\n",
    "\n",
    "#SQL create table function\n",
    "def create_table(db_file,tablename,colums):\n",
    "    \"\"\" create a database connection to a SQLite database \"\"\"\n",
    "    conn = None\n",
    "    try:\n",
    "        conn = sqlite3.connect(db_file)\n",
    "        sqlite_create_table_query = '''CREATE TABLE '''+ tablename +''' ( '''+ colums + ''' );'''\n",
    "        cursor = conn.cursor()\n",
    "        cursor.execute(sqlite_create_table_query)\n",
    "        conn.commit()\n",
    "        \n",
    "    except Error as e:\n",
    "        print(\"Was unable to perform operation on SQL database: \" + db_file + \" due to: \")\n",
    "        print(e)\n",
    "    finally:\n",
    "        if conn:\n",
    "            cursor.close()\n",
    "            conn.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9e45dbb",
   "metadata": {},
   "source": [
    "The following section loads the data from the csv files for analysis.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "id": "482306bc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     X   Y1   Y2   Y3   Y4\n",
      "0    1    2    2    2    2\n",
      "1    2    4    4    4    4\n",
      "2    3    6    6    6    6\n",
      "3    4    8    8    8    8\n",
      "4    5   10   10   10   10\n",
      "..  ..  ...  ...  ...  ...\n",
      "94  95  190  190  190  190\n",
      "95  96  192  192  192  192\n",
      "96  97  194  194  194  194\n",
      "97  98  196  196  196  196\n",
      "98  99  198  198  198  198\n",
      "\n",
      "[99 rows x 5 columns]\n",
      "     X    Y\n",
      "0    1    2\n",
      "1    2    4\n",
      "2    3    6\n",
      "3    4    8\n",
      "4    5   10\n",
      "..  ..  ...\n",
      "94  95  190\n",
      "95  96  192\n",
      "96  97  194\n",
      "97  98  196\n",
      "98  99  198\n",
      "\n",
      "[99 rows x 2 columns]\n",
      "     X   Y1   Y2   Y3   Y4\n",
      "0    1    2    2    2    2\n",
      "1    2    4    4    4    4\n",
      "2    3    6    6    6    6\n",
      "3    4    8    8    8    8\n",
      "4    5   10   10   10   10\n",
      "..  ..  ...  ...  ...  ...\n",
      "94  95  190  190  190  190\n",
      "95  96  192  192  192  192\n",
      "96  97  194  194  194  194\n",
      "97  98  196  196  196  196\n",
      "98  99  198  198  198  198\n",
      "\n",
      "[99 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "#load training datasets\n",
    "Training_dictionary = {}\n",
    "for number in range(1,5):\n",
    "    td = pd.read_csv ('Train' + str(number) +'.csv')\n",
    "    Training_dictionary[\"Set%s\" %number] = td.rename(columns={'Y': 'Y' + str(number)})\n",
    "\n",
    "#Combine training data into a single object\n",
    "for key in Test_dictionary.keys():\n",
    "    if key==\"Set1\":\n",
    "        Trainingdata=Training_dictionary[\"Set1\"]\n",
    "    else:\n",
    "        Trainingdata = pd.merge(Trainingdata,Training_dictionary[key], on=[\"X\"])\n",
    "print(Trainingdata)\n",
    "\n",
    "#load test datasets\n",
    "Testdata = pd.read_csv ('Test.csv')\n",
    "print(Testdata)\n",
    "\n",
    "#load ideal functions\n",
    "Ideal_dictionary = {}\n",
    "for number in range(1,5):\n",
    "    td = pd.read_csv ('Ideal' + str(number) +'.csv')\n",
    "    Ideal_dictionary[\"Set%s\" %number] = td.rename(columns={'Y': 'Y' + str(number)})\n",
    "\n",
    "    \n",
    "for key in Ideal_dictionary.keys():\n",
    "    if key==\"Set1\":\n",
    "        Idealdata=Ideal_dictionary[\"Set1\"]\n",
    "    else:\n",
    "        Idealdata = pd.merge(Idealdata,Ideal_dictionary[key], on=[\"X\"])\n",
    "print(Idealdata)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "e5a824b3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "     X   Y1\n",
      "0    1    2\n",
      "1    2    4\n",
      "2    3    6\n",
      "3    4    8\n",
      "4    5   10\n",
      "..  ..  ...\n",
      "94  95  190\n",
      "95  96  192\n",
      "96  97  194\n",
      "97  98  196\n",
      "98  99  198\n",
      "\n",
      "[99 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "Training_dictionary = Training_dictionary[\"Set1\"].rename(columns={'Y': 'Y' + str(1)})\n",
    "print(Training_dictionary)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba1526bd",
   "metadata": {},
   "source": [
    "Create SQLite Databases from the imported data sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "id": "771785e2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Successful connection/creation of SQL database, SQL version: 2.6.0\n",
      "Was unable to perform operation on SQL databaseexamsqlite.db due to: \n",
      "table Training_Data already exists\n",
      "Was unable to perform operation on SQL databaseexamsqlite.db due to: \n",
      "table Ideal_Functions already exists\n",
      "Was unable to perform operation on SQL databaseexamsqlite.db due to: \n",
      "table Test_data already exists\n"
     ]
    }
   ],
   "source": [
    "#Create SQL Database file\n",
    "create_connection(r\"examsqlite.db\")\n",
    "\n",
    "#insert training data Table into SQL Database - TABLENAME: Training_Data\n",
    "column_tocreate =\"X INTEGER UNIQUE PRIMARY KEY,Y1_training_func REAL NOT NULL,Y2_training_func REAL NOT NULL,Y3_training_func REAL NOT NULL,Y4_training_func REAL NOT NULL\"\n",
    "create_table(r\"examsqlite.db\",r\"Training_Data\",column_tocreate)\n",
    "\n",
    "#insert ideal functions data Table into SQL Database - TABLENAME: Ideal_Functions\n",
    "column_tocreate =\"X INTEGER UNIQUE PRIMARY KEY\"\n",
    "\n",
    "for number in range(1,51):\n",
    "    column_tocreate=column_tocreate + \",Y\" + str(number) + \" REAL NOT NULL\"\n",
    "create_table(r\"examsqlite.db\",r\"Ideal_Functions\",column_tocreate)\n",
    "\n",
    "#insert testing data Table into SQL Database - TABLENAME: Test\n",
    "column_tocreate =\"X INTEGER UNIQUE PRIMARY KEY,Y_test_function REAL NOT NULL,Delta_y_test_fucntion REAL NOT NULL,no_of_ideal_function REAL NOT NULL\"\n",
    "create_table(r\"examsqlite.db\",r\"Test_data\",column_tocreate)\n",
    "\n",
    "#Write data from the imported csv datafiles into the SQL Tables\n",
    "conn = sqlite3.connect(\"examsqlite.db\")\n",
    "Trainingdata.to_sql('Training_Data', con=conn, if_exists='replace')\n",
    "Idealdata.to_sql('Idealdata', con=conn, if_exists='replace')\n",
    "Testdata.to_sql('Test_data', con=conn, if_exists='replace')\n",
    "conn.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "eeafaafd",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Set1\n",
      "Set2\n",
      "Set3\n",
      "Set4\n",
      "     X   Y1   Y2   Y3   Y4\n",
      "0    1    2    2    2    2\n",
      "1    2    4    4    4    4\n",
      "2    3    6    6    6    6\n",
      "3    4    8    8    8    8\n",
      "4    5   10   10   10   10\n",
      "..  ..  ...  ...  ...  ...\n",
      "94  95  190  190  190  190\n",
      "95  96  192  192  192  192\n",
      "96  97  194  194  194  194\n",
      "97  98  196  196  196  196\n",
      "98  99  198  198  198  198\n",
      "\n",
      "[99 rows x 5 columns]\n"
     ]
    }
   ],
   "source": [
    "Testdata=[]\n",
    "#Testdata=Test_dictionary[\"Set1\"].iloc[:,0]\n",
    "#Testdata.array\n",
    "#for key in Test_dictionary.keys():\n",
    "#    print(key)\n",
    "#print(Testdata)\n",
    "\n",
    "for key in Test_dictionary.keys():\n",
    "    print(key)\n",
    "    if key==\"Set1\":\n",
    "        Testdata=Training_dictionary[\"Set1\"]\n",
    "    else:\n",
    "        Testdata = pd.merge(Testdata,Training_dictionary[key], on=[\"X\"])\n",
    "\n",
    "#Testdata = pd.concat(Training_dictionary, axis =1)\n",
    "#Testdata = pd.merge(Training_dictionary[\"Set1\"],Training_dictionary[\"Set2\"], on=[\"X\"])\n",
    "#print(Training_dictionary[\"Set1\"])\n",
    "print(Testdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "a49dc7a6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "      X    Y\n",
      "0     1    2\n",
      "1     2    4\n",
      "2     3    6\n",
      "3     4    8\n",
      "4     5   10\n",
      "..   ..  ...\n",
      "193  95  190\n",
      "194  96  192\n",
      "195  97  194\n",
      "196  98  196\n",
      "197  99  198\n",
      "\n",
      "[198 rows x 2 columns]\n"
     ]
    }
   ],
   "source": [
    "Testdata = pd.concat([Test_dictionary[\"Set1\"], Test_dictionary[\"Set2\"]], ignore_index=True)\n",
    "print(Testdata)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "9a06cb4a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   X  Y_test_function  Delta_y_test_fucntion  no_of_ideal_function\n",
      "0  1              2.0                    3.0                   4.0\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "conn = sqlite3.connect(r\"examsqlite.db\")\n",
    "df = pd.read_sql_query(\"SELECT * from Test\", conn)\n",
    "Test_dictionary\n",
    "surveys2002.to_sql(\"Test\", conn, if_exists=\"replace\")\n",
    "# Verify that result of SQL query is stored in the dataframe\n",
    "print(df.head())\n",
    "\n",
    "con.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8de00738",
   "metadata": {},
   "source": [
    "Analysis and run regressions on the training data against the "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "751aa0c6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "3878cd86",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0      1\n",
      "1      2\n",
      "2      3\n",
      "3      4\n",
      "4      5\n",
      "      ..\n",
      "94    95\n",
      "95    96\n",
      "96    97\n",
      "97    98\n",
      "98    99\n",
      "Name: X, Length: 99, dtype: int64\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "pandas.core.series.Series"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(Training_dictionary[\"Set1\"].iloc[:,0])\n",
    "type(Training_dictionary[\"Set1\"].iloc[:,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0e107afe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Test plot line\n",
    "plt.plot(Training_dictionary[\"Set1\"].iloc[:,0],Training_dictionary[\"Set1\"].iloc[:,1])\n",
    "plt.ylabel('some numbers')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "948917e0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Test plot scatter with line\n",
    "\n",
    "plt.plot(Training_dictionary[\"Set1\"].iloc[0:10,0],Training_dictionary[\"Set1\"].iloc[0:10,1],Training_dictionary[\"Set1\"].iloc[0:10,0],Training_dictionary[\"Set1\"].iloc[0:10,1],\"o\")\n",
    "plt.ylabel('some numbers')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9595ec3",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "exam",
   "language": "python",
   "name": "exam"
  },
  "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}