Airbnb_Exercise_Student_Facing_170221.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Welcome to the Airbnb Mini Practice Project\n",
    "\n",
    "As you've worked through Python Sub Unit you would have realised there are a number of powerful functions you can use.\n",
    "\n",
    "You would have covered the following libraries:\n",
    "\n",
    "<li> Matplotlib </li>\n",
    "<li> Seaborn </li>\n",
    "<li> Pandas </li> \n",
    "    \n",
    "These are all powerful libraries to help augment your data analysis capabilities.\n",
    "In these set of exercises below, we've crafted a few extra challenges to reinforce your understanding of how these libraries work. \n",
    "\n",
    "Please note there is a particular emphasis on the Pandas Library as this is the most critical library you will be using throughout your career as a data analyst. You'll see the similarities that hold with respect to Pandas and Pivot Tables!\n",
    "    \n",
    "<b> The most important thing to build confidence with Python is to practice all the time. This way you will build muscle memory. Don't simply copy the code you've written previously but write it again and again so you build the muscle memory associated with these coding libraries. </b> \n",
    "\n",
    "<H3>  Let's get started! </H3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've provided a file called airbnb_2.csv that you'll need to import.\n",
    "\n",
    "Let's do this first before we start our analysis.\n",
    "\n",
    "<b> Don't forget to import the libraries you need to read .csv files! </b> \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 1: <span style=\"color:green\">Import Libraries</span> \n",
    "<b> Put your code in the box below </b>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 2: <span style=\"color:green\">Import the Airbnb Dataset</span> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that you have the Pandas Libraries imported, it's time to import the airbnb dataset.\n",
    "\n",
    "<b> i) Please import the airbnb dataset.\n",
    "\n",
    "ii) Upon completion of this, use .info() to better understand the variables inside your dataset.\n",
    "<p>    \n",
    "\n",
    "<b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read in the data\n",
    "df = pd.read_csv('airbnb_2.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get a feel for size, shape, and variables inside dataset\n",
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Step 3: <span style=\"color:green\">Exploring your data with Pandas</span> \n",
    "\n",
    "The rest of these questions will have you focus on using the following Pandas Skills:\n",
    "\n",
    "<li> Subsetting a Pandas dataframe using [] and boolean operators </li>\n",
    "<li> Summing up Records with value_counts()</li>\n",
    "<li> Creating calculated fields </li>\n",
    "<li> Group By in Pandas </li> \n",
    "<li> Creating Bar Plots with Matplotlib</li> \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> i)  Please count how many airbnb listings are in each of the 5 Neighbourhood Groups (Manhattan, Brooklyn, Queens, Bronx, Staten Island) and identify which Neighbourhood Groups has the largest number of Airbnb Listings </b>\n",
    "<p>\n",
    "    <b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group the data by 'neighbourhood_group' and count the number of listings in each group\n",
    "neighborhood_group_count = df[\"neighbourhood_group\"].value_counts().reset_index()\n",
    "neighborhood_group_count.columns = ['Neighbourhood Group', 'Number of Listings']\n",
    "\n",
    "# Identify the Neighborhood Group with the largest number of listings\n",
    "largest_neighborhood_group = neighborhood_group_count.loc[neighborhood_group_count['Number of Listings'].idxmax()]['Neighbourhood Group']\n",
    "\n",
    "neighborhood_group_count, \"Largest Neighborhood Group: \" + largest_neighborhood_group"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We want to focus our attention on the Neighbourhood Groups that have the top 3 number of Airbnb Listings.\n",
    "\n",
    "<b> ii) Calculate the % listings that each Neighbourhood Group contains. </b>\n",
    "\n",
    "<b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calculate the total number of Airbnb listings\n",
    "total_listings = df[\"neighbourhood_group\"].count()\n",
    "\n",
    "# Print the total number of Airbnb listings\n",
    "print(\"\\n\\nThe total number of listings is\", total_listings)\n",
    "\n",
    "# Select the top 3 Neighborhood Groups by number of listings\n",
    "top_3_neighborhoods = neighborhood_group_count.nlargest(3)\n",
    "\n",
    "# Print the top 3 Neighborhood Groups by number of listings\n",
    "print(\"\\n\\nThe top 3 neighborhoods are:\\n\", top_3_neighborhoods)\n",
    "\n",
    "# Calculate the percentage of listings in the top 3 Neighborhood Groups\n",
    "percentage_listings_top_3 = (top_3_neighborhoods / total_listings) * 100\n",
    "\n",
    "# Print the percentage of listings in the top 3 Neighborhood Groups\n",
    "print(\"\\n\\nThe percentage of listings in the top 3 neighborhoods is:\\n\", percentage_listings_top_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> iii) Create a new calculated field called Revenue and place this into the Airbnb Dataframe. This is to be calculated by using the Price Column x Number_Of_Reviews Columns </b>\n",
    "\n",
    "<b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a new calculated field 'Revenue' = Price x Number_of_Reviews\n",
    "df[\"Revenue\"] = df[\"price\"] * df[\"number_of_reviews\"]\n",
    "\n",
    "# Display the first few rows to confirm the new field\n",
    "df[['id', 'price', 'number_of_reviews', 'Revenue']].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> iv) Create a Bar Plot that shows which Neighbourhood Group has the highest average revenues. In order to best\n",
    "calculate this, you'd want to consider how you can use the .groupby() syntax to assist you! </b>\n",
    "\n",
    "If you're stuck, we recommend you go back to <a href = https://learn.datacamp.com/courses/manipulating-dataframes-with-pandas> this </a> datacamp link. Specifically Chapter 4 which covers how GROUP BY is used in Pandas.\n",
    "\n",
    "<b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Group the data by 'neighbourhood_group' and calculate the mean revenue\n",
    "avg_revenue_by_group = df.groupby(\"neighbourhood_group\")[\"Revenue\"].mean().sort_values(ascending=False)\n",
    "\n",
    "# Create a bar plot for the average revenue by Neighborhood Group\n",
    "plt.figure(figsize=(10, 6))\n",
    "plt.bar(avg_revenue_by_group.index, avg_revenue_by_group.values, color=\"blue\")\n",
    "plt.title(\"Average Revenue by Neighborhood Group\")\n",
    "plt.xlabel(\"Neighborhood Group\")\n",
    "plt.ylabel(\"Average Revenue ($)\")\n",
    "\n",
    "# Show the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3> <span style=\"color:green\">Challenge Questions</span> </h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> V) Filter the Airbnb Dataframe to include only the Neighbourhood Groups Manhattan, Brookly and Queens. \n",
    "    \n",
    "Upon completion of this, identify the top 3 Revenue Generating Neighborhoods within each of the three Neighbourhood_Groups. This should give us 9 Overall Rows: 3 of the top generating neighbourhoods within each of the 3 Neighbourhood_Groups </b>\n",
    "\n",
    "This is a tricky question that will *test* your group-by skills.\n",
    "\n",
    "We recommend you consider the following:\n",
    "\n",
    "    condition1 = someDataFrame['someColumn']=='someCondition'\n",
    "    condition2 = someDataFrame['someColumn']=='someCondition'\n",
    "    \n",
    "    Step One - Filter the Dataframe using the Conditions\n",
    "    filtered_dataframe = someDataFrame[condition1 OR condition 2] \n",
    "    #Hint: You might want to look up what the OR symbol in Python is represented as in operator form (i.e. AND (&) )\n",
    "    \n",
    "    Step Two - Group the Data by Neighbourhood_Group and Neighbourhood. Don't forget you're looking to SUM up the Revenues.\n",
    "    \n",
    "    The remaining steps we recommend you think very carefully about.\n",
    "    \n",
    "    You might want to make use of the .reset_index(inplace=True) function to help reset the indexes in \n",
    "    your Grouped Up Dataframe...!\n",
    "    \n",
    "    \n",
    "<b> Put your code in the box below </b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step One - Filter the DataFrame to include only 'Manhattan', 'Brooklyn', and 'Queens'\n",
    "manhattan_group = df['neighbourhood_group'] == 'Manhattan'\n",
    "brooklyn_group = df['neighbourhood_group'] == 'Brooklyn'\n",
    "queens_group = df['neighbourhood_group'] == 'Queens'\n",
    "\n",
    "# Using the OR operator '|' to combine conditions\n",
    "filtered_df = df[manhattan_group | brooklyn_group | queens_group]\n",
    "\n",
    "# Step Two - Group the filtered DataFrame by 'neighbourhood_group' and 'neighbourhood, and sum up the revenues\n",
    "grouped_df = filtered_df.groupby(['neighbourhood_group', 'neighbourhood'])['Revenue'].sum().reset_index()\n",
    "\n",
    "# Step Three - Identify the top 3 revenue-generating neighborhoods within each Neighborhood Group\n",
    "top_3_neighborhoods_manhattan = grouped_df[grouped_df['neighbourhood_group'] == 'Manhattan'].nlargest(3, 'Revenue')\n",
    "top_3_neighborhoods_brooklyn = grouped_df[grouped_df['neighbourhood_group'] == 'Brooklyn'].nlargest(3, 'Revenue')\n",
    "top_3_neighborhoods_queens = grouped_df[grouped_df['neighbourhood_group'] == 'Queens'].nlargest(3, 'Revenue')\n",
    "\n",
    "# Step Four - Combine to get the overall top 9 neighborhoods across the three Neighborhood Groups\n",
    "overall_top_9_neighborhoods = pd.concat([top_3_neighborhoods_manhattan, top_3_neighborhoods_brooklyn, top_3_neighborhoods_queens]).reset_index(drop=True)\n",
    "\n",
    "# Print the overall top 9 neighborhoods\n",
    "overall_top_9_neighborhoods\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b> VI) Building on the previous question where you identified the top 3 Neighbourhoods within each of the three neighbourhood_groups based off Revenues, please filter the Airbnb Dataframe to include only these neighbourhoods. \n",
    "    \n",
    "Upon completion of this, identify the  top average revenue generating room type for each of the nine neighbourhoods and plot this out in a Bar Chart.</b>\n",
    "\n",
    "This is a tricky question that will *test* your group-by skills. Think back to the previous question and how you approached this; you can approach this in a similar manner. \n",
    "\n",
    "We recommend you consider the following:\n",
    "\n",
    "    condition1 = someDataFrame['someColumn']=='someCondition'\n",
    "    condition2 = someDataFrame['someColumn']=='someCondition'\n",
    "    \n",
    "    Step One - Filter the Dataframe using the Conditions\n",
    "    filtered_dataframe = someDataFrame[condition1 OR condition 2] \n",
    "    #Hint: You might want to look up what the OR symbol in Python is represented as in operator form (i.e. AND (&) )\n",
    "    \n",
    "    Step Two - Group the Data by Neighbourhood_Group and Neighbourhood. Don't forget you're looking to SUM up the Revenues.\n",
    "    \n",
    "    The remaining steps we recommend you think very carefully about.\n",
    "    \n",
    "    You might want to make use of the .reset_index(inplace=True) function to help reset the indexes in \n",
    "    your Grouped Up Dataframe...!\n",
    "    \n",
    "    \n",
    " <b> Put your code in the box below </b>      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Step One - Filter the DataFrame to include only the top 3 neighborhoods from each Neighborhood Group\n",
    "top_neighborhoods = overall_top_9_neighborhoods['neighbourhood'].tolist()\n",
    "top_neighborhoods_filter = df['neighbourhood'].isin(top_neighborhoods)\n",
    "\n",
    "# Using the condition to filter the DataFrame\n",
    "filtered_df_top_neighborhoods = df[top_neighborhoods_filter]\n",
    "\n",
    "# Step Two - Group the DataFrame by 'neighbourhood_group', 'neighbourhood', and 'room_type', and calculate the mean revenue\n",
    "grouped_df_room_type = filtered_df_top_neighborhoods.groupby(['neighbourhood_group', 'neighbourhood', 'room_type'])['Revenue'].mean().reset_index()\n",
    "\n",
    "# Identify the top average revenue-generating room type for each of the nine neighborhoods\n",
    "top_room_types = grouped_df_room_type.groupby(['neighbourhood_group', 'neighbourhood'])['Revenue'].idxmax()\n",
    "top_room_types_data = grouped_df_room_type.loc[top_room_types].reset_index(drop=True)\n",
    "\n",
    "# Step Four - Create the Bar Chart\n",
    "plt.figure(figsize=(15, 3))\n",
    "for idx, group in enumerate(top_room_types_data['neighbourhood_group'].unique()):\n",
    "    plt.subplot(1, 3, idx+1)\n",
    "    data = top_room_types_data[top_room_types_data['neighbourhood_group'] == group].sort_values('Revenue', ascending=True)\n",
    "    bars = plt.barh(data['neighbourhood'], data['Revenue'], color='blue')\n",
    "    plt.xlabel('Average Revenue ($)', fontsize=12)\n",
    "    plt.ylabel('Neighborhood', fontsize=12)\n",
    "    plt.title(f'Top Revenue-Generating Room Types in {group}', fontsize=12)\n",
    "    \n",
    "# Place the room type and revenue numbers in the middle of each bar\n",
    "    for i, bar in enumerate(bars):\n",
    "        room_type = data.iloc[i]['room_type'].split()[0]\n",
    "        plt.text(bar.get_width() / 2, bar.get_y() + bar.get_height() / 2, \n",
    "                 f\"{room_type}, ${int(bar.get_width()):,}\", \n",
    "                 va='center', ha='center', color='white', fontsize=12)\n",
    "\n",
    "# Add a little space between subplots\n",
    "plt.subplots_adjust(wspace=0.3)\n",
    "\n",
    "# Show the plot\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Revenue Insights by Neighborhood Group\n",
    "**Brooklyn**:\n",
    "Bedford-Stuyvesant generates the most revenue on average for \"Entire home/apt\" listings, followed by Williamsburg and Bushwick.\n",
    "\n",
    "**Manhattan**:\n",
    "Harlem leads in generating the most revenue on average for \"Entire home/apt\" listings, closely followed by East Village.\n",
    "Interestingly, \"Private room\" listings in Hell's Kitchen also generate significant revenue.\n",
    "\n",
    "**Queens**:\n",
    "Flushing takes the lead for \"Entire home/apt\" listings, followed by Long Island City and Astoria."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}