From 77d280fe266624fcab39cc47cc73f72e0d22e31c Mon Sep 17 00:00:00 2001 From: ayanrobinsonar-cloud Date: Tue, 26 May 2026 19:58:37 -0400 Subject: [PATCH 1/9] testing updates for testing --- .idea/DataScienceGuidedCapstone.iml | 12 + .../inspectionProfiles/profiles_settings.xml | 6 + .idea/modules.xml | 8 + .idea/vcs.xml | 6 + .idea/workspace.xml | 69 + Notebooks/02_data_wrangling.ipynb | 1479 +++-------------- 6 files changed, 341 insertions(+), 1239 deletions(-) create mode 100644 .idea/DataScienceGuidedCapstone.iml create mode 100644 .idea/inspectionProfiles/profiles_settings.xml create mode 100644 .idea/modules.xml create mode 100644 .idea/vcs.xml create mode 100644 .idea/workspace.xml diff --git a/.idea/DataScienceGuidedCapstone.iml b/.idea/DataScienceGuidedCapstone.iml new file mode 100644 index 000000000..8b8c39547 --- /dev/null +++ b/.idea/DataScienceGuidedCapstone.iml @@ -0,0 +1,12 @@ + + + + + + + + + + \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 000000000..105ce2da2 --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 000000000..0d0d51796 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 000000000..35eb1ddfb --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml new file mode 100644 index 000000000..71a633ea4 --- /dev/null +++ b/.idea/workspace.xml @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + 1779231074418 + + + + + + \ No newline at end of file diff --git a/Notebooks/02_data_wrangling.ipynb b/Notebooks/02_data_wrangling.ipynb index a52eb6c24..7aa596fa2 100644 --- a/Notebooks/02_data_wrangling.ipynb +++ b/Notebooks/02_data_wrangling.ipynb @@ -120,19 +120,19 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 1#\n", "#Import pandas, matplotlib.pyplot, and seaborn in the correct lines below\n", - "import ___ as pd\n", - "import ___ as plt\n", - "import ___ as sns\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", "import os\n", "\n", "from library.sb_utils import save_file\n" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -162,13 +162,13 @@ }, { "cell_type": "code", - "execution_count": 2, "metadata": {}, - "outputs": [], "source": [ "# the supplied CSV data file is the raw_data directory\n", - "ski_data = pd.read_csv('../raw_data/ski_resort_data.csv')" - ] + "ski_data = pd.read_csv('/raw_data/ski_resort_data.csv')" + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -179,14 +179,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 2#\n", "#Call the info method on ski_data to see a summary of the data\n", - "ski_data.___" - ] + "ski_data.head" + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -204,16 +204,17 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [], "source": [ "#Code task 3#\n", "#Call the head method on ski_data to print the first several rows of the data\n", - "ski_data.___" - ] + "\n", + "ski_data.head(10)" + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -245,16 +246,16 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 4#\n", "#Filter the ski_data dataframe to display just the row for our resort with the name 'Big Mountain Resort'\n", "#Hint: you will find that the transpose of the row will give a nicer output. DataFrame's do have a\n", "#transpose method, but you can access this conveniently with the `T` property.\n", - "ski_data[ski_data.Name == ___].___" - ] + "ski_data[ski_data.Name == 'Big Mountain Resort'].T" + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -279,19 +280,19 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 5#\n", "#Count (using `.sum()`) the number of missing values (`.isnull()`) in each column of \n", "#ski_data as well as the percentages (using `.mean()` instead of `.sum()`).\n", "#Order them (increasing or decreasing) using sort_values\n", "#Call `pd.concat` to present these in a single table (DataFrame) with the helpful column names 'count' and '%'\n", - "missing = ___([ski_data.___.___, 100 * ski_data.___.___], axis=1)\n", + "missing = ski_data([ski_data.sum().isnull(), 100 * ski_data.mean().isnull()], axis=1)\n", "missing.columns=[___, ___]\n", "missing.___(by=___)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -316,14 +317,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 6#\n", "#Use ski_data's `select_dtypes` method to select columns of dtype 'object'\n", "ski_data.___(___)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -344,14 +345,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 7#\n", "#Use pandas' Series method `value_counts` to find any duplicated resort names\n", "ski_data['Name'].___.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -369,34 +370,39 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 8#\n", "#Concatenate the string columns 'Name' and 'Region' and count the values again (as above)\n", "(ski_data[___] + ', ' + ski_data[___]).___.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-26T22:57:20.471576Z", + "start_time": "2026-05-26T22:57:20.469944Z" + } + }, "source": [ "#Code task 9#\n", "#Concatenate 'Name' and 'state' and count the values again (as above)\n", "(ski_data[___] + ', ' + ski_data[___]).___.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "**NB** because you know `value_counts()` sorts descending, you can use the `head()` method and know the rest of the counts must be 1." - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -407,139 +413,12 @@ }, { "cell_type": "code", - "execution_count": 11, - "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", - "
NameRegionstatesummit_elevvertical_dropbase_elevtramsfastEightfastSixesfastQuads...LongestRun_miSkiableTerrain_acSnow Making_acdaysOpenLastYearyearsOpenaverageSnowfallAdultWeekdayAdultWeekendprojectedDaysOpenNightSkiing_ac
104Crystal MountainMichiganMichigan113237575700.001...0.3102.096.0120.063.0132.054.064.0135.056.0
295Crystal MountainWashingtonWashington7012310044001NaN22...2.52600.010.0NaN57.0486.099.099.0NaNNaN
\n", - "

