numpy/paphosWeatherSummerHottestJuly2023.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "from datetime import date\n",
    "from datetime import datetime\n",
    "import time\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def toDate(epoch_time):\n",
    "    return datetime.fromtimestamp(epoch_time)\n",
    "\n",
    "def calculate_heat_index(temperature, relative_humidity):\n",
    "    heat_index = int((-8.784695 +\n",
    "                  1.61139411 * temperature +\n",
    "                  (2.338549 * relative_humidity) +\n",
    "                  (-0.14611605 * temperature * relative_humidity) +\n",
    "                  (-0.01230809 * (temperature ** 2)) +\n",
    "                  (-0.01642482 * (relative_humidity ** 2)) +\n",
    "                  (0.00221173 * (temperature ** 2) * relative_humidity) +\n",
    "                  (0.00072546 * temperature * (relative_humidity ** 2)) +\n",
    "                  (-0.000003582 * (temperature ** 2) * (relative_humidity ** 2))))\n",
    "    return heat_index"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0       2013-07-31 03:00:00\n",
       "1       2013-07-31 04:00:00\n",
       "2       2013-07-31 05:00:00\n",
       "3       2013-07-31 06:00:00\n",
       "4       2013-07-31 07:00:00\n",
       "                ...        \n",
       "87667   2023-07-31 22:00:00\n",
       "87668   2023-07-31 23:00:00\n",
       "87669   2023-08-01 00:00:00\n",
       "87670   2023-08-01 01:00:00\n",
       "87671   2023-08-01 02:00:00\n",
       "Name: dt, Length: 87672, dtype: datetime64[ns]"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df=pd.read_json('/Users/walkerrowe/Documents/hypatia/paphosWeatherFiveYearsThroughJuly.json')\n",
    "\n",
    "df['dt'].map(toDate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/bk/np4nlklx4vs5wr6lym8k3w8w0000gn/T/ipykernel_92662/1587566322.py:16: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame.\n",
      "Try using .loc[row_indexer,col_indexer] = value instead\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  target['days over 31']=target['temp_max'].map(lambda l : 1 if l > 31 else 0)\n"
     ]
    }
   ],
   "source": [
    "df['month']=df['dt'].map(lambda l: toDate(l).strftime(\"%m\"))\n",
    "df['day']=df['dt'].map(lambda l: toDate(l).strftime(\"%d\"))\n",
    "df['year']=df['dt'].map(lambda l: toDate(l).strftime(\"%y\"))\n",
    "df['hour']=df['dt'].map(lambda l: toDate(l).strftime(\"%H\"))\n",
    " \n",
    "df['temp']=df[\"main\"].map(lambda x: int(x[\"temp\"]))\n",
    "df['temp_min']=df[\"main\"].map(lambda x: int(x[\"temp_min\"]) )\n",
    "df['temp_max']=df[\"main\"].map(lambda x: int(x[\"temp_max\"]) )\n",
    "df['humidity']=df[\"main\"].map(lambda x: int(x[\"humidity\"]))\n",
    "\n",
    "df['heatIndex'] = df.apply(lambda row: calculate_heat_index(row['temp'], row['humidity']), axis=1)\n",
    "#df.set_index(\"dt_iso\",inplace=True)\n",
    "\n",
    "target=df[['year','month','day', 'hour' ,'temp','temp_min','temp_max', 'humidity', 'heatIndex']]\n",
    "\n",
    "target['days over 31']=target['temp_max'].map(lambda l : 1 if l > 31 else 0)\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "july=target.loc[(target['month'] == '07') & (target['year'] != '13') & (target['hour']=='15')]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "july.set_index(['year','day'],inplace=True)\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "hot=july.loc[july['temp_max']>31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/bk/np4nlklx4vs5wr6lym8k3w8w0000gn/T/ipykernel_92662/2834321788.py:1: FutureWarning: The default value of numeric_only in DataFrameGroupBy.sum is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.\n",
      "  hottest=hot.groupby('year').sum()\n"
     ]
    }
   ],
   "source": [
    "hottest=hot.groupby('year').sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "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>days over 31</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>3</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>15</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>21</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      days over 31\n",
       "year              \n",
       "14               1\n",
       "15               1\n",
       "19               3\n",
       "16               6\n",
       "18               9\n",
       "17              15\n",
       "20              21\n",
       "21              21\n",
       "22              28\n",
       "23              28"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "over31=pd.DataFrame(hottest['days over 31'].sort_values())\n",
    "over31"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'Days over 31 Degrees in July')"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.bar(hottest['days over 31'].index, hottest['days over 31'].values)\n",
    "\n",
    "# Set labels and title\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Days over 31 Degrees')\n",
    "plt.title('Days over 31 Degrees in July')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    " july=target.loc[(target['month'] == '07') & (target['year'] != '13') & (target['hour']=='15')]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "july.set_index(['year','day'],inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/bk/np4nlklx4vs5wr6lym8k3w8w0000gn/T/ipykernel_92662/1903866960.py:1: SettingWithCopyWarning: \n",
      "A value is trying to be set on a copy of a slice from a DataFrame\n",
      "\n",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  july.drop('days over 31',axis=1,inplace=True)\n"
     ]
    }
   ],
   "source": [
    "july.drop('days over 31',axis=1,inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/bk/np4nlklx4vs5wr6lym8k3w8w0000gn/T/ipykernel_92662/807721493.py:1: FutureWarning: The default value of numeric_only in DataFrameGroupBy.mean is deprecated. In a future version, numeric_only will default to False. Either specify numeric_only or select only columns which should be valid for the function.\n",
      "  july.groupby(['year']).mean().astype(int).sort_values(by='temp')\n"
     ]
    },
    {
     "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>temp</th>\n",
       "      <th>temp_min</th>\n",
       "      <th>temp_max</th>\n",
       "      <th>humidity</th>\n",
       "      <th>heatIndex</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>year</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>27</td>\n",
       "      <td>24</td>\n",
       "      <td>29</td>\n",
       "      <td>71</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15</th>\n",
       "      <td>27</td>\n",
       "      <td>25</td>\n",
       "      <td>29</td>\n",
       "      <td>71</td>\n",
       "      <td>28</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>18</th>\n",
       "      <td>27</td>\n",
       "      <td>25</td>\n",
       "      <td>30</td>\n",
       "      <td>67</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>16</th>\n",
       "      <td>28</td>\n",
       "      <td>25</td>\n",
       "      <td>30</td>\n",
       "      <td>70</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>17</th>\n",
       "      <td>28</td>\n",
       "      <td>26</td>\n",
       "      <td>31</td>\n",
       "      <td>68</td>\n",
       "      <td>31</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>19</th>\n",
       "      <td>28</td>\n",
       "      <td>26</td>\n",
       "      <td>30</td>\n",
       "      <td>66</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>21</th>\n",
       "      <td>28</td>\n",
       "      <td>26</td>\n",
       "      <td>33</td>\n",
       "      <td>59</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>22</th>\n",
       "      <td>28</td>\n",
       "      <td>26</td>\n",
       "      <td>32</td>\n",
       "      <td>59</td>\n",
       "      <td>29</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20</th>\n",
       "      <td>29</td>\n",
       "      <td>29</td>\n",
       "      <td>32</td>\n",
       "      <td>65</td>\n",
       "      <td>32</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23</th>\n",
       "      <td>29</td>\n",
       "      <td>26</td>\n",
       "      <td>34</td>\n",
       "      <td>57</td>\n",
       "      <td>30</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      temp  temp_min  temp_max  humidity  heatIndex\n",
       "year                                               \n",
       "14      27        24        29        71         28\n",
       "15      27        25        29        71         28\n",
       "18      27        25        30        67         29\n",
       "16      28        25        30        70         31\n",
       "17      28        26        31        68         31\n",
       "19      28        26        30        66         30\n",
       "21      28        26        33        59         29\n",
       "22      28        26        32        59         29\n",
       "20      29        29        32        65         32\n",
       "23      29        26        34        57         30"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "july.groupby(['year']).mean().astype(int).sort_values(by='temp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}