From e4899d9d530320297dd2ee3f99f8a72e29e74449 Mon Sep 17 00:00:00 2001 From: Anna Sosnovske Date: Mon, 9 Feb 2026 13:43:16 -0700 Subject: [PATCH 1/5] Completed NumPy Module 4 Exercises --- Introduction-to-Python | 1 + NumPy/3. Inspect an Array.ipynb | 2 +- NumPy/4. Sampling Methods.ipynb | 61 ++++++++++++++++++++++++++++++++- 3 files changed, 62 insertions(+), 2 deletions(-) create mode 160000 Introduction-to-Python diff --git a/Introduction-to-Python b/Introduction-to-Python new file mode 160000 index 0000000..eda4e59 --- /dev/null +++ b/Introduction-to-Python @@ -0,0 +1 @@ +Subproject commit eda4e59af2fe84c073f3b35d84674b6cd9aa7a68 diff --git a/NumPy/3. Inspect an Array.ipynb b/NumPy/3. Inspect an Array.ipynb index 413d0a9..5722e9e 100644 --- a/NumPy/3. Inspect an Array.ipynb +++ b/NumPy/3. Inspect an Array.ipynb @@ -240,7 +240,7 @@ ], "metadata": { "kernelspec": { - "display_name": "p310env", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/NumPy/4. Sampling Methods.ipynb b/NumPy/4. Sampling Methods.ipynb index 0d19af7..c4db4cc 100644 --- a/NumPy/4. Sampling Methods.ipynb +++ b/NumPy/4. Sampling Methods.ipynb @@ -417,6 +417,65 @@ "Next [Module](./5.%20Math%20Functions.ipynb)" ] }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.77395605 0.43887844 0.85859792 0.69736803 0.09417735 0.97562235\n", + " 0.7611397 0.78606431 0.12811363 0.45038594 0.37079802 0.92676499\n", + " 0.64386512 0.82276161 0.4434142 0.22723872 0.55458479 0.06381726\n", + " 0.82763117 0.6316644 ]\n", + " [0.75808774 0.35452597 0.97069802 0.89312112 0.7783835 0.19463871\n", + " 0.466721 0.04380377 0.15428949 0.68304895 0.74476216 0.96750973\n", + " 0.32582536 0.37045971 0.46955581 0.18947136 0.12992151 0.47570493\n", + " 0.22690935 0.66981399]\n", + " [0.43715192 0.8326782 0.7002651 0.31236664 0.8322598 0.80476436\n", + " 0.38747838 0.2883281 0.6824955 0.13975248 0.1999082 0.00736227\n", + " 0.78692438 0.66485086 0.70516538 0.78072903 0.45891578 0.5687412\n", + " 0.139797 0.11453007]\n", + " [0.66840296 0.47109621 0.56523611 0.76499886 0.63471832 0.5535794\n", + " 0.55920716 0.3039501 0.03081783 0.43671739 0.21458467 0.40852864\n", + " 0.85340307 0.23393949 0.05830274 0.28138389 0.29359376 0.66191651\n", + " 0.55703215 0.78389821]\n", + " [0.66431354 0.40638686 0.81402038 0.16697292 0.02271207 0.09004786\n", + " 0.72235935 0.46187723 0.16127178 0.50104478 0.1523121 0.69632038\n", + " 0.44615628 0.38102123 0.30151209 0.63028259 0.36181261 0.08764992\n", + " 0.1180059 0.96189766]\n", + " [0.90858069 0.69970713 0.26586996 0.96917638 0.7787509 0.71689019\n", + " 0.4493615 0.27224156 0.09639096 0.9026024 0.45577629 0.20236336\n", + " 0.30595662 0.57921957 0.17677278 0.85661428 0.75851953 0.71946296\n", + " 0.43209304 0.62730884]\n", + " [0.58409797 0.6498466 0.08444432 0.4158074 0.04161417 0.49399082\n", + " 0.32986121 0.14452419 0.10340297 0.58764457 0.17059297 0.92512012\n", + " 0.58106114 0.3468698 0.59091549 0.02280387 0.95855921 0.48230344\n", + " 0.78273523 0.08273 ]\n", + " [0.48665833 0.49070699 0.93782645 0.57172805 0.4734894 0.26697566\n", + " 0.331569 0.5206724 0.43891146 0.02161208 0.82629192 0.89616077\n", + " 0.14024909 0.55403614 0.10857574 0.67224009 0.28123378 0.65942263\n", + " 0.72699461 0.76864749]\n", + " [0.10774095 0.91601185 0.23021399 0.03741256 0.55485247 0.37092228\n", + " 0.82978974 0.80825147 0.31713889 0.9528994 0.29091784 0.51505713\n", + " 0.25596509 0.93604357 0.16460782 0.04491062 0.43509706 0.99237556\n", + " 0.89167727 0.74860802]\n", + " [0.89079249 0.89344664 0.51885836 0.31592905 0.77201243 0.66166126\n", + " 0.37365773 0.09446667 0.74678961 0.26246052 0.93681315 0.24097058\n", + " 0.12275793 0.83111267 0.15328432 0.17926831 0.59938279 0.87456204\n", + " 0.19643467 0.31032367]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "rng = np.random.default_rng(42) # choose any integer seed\n", + "arr = rng.random((10, 20)) \n", + "print(arr)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -427,7 +486,7 @@ ], "metadata": { "kernelspec": { - "display_name": "p310env", + "display_name": "Python 3", "language": "python", "name": "python3" }, From f934a792f94b8cba89a791e1a91eae2cb21071c8 Mon Sep 17 00:00:00 2001 From: Anna Sosnovske Date: Mon, 9 Feb 2026 14:22:34 -0700 Subject: [PATCH 2/5] completed exercises --- Introduction-to-Python | 1 + NumPy/5. Math Functions.ipynb | 94 +++++++++++++++++++++++++++---- NumPy/7. Slicing & Indexing.ipynb | 2 +- 3 files changed, 86 insertions(+), 11 deletions(-) create mode 160000 Introduction-to-Python diff --git a/Introduction-to-Python b/Introduction-to-Python new file mode 160000 index 0000000..eda4e59 --- /dev/null +++ b/Introduction-to-Python @@ -0,0 +1 @@ +Subproject commit eda4e59af2fe84c073f3b35d84674b6cd9aa7a68 diff --git a/NumPy/5. Math Functions.ipynb b/NumPy/5. Math Functions.ipynb index 55b1106..7b9accd 100644 --- a/NumPy/5. Math Functions.ipynb +++ b/NumPy/5. Math Functions.ipynb @@ -854,10 +854,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[-0.5 0.91421356 1.5 0.91421356 -0.5 ]\n", + "[-0.34657359 -0.04484554 0.20273255 -0.04484554 -0.34657359]\n", + "[False False True False False]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "arr = np.array([0, np.pi/4, np.pi/2, 3*np.pi/4, np.pi]) \n", + "math = np.sin(arr) * 2 \n", + "math2 = math - 0.5\n", + "print(math2)\n", + "math3= np.abs(math2)\n", + "math4 = np.sqrt(math3)\n", + "math5= np.log(math4)\n", + "print(math5)\n", + "mask= math5 > 0\n", + "print(mask)\n", + "\n", + "\n" + ] }, { "cell_type": "markdown", @@ -884,10 +908,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[22.66 19.98 25.62 18.58]\n", + "[25.4 26.1 24.9 25.2 26.5]\n", + "[1 2 4 2]\n", + "8.3\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "temps = np.array([\n", + " [22.1, 23.5, 22.8, 21.9, 23.0],\n", + " [19.5, 20.1, 20.5, 19.8, 20.0],\n", + " [25.4, 26.1, 24.9, 25.2, 26.5],\n", + " [18.2, 18.5, 19.0, 18.8, 18.4]])\n", + "mean_axis1 = temps.mean(axis=1) \n", + "max_axis0 = temps.max(axis=0) \n", + "print(mean_axis1)\n", + "print(max_axis0)\n", + "outliers = np.argmax(temps, axis=1)\n", + "print(outliers)\n", + "range = temps.max() - temps.min()\n", + "print(range)" + ] }, { "cell_type": "markdown", @@ -913,10 +963,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[11.2 14.7 13.9 19.1 23.2 21.7 22.2]\n", + "14.5\n", + "[False False False True True True True]\n", + "4\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "inflow = np.array([1.2, 3.5, -.8, 5.2, 4.1, -1.5, 0.5])\n", + "initial = 10\n", + "result = initial + np.cumsum(inflow)\n", + "print(result)\n", + "volume = inflow[inflow > 0].sum()\n", + "print(volume)\n", + "flood = 18\n", + "mask = (initial + np.cumsum(inflow)) > flood\n", + "print(mask) \n", + "peak = np.argmax(result)\n", + "print(peak)" + ] }, { "cell_type": "markdown", @@ -928,7 +1002,7 @@ ], "metadata": { "kernelspec": { - "display_name": "p310env", + "display_name": "Python 3", "language": "python", "name": "python3" }, diff --git a/NumPy/7. Slicing & Indexing.ipynb b/NumPy/7. Slicing & Indexing.ipynb index 87c4019..a2c7877 100644 --- a/NumPy/7. Slicing & Indexing.ipynb +++ b/NumPy/7. Slicing & Indexing.ipynb @@ -619,7 +619,7 @@ ], "metadata": { "kernelspec": { - "display_name": "p310env", + "display_name": "Python 3", "language": "python", "name": "python3" }, From d0a673c5fd6a795083f33eb0533d8ab8e35a2abd Mon Sep 17 00:00:00 2001 From: Anna Sosnovske Date: Tue, 10 Feb 2026 10:27:00 -0700 Subject: [PATCH 3/5] Completed module 7 exercises --- NumPy/7. Slicing & Indexing.ipynb | 81 +++++++++++++++++++++++++++---- 1 file changed, 72 insertions(+), 9 deletions(-) diff --git a/NumPy/7. Slicing & Indexing.ipynb b/NumPy/7. Slicing & Indexing.ipynb index a2c7877..4cabead 100644 --- a/NumPy/7. Slicing & Indexing.ipynb +++ b/NumPy/7. Slicing & Indexing.ipynb @@ -540,10 +540,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "(24, 3)" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "arr1 = np.linspace(1.5,5.0,72)\n", + "arr = arr1.reshape(3,24)\n", + "arr2 = arr.transpose(1, 0)\n", + "arr2.shape" + ] }, { "cell_type": "markdown", @@ -571,10 +587,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "52\n", + "[[32 35 30]\n", + " [40 42 38]\n", + " [55 58 52]]\n", + "[28 35 48 58 68]\n" + ] + } + ], + "source": [ + "moisture_grid = np.array([\n", + " [32, 35, 30, 28, 25],\n", + " [40, 42, 38, 35, 30],\n", + " [55, 58, 52, 48, 42],\n", + " [60, 65, 62, 58, 55],\n", + " [70, 72, 70, 68, 65]\n", + "])\n", + "value = moisture_grid[2,2]\n", + "print(value)\n", + "subbasin = moisture_grid[0:3, 0:3]\n", + "print(subbasin)\n", + "column4 = moisture_grid[:, 3]\n", + "print(column4)" + ] }, { "cell_type": "markdown", @@ -597,10 +639,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0. 0. 0.4875 1.755 0.2028 0. 0.7371 1.2168 0. 0.0819]\n", + "[45. 31.2]\n", + "(array([0, 1, 5, 8]),)\n", + "[12.5 45. 18.9]\n" + ] + } + ], + "source": [ + "rain = np.array([0, 0, 12.5, 45.0, 5.2, 0, 18.9, 31.2, 0, 2.1])\n", + "inrain = rain * 0.039 \n", + "print(inrain)\n", + "heavy = rain[rain>20]\n", + "print(heavy)\n", + "norain= np.where(rain==0)\n", + "print(norain)\n", + "accurate=[2,3,6]\n", + "print(rain[accurate])" + ] }, { "cell_type": "markdown", From 7576afce9172a0fde81c22355e91d6b7b6510139 Mon Sep 17 00:00:00 2001 From: Anna Sosnovske Date: Tue, 10 Feb 2026 17:01:02 -0700 Subject: [PATCH 4/5] Worked through Pandas exercise 1 --- Pandas/PandasExercise1.ipynb | 659 ++++++++++++++++++++++++++++++++++- 1 file changed, 641 insertions(+), 18 deletions(-) diff --git a/Pandas/PandasExercise1.ipynb b/Pandas/PandasExercise1.ipynb index b13c275..e6bf53a 100644 --- a/Pandas/PandasExercise1.ipynb +++ b/Pandas/PandasExercise1.ipynb @@ -1,5 +1,31 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "8be1e28c", + "metadata": {}, + "source": [ + "The \"Broken\" Weather Station\n", + "Background: A mountain weather station has been offline for months and recently sent a burst of messy data. Before we can use the data and connect it to streamflow, it must be repaired and the Pandas toolkit can support this.\n", + "\n", + "Task 1: The Raw Feed\n", + "Load the .csv of rainfall values and convert into a Pandas DataFrame named Rainfall_mm. The data can be found here:\n", + "\n", + "data/snotel_rainfall_data.csv\n", + "\n", + "Check your work: Use .head() and .describe(). Does the data look right?" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "992a43f5", + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd" + ] + }, { "cell_type": "markdown", "id": "de778329", @@ -22,8 +48,247 @@ "execution_count": null, "id": "2e231547", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DatePrecip_in
count6158
unique6032
top2024-01-160.0
freq227
\n", + "
" + ], + "text/plain": [ + " Date Precip_in\n", + "count 61 58\n", + "unique 60 32\n", + "top 2024-01-16 0.0\n", + "freq 2 27" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Load rainfall data\n", + "Rainfall_mm = pd.read_csv(\"data/snotel_rainfall_data.csv\") # Load the dataset\n", + "\n", + "Rainfall_mm.head(3)\n", + "\n", + "Rainfall_mm.describe()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "91e5cd28", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DatePrecip_in
02024-01-010.14028030062619642
12024-01-020.6590180328421851
22024-01-030.0
32024-01-040.0
42024-01-050.3757291395473922
52024-01-060.0
62024-01-071.0954577625968716
72024-01-080.0
82024-01-090.0
92024-01-100.18657649912973773
102024-01-11NaN
112024-01-12NaN
122024-01-13NaN
132024-01-140.0
142024-01-150.3857564153298166
152024-01-160.0
162024-01-160.0
172024-01-173.3809706015167627
182024-01-180.0
192024-01-190.5326106545399638
\n", + "
" + ], + "text/plain": [ + " Date Precip_in\n", + "0 2024-01-01 0.14028030062619642\n", + "1 2024-01-02 0.6590180328421851\n", + "2 2024-01-03 0.0\n", + "3 2024-01-04 0.0\n", + "4 2024-01-05 0.3757291395473922\n", + "5 2024-01-06 0.0\n", + "6 2024-01-07 1.0954577625968716\n", + "7 2024-01-08 0.0\n", + "8 2024-01-09 0.0\n", + "9 2024-01-10 0.18657649912973773\n", + "10 2024-01-11 NaN\n", + "11 2024-01-12 NaN\n", + "12 2024-01-13 NaN\n", + "13 2024-01-14 0.0\n", + "14 2024-01-15 0.3857564153298166\n", + "15 2024-01-16 0.0\n", + "16 2024-01-16 0.0\n", + "17 2024-01-17 3.3809706015167627\n", + "18 2024-01-18 0.0\n", + "19 2024-01-19 0.5326106545399638" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Rainfall_mm.head(20)" + ] }, { "cell_type": "markdown", @@ -42,11 +307,95 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "id": "9c41bef2", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Precip_in
count54.000000
mean0.460056
std0.790430
min0.000000
25%0.000000
50%0.050563
75%0.641326
max3.609354
\n", + "
" + ], + "text/plain": [ + " Precip_in\n", + "count 54.000000\n", + "mean 0.460056\n", + "std 0.790430\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.050563\n", + "75% 0.641326\n", + "max 3.609354" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Rainfall_mm['Precip_in'] = pd.to_numeric(Rainfall_mm['Precip_in'], errors='coerce') \n", + "Rainfall_mm.describe()\n", + "# remove values greater than 20 and less than 0 from the Precip_in column\n", + "Rainfall_mm_cleaned = Rainfall_mm[(Rainfall_mm['Precip_in'] <= 20) & (Rainfall_mm['Precip_in'] >= 0)]\n", + "Rainfall_mm_cleaned.describe()" + ] }, { "cell_type": "markdown", @@ -64,11 +413,96 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "id": "4817f0f6", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Streamflow_cfs
count54.000000
mean40.058333
std369.096212
min-999.000000
25%10.100000
50%10.600000
75%13.900000
max2510.000000
\n", + "
" + ], + "text/plain": [ + " Streamflow_cfs\n", + "count 54.000000\n", + "mean 40.058333\n", + "std 369.096212\n", + "min -999.000000\n", + "25% 10.100000\n", + "50% 10.600000\n", + "75% 13.900000\n", + "max 2510.000000" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "streamflow_cfs = pd.read_csv(\"data/streamflow_data.csv\")\n", + "streamflow_cfs.describe()\n", + "streamflow_cfs.head(20)\n", + "streamflow_cfs['Streamflow_cfs'] = pd.to_numeric(streamflow_cfs['Streamflow_cfs'], errors='coerce') \n", + "streamflow_cfs.describe()\n", + "\n" + ] }, { "cell_type": "markdown", @@ -88,11 +522,96 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "id": "fb7eee2c", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/scratch/local/u1589214/845786/ipykernel_3279183/2806379309.py:12: FutureWarning: Series.interpolate with object dtype is deprecated and will raise in a future version. Call obj.infer_objects(copy=False) before interpolating instead.\n", + " streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].interpolate(method='linear')\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateStreamflow_cfs
count6053.0
unique6035.0
top2024-01-0110.0
freq18.0
\n", + "
" + ], + "text/plain": [ + " Date Streamflow_cfs\n", + "count 60 53.0\n", + "unique 60 35.0\n", + "top 2024-01-01 10.0\n", + "freq 1 8.0" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# remove NaN and -999 values from the Streamflow_cfs column\n", + "streamflow_cfs_cleaned = streamflow_cfs[(streamflow_cfs['Streamflow_cfs'] >= 0) & (streamflow_cfs['Streamflow_cfs'].notna())]\n", + "streamflow_cfs_cleaned.describe() \n", + "# create a data set replacing the removed values with the mean of the column\n", + "streamflow_cfs_filled = streamflow_cfs.copy()\n", + "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].replace(-999, streamflow_cfs_filled['Streamflow_cfs'].mean())\n", + "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].fillna(streamflow_cfs_filled['Streamflow_cfs'].mean())\n", + "streamflow_cfs_filled.describe() \n", + "# create a data set interpolating the removed values\n", + "streamflow_cfs_interpolated = streamflow_cfs.copy()\n", + "streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].replace(-999, pd.NA)\n", + "streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].interpolate(method='linear')\n", + "streamflow_cfs_interpolated.describe() \n" + ] }, { "cell_type": "markdown", @@ -108,11 +627,104 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 40, "id": "bd2fa519", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Precip_inStreamflow_cfs
count51.00000051.000000
mean0.45852161.533333
std0.806482349.729992
min0.00000010.000000
25%0.00000010.100000
50%0.00000010.700000
75%0.62363413.950000
max3.6093542510.000000
\n", + "
" + ], + "text/plain": [ + " Precip_in Streamflow_cfs\n", + "count 51.000000 51.000000\n", + "mean 0.458521 61.533333\n", + "std 0.806482 349.729992\n", + "min 0.000000 10.000000\n", + "25% 0.000000 10.100000\n", + "50% 0.000000 10.700000\n", + "75% 0.623634 13.950000\n", + "max 3.609354 2510.000000" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create merged dataset with the cleaned, filled, and interpolated streamflow data\n", + "merged_data = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_cleaned, on='Date', how='inner')\n", + "merged_data_filled = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_filled, on='Date', how='inner')\n", + "merged_data_interpolated = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_interpolated, on='Date', how='inner') \n", + "merged_data.describe()\n" + ] }, { "cell_type": "markdown", @@ -126,11 +738,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "id": "9c76bf67", "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Matplotlib is building the font cache; this may take a moment.\n" + ] + } + ], + "source": [ + "# plot the cleaned, filled, and interpolated streamflow data against the cleaned rainfall data\n", + "import matplotlib.pyplot as plt" + ] }, { "cell_type": "markdown", @@ -239,7 +862,7 @@ ], "metadata": { "kernelspec": { - "display_name": "p310env", + "display_name": "Python 3", "language": "python", "name": "python3" }, From d7c1e8b0ccb9dfec290ef26ca29b655bb95c198e Mon Sep 17 00:00:00 2001 From: Anna Sosnovske Date: Thu, 12 Feb 2026 17:06:55 -0700 Subject: [PATCH 5/5] more work on exercise --- Pandas/PandasExercise1.ipynb | 711 +++++++++++++++++++++++++++++------ 1 file changed, 586 insertions(+), 125 deletions(-) diff --git a/Pandas/PandasExercise1.ipynb b/Pandas/PandasExercise1.ipynb index e6bf53a..6970378 100644 --- a/Pandas/PandasExercise1.ipynb +++ b/Pandas/PandasExercise1.ipynb @@ -45,7 +45,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "2e231547", "metadata": {}, "outputs": [ @@ -107,7 +107,7 @@ "freq 2 27" ] }, - "execution_count": 15, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -123,7 +123,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 3, "id": "91e5cd28", "metadata": {}, "outputs": [ @@ -281,7 +281,7 @@ "19 2024-01-19 0.5326106545399638" ] }, - "execution_count": 16, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -307,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 58, "id": "9c41bef2", "metadata": {}, "outputs": [ @@ -332,59 +332,50 @@ " \n", " \n", " \n", + " Date\n", " Precip_in\n", " \n", " \n", " \n", " \n", - " count\n", - " 54.000000\n", - " \n", - " \n", - " mean\n", - " 0.460056\n", + " 0\n", + " 2024-01-01\n", + " 0.140280\n", " \n", " \n", - " std\n", - " 0.790430\n", + " 1\n", + " 2024-01-02\n", + " 0.659018\n", " \n", " \n", - " min\n", + " 2\n", + " 2024-01-03\n", " 0.000000\n", " \n", " \n", - " 25%\n", + " 3\n", + " 2024-01-04\n", " 0.000000\n", " \n", " \n", - " 50%\n", - " 0.050563\n", - " \n", - " \n", - " 75%\n", - " 0.641326\n", - " \n", - " \n", - " max\n", - " 3.609354\n", + " 4\n", + " 2024-01-05\n", + " 0.375729\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Precip_in\n", - "count 54.000000\n", - "mean 0.460056\n", - "std 0.790430\n", - "min 0.000000\n", - "25% 0.000000\n", - "50% 0.050563\n", - "75% 0.641326\n", - "max 3.609354" + " Date Precip_in\n", + "0 2024-01-01 0.140280\n", + "1 2024-01-02 0.659018\n", + "2 2024-01-03 0.000000\n", + "3 2024-01-04 0.000000\n", + "4 2024-01-05 0.375729" ] }, - "execution_count": 30, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -394,7 +385,33 @@ "Rainfall_mm.describe()\n", "# remove values greater than 20 and less than 0 from the Precip_in column\n", "Rainfall_mm_cleaned = Rainfall_mm[(Rainfall_mm['Precip_in'] <= 20) & (Rainfall_mm['Precip_in'] >= 0)]\n", - "Rainfall_mm_cleaned.describe()" + "Rainfall_mm_cleaned.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "68d1a32b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 10.25\n", + "1 10.70\n", + "2 13.30\n", + "3 10.10\n", + "4 10.00\n", + "Name: Streamflow_cfs, dtype: float64" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "streamflow_cfs.head() \n" ] }, { @@ -413,7 +430,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 61, "id": "4817f0f6", "metadata": {}, "outputs": [ @@ -490,17 +507,16 @@ "max 2510.000000" ] }, - "execution_count": 27, + "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "streamflow_cfs = pd.read_csv(\"data/streamflow_data.csv\")\n", - "streamflow_cfs.describe()\n", - "streamflow_cfs.head(20)\n", - "streamflow_cfs['Streamflow_cfs'] = pd.to_numeric(streamflow_cfs['Streamflow_cfs'], errors='coerce') \n", - "streamflow_cfs.describe()\n", + "streamflow = pd.read_csv(\"data/streamflow_data.csv\")\n", + "streamflow['Streamflow_cfs'] = pd.to_numeric(streamflow['Streamflow_cfs'], errors='coerce') \n", + "streamflow.describe()\n", + "\n", "\n" ] }, @@ -522,18 +538,10 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 62, "id": "fb7eee2c", "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/scratch/local/u1589214/845786/ipykernel_3279183/2806379309.py:12: FutureWarning: Series.interpolate with object dtype is deprecated and will raise in a future version. Call obj.infer_objects(copy=False) before interpolating instead.\n", - " streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].interpolate(method='linear')\n" - ] - }, { "data": { "text/html": [ @@ -555,80 +563,160 @@ " \n", " \n", " \n", - " Date\n", " Streamflow_cfs\n", " \n", " \n", " \n", " \n", " count\n", - " 60\n", - " 53.0\n", + " 53.000000\n", " \n", " \n", - " unique\n", - " 60\n", - " 35.0\n", + " mean\n", + " 59.663208\n", " \n", " \n", - " top\n", - " 2024-01-01\n", - " 10.0\n", + " std\n", + " 343.071082\n", " \n", " \n", - " freq\n", - " 1\n", - " 8.0\n", + " min\n", + " 10.000000\n", + " \n", + " \n", + " 25%\n", + " 10.100000\n", + " \n", + " \n", + " 50%\n", + " 10.700000\n", + " \n", + " \n", + " 75%\n", + " 13.950000\n", + " \n", + " \n", + " max\n", + " 2510.000000\n", " \n", " \n", "\n", "" ], "text/plain": [ - " Date Streamflow_cfs\n", - "count 60 53.0\n", - "unique 60 35.0\n", - "top 2024-01-01 10.0\n", - "freq 1 8.0" + " Streamflow_cfs\n", + "count 53.000000\n", + "mean 59.663208\n", + "std 343.071082\n", + "min 10.000000\n", + "25% 10.100000\n", + "50% 10.700000\n", + "75% 13.950000\n", + "max 2510.000000" ] }, - "execution_count": 39, + "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# remove NaN and -999 values from the Streamflow_cfs column\n", - "streamflow_cfs_cleaned = streamflow_cfs[(streamflow_cfs['Streamflow_cfs'] >= 0) & (streamflow_cfs['Streamflow_cfs'].notna())]\n", + "streamflow_cfs_cleaned = streamflow[streamflow['Streamflow_cfs'] >= 0]\n", + " # & (streamflow_cfs['Streamflow_cfs'].notna())]\n", "streamflow_cfs_cleaned.describe() \n", - "# create a data set replacing the removed values with the mean of the column\n", - "streamflow_cfs_filled = streamflow_cfs.copy()\n", - "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].replace(-999, streamflow_cfs_filled['Streamflow_cfs'].mean())\n", - "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].fillna(streamflow_cfs_filled['Streamflow_cfs'].mean())\n", - "streamflow_cfs_filled.describe() \n", - "# create a data set interpolating the removed values\n", - "streamflow_cfs_interpolated = streamflow_cfs.copy()\n", - "streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].replace(-999, pd.NA)\n", - "streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].interpolate(method='linear')\n", - "streamflow_cfs_interpolated.describe() \n" + " \n", + "\n", + "\n" ] }, { - "cell_type": "markdown", - "id": "502c3140", + "cell_type": "code", + "execution_count": 63, + "id": "97ca8838", "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
DateStreamflow_cfs
02024-01-0110.25
12024-01-0210.70
22024-01-0313.30
32024-01-0410.10
42024-01-0510.00
\n", + "
" + ], + "text/plain": [ + " Date Streamflow_cfs\n", + "0 2024-01-01 10.25\n", + "1 2024-01-02 10.70\n", + "2 2024-01-03 13.30\n", + "3 2024-01-04 10.10\n", + "4 2024-01-05 10.00" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "## Task 5: Join Pandas DataFrames\n", - "\n", - "We often want to relate data to another, and having all the data in once centralized data frame supports this comparison. Create a new Pandas DataFrame named:\n", - "* rainfall_methods fill it with the three rainfall dataframes we cleaned\n", - "* streamflow_methods and fill it with the three streamflow dataframes we cleaned\n" + "# create a data set replacing the removed values with the mean of the column\n", + "streamflow_cfs_filled = streamflow_cfs_cleaned.copy()\n", + "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].replace(-999, streamflow_cfs_filled['Streamflow_cfs'].mean())\n", + "streamflow_cfs_filled['Streamflow_cfs'] = streamflow_cfs_filled['Streamflow_cfs'].fillna(streamflow_cfs_filled['Streamflow_cfs'].mean())\n", + "streamflow_cfs_filled.head() " ] }, { "cell_type": "code", - "execution_count": 40, - "id": "bd2fa519", + "execution_count": 48, + "id": "b2d330e3", "metadata": {}, "outputs": [ { @@ -652,49 +740,40 @@ " \n", " \n", " \n", - " Precip_in\n", " Streamflow_cfs\n", " \n", " \n", " \n", " \n", " count\n", - " 51.000000\n", - " 51.000000\n", + " 53.000000\n", " \n", " \n", " mean\n", - " 0.458521\n", - " 61.533333\n", + " 59.663208\n", " \n", " \n", " std\n", - " 0.806482\n", - " 349.729992\n", + " 343.071082\n", " \n", " \n", " min\n", - " 0.000000\n", " 10.000000\n", " \n", " \n", " 25%\n", - " 0.000000\n", " 10.100000\n", " \n", " \n", " 50%\n", - " 0.000000\n", " 10.700000\n", " \n", " \n", " 75%\n", - " 0.623634\n", " 13.950000\n", " \n", " \n", " max\n", - " 3.609354\n", " 2510.000000\n", " \n", " \n", @@ -702,28 +781,366 @@ "" ], "text/plain": [ - " Precip_in Streamflow_cfs\n", - "count 51.000000 51.000000\n", - "mean 0.458521 61.533333\n", - "std 0.806482 349.729992\n", - "min 0.000000 10.000000\n", - "25% 0.000000 10.100000\n", - "50% 0.000000 10.700000\n", - "75% 0.623634 13.950000\n", - "max 3.609354 2510.000000" + " Streamflow_cfs\n", + "count 53.000000\n", + "mean 59.663208\n", + "std 343.071082\n", + "min 10.000000\n", + "25% 10.100000\n", + "50% 10.700000\n", + "75% 13.950000\n", + "max 2510.000000" ] }, - "execution_count": 40, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "# create merged dataset with the cleaned, filled, and interpolated streamflow data\n", - "merged_data = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_cleaned, on='Date', how='inner')\n", - "merged_data_filled = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_filled, on='Date', how='inner')\n", - "merged_data_interpolated = pd.merge(Rainfall_mm_cleaned, streamflow_cfs_interpolated, on='Date', how='inner') \n", - "merged_data.describe()\n" + "# create a data set replacing removed values with interpolated values for streamflow using .interpolate()\n", + "streamflow_cfs_interpolated = streamflow_cfs_cleaned.copy()\n", + "# replace -999 with NaN to prepare for interpolation \n", + "streamflow_cfs_interpolated['Streamflow_cfs'] = streamflow_cfs_interpolated['Streamflow_cfs'].fillna(streamflow_cfs_interpolated['Streamflow_cfs'].interpolate(method='linear')) \n", + "streamflow_cfs_interpolated.describe() " + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "507aa64c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Date Precip_in\n", + "15 2024-01-16 0.0\n", + "16 2024-01-16 0.0\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Precip_in
count54.000000
mean9.719315
std67.982160
min0.000000
25%0.000000
50%0.120703
75%0.730634
max500.000000
\n", + "
" + ], + "text/plain": [ + " Precip_in\n", + "count 54.000000\n", + "mean 9.719315\n", + "std 67.982160\n", + "min 0.000000\n", + "25% 0.000000\n", + "50% 0.120703\n", + "75% 0.730634\n", + "max 500.000000" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#remove NaN and -999 values from the precipitation data\n", + "Rainfall_mm_cleaned = Rainfall_mm[(Rainfall_mm['Precip_in'] >= 0) & (Rainfall_mm['Precip_in'].notna())]\n", + "Rainfall_mm_cleaned.describe() \n", + "# create a data set replacing the removed values with the mean of the column\n", + "Rainfall_mm_filled = Rainfall_mm_cleaned.copy()\n", + "Rainfall_mm_filled['Precip_in'] = Rainfall_mm_filled['Precip_in'].replace(-999, Rainfall_mm_filled['Precip_in'].mean())\n", + "Rainfall_mm_filled['Precip_in'] = Rainfall_mm_filled['Precip_in'].fillna(Rainfall_mm_filled['Precip_in'].mean())\n", + "Rainfall_mm_filled.describe() \n", + "# create a data set replacing the removed values with interpolated values\n", + "Rainfall_mm_interpolated = Rainfall_mm_cleaned.copy()\n", + "Rainfall_mm_interpolated['Precip_in'] = Rainfall_mm_interpolated['Precip_in'].fillna(Rainfall_mm_interpolated['Precip_in'].interpolate(method='linear')) \n", + "Rainfall_mm_interpolated.describe()\n", + "\n", + "# find and remove one duplicate date in the rainfall data\n", + "duplicate_dates = Rainfall_mm_interpolated[Rainfall_mm_interpolated.duplicated(subset='Date', keep=False)]\n", + "print(duplicate_dates)\n", + "Rainfall_mm_interpolated = Rainfall_mm_interpolated.drop_duplicates(subset='Date', keep='first')\n", + "Rainfall_mm_interpolated.describe() " + ] + }, + { + "cell_type": "markdown", + "id": "502c3140", + "metadata": {}, + "source": [ + "## Task 5: Join Pandas DataFrames\n", + "\n", + "We often want to relate data to another, and having all the data in once centralized data frame supports this comparison. Create a new Pandas DataFrame named:\n", + "* rainfall_methods fill it with the three rainfall dataframes we cleaned\n", + "* streamflow_methods and fill it with the three streamflow dataframes we cleaned\n" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "bd2fa519", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Streamflow_cfs_cleanedStreamflow_cfs_filledStreamflow_cfs_interpolated
Date
2024-01-0110.2510.2510.25
2024-01-0210.7010.7010.70
2024-01-0313.3013.3013.30
2024-01-0410.1010.1010.10
2024-01-0510.0010.0010.00
\n", + "
" + ], + "text/plain": [ + " Streamflow_cfs_cleaned Streamflow_cfs_filled \\\n", + "Date \n", + "2024-01-01 10.25 10.25 \n", + "2024-01-02 10.70 10.70 \n", + "2024-01-03 13.30 13.30 \n", + "2024-01-04 10.10 10.10 \n", + "2024-01-05 10.00 10.00 \n", + "\n", + " Streamflow_cfs_interpolated \n", + "Date \n", + "2024-01-01 10.25 \n", + "2024-01-02 10.70 \n", + "2024-01-03 13.30 \n", + "2024-01-04 10.10 \n", + "2024-01-05 10.00 " + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#create merged data set of streamflow_cfs cleaned, streamfall_cfs filled, and streamflow_cfs interpolated with date as the index\n", + "streamflow_methods = pd.DataFrame({\n", + " 'Streamflow_cfs_cleaned': streamflow_cfs_cleaned['Streamflow_cfs'],\n", + " 'Streamflow_cfs_filled': streamflow_cfs_filled['Streamflow_cfs'],\n", + " 'Streamflow_cfs_interpolated': streamflow_cfs_interpolated['Streamflow_cfs']\n", + "})\n", + "streamflow_methods.head() \n", + "# set date as the index\n", + "streamflow_methods.index = streamflow_cfs_cleaned['Date']\n", + "streamflow_methods.head()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "2898fd72", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Precip_in_cleanedPrecip_in_filledPrecip_in_interpolated
Date
2024-01-010.1402800.1402800.140280
2024-01-020.6590180.6590180.659018
2024-01-030.0000000.0000000.000000
2024-01-040.0000000.0000000.000000
2024-01-050.3757290.3757290.375729
\n", + "
" + ], + "text/plain": [ + " Precip_in_cleaned Precip_in_filled Precip_in_interpolated\n", + "Date \n", + "2024-01-01 0.140280 0.140280 0.140280\n", + "2024-01-02 0.659018 0.659018 0.659018\n", + "2024-01-03 0.000000 0.000000 0.000000\n", + "2024-01-04 0.000000 0.000000 0.000000\n", + "2024-01-05 0.375729 0.375729 0.375729" + ] + }, + "execution_count": 75, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# create a data set with the cleaned, filled, and interpolated rainfall data\n", + "rainfall_methods = pd.DataFrame({\n", + " 'Precip_in_cleaned': Rainfall_mm_cleaned['Precip_in'],\n", + " 'Precip_in_filled': Rainfall_mm_filled['Precip_in'],\n", + " 'Precip_in_interpolated': Rainfall_mm_interpolated['Precip_in']\n", + "})\n", + "rainfall_methods.head()\n", + "\n", + "# set date as the index\n", + "rainfall_methods.index = Rainfall_mm_cleaned['Date']\n", + "rainfall_methods.head()\n" ] }, { @@ -738,23 +1155,67 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 78, "id": "9c76bf67", "metadata": {}, "outputs": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "Matplotlib is building the font cache; this may take a moment.\n" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# plot the cleaned, filled, and interpolated streamflow data against the cleaned rainfall data\n", - "import matplotlib.pyplot as plt" + "# create a plot with df.plot() with the cleaned, filled, and interpolated precipitation data \n", + "rainfall_methods.plot(figsize=(10,6), title='Precipitation Data with Different Methods', ylabel='Precipitation (inches)', xlabel='Date')\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "id": "af9d20cf", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'Date'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3812\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3811\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 3812\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_engine\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcasted_key\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3813\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m err:\n", + "File \u001b[0;32mpandas/_libs/index.pyx:167\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mpandas/_libs/index.pyx:196\u001b[0m, in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7088\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "File \u001b[0;32mpandas/_libs/hashtable_class_helper.pxi:7096\u001b[0m, in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", + "\u001b[0;31mKeyError\u001b[0m: 'Date'", + "\nThe above exception was the direct cause of the following exception:\n", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[70], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# create a plot with x axis as date and y axis as rainfall data cleaned, filled and interpolated\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m plot \u001b[38;5;241m=\u001b[39m \u001b[43mrainfall_methods\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot\u001b[49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mDate\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43my\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPrecip_in_cleaned\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPrecip_in_filled\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mPrecip_in_interpolated\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfigsize\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m12\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m6\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m plot\u001b[38;5;241m.\u001b[39mset_xlabel(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mDate\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 4\u001b[0m plot\u001b[38;5;241m.\u001b[39mset_ylabel(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mPrecipitation (in)\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/plotting/_core.py:995\u001b[0m, in \u001b[0;36mPlotAccessor.__call__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m 993\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(x) \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m data\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39m_holds_integer():\n\u001b[1;32m 994\u001b[0m x \u001b[38;5;241m=\u001b[39m data_cols[x]\n\u001b[0;32m--> 995\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(\u001b[43mdata\u001b[49m\u001b[43m[\u001b[49m\u001b[43mx\u001b[49m\u001b[43m]\u001b[49m, ABCSeries):\n\u001b[1;32m 996\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mx must be a label or position\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 997\u001b[0m data \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39mset_index(x)\n", + "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/frame.py:4113\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 4111\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mcolumns\u001b[38;5;241m.\u001b[39mnlevels \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 4112\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_getitem_multilevel(key)\n\u001b[0;32m-> 4113\u001b[0m indexer \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcolumns\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_loc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mkey\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 4114\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m is_integer(indexer):\n\u001b[1;32m 4115\u001b[0m indexer \u001b[38;5;241m=\u001b[39m [indexer]\n", + "File \u001b[0;32m~/.conda/envs/p310env/lib/python3.10/site-packages/pandas/core/indexes/base.py:3819\u001b[0m, in \u001b[0;36mIndex.get_loc\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3814\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(casted_key, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;129;01mor\u001b[39;00m (\n\u001b[1;32m 3815\u001b[0m \u001b[38;5;28misinstance\u001b[39m(casted_key, abc\u001b[38;5;241m.\u001b[39mIterable)\n\u001b[1;32m 3816\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;28many\u001b[39m(\u001b[38;5;28misinstance\u001b[39m(x, \u001b[38;5;28mslice\u001b[39m) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m casted_key)\n\u001b[1;32m 3817\u001b[0m ):\n\u001b[1;32m 3818\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m InvalidIndexError(key)\n\u001b[0;32m-> 3819\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mKeyError\u001b[39;00m(key) \u001b[38;5;28;01mfrom\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01merr\u001b[39;00m\n\u001b[1;32m 3820\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m:\n\u001b[1;32m 3821\u001b[0m \u001b[38;5;66;03m# If we have a listlike key, _check_indexing_error will raise\u001b[39;00m\n\u001b[1;32m 3822\u001b[0m \u001b[38;5;66;03m# InvalidIndexError. Otherwise we fall through and re-raise\u001b[39;00m\n\u001b[1;32m 3823\u001b[0m \u001b[38;5;66;03m# the TypeError.\u001b[39;00m\n\u001b[1;32m 3824\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_indexing_error(key)\n", + "\u001b[0;31mKeyError\u001b[0m: 'Date'" + ] + } + ], + "source": [] + }, { "cell_type": "markdown", "id": "fe204f6e",