climate_analysis.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "from matplotlib import style\n",
    "style.use('fivethirtyeight')\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime as dt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Reflect Tables into SQLAlchemy ORM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python SQL toolkit and Object Relational Mapper\n",
    "import sqlalchemy\n",
    "from sqlalchemy.ext.automap import automap_base\n",
    "from sqlalchemy.orm import Session\n",
    "from sqlalchemy import create_engine, func"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up the abiity to query a SQLite database.\n",
    "engine = create_engine(\"sqlite:///hawaii.sqlite\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reflect an existing database into a new model\n",
    "# Transfer the contents of the database into a different structure of data.\n",
    "\n",
    "# Automap base creates a base class for an automap schema in SQLAlchemy - sets up a foundation for us to build on in SQLAlchemy\n",
    "Base = automap_base()\n",
    "\n",
    "# reflect the tables\n",
    "# Reflect the schema of the SQLite tables into our code and mappings.\n",
    "# When we reflect tables, we create classes that help keep code separate.\n",
    "# This ensures that our code is separated such that if other classes or \n",
    "# systems want to interact with it, they can interact with only \n",
    "# specific subsets of data instead of the whole dataset\n",
    "Base.prepare(engine, reflect=True)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['measurement', 'station']"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can view all of the classes that automap found\n",
    "# to confirm that the Automap was able to find all of the data in the SQLite database.\n",
    "# Reference the classes that were mapped in each database.\n",
    "# Base.classes = gives access to all the classes.\n",
    "# keys() references all the names of the classes.\n",
    "Base.classes.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save references to each table\n",
    "\n",
    "# Reference the measurement class.\n",
    "Measurement = Base.classes.measurement\n",
    "\n",
    "# Reference the station class.\n",
    "Station = Base.classes.station\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create our session (link) from Python to the DB - session allows query for data.\n",
    "session = Session(engine)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exploratory Climate Analysis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:xlabel='date'>"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Design a query to retrieve the last 12 months of precipitation data and plot the results. \n",
    "#Starting from the last data point in the database. \n",
    "prev_year = dt.date(2017, 8, 23)\n",
    "\n",
    "# Calculate the date one year from the last date in data set.\n",
    "prev_year = dt.date(2017, 8, 23) - dt.timedelta(days=365)\n",
    "\n",
    "# Perform a query to retrieve the data and precipitation scores and filter to the last 12 months.\n",
    "results = []\n",
    "\n",
    "results = session.query(Measurement.date, Measurement.prcp).filter(Measurement.date >= prev_year).all()\n",
    "\n",
    "# can also move all() to print(results.all())\n",
    "# print(results)\n",
    "\n",
    "# Save the query results as a Pandas DataFrame and set the index to the date column\n",
    "df = pd.DataFrame(results, columns=['date','precipitation'])\n",
    "df.set_index(df['date'], inplace=True)\n",
    "\n",
    "# Print without index because date shows up twice otherwise.\n",
    "# print(df.to_string(index=False))\n",
    "\n",
    "# Sort the dataframe by date\n",
    "df = df.sort_index()\n",
    "\n",
    "# Use Pandas Plotting with Matplotlib to plot the data\n",
    "df.plot()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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>precipitation</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>count</th>\n",
       "      <td>2021.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>mean</th>\n",
       "      <td>0.177279</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>std</th>\n",
       "      <td>0.461190</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>min</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25%</th>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50%</th>\n",
       "      <td>0.020000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>75%</th>\n",
       "      <td>0.130000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>max</th>\n",
       "      <td>6.700000</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "       precipitation\n",
       "count    2021.000000\n",
       "mean        0.177279\n",
       "std         0.461190\n",
       "min         0.000000\n",
       "25%         0.000000\n",
       "50%         0.020000\n",
       "75%         0.130000\n",
       "max         6.700000"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Use Pandas to calcualte the summary statistics for the precipitation data\n",
    "df.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(9,)]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How many stations are available in this dataset?\n",
    "session.query(func.count(Station.station)).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('USC00519281', 2772),\n",
       " ('USC00519397', 2724),\n",
       " ('USC00513117', 2709),\n",
       " ('USC00519523', 2669),\n",
       " ('USC00516128', 2612),\n",
       " ('USC00514830', 2202),\n",
       " ('USC00511918', 1979),\n",
       " ('USC00517948', 1372),\n",
       " ('USC00518838', 511)]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# What are the most active stations?\n",
    "# List the stations and the counts in descending order.\n",
    "session.query(Measurement.station, func.count(Measurement.station)).\\\n",
    "    group_by(Measurement.station).order_by(func.count(Measurement.station).desc()).all()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(54.0, 85.0, 71.66378066378067)]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using the station id from the previous query, calculate the lowest temperature recorded, \n",
    "# highest temperature recorded, and average temperature at the most active station.\n",
    "# tobs = temperature observations\n",
    "session.query(func.min(Measurement.tobs), func.max(Measurement.tobs), func.avg(Measurement.tobs)).\\\n",
    "    filter(Measurement.station == 'USC00519281').all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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>tobs</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>77.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>77.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>80.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>75.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>347</th>\n",
       "      <td>77.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>348</th>\n",
       "      <td>77.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>349</th>\n",
       "      <td>76.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>350</th>\n",
       "      <td>76.0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>351</th>\n",
       "      <td>79.0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>352 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     tobs\n",
       "0    77.0\n",
       "1    77.0\n",
       "2    80.0\n",
       "3    80.0\n",
       "4    75.0\n",
       "..    ...\n",
       "347  77.0\n",
       "348  77.0\n",
       "349  76.0\n",
       "350  76.0\n",
       "351  79.0\n",
       "\n",
       "[352 rows x 1 columns]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Choose the station with the highest number of temperature observations.\n",
    "# Query the last 12 months of temperature observation data for this station and plot the results as a histogram\n",
    "results = session.query(Measurement.tobs).\\\n",
    "            filter(Measurement.station == 'USC00519281').\\\n",
    "            filter(Measurement.date >= prev_year).all()\n",
    "\n",
    "# print(results)\n",
    "\n",
    "df = pd.DataFrame(results, columns=['tobs'])\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Divide temperature observations into 12 different bins and display data in a histogram.\n",
    "df.plot.hist(bins=12)\n",
    "\n",
    "# Compress the x-axis labels so that they fit into the box holding our plot.\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a function called `calc_temps` that will accept start date and end date in the format '%Y-%m-%d' \n",
    "# and return the minimum, average, and maximum temperatures for that range of dates\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Challenge"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "PythonData",
   "language": "python",
   "name": "pythondata"
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}