2 rows × 27 columns

\n", - "
" - ], - "text/plain": [ - " Name Region state summit_elev vertical_drop \\\n", - "104 Crystal Mountain Michigan Michigan 1132 375 \n", - "295 Crystal Mountain Washington Washington 7012 3100 \n", - "\n", - " base_elev trams fastEight fastSixes fastQuads ... LongestRun_mi \\\n", - "104 757 0 0.0 0 1 ... 0.3 \n", - "295 4400 1 NaN 2 2 ... 2.5 \n", - "\n", - " SkiableTerrain_ac Snow Making_ac daysOpenLastYear yearsOpen \\\n", - "104 102.0 96.0 120.0 63.0 \n", - "295 2600.0 10.0 NaN 57.0 \n", - "\n", - " averageSnowfall AdultWeekday AdultWeekend projectedDaysOpen \\\n", - "104 132.0 54.0 64.0 135.0 \n", - "295 486.0 99.0 99.0 NaN \n", - "\n", - " NightSkiing_ac \n", - "104 56.0 \n", - "295 NaN \n", - "\n", - "[2 rows x 27 columns]" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "ski_data[ski_data['Name'] == 'Crystal Mountain']" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -571,14 +450,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 10#\n", "#Calculate the number of times Region does not equal state\n", "(ski_data.Region ___ ski_data.state).___" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -589,61 +468,12 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "New York 33\n", - "Michigan 29\n", - "Sierra Nevada 22\n", - "Colorado 22\n", - "Pennsylvania 19\n", - "Wisconsin 16\n", - "New Hampshire 16\n", - "Vermont 15\n", - "Minnesota 14\n", - "Montana 12\n", - "Idaho 12\n", - "Massachusetts 11\n", - "Washington 10\n", - "Maine 9\n", - "New Mexico 9\n", - "Wyoming 8\n", - "Utah 7\n", - "Oregon 6\n", - "Salt Lake City 6\n", - "North Carolina 6\n", - "Connecticut 5\n", - "Ohio 5\n", - "West Virginia 4\n", - "Virginia 4\n", - "Mt. Hood 4\n", - "Illinois 4\n", - "Alaska 3\n", - "Iowa 3\n", - "Missouri 2\n", - "Arizona 2\n", - "Indiana 2\n", - "South Dakota 2\n", - "New Jersey 2\n", - "Nevada 2\n", - "Rhode Island 1\n", - "Maryland 1\n", - "Tennessee 1\n", - "Northern California 1\n", - "Name: Region, dtype: int64" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "ski_data['Region'].value_counts()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -654,9 +484,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 11#\n", "#Filter the ski_data dataframe for rows where 'Region' and 'state' are different,\n", @@ -664,7 +492,9 @@ "(ski_data[ski_data.___ ___ ski_data.___]\n", " .groupby(___)[___]\n", " .value_counts())" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -682,15 +512,15 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 12#\n", "#Select the 'Region' and 'state' columns from ski_data and use the `nunique` method to calculate\n", "#the number of unique values in each\n", "ski_data[[___, ___]].___" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -715,9 +545,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 13#\n", "#Create two subplots on 1 row and 2 columns with a figsize of (12, 8)\n", @@ -739,7 +567,9 @@ "#You're encouraged to explore a few different figure sizes, orientations, and spacing here\n", "# as the importance of easy-to-read and informative figures is frequently understated\n", "# and you will find the ability to tweak figures invaluable later on" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -771,35 +601,20 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 14#\n", "# Calculate average weekday and weekend price by state and sort by the average of the two\n", "# Hint: use the pattern dataframe.groupby()[].mean()\n", "state_price_means = ski_data.___(___)[[___, ___]].mean()\n", "state_price_means.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 18, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "# The next bit simply reorders the index by increasing average of weekday and weekend prices\n", "# Compare the index order you get from\n", @@ -812,16 +627,18 @@ " .index)\n", " .plot(kind='barh', figsize=(10, 10), title='Average ticket price by State'))\n", "plt.xlabel('Price ($)');" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "The figure above represents a dataframe with two columns, one for the average prices of each kind of ticket. This tells you how the average ticket price varies from state to state. But can you get more insight into the difference in the distributions between states?" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -839,9 +656,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 15#\n", "#Use the pd.melt function, pass in the ski_data columns 'state', 'AdultWeekday', and 'Adultweekend' only,\n", @@ -854,91 +669,18 @@ " var_name=___, \n", " value_vars=[___, ___], \n", " value_name=___)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 20, - "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", - "
stateTicketPrice
0AlaskaAdultWeekday65.0
1AlaskaAdultWeekday47.0
2AlaskaAdultWeekday30.0
3ArizonaAdultWeekday89.0
4ArizonaAdultWeekday74.0
\n", - "
" - ], - "text/plain": [ - " state Ticket Price\n", - "0 Alaska AdultWeekday 65.0\n", - "1 Alaska AdultWeekday 47.0\n", - "2 Alaska AdultWeekday 30.0\n", - "3 Arizona AdultWeekday 89.0\n", - "4 Arizona AdultWeekday 74.0" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "ticket_prices.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -949,9 +691,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 16#\n", "#Create a seaborn boxplot of the ticket price dataframe we created above,\n", @@ -962,7 +702,9 @@ "plt.xticks(rotation='vertical')\n", "plt.ylabel('Price ($)')\n", "plt.xlabel('State');" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -996,12 +738,12 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "Having decided to reserve judgement on how exactly you utilize the State, turn your attention to cleaning the numeric features." - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1012,16 +754,16 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 17#\n", "#Call ski_data's `describe` method for a statistical summary of the numerical columns\n", "#Hint: there are fewer summary stat columns than features, so displaying the transpose\n", "#will be useful again\n", "ski_data.___.___" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1032,27 +774,13 @@ }, { "cell_type": "code", - "execution_count": 23, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 82.424242\n", - "2 14.242424\n", - "1 3.333333\n", - "dtype: float64" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "missing_price = ski_data[['AdultWeekend', 'AdultWeekday']].isnull().sum(axis=1)\n", "missing_price.value_counts()/len(missing_price) * 100" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1077,9 +805,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 18#\n", "#Call ski_data's `hist` method to plot histograms of each of the numeric features\n", @@ -1089,7 +815,9 @@ "ski_data.___(___)\n", "#plt.subplots_adjust(hspace=___);\n", "#Hint: notice how the terminating ';' \"swallows\" some messy output and leads to a tidier notebook" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1114,14 +842,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 19#\n", "#Filter the 'SkiableTerrain_ac' column to print the values greater than 10000\n", "ski_data.___[ski_data.___ > ___]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1132,15 +860,15 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 20#\n", "#Now you know there's only one, print the whole row to investigate all values, including seeing the resort name\n", "#Hint: don't forget the transpose will be helpful here\n", "ski_data[ski_data.___ > ___].___" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1179,36 +907,36 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 21#\n", "#Use the .loc accessor to print the 'SkiableTerrain_ac' value only for this resort\n", "ski_data.___[39, 'SkiableTerrain_ac']" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 22#\n", "#Use the .loc accessor again to modify this value with the correct value of 1819\n", "ski_data.___[39, 'SkiableTerrain_ac'] = ___" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 23#\n", "#Use the .loc accessor a final time to verify that the value has been modified\n", "ski_data.___[39, 'SkiableTerrain_ac']" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1226,28 +954,15 @@ }, { "cell_type": "code", - "execution_count": 30, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "ski_data.SkiableTerrain_ac.hist(bins=30)\n", "plt.xlabel('SkiableTerrain_ac')\n", "plt.ylabel('Count')\n", "plt.title('Distribution of skiable area (acres) after replacing erroneous value');" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1265,207 +980,21 @@ }, { "cell_type": "code", - "execution_count": 31, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "11 3379.0\n", - "18 1500.0\n", - "Name: Snow Making_ac, dtype: float64" - ] - }, - "execution_count": 31, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ski_data['Snow Making_ac'][ski_data['Snow Making_ac'] > 1000]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 32, - "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", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
11
NameHeavenly Mountain Resort
RegionSierra Nevada
stateCalifornia
summit_elev10067
vertical_drop3500
base_elev7170
trams2
fastEight0
fastSixes2
fastQuads7
quad1
triple5
double3
surface8
total_chairs28
Runs97
TerrainParks3
LongestRun_mi5.5
SkiableTerrain_ac4800
Snow Making_ac3379
daysOpenLastYear155
yearsOpen64
averageSnowfall360
AdultWeekdayNaN
AdultWeekendNaN
projectedDaysOpen157
NightSkiing_acNaN
\n", - "
" - ], - "text/plain": [ - " 11\n", - "Name Heavenly Mountain Resort\n", - "Region Sierra Nevada\n", - "state California\n", - "summit_elev 10067\n", - "vertical_drop 3500\n", - "base_elev 7170\n", - "trams 2\n", - "fastEight 0\n", - "fastSixes 2\n", - "fastQuads 7\n", - "quad 1\n", - "triple 5\n", - "double 3\n", - "surface 8\n", - "total_chairs 28\n", - "Runs 97\n", - "TerrainParks 3\n", - "LongestRun_mi 5.5\n", - "SkiableTerrain_ac 4800\n", - "Snow Making_ac 3379\n", - "daysOpenLastYear 155\n", - "yearsOpen 64\n", - "averageSnowfall 360\n", - "AdultWeekday NaN\n", - "AdultWeekend NaN\n", - "projectedDaysOpen 157\n", - "NightSkiing_ac NaN" - ] - }, - "execution_count": 32, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "ski_data[ski_data['Snow Making_ac'] > 3000].T" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1483,23 +1012,12 @@ }, { "cell_type": "code", - "execution_count": 33, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2880.0" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ ".6 * 4800" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1524,25 +1042,12 @@ }, { "cell_type": "code", - "execution_count": 34, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0 163\n", - "1.0 1\n", - "Name: fastEight, dtype: int64" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ski_data.fastEight.value_counts()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1553,14 +1058,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 24#\n", "#Drop the 'fastEight' column from ski_data. Use inplace=True\n", "ski_data.drop(columns=___, inplace=___)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1571,14 +1076,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 25#\n", "#Filter the 'yearsOpen' column for values greater than 100\n", "ski_data.___[ski_data.___ > ___]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1596,9 +1101,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 26#\n", "#Call the hist method on 'yearsOpen' after filtering for values under 1000\n", @@ -1607,7 +1110,9 @@ "plt.xlabel('Years open')\n", "plt.ylabel('Count')\n", "plt.title('Distribution of years open excluding 2019');" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1625,31 +1130,12 @@ }, { "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "count 328.000000\n", - "mean 57.695122\n", - "std 16.841182\n", - "min 6.000000\n", - "25% 50.000000\n", - "50% 58.000000\n", - "75% 68.250000\n", - "max 104.000000\n", - "Name: yearsOpen, dtype: float64" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "ski_data.yearsOpen[ski_data.yearsOpen < 1000].describe()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1660,12 +1146,12 @@ }, { "cell_type": "code", - "execution_count": 39, "metadata": {}, - "outputs": [], "source": [ "ski_data = ski_data[ski_data.yearsOpen < 1000]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1720,9 +1206,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 27#\n", "#Add named aggregations for the sum of 'daysOpenLastYear', 'TerrainParks', and 'NightSkiing_ac'\n", @@ -1738,7 +1222,9 @@ " ___=pd.NamedAgg(column=___, aggfunc=___)\n", ").___\n", "state_summary.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1756,27 +1242,13 @@ }, { "cell_type": "code", - "execution_count": 41, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 82.317073\n", - "2 14.329268\n", - "1 3.353659\n", - "dtype: float64" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "missing_price = ski_data[['AdultWeekend', 'AdultWeekday']].isnull().sum(axis=1)\n", "missing_price.value_counts()/len(missing_price) * 100" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1787,14 +1259,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 28#\n", "#Use `missing_price` to remove rows from ski_data where both price values are missing\n", "ski_data = ski_data[___ != 2]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1805,26 +1277,13 @@ }, { "cell_type": "code", - "execution_count": 43, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], "source": [ "ski_data.hist(figsize=(15, 10))\n", "plt.subplots_adjust(hspace=0.5);" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -1849,228 +1308,43 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 29#\n", "#Use pandas' `read_html` method to read the table from the URL below\n", "states_url = 'https://simple.wikipedia.org/w/index.php?title=List_of_U.S._states&oldid=7168473'\n", "usa_states = pd.___(___)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 45, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "list" - ] - }, - "execution_count": 45, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "type(usa_states)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 46, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "1" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "len(usa_states)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 47, - "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", - " \n", - " \n", - "
Name &postal abbs. [1]CitiesEstablished[upper-alpha 1]Population[upper-alpha 2][3]Total area[4]Land area[4]Water area[4]Numberof Reps.
Name &postal abbs. [1]Name &postal abbs. [1].1CapitalLargest[5]Established[upper-alpha 1]Population[upper-alpha 2][3]mi2km2mi2km2mi2km2Numberof Reps.
0AlabamaALMontgomeryBirminghamDec 14, 181949031855242013576750645131171177545977
1AlaskaAKJuneauAnchorageJan 3, 195973154566538417233375706411477953947432453841
2ArizonaAZPhoenixPhoenixFeb 14, 1912727871711399029523411359429420739610269
3ArkansasARLittle RockLittle RockJun 15, 183630178045317913773252035134771114329614
4CaliforniaCASacramentoLos AngelesSep 9, 18503951222316369542396715577940346679162050153
\n", - "
" - ], - "text/plain": [ - " Name &postal abbs. [1] Cities \\\n", - " Name &postal abbs. [1] Name &postal abbs. [1].1 Capital Largest[5] \n", - "0 Alabama AL Montgomery Birmingham \n", - "1 Alaska AK Juneau Anchorage \n", - "2 Arizona AZ Phoenix Phoenix \n", - "3 Arkansas AR Little Rock Little Rock \n", - "4 California CA Sacramento Los Angeles \n", - "\n", - " Established[upper-alpha 1] Population[upper-alpha 2][3] Total area[4] \\\n", - " Established[upper-alpha 1] Population[upper-alpha 2][3] mi2 \n", - "0 Dec 14, 1819 4903185 52420 \n", - "1 Jan 3, 1959 731545 665384 \n", - "2 Feb 14, 1912 7278717 113990 \n", - "3 Jun 15, 1836 3017804 53179 \n", - "4 Sep 9, 1850 39512223 163695 \n", - "\n", - " Land area[4] Water area[4] Numberof Reps. \n", - " km2 mi2 km2 mi2 km2 Numberof Reps. \n", - "0 135767 50645 131171 1775 4597 7 \n", - "1 1723337 570641 1477953 94743 245384 1 \n", - "2 295234 113594 294207 396 1026 9 \n", - "3 137732 52035 134771 1143 2961 4 \n", - "4 423967 155779 403466 7916 20501 53 " - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "usa_states = usa_states[0]\n", "usa_states.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2081,85 +1355,24 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 30#\n", "#Use the iloc accessor to get the pandas Series for column number 4 from `usa_states`\n", "#It should be a column of dates\n", "established = usa_sates.___[:, 4]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 Dec 14, 1819\n", - "1 Jan 3, 1959\n", - "2 Feb 14, 1912\n", - "3 Jun 15, 1836\n", - "4 Sep 9, 1850\n", - "5 Aug 1, 1876\n", - "6 Jan 9, 1788\n", - "7 Dec 7, 1787\n", - "8 Mar 3, 1845\n", - "9 Jan 2, 1788\n", - "10 Aug 21, 1959\n", - "11 Jul 3, 1890\n", - "12 Dec 3, 1818\n", - "13 Dec 11, 1816\n", - "14 Dec 28, 1846\n", - "15 Jan 29, 1861\n", - "16 Jun 1, 1792\n", - "17 Apr 30, 1812\n", - "18 Mar 15, 1820\n", - "19 Apr 28, 1788\n", - "20 Feb 6, 1788\n", - "21 Jan 26, 1837\n", - "22 May 11, 1858\n", - "23 Dec 10, 1817\n", - "24 Aug 10, 1821\n", - "25 Nov 8, 1889\n", - "26 Mar 1, 1867\n", - "27 Oct 31, 1864\n", - "28 Jun 21, 1788\n", - "29 Dec 18, 1787\n", - "30 Jan 6, 1912\n", - "31 Jul 26, 1788\n", - "32 Nov 21, 1789\n", - "33 Nov 2, 1889\n", - "34 Mar 1, 1803\n", - "35 Nov 16, 1907\n", - "36 Feb 14, 1859\n", - "37 Dec 12, 1787\n", - "38 May 29, 1790\n", - "39 May 23, 1788\n", - "40 Nov 2, 1889\n", - "41 Jun 1, 1796\n", - "42 Dec 29, 1845\n", - "43 Jan 4, 1896\n", - "44 Mar 4, 1791\n", - "45 Jun 25, 1788\n", - "46 Nov 11, 1889\n", - "47 Jun 20, 1863\n", - "48 May 29, 1848\n", - "49 Jul 10, 1890\n", - "Name: (Established[upper-alpha 1], Established[upper-alpha 1]), dtype: object" - ] - }, - "execution_count": 49, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "established" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2170,9 +1383,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 31#\n", "#Now use the iloc accessor again to extract columns 0, 5, and 6 and the dataframe's `copy()` method\n", @@ -2181,7 +1392,9 @@ "usa_states_sub = usa_states.___[:, [___]].copy()\n", "usa_states_sub.columns = [___]\n", "usa_states_sub.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2192,16 +1405,16 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 32#\n", "#Find the states in `state_summary` that are not in `usa_states_sub`\n", "#Hint: set(list1) - set(list2) is an easy way to get items in list1 that are not in list2\n", "missing_states = ___(state_summary.state) - ___(usa_states_sub.state)\n", "missing_states" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2219,28 +1432,12 @@ }, { "cell_type": "code", - "execution_count": 52, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "20 Massachusetts[upper-alpha 3]\n", - "37 Pennsylvania[upper-alpha 3]\n", - "38 Rhode Island[upper-alpha 4]\n", - "45 Virginia[upper-alpha 3]\n", - "47 West Virginia\n", - "Name: state, dtype: object" - ] - }, - "execution_count": 52, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "usa_states_sub.state[usa_states_sub.state.str.contains('Massachusetts|Pennsylvania|Rhode Island|Virginia')]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2251,9 +1448,7 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 33#\n", "#Use pandas' Series' `replace()` method to replace anything within square brackets (including the brackets)\n", @@ -2264,20 +1459,22 @@ "#inplace=True #Do this \"in place\"\n", "usa_states_sub.state.___(to_replace=___, value=__, regex=___, inplace=___)\n", "usa_states_sub.state[usa_states_sub.state.str.contains('Massachusetts|Pennsylvania|Rhode Island|Virginia')]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 34#\n", "#And now verify none of our states are missing by checking that there are no states in\n", "#state_summary that are not in usa_states_sub (as earlier using `set()`)\n", "missing_states = ___(state_summary.state) - ___(usa_states_sub.state)\n", "missing_states" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2288,16 +1485,16 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 35#\n", "#Use 'state_summary's `merge()` method to combine our new data in 'usa_states_sub'\n", "#specify the arguments how='left' and on='state'\n", "state_summary = state_summary.___(usa_states_sub, ___=___, ___=___)\n", "state_summary.head()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2322,15 +1519,15 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 36#\n", "#Use ski_data's `plot()` method to create a scatterplot (kind='scatter') with 'AdultWeekday' on the x-axis and\n", "#'AdultWeekend' on the y-axis\n", "ski_data.___(x=___, y=___, kind=___);" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2341,14 +1538,14 @@ }, { "cell_type": "code", - "execution_count": null, "metadata": {}, - "outputs": [], "source": [ "#Code task 37#\n", "#Use the loc accessor on ski_data to print the 'AdultWeekend' and 'AdultWeekday' columns for Montana only\n", "ski_data.___[ski_data.state == ___, [___, ___]]" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2359,25 +1556,12 @@ }, { "cell_type": "code", - "execution_count": 58, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "AdultWeekend 4\n", - "AdultWeekday 7\n", - "dtype: int64" - ] - }, - "execution_count": 58, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ski_data[['AdultWeekend', 'AdultWeekday']].isnull().sum()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2388,33 +1572,22 @@ }, { "cell_type": "code", - "execution_count": 59, "metadata": {}, - "outputs": [], "source": [ "ski_data.drop(columns='AdultWeekday', inplace=True)\n", "ski_data.dropna(subset=['AdultWeekend'], inplace=True)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 60, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(277, 25)" - ] - }, - "execution_count": 60, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ski_data.shape" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2439,113 +1612,14 @@ }, { "cell_type": "code", - "execution_count": 61, - "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", - "
count%
329520.0
62520.0
141520.0
86520.0
74520.0
146520.0
184416.0
108416.0
198416.0
39416.0
\n", - "
" - ], - "text/plain": [ - " count %\n", - "329 5 20.0\n", - "62 5 20.0\n", - "141 5 20.0\n", - "86 5 20.0\n", - "74 5 20.0\n", - "146 5 20.0\n", - "184 4 16.0\n", - "108 4 16.0\n", - "198 4 16.0\n", - "39 4 16.0" - ] - }, - "execution_count": 61, - "metadata": {}, - "output_type": "execute_result" - } - ], + "metadata": {}, "source": [ "missing = pd.concat([ski_data.isnull().sum(axis=1), 100 * ski_data.isnull().mean(axis=1)], axis=1)\n", "missing.columns=['count', '%']\n", "missing.sort_values(by='count', ascending=False).head(10)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2556,23 +1630,12 @@ }, { "cell_type": "code", - "execution_count": 62, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0., 4., 8., 12., 16., 20.])" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "missing['%'].unique()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2583,29 +1646,12 @@ }, { "cell_type": "code", - "execution_count": 63, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.0 107\n", - "4.0 94\n", - "8.0 45\n", - "12.0 15\n", - "16.0 10\n", - "20.0 6\n", - "Name: %, dtype: int64" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "missing['%'].value_counts()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2616,51 +1662,12 @@ }, { "cell_type": "code", - "execution_count": 64, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Int64Index: 277 entries, 0 to 329\n", - "Data columns (total 25 columns):\n", - " # Column Non-Null Count Dtype \n", - "--- ------ -------------- ----- \n", - " 0 Name 277 non-null object \n", - " 1 Region 277 non-null object \n", - " 2 state 277 non-null object \n", - " 3 summit_elev 277 non-null int64 \n", - " 4 vertical_drop 277 non-null int64 \n", - " 5 base_elev 277 non-null int64 \n", - " 6 trams 277 non-null int64 \n", - " 7 fastSixes 277 non-null int64 \n", - " 8 fastQuads 277 non-null int64 \n", - " 9 quad 277 non-null int64 \n", - " 10 triple 277 non-null int64 \n", - " 11 double 277 non-null int64 \n", - " 12 surface 277 non-null int64 \n", - " 13 total_chairs 277 non-null int64 \n", - " 14 Runs 274 non-null float64\n", - " 15 TerrainParks 233 non-null float64\n", - " 16 LongestRun_mi 272 non-null float64\n", - " 17 SkiableTerrain_ac 275 non-null float64\n", - " 18 Snow Making_ac 240 non-null float64\n", - " 19 daysOpenLastYear 233 non-null float64\n", - " 20 yearsOpen 277 non-null float64\n", - " 21 averageSnowfall 268 non-null float64\n", - " 22 AdultWeekend 277 non-null float64\n", - " 23 projectedDaysOpen 236 non-null float64\n", - " 24 NightSkiing_ac 163 non-null float64\n", - "dtypes: float64(11), int64(11), object(3)\n", - "memory usage: 56.3+ KB\n" - ] - } - ], + "metadata": {}, "source": [ "ski_data.info()" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2678,23 +1685,12 @@ }, { "cell_type": "code", - "execution_count": 65, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(277, 25)" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], "source": [ "ski_data.shape" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", @@ -2705,25 +1701,30 @@ }, { "cell_type": "code", - "execution_count": 66, "metadata": {}, - "outputs": [], "source": [ "# save the data to a new csv file\n", "datapath = '../data'\n", "save_file(ski_data, 'ski_data_cleaned.csv', datapath)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "code", - "execution_count": 67, - "metadata": {}, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2026-05-26T22:57:21.024634Z", + "start_time": "2026-05-26T22:57:21.021667Z" + } + }, "source": [ "# save the state_summary separately.\n", "datapath = '../data'\n", "save_file(state_summary, 'state_summary.csv', datapath)" - ] + ], + "outputs": [], + "execution_count": null }, { "cell_type": "markdown", From d611d006a20e9b876bbfdb6ca1bdca7b733fa154 Mon Sep 17 00:00:00 2001 From: ayanrobinsonar-cloud Date: Tue, 26 May 2026 20:13:01 -0400 Subject: [PATCH 2/9] idk i am lost --- .idea/workspace.xml | 50 ++++++++++++++++--------------- Notebooks/02_data_wrangling.ipynb | 35 ++++++++++++---------- 2 files changed, 46 insertions(+), 39 deletions(-) diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 71a633ea4..d02209ea7 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -5,6 +5,7 @@ + - - - - + From 85703d66f0db7088cec3cc52b6a79a162711483f Mon Sep 17 00:00:00 2001 From: ayanrobinsonar-cloud Date: Wed, 27 May 2026 18:08:59 -0400 Subject: [PATCH 4/9] idk test --- .idea/workspace.xml | 10 +- Notebooks/02_data_wrangling.ipynb | 441 ++++++++++--------- Notebooks/03_exploratory_data_analysis.ipynb | 4 +- anaconda_projects/db/project_filebrowser.db | Bin 0 -> 32768 bytes 4 files changed, 239 insertions(+), 216 deletions(-) create mode 100644 anaconda_projects/db/project_filebrowser.db diff --git a/.idea/workspace.xml b/.idea/workspace.xml index c1350b68e..9b9ca848d 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -4,7 +4,11 @@