SQLAlchemy_Bonus_Submit.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlalchemy\n",
    "from sqlalchemy import create_engine, inspect, func\n",
    "from sqlalchemy.orm import Session\n",
    "from sqlalchemy.ext.automap import automap_base\n",
    "Base= automap_base()\n",
    "import pandas as pd\n",
    "import datetime as dt\n",
    "from dateutil.relativedelta import relativedelta\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib import style\n",
    "from scipy import stats"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "database_path='hawaii.sqlite'\n",
    "engine=create_engine(f'sqlite:///{database_path}')\n",
    "conn= engine.connect()\n",
    "Base.prepare(engine, reflect= True)\n",
    "Base.classes.keys()\n",
    "Measurement= Base.classes.measurement\n",
    "Station= Base.classes.station\n",
    "session=Session(engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Average temperature in June is [74.94411764705882] and in December is [71.04152933421226]\n"
     ]
    }
   ],
   "source": [
    "# Temperature Analysis I\n",
    "## Average temperature in June and Dec at all stations across all available years in the dataset\n",
    "june='06'\n",
    "dec='12'\n",
    "average_june=session.query(func.avg(Measurement.tobs)).\\\n",
    "            filter(func.strftime(\"%m\", Measurement.date) == june).all()\n",
    "average_dec=session.query(func.avg(Measurement.tobs)).\\\n",
    "            filter(func.strftime(\"%m\", Measurement.date) == dec).all()\n",
    "print(f'Average temperature in June is {list(np.ravel(average_june))} and in December is {list(np.ravel(average_dec))}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "t-statistics is 31.355036920962423.\n",
      "p-value is 4.193529835915756e-187.\n",
      "The difference in sample means is significant.\n"
     ]
    }
   ],
   "source": [
    "## Use the paired t-test to determine whether the difference in the means, if any, is statistically significant\n",
    "temp_june=session.query(Measurement.date,Measurement.tobs).\\\n",
    "            filter(func.strftime(\"%m\", Measurement.date) == june).all()\n",
    "temp_dec=session.query(Measurement.date, Measurement.tobs).\\\n",
    "            filter(func.strftime(\"%m\", Measurement.date) == dec).all()\n",
    "df_temp_june=pd.DataFrame(temp_june)\n",
    "df_temp_june['tobs']\n",
    "df_temp_dec=pd.DataFrame(temp_dec)\n",
    "df_temp_dec['tobs']\n",
    "(t_stat, p) = stats.ttest_ind(df_temp_june['tobs'], df_temp_dec['tobs'], equal_var=False)\n",
    "print(\"t-statistics is {}.\".format(t_stat))\n",
    "print(\"p-value is {}.\".format(p))\n",
    "if p < 0.05:\n",
    "    print(\"The difference in sample means is significant.\")\n",
    "else:\n",
    "    print(\"The difference in sample means is not significant.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[64.0, 72.02777777777777, 78.0]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Temperature Analysis II\n",
    "## Calculate min, avg, max temps for the trip from 02/28/2017 to 03/05/2017\n",
    "def calc_temps(start_date, end_date):\n",
    "    return session.query(func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs)).\\\n",
    "        filter(Measurement.date >= start_date).filter(Measurement.date <= end_date).all()\n",
    "my_start='2017-02-28'\n",
    "my_end='2017-03-05'\n",
    "my_trip_data = list(np.ravel(calc_temps(my_start, my_end)))\n",
    "my_trip_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPgAAAHECAYAAAAUHudpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAfVElEQVR4nO3dfVRUBf7H8c8gjDz5kDiwYUmt5fiU4IygaD8yU9TCEHfTdrfWjtGxfKA8dBI1M7UiXc3TqphUuutSmKKYlDxoknrSMscBlZxWzQ0w1CE1Q4gBnd8fHeY0DQ+jzTB3vn1e53T2zL13Zr6y8+beufOAymq1WkFEIvl4egAich8GTiQYAycSjIETCcbAiQRj4ESCMXAPWbVqFbRaLbRaLVauXNnqtpmZmbZtv/jiC5fcf9PtOfPftm3bWr2tyspKaLVaTJs2zSWztWT69OnQarWYMmWKW+9HEl9PD0BAUVERZs+e3eL6goICl9/nzJkz7S6fPXsWubm56NOnD0aNGmW3rm/fvq3eVufOnTFz5kzccccdrh7T5tKlS9i3bx8CAgLwxRdf4Ntvv0VERITb7k8KBu5hGo0G33zzDU6fPo1evXo5rK+oqEBZWRkCAwNRW1vrsvudNWuW3eUvvvgCubm56Nu3r8O6tnTu3PmGr3OjPvroIzQ0NGDatGlYvXo1cnJykJqa6tb7lICH6B7WtLcsLCxsdn1BQQF8fHwwYsSIdpxKeXJzcxEYGIjk5GTccsstyM3NRWNjo6fHUjwG7mExMTG45ZZbsGvXrmbXFxQUYPDgwejevbvd8ilTpkCr1eL06dMO19m9eze0Wi0yMzNdOqtWq8Xzzz+PzMxMREdHQ6/XY+3atc0+B286x3DixAm8+uqriI2NxaBBg/DYY4/h4MGDN3S/p06dQllZGYYMGYKAgADEx8fDbDajuLjYbrsLFy6gX79+mDx5crO3M2vWLGi1Wvzvf/+zLdu1axcmT56MQYMGYdiwYVi8eDFMJhO0Wi0yMjJuaE4lYuAe5uPjg1GjRuGrr75CRUWF3brKykocP34cY8eOdbheUlISACAvL89h3Y4dO+Dj44Px48e7fN6DBw/irbfeQmJiIkaMGIHIyMhWt58/fz62bduGMWPGYOzYsSgrK8OTTz7Z4hFLc3JzcwEA48aNAwDbv2vLli1224WGhiI2NhYlJSWorKy0W1dTU4O9e/di4MCBtnMFGzduxMyZM1FRUYHx48dj1KhR2LFjh9ufbrQnBq4AY8aMAQCHvXjT4XnT+l+Kj49HYGAgPv74Y7vlP/74Iz799FPExMTg1ltvdfms1dXVWLZsGV588UWsWLECw4YNa3X7M2fOYPPmzXj55ZeRnp6OTZs2wc/PD0uWLMFPP/3U5v1dv34deXl5CAgIsD2dGTx4MHr06IH9+/ejqqrKbvuHH34YAJCfn2+3fPfu3aivr7etr6qqwvLly9GjRw9s374dixcvxuLFi7Ft2zZcunTJ6Z+H0jFwBRg6dCi6dOmCoqIiu+UtHZ4DQGBgIMaOHYvy8nKUlpbaXae+vh4TJkxwy6xqtRr33Xef09v/5S9/sTt5qNVq8ec//xlmsxkHDhxo8/oHDhzA+fPnMXLkSAQFBQEAVCoVEhIScP36dWzdutVu+9GjRyMwMBA7d+60W75z5074+vriwQcftF2ur6/HM888g9DQUNt2PXv2FPUyHANXAD8/P4wcORIlJSU4f/48gJ9ftjp27JjtsLQ5TRH/8jB9x44dCAwMRHx8vFtmDQsLg5+fn9PbDxkyxGHZPffcAwD46quv2rx+0+F5QkKC3fKmPfHWrVtx/fp12/LAwEDbU56m59qXL1/GgQMHMHz4cISEhAAAjh49CgDNPsXQ6/VtzuUtGLhCjBkzBlarFbt37wbw8564Q4cOzR6eN4mJiUGPHj2Qn5+Pa9euoaqqCl9++SVGjRpl29u5mr+//w1tHxYW5rBMo9EA+Pl5cWtqampsP49nnnnG7s03Dz30EADgu+++w/79++2ul5iYCAC2py+FhYVoaGiw/VIAYDsMb+7oqLmZvRVfB1eI4cOHIzg4GEVFRfjb3/6GgoICREdH2/Y4zVGpVEhMTERGRgYOHToEk8kEq9XqtsPzm1FfX++w7McffwQA3HLLLa1et6CgAD/99BPuuece9OvXz2F9ZWUlPvvsM+Tk5Ng9bYiNjYVGo0F+fj5mzJiBjz/+GIGBgXjggQds2zT9AqypqUG3bt3sbretXzzehIErhFqtxogRI1BQUACTyYRjx45h4cKFbV5vwoQJyMjIwCeffIL//ve/CAsLQ2xsbDtM7Jxjx445HAYfOXIEADBw4MBWr7t9+3YAQFpaGgYPHuyw/uLFi4iLi8OePXtQXV1t2xt36NABCQkJ2LBhA4xGIw4fPozx48cjICDAdt0BAwZgz549KC0tRc+ePe1u12g03vg/VKF4iK4gY8aMQWNjIxYuXNji2fNfi4iIgE6nQ2FhIY4cOYLx48fDx0c5/7euX7/edl4BAMrKyrBlyxb07NkT0dHRLV6vsrIShw8fRo8ePVp8TtytWzeMGDECjY2NDu+XbzpMX7RoEa5du2Z3eN603s/PD2vXrsX3339vd7/r16+/4X+nUnEPriBxcXEIDAxESUkJYmNjHQ4dW5KUlIQFCxYAgKIOzwHgypUrmDBhAkaPHo36+noUFhZCpVIhPT0dvr4tP/y2b98Oq9WK8ePHQ6VStbjdn/70J+zatQs5OTl46qmnbNv27dsXvXv3xokTJ6DRaDB06FC7691222149tlnsXz5ciQmJmLkyJFobGzE7t270aFDBwCw/a83U86veoK/vz/i4uIAoNWz5782duxYqFQq9O/fH3fffbe7xrspc+fORXx8PAoKCrBnzx7ExsYiOzu72UPuX/rwww8BwGHP+2txcXEIDQ3Ft99+6/BJu6brJiQkNBvrU089haVLl0Kj0WD79u349NNPkZiYiBdffBHAjZ9QVCQreb1Dhw5Ze/fubd24caOnR7H55z//ae3du7c1Pz/f06M06/vvv7eazeZm133wwQfW3r17WwsLC9t5Ktfz2B7cYrEgISHB7s0Oly9fRkpKCnQ6HUaOHGl7DbSJyWTC5MmTERkZiYkTJ9pey/w9a2howFtvvQV/f3+3vDVVqoMHD2L48OEOn8W/evUqsrKy4OfnB51O56HpXMcjz8Hr6+uRmpqKkydP2i1PS0tDbW0tsrOzcezYMbz00ku2k0i1tbVITk7Ggw8+iNdeew2bNm3CtGnTsGvXLgQHB3vin+FRFRUVmDFjBsxmMy5evIinnnoKXbt29fRYXuO+++5DeHg41q1bh7KyMvTp0wdXr15FcXExqqqqMGfOnGZfI/c27R74qVOnkJqaCuuv/t5CeXk5iouLUVRUhIiICGi1WhiNRrz//vvQ6XTYuXMn/Pz8kJaWBh8fH8ybNw979+5Ffn4+Hnnkkfb+Z3icRqPBjz/+iJ9++gmTJ09GSkqKp0fyKsHBwfjggw/w7rvv4tNPP8WhQ4cQEBCAvn37YsGCBXavmXuzdg/88OHDGD58OGbNmoWoqCjb8tLSUmg0Grtv6dDr9baP7JWWlkKn09leAlKpVNDpdDAajb/LwP39/R0+Lqkks2bNUvynskJDQzF37lzMnTvX06O4TbsH/uijjza73Gw2273pHwBCQkJw7tw52/o777zTYb3JZHLPoEQCKOZ18Lq6OqjVartlarUaDQ0NsFqtLa63WCwOt2UwGNw6K5HStPRmIMUE3rFjR4dYLRYL/P39oVKpWl3fHEmfCCJqTWs7NMW80SUsLAzV1dV2y6qrq22fPAoLC4PZbG5xPRE5UkzgUVFROH/+vN1X7RgMBtsHFSIjI2E0Gm1n361WK4xGo92JOiKyp5jAb7/9dtx7772YM2cOTCYTtm7diry8PDz22GMAfn47Zm1tLZYsWYJTp04hPT0dNTU1tm/oICJHigkcAJYtW4ZOnTph0qRJWLNmDV555RUMGjQIwM+vW65btw5GoxFJSUk4cuQIMjMzf5dvciFylsr663ecCGAwGHiSjX43Wnu8K2oPTkSuxcCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBPP19ADk/VQqld1lq9XqoUno17gHJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwmmuMB/+OEHPP/884iJicH//d//Yfny5bh27RoA4PLly0hJSYFOp8PIkSORm5vr4WmJlE1x38m2aNEimM1mZGVl4eLFi3j++efRtWtXJCcnIy0tDbW1tcjOzsaxY8fw0ksvISIiAjqdztNjEymS4gLfu3cvli5dit69ewMAEhIS8PnnnyM+Ph7FxcUoKipCREQEtFotjEYj3n//fQZO1ALFHaJ37doVO3bsQF1dHc6fP4/9+/ejf//+KC0thUajQUREhG1bvV6PkpISD05LpGyKC3zhwoU4dOgQdDod4uLi0L17d8yaNQtmsxmhoaF224aEhODcuXMempRI+RQXeHl5Ofr164esrCxkZmbi7NmzWLp0Kerq6qBWq+22VavVaGho4PdwE7VAUc/By8vL8dprr2HPnj34wx/+AADo2LEjpk6diueeew4Wi8Vue4vFAn9/f4cv3gcAg8HQLjOTI/7slUNRgR8/fhxBQUG2uAFgwIABuHbtGiwWC6qrq+22r66uhkajafa29Hq9W2ellvFn375a+4WqqEP00NBQXLlyBVVVVbZlp0+fBgDExcXh/PnzqKystK0zGAyIjIxs9zmJvIWiAo+KikLfvn0xd+5cmEwmlJSUYMGCBUhMTMTAgQNx7733Ys6cOTCZTNi6dSvy8vLw2GOPeXpsIsVSVOC+vr5Yt24dunTpgilTpmDmzJmIiYnB4sWLAQDLli1Dp06dMGnSJKxZswavvPIKBg0a5OGpiZRLZRV4CtpgMPB5YDviXxf1rNYe74ragxORazFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEU9eeD21XxJk9PIBd/tq5z/6O/6ercgxMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgiku8IaGBqSnp2PIkCEYMmQIFi5cCIvFAgA4e/Yspk6diqioKIwbNw579+718LREyqa4wJctW4Zdu3YhIyMDa9euxf79+7FmzRpYrVZMnz4dXbt2RU5ODpKSkpCSkoKKigpPj0ykWL6eHuCXrly5guzsbKxbtw56vR4AMHPmTOzcuROff/45zpw5g/feew/BwcG46667cODAAeTk5GD27NkenpxImRS1BzcYDPD398ewYcNsyyZOnIh33nkHpaWl6NevH4KDg23r9Ho9SkpKPDEqkVdQVODl5eXo0aMHPvroIzz00EO4//77sXTpUlgsFpjNZoSGhtptHxISgnPnznloWiLlU9Qh+tWrV1FZWYmsrCwsWrQIV69exaJFi9DY2Ii6ujr4+fnZba9Wq9HQ0NDsbRkMhlbv69aq71w2N9n7jj9bl6lq43HcFkUF7uvri5qaGvzjH/9Az549AQAvvPACXnjhBSQlJaGmpsZue4vFAn9//2Zvq+k5fIuunHTJzOQo/NZwT48gRnhbj2O0vjNT1CF6aGgofH19bXEDwJ133on6+npoNBqYzWa77aurq6HRaNp7TCKvoajAo6Ki0NjYiK+//tq27PTp0wgKCkJUVBRMJhNqa2tt6wwGA6KiojwxKpFXUFTgd9xxBx544AHMnTsXx48fx+HDh7F8+XJMmjQJsbGxCA8PR1paGk6ePInMzEyUlpbikUce8fTYRIqlqMCBn9/ootVqMWXKFMyYMQOjR49GamoqOnTogIyMDFy8eBETJ07Ehx9+iNWrV+O2227z9MhEiqWok2wAEBwcjPT0dKSnpzusi4iIQFZWlgemIvJOituDE5HrKG4PTt7Huifb0yNQC7gHJxKMgRMJxsCJBGPgRIK1GHhFRYXtm1SIyDu1GHh8fDyOHz9ut+zgwYN2bxUlImVrMXCr1Wp3+dq1a5g6dSrOnDnj9qGIyDVu6Dn4r6MnImXjSTYiwRg4kWCtBq5SqZxaRkTK1Op70d966y1069bNdlmlUmHVqlXo2rWr3XYqlQqvvfaaeyYkopvWYuChoaEwmUwOy7766iuHbblXJ1KmFgPft29fe85BRG7Ak2xEgjFwIsEYOJFgDJxIMAZOJNgNfSdbTU0NSkpKcOXKFXTr1g1RUVEt/ukgIvI8pwK3Wq1YsWIFNm7ciIaGBtuHTgICAjBjxgwkJye7dUgiujlOBZ6RkYF3330Xjz76KMaOHYuQkBCYzWbk5+fjjTfeQOfOnTFp0iR3z0pEN8ipwHNycpCcnIzU1FTbsrvuuguxsbEICgrChg0bGDiRAjl1ku3SpUsYPHhws+uGDh2Kqqoqlw5FRK7hVOBDhw7FRx991Oy6ffv2ISYmxqVDEZFrOHWI/vDDD2PRokV48skn8fDDDyMsLAyXLl3Crl27UFhYiOeeew7bt2+3bT9hwgS3DUxEzlNZnfgepj59+jh/gyoVTpw48ZuG+q0MBgP0en3rGxVvap9hiH6L+x9tc5PWHu9O7cGLiopubCgiUgSnAu/Zs6e75yAiN3D6nWxFRUU4cuQIfvjhB4d1/EYXImVyKvCVK1di3bp1CAgIQKdOnRy+wYXf6EKkTE4FvnXrViQlJeHVV1+Fjw8/n0LkLZyqtba2FuPGjWPcRF7GqWLj4uJw6NAhd89CRC7m1CH6ggUL8Pjjj+PChQuIiopCYGCgwzZ8cwuR8jgVeHFxMb799lt888032LFjh8N6lUrFwIkUyKnA16xZA71ej5SUFISGhrp7JiJyEacCv3jxIl555ZUWP1FGRMrk1Em2yMhIfP311+6ehYhczKk9+PTp05GamopLly5Bp9MhKCjI4c0t0dHRbhmQiG6eU4E/8cQTAIC3334bgP0716xWqyI+QUZEjpwKfMOGDe6eg4jcwKnAY2Nj3T0HEbmB058mq6urQ3Z2Nj777DNcuHABK1euxP79+zFw4MC2v1yBiDzCqbPo1dXVmDhxIt544w388MMPOHXqFOrr63Hw4EE88cQTOHz4sLvnJKKb4FTgS5cuRX19PfLz87Fp0ybbHz5YvXo1oqKisGrVKrcOSUQ3x6nA9+3bh5SUFNx+++12Z9DVajWmTJnCM+hECuVU4PX19ejUqVPzN+Djg4aGBpcORUSu4VTg99xzD9577z1cv37dtqxpT75jxw4MGDDAPdMR0W/i1Fn0Z599Fk888QQSExMxYsQIqFQq5OXl4c0338Rnn32Gd999191zEtFNcGoPPnjwYGzYsAEBAQF45513YLVasWHDBly4cAFr167FkCFD3D0nEd0Ep18Hj46OxubNm1FbW4vLly+jU6dOLT4vJyJlaHEP/sADD6CsrMxheWBgIMLDwxk3kRdoMfCzZ8+ivr6+PWchIhfj16QSCdZq4PyDBkTerdWTbDNnzoSfn1+bN6JSqVBcXOyyoYjINVoNvH///ggJCWmvWYjIxVoN/Omnn4ZOp2uvWYjIxXiSjUgwBk4kWIuBJyUloXv37u05CxG5WIvPwdPT09tzDiJyAx6iEwnGwIkEY+BEgjFwIsEYOJFgig18/vz5ePzxx22XTSYTJk+ejMjISEycOBFHjx714HRE3kGRgR88eBA5OTm2y7W1tUhOTkZkZCS2bdsGvV6PadOmoaamxoNTEimf4gKvra3FggUL7N4Dv3PnTvj5+SEtLQ29evXCvHnz0KlTJ+Tn53twUiLlU1zgK1euRExMDGJiYmzLSktLodPp4OPz87gqlQo6nQ5Go9FTYxJ5BUUFbjQaUVBQgDlz5tgtN5vNCA0NtVsWEhKC8+fPt+d4RF7H6W9VdTeLxYL58+dj3rx56NKli926uro6qNVqu2VqtRoWi6XF2zMYDK3e361V3938sETtpKqNx3FbFBP4mjVrEBERgXHjxjms69ixo0PMFosF/v7+Ld5em3/S+MrJm5qTqD2FO/GnuVvbmSkm8Ly8PJjNZgwaNAgA0NDQgGvXrmHQoEFISEiA2Wy22766uhoajcYToxJ5DcUE/p///AeNjY22y//6179w/PhxLF++HF9++SXWrl0Lq9UKlUoFq9UKo9GI5ORkD05MpHyKCbxHjx52lzt37gx/f39EREQgJCQEK1aswJIlS/DXv/4VmzdvRk1NDR588EEPTUvkHRR1Fr0lwcHBWLduHYxGI5KSknDkyBFkZmYiODjY06MRKZpi9uC/Nnv2bLvLAwcORG5uroemIfJOXrEHJ6Kbw8CJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgigq8vLwcTz/9NKKjoxEXF4fXX38d9fX1AICzZ89i6tSpiIqKwrhx47B3714PT0ukfIoJ3GKx4Omnn4ZarcamTZuwfPly7N69GytXroTVasX06dPRtWtX5OTkICkpCSkpKaioqPD02ESK5uvpAZocPXoU5eXl2LJlC4KCgtCrVy88++yzeP3113HffffhzJkzeO+99xAcHIy77roLBw4cQE5ODmbPnu3p0YkUSzF78D/+8Y/IzMxEUFCQbZlKpYLFYkFpaSn69euH4OBg2zq9Xo+SkhJPjErkNRQTeLdu3TBs2DDb5evXryMrKwt6vR5msxmhoaF224eEhODcuXPtPSaRV1FM4L+Wnp6OEydOIDU1FXV1dfDz87Nbr1ar0dDQ4KHpiLyDYp6DN7FarXj11VeRnZ2NN998E3fffTc6duyImpoau+0sFgv8/f1bvB2DwdDq/dxa9Z1L5iVyp6o2HsdtUVTg169fx/z585GXl4eVK1di1KhRAICwsDCYTCa7baurq6HRaFq8Lb1e3/qdXTn5m+clcrfwth7HaH1npqhD9Ndffx15eXlYtWoV4uPjbcsjIyNhMplQW1trW2YwGBAVFeWJMYm8hmICLykpwb///W+kpKRgwIABMJvNtv9iYmIQHh6OtLQ0nDx5EpmZmSgtLcUjjzzi6bGJFE0xh+iFhYUAgBUrVmDFihV268rKypCRkYH58+dj4sSJ6NmzJ1avXo3bbrvNE6MSeQ2V1Wq1enoIVzMYDG0/By/e1D7DEP0W9z/a5iatPd4Vc4hORK7HwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwBk4kGAMnEoyBEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxKMgRMJxsCJBGPgRIIxcCLBGDiRYAycSDAGTiQYAycSjIETCcbAiQRj4ESCMXAiwRg4kWAMnEgwrwrcYrFgwYIFiI6OxvDhw/H22297eiQiRfP19AA3YtmyZTAajdiwYQPOnTuHF154AeHh4XjooYc8PRqRInnNHry2thabN2/GvHnzMGDAAIwaNQrJycnIysry9GhEiuU1gZtMJlgsFuj1etsyvV6PY8eOobGx0YOTESmX1wRuNpvRpUsXdOzY0base/fuaGhowMWLFz04GZFyec1z8Lq6OqjVartlTZctFovD9gaDofUb7Hy3y2Yjcpu2Hsdt8JrAO3bs6BBy0+WAgAC75b88jCf6PfOaQ/SwsDBcuXLFLnKz2Qy1Wo0uXbp4cDIi5fKawPv27Qs/Pz8YjUbbMoPBgP79+8PX12sORIjaldcEHhAQgAkTJmDRokU4evQoPvnkE6xfvx5///vfPT0akWKprFar1dNDOKuurg4vv/wyioqKEBQUhKlTp2Lq1KmeHotIsbwqcCK6MV5ziE5EN46BEwnGwIkEY+BEgjFwIsEYOJFgDJxIMAZOJBgDJxLs/wF9UocwUv0tfAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 216x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Plot min, avg, max temps for the trip from 02/28/2017 to 03/05/2017\n",
    "plt.figure(0)\n",
    "style.use('seaborn-whitegrid')\n",
    "ptp=my_trip_data[2]-my_trip_data[0]\n",
    "y=[my_trip_data[1]]\n",
    "x_axis = np.arange(len(y))\n",
    "plt.bar(x_axis, y, color='coral', alpha=0.50,yerr=ptp)\n",
    "plt.ylim(0,100)\n",
    "plt.ylabel(\"Temp F\")\n",
    "plt.title(\"My Trip Avg\")\n",
    "plt.xticks([], [])\n",
    "plt.rcParams[\"figure.figsize\"] = [3, 7]\n",
    "plt.savefig('myTripTemp.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('USC00519281',\n",
       "  'WAIHEE 837.5, HI US',\n",
       "  21.45167,\n",
       "  -157.84888999999998,\n",
       "  32.9,\n",
       "  4.720000000000001),\n",
       " ('USC00513117', 'KANEOHE 838.1, HI US', 21.4234, -157.8015, 14.6, 4.45),\n",
       " ('USC00516128',\n",
       "  'MANOA LYON ARBO 785.2, HI US',\n",
       "  21.3331,\n",
       "  -157.8025,\n",
       "  152.4,\n",
       "  4.07),\n",
       " ('USC00517948', 'PEARL CITY, HI US', 21.3934, -157.9751, 11.9, 2.98),\n",
       " ('USC00519397',\n",
       "  'WAIKIKI 717.2, HI US',\n",
       "  21.2716,\n",
       "  -157.8168,\n",
       "  3.0,\n",
       "  2.7399999999999998),\n",
       " ('USC00519523',\n",
       "  'WAIMANALO EXPERIMENTAL FARM, HI US',\n",
       "  21.33556,\n",
       "  -157.71139,\n",
       "  19.5,\n",
       "  2.32),\n",
       " ('USC00514830',\n",
       "  'KUALOA RANCH HEADQUARTERS 886.9, HI US',\n",
       "  21.5213,\n",
       "  -157.8374,\n",
       "  7.0,\n",
       "  1.1600000000000001)]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Daily Rainfall Average\n",
    "station_rain=[Station.station, Station.name, Station.latitude, Station.longitude, Station.elevation, func.sum(Measurement.prcp)]\n",
    "station_rainfall= session.query(*station_rain).\\\n",
    "    filter(Station.station==Measurement.station).\\\n",
    "    filter(Measurement.date>=my_start).\\\n",
    "    filter(Measurement.date<=my_end).\\\n",
    "    group_by(Measurement.station).\\\n",
    "    order_by(func.sum(Measurement.prcp).desc()).all()\n",
    "station_rainfall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[65.0, 70.65517241379311, 80.0],\n",
       " [67.0, 71.73333333333333, 79.0],\n",
       " [64.0, 70.0327868852459, 76.0],\n",
       " [61.0, 70.36666666666666, 78.0],\n",
       " [60.0, 70.06896551724138, 78.0],\n",
       " [57.0, 69.27272727272727, 77.0],\n",
       " [60.0, 67.89090909090909, 76.0]]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def daily_normals(date):\n",
    "    sel = [func.min(Measurement.tobs), func.avg(Measurement.tobs), func.max(Measurement.tobs)]\n",
    "    return session.query(*sel).filter(func.strftime(\"%m-%d\", Measurement.date) == date).all()\n",
    "date_list=[\"02-28\",\"02-29\",\"03-01\",\"03-02\",\"03-03\",\"03-04\",\"03-05\"]\n",
    "normal_list=[]\n",
    "for date in date_list:\n",
    "    x=daily_normals(date)\n",
    "    x_unzip=list(np.ravel(x))\n",
    "    normal_list.append(x_unzip)\n",
    "normal_list\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>tmin</th>\n",
       "      <th>tavg</th>\n",
       "      <th>tmax</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <td>2017-02-28</td>\n",
       "      <td>65.0</td>\n",
       "      <td>70.655172</td>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-01</td>\n",
       "      <td>67.0</td>\n",
       "      <td>71.733333</td>\n",
       "      <td>79.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-02</td>\n",
       "      <td>64.0</td>\n",
       "      <td>70.032787</td>\n",
       "      <td>76.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-03</td>\n",
       "      <td>61.0</td>\n",
       "      <td>70.366667</td>\n",
       "      <td>78.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-04</td>\n",
       "      <td>60.0</td>\n",
       "      <td>70.068966</td>\n",
       "      <td>78.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-05</td>\n",
       "      <td>57.0</td>\n",
       "      <td>69.272727</td>\n",
       "      <td>77.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <td>2017-03-06</td>\n",
       "      <td>60.0</td>\n",
       "      <td>67.890909</td>\n",
       "      <td>76.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            tmin       tavg  tmax\n",
       "date                             \n",
       "2017-02-28  65.0  70.655172  80.0\n",
       "2017-03-01  67.0  71.733333  79.0\n",
       "2017-03-02  64.0  70.032787  76.0\n",
       "2017-03-03  61.0  70.366667  78.0\n",
       "2017-03-04  60.0  70.068966  78.0\n",
       "2017-03-05  57.0  69.272727  77.0\n",
       "2017-03-06  60.0  67.890909  76.0"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_normal=pd.DataFrame(normal_list, columns=['tmin', 'tavg','tmax'])\n",
    "df_normal['date'] = pd.date_range(start='2/28/2017', periods=len(df_normal), freq='D')\n",
    "df_normal_final=df_normal.set_index('date')\n",
    "df_normal_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 504x360 with 0 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot daily normal for my trip from 02/28/2017 to 03/05/2017\n",
    "plt.figure(1)\n",
    "style.use('fivethirtyeight')\n",
    "df_normal_final.plot.area(stacked=False, alpha=0.18)\n",
    "plt.xlabel('date')\n",
    "plt.grid()\n",
    "plt.tight_layout()\n",
    "plt.rcParams[\"figure.figsize\"] = [7, 5]\n",
    "plt.savefig('myTripDailyNormal.png')\n",
    "plt.show()"
   ]
  },
  {
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}