Analyze Bike Rental Demand with Python

Use Python to chart bike demand and make data-backed staffing recommendations.

Introduction

30 Second Summary

Bike-sharing operators have to place bikes and staff before riders arrive. A schedule built on guesswork can leave busy stations underprepared.

In this project, you will use Google Colab to analyze an official bike-sharing dataset with Python. You'll use pandas and Matplotlib to uncover demand patterns before turning the results into an operational recommendation.

What You'll Build

Picture running your notebook to reveal the busiest hours, distinct working-day patterns, and the weather conditions linked to the highest average demand.

By the end of this project, you'll have:

A shareable analysis notebook you can rerun to fetch the official dataset and display its quality checks.
Three clear demand charts showing hourly demand, differences between day types, and weather-related demand.
A calculated operational recommendation identifying when the operator should prioritize bikes and staff.
Secret Mission: Compare casual and registered riders to discover whether they need different operating plans.

Are there any prerequisites?

You need a Google account plus a Mac running Safari. No Python or data-analysis experience is required because the project includes the full setup.

Before We Start

Your charts will be most useful when every calculation stays connected to an operational decision. Before the hands-on work begins, take a moment to define the analysis you are building and why its answer matters.

Set Up Your Colab Analysis Environment

You have an operational question to answer about bike allocation. Your answer needs an analysis that another person can rerun.

Google Colab gives you a temporary Python runtime in your browser. Pinned libraries keep every notebook run aligned with this project.

In this step, get ready to:

Create a Google Colab notebook for your bike rental analysis.
Install the pinned analysis libraries in the temporary runtime.
Confirm every required version with a verification cell.

Create and name the notebook

Your notebook stays in Google Drive. Its managed runtime is temporary.

Visit Google Colab in Safari.
Complete the Google account sign-in prompt if it appears.

You should see the Colab welcome screen after your account opens.

Create a blank notebook from the Colab welcome screen.

You should see an untitled notebook with an empty code cell.

Select the notebook's title field in the upper-left corner.
Enter Bike Rental Demand Analysis as the notebook title.

The upper-left corner should now show Bike Rental Demand Analysis.

Why Use Colab Here?

A local Python setup would add installation work on your Mac. Colab keeps this project focused on analysis in a shareable notebook.

The installation cell stays in the notebook because custom libraries belong to each temporary runtime.

Prepare a reproducible runtime

Your analysis depends on three libraries. Pinned versions give the notebook a known dependency baseline.

Add a code cell at the top of the notebook.
Install the pinned libraries by running this code in the new cell:

!pip3 install pandas==3.1.0 matplotlib==3.11.2 ucimlrepo==0.0.7

What Did This Cell Install?

pandas 3.1.0 supplies the DataFrame tools used to inspect grouped rental data.
Matplotlib 3.11.2 turns calculated results into charts.
ucimlrepo 0.0.7 provides the dataset-fetching helper used in the analysis.
The leading ! sends the pip3 installation command from the notebook to the runtime.

Wait for the installation cell to finish running.
Confirm the cell finishes without a red failure message.

That installation gives your runtime the exact library releases used throughout this project.

Package Installation Failed?

Confirm the notebook shows an active runtime connection.
Rerun the installation cell after the connection returns.

Help me fix my Colab package installation

Confirm the environment

The installation output shows that packages were downloaded. An import check proves that the current runtime can load them.

Add a new code cell below the package-installation cell.

Before you run the check, do you expect every installed version to match the pinned environment?

Verify the current runtime by running this code in the new cell:

import sys
import pandas as pd
import matplotlib
from ucimlrepo import fetch_ucirepo

print(sys.version.split()[0])
print(pd.__version__)
print(matplotlib.__version__)
print("Setup complete")

What Does This Check Prove?

The sys import reads the Python version from the hosted runtime.
The pd.__version__ value reports the loaded pandas release.
The matplotlib.__version__ value reports the loaded Matplotlib release.
The fetch_ucirepo import proves that the dataset helper is available.
The final print statement marks the end of a successful verification run.

Match your verification output to the scenario below.

✔️ I see all expected versions

The first line should show Python 3.13.15.

The next lines should show pandas 3.1.0 and Matplotlib 3.11.2. The final line should read Setup complete.

You have confirmed that the notebook can load every pinned dependency.

ⓧ I see an older Python version

An older managed runtime does not match the project's Python 3.13.15 environment.

Use Colab's runtime controls to disconnect the current managed runtime.
Connect the notebook to a fresh managed runtime.
Rerun the package-installation cell.
Rerun the verification cell.

The first output line should now show 3.13.15.

ⓧ I see a package or import problem

A package problem means the installation did not finish in the currently connected runtime.

Return to the package-installation cell.
Run the package-installation cell again.
Run the verification cell again.

The four output lines should now match the success tab.

Still Seeing a Version Mismatch?

Each managed runtime has its own installed packages. A fresh runtime needs the installation cell before it can pass this verification.

Help me diagnose my Colab version check

Your Colab notebook now has a verified Python environment with every required library ready. Next, you will bring in the bike-sharing data to reveal its first demand pattern.

Reveal the Overall Hourly Demand Pattern

Your pinned analysis environment is ready in Google Colab. The operator now needs a broad view of demand across a full day.

You will use pandas to turn the rental records into an hourly baseline. That average combines every day into one view whose usefulness you can judge once it appears.

In this step, get ready to:

Load the official Bike Sharing dataset into one analysis DataFrame.
Inspect sample rows plus the missing-value and duplicate-row totals.
Calculate mean rentals by hour in a line chart.

Fetch and combine the dataset

The UCI Machine Learning Repository stores input features separately from rental targets. One DataFrame keeps both parts aligned row by row.

Add a new code cell directly beneath the verification cell from earlier.
Load dataset ID 275 into one DataFrame by running the code below:

import pandas as pd
import matplotlib.pyplot as plt
from ucimlrepo import fetch_ucirepo

bike_sharing = fetch_ucirepo(id=275)
data = pd.concat(
    [bike_sharing.data.features, bike_sharing.data.targets],
    axis=1,
)

What does this code do?

The imports provide table operations plus charting tools.
The fetch_ucirepo helper retrieves dataset ID 275 from UCI.
The features DataFrame holds fields such as the hour plus weather conditions.
The targets DataFrame holds the rental counts.
The axis=1 setting places both DataFrames side by side while preserving their row alignment.

Confirm the cell finishes without an error message.

That first data step is complete: your runtime now holds the source dataset in bike_sharing plus the combined table in data.

Dataset cell did not finish?

Confirm that the notebook runtime is still connected.
Rerun the package-installation cell if the import mentions a missing dependency.
Rerun the dataset cell after restoring your internet connection if the download fails.

Help me troubleshoot the dataset load.

Check the data quality

A data-quality check reveals obvious gaps before you trust a chart. Sample rows also confirm that the expected columns arrived.

Add a new code cell beneath the dataset-loading cell.
Print the sample rows plus the quality totals by running the code below:

print(f"Rows: {len(data):,}")
print(data.head())
print("Missing values:", int(data.isna().sum().sum()))
print("Duplicate rows:", int(data.duplicated().sum()))

What do these checks reveal?

The len(data) expression reports the number of available hourly records.
The head() method displays the first five rows for a quick structure check.
The nested isna() calculation counts missing values across the entire DataFrame.
The duplicated() calculation counts repeated rows that could distort averages.

You will see a row count followed by five sample rows. You will also see numeric totals for missing values plus duplicate rows.

You now have evidence about the dataset's condition before calculating demand patterns.

Quality output looks incomplete?

Confirm that the dataset-loading cell completed before this cell.
Compare each print statement with the reference code if one of the four outputs is missing.
Rerun the quality-check cell after correcting any copied parentheses or quotation marks.

Help me troubleshoot the quality checks.

Chart average demand by hour

Grouping and aggregation collect rentals that share the same hour before calculating their mean. Matplotlib turns those hourly means into a visible daily pattern.

Add a new code cell beneath the quality-check cell.

Before you run this cell, what hourly shape do you expect one overall average to reveal?

Reveal the hourly demand pattern by running the code below:

overall_by_hour = data.groupby("hr")["cnt"].mean()
ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(overall_by_hour.index, overall_by_hour.values, marker="o")
ax.set(
    title="Average Bike Rentals by Hour",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
plt.show()

How does the chart work?

The groupby("hr") expression collects rows that share the same hour.
The ["cnt"].mean() expression calculates average total rentals for each hourly group.
The ax variable holds the chart axes used for the line plus its labels.
The marker="o" setting makes each hourly average visible as a point.
The plt.show() call displays the completed chart in the notebook.

Your first demand chart is live: you will see a line chart titled Average Bike Rentals by Hour.

Confirm that the chart spans hour values from 0 through 23.
Confirm that the earlier output still shows five sample rows plus both quality-check totals.

The line summarizes a broad daily pattern. Because the average combines working days with weekends or holidays, it cannot show whether those day types peak at different times.

That shortfall is intentional. You have now seen the limit of using one all-week schedule.

Chart not appearing?

Confirm that the dataset-loading cell completed before the chart cell.
Confirm that overall_by_hour uses the hr column for grouping.
Compare the chart title plus axis labels with the reference code if the figure appears without readable context.

Help me troubleshoot the hourly chart.

✔️ Awesome, I've got everything!

Your first analysis slice is complete. The notebook now contains its data load, quality checks, and hourly chart.

ⓧ I'd like to double check the full code

Compare your three analysis cells with this complete reference:

import pandas as pd
import matplotlib.pyplot as plt
from ucimlrepo import fetch_ucirepo

bike_sharing = fetch_ucirepo(id=275)
data = pd.concat(
    [bike_sharing.data.features, bike_sharing.data.targets],
    axis=1,
)

print(f"Rows: {len(data):,}")
print(data.head())
print("Missing values:", int(data.isna().sum().sum()))
print("Duplicate rows:", int(data.duplicated().sum()))

overall_by_hour = data.groupby("hr")["cnt"].mean()
ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(overall_by_hour.index, overall_by_hour.values, marker="o")
ax.set(
    title="Average Bike Rentals by Hour",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
plt.show()

Your notebook now exposes the overall hourly pattern plus its limitation. Next, you will test whether working days follow the same pattern as weekends or holidays.

Separate Working Days from Off Days

Your first chart now reveals the overall hourly demand rhythm. Its average blends working days with weekends and holidays.

In this step, you'll use segmentation to separate those records by day type. The comparison reveals where one all-week schedule loses useful detail.

In this step, get ready to:

Calculate separate hourly averages for both day types.
Plot both demand patterns on one labeled chart.
Interpret why each day type needs its own operating schedule.

Calculate and plot each day type

Each row in the data DataFrame records whether that date is a working day. Grouping each subset by hr produces a separate hourly demand pattern.

Matplotlib can draw both patterns on one chart. Labels make the two lines easy to compare.

Insert a code cell directly below the cell that displays the overall hourly chart.
Build both hourly series plus the comparison chart by pasting this code into the new cell:

workday_by_hour = data[data["workingday"] == 1].groupby("hr")["cnt"].mean()
offday_by_hour = data[data["workingday"] == 0].groupby("hr")["cnt"].mean()

ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(
    workday_by_hour.index,
    workday_by_hour.values,
    marker="o",
    label="Working day",
)
ax.plot(
    offday_by_hour.index,
    offday_by_hour.values,
    marker="o",
    label="Weekend or holiday",
)
ax.set(
    title="Working-Day vs Off-Day Demand",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
ax.legend()
plt.show()

How does the comparison work?

The first calculation keeps records where workingday == 1. It stores their hourly mean rentals in workday_by_hour.
The second calculation keeps records where workingday == 0. It stores their hourly mean rentals in offday_by_hour.
The two ax.plot() calls draw both series on the same axes. Their labels identify the corresponding day type.
The ax.legend() call displays those labels beside the chart.

Allow Google Colab to save the new cell in the notebook.

Before you run the comparison, do you expect both day types to reach their highest demand at the same hours?

Run the new cell using the play icon beside it.

You should see a chart titled Working-Day vs Off-Day Demand with two visible lines. The legend should show Working day plus Weekend or holiday.

Missing a line or legend?

Check that both ax.plot() sections appear in the new cell.
Confirm that ax.legend() appears before plt.show().
Run the earlier data-loading cells if data is unavailable in the current runtime.

Help me fix my day-type comparison chart.

✔️ Awesome, I've got everything!

Your notebook now contains the two hourly averages plus their labeled comparison chart.

ⓧ I'd like to double check the full code

Compare your notebook cells with this cumulative analysis code.

import pandas as pd
import matplotlib.pyplot as plt
from ucimlrepo import fetch_ucirepo

bike_sharing = fetch_ucirepo(id=275)
data = pd.concat(
    [bike_sharing.data.features, bike_sharing.data.targets],
    axis=1,
)

print(f"Rows: {len(data):,}")
print(data.head())
print("Missing values:", int(data.isna().sum().sum()))
print("Duplicate rows:", int(data.duplicated().sum()))

overall_by_hour = data.groupby("hr")["cnt"].mean()
ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(overall_by_hour.index, overall_by_hour.values, marker="o")
ax.set(
    title="Average Bike Rentals by Hour",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
plt.show()

workday_by_hour = data[data["workingday"] == 1].groupby("hr")["cnt"].mean()
offday_by_hour = data[data["workingday"] == 0].groupby("hr")["cnt"].mean()

ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(
    workday_by_hour.index,
    workday_by_hour.values,
    marker="o",
    label="Working day",
)
ax.plot(
    offday_by_hour.index,
    offday_by_hour.values,
    marker="o",
    label="Weekend or holiday",
)
ax.set(
    title="Working-Day vs Off-Day Demand",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
ax.legend()
plt.show()

Inspect the distinct peak patterns

The highest point on each line represents the period when that day type needs the most bike capacity. Comparing those points turns the chart into scheduling evidence.

Trace the Working day line to its highest point.
Trace the Weekend or holiday line to its highest point.
Compare the hours where those highest points occur.

The working-day line forms pronounced peaks around commuting periods. The weekend or holiday line builds toward a later daytime peak.

The visibly different patterns prove that one blended schedule would hide useful allocation detail.

That is the key limitation solved: your notebook now separates two distinct operating patterns. Next, you'll add weather conditions to make the allocation recommendation more practical.

Turn Weather Patterns into a Recommendation

Your working-day comparison now exposes two distinct peak patterns. The next goal is to add weather context to the schedule in your Google Colab notebook.

Time patterns tell the operator when demand rises. Readable weather categories add the conditions needed for a useful allocation recommendation.

You'll use pandas to calculate average demand by weather category. Matplotlib turns those results into the final chart.

In this step, get ready to:

Translate numeric weather codes into readable categories.
Visualize average rentals for each weather category.
Turn the strongest periods into printed operational recommendations.

Translate weather codes into labels

The dataset stores each weather condition as a number in weathersit. Readable labels make the grouped results easier to interpret.

Return to the bottom of the notebook from earlier.
Use the notebook toolbar to add a code cell beneath the day-type comparison cell.
Populate the new cell by copying this code:

weather_labels = {
    1: "Clear or partly cloudy",
    2: "Mist or cloudy",
    3: "Light snow or rain",
    4: "Heavy rain or snow",
}
data["weather_label"] = data["weathersit"].map(weather_labels)
weather_demand = data.groupby("weather_label")["cnt"].mean()

What does this code do?

The weather_labels dictionary connects each numeric weather code to a readable category.
The map() call creates a weather_label column in the data DataFrame.
The groupby("weather_label")["cnt"].mean() calculation finds the average number of rentals for each readable category.

Run the cell by clicking the play button to its left.

The cell should finish in a completed state without an exception. Your notebook now holds weather_label and weather_demand.

That data preparation is complete. The weather categories are ready for a chart someone can read.

Having trouble creating the weather groups?

Check that this cell runs after the dataset-loading cell because data must already exist. Confirm that weathersit and cnt match the column names shown in the code.

Compare the braces around weather_labels with the code block above. Each numeric code needs one matching label.

Help me fix the weather grouping cell

Plot average demand by weather

A bar chart makes the differences between weather categories visible. Each bar represents the mean rental count stored in weather_demand.

Add a code cell beneath the weather calculation cell by using the notebook toolbar.
Populate the new cell by copying this code:

ax = plt.subplots(figsize=(10, 5))[1]
ax.bar(weather_demand.index, weather_demand.values)
ax.set(
    title="Average Bike Rentals by Weather",
    xlabel="Weather category",
    ylabel="Average rentals",
)
plt.show()

How does this chart work?

The plt.subplots(figsize=(10, 5)) call creates the chart area with enough width for the category labels.
The bar() call uses weather categories along the horizontal axis. Their average rental counts determine the bar heights.
The ax.set() call adds a title plus labels that explain both axes.
The plt.show() call displays the completed chart in the notebook.

Before you run this cell, which weather category do you expect to have the tallest bar?

Run the chart cell by clicking the play button to its left.

You'll see a bar chart titled Average Bike Rentals by Weather. Its bars show how average demand changes across the readable weather categories.

You have turned coded weather values into visible evidence. The remaining task is to connect that evidence with the two day-type peaks.

Don't see the weather chart?

Confirm that the weather calculation cell completed before this chart cell. The chart depends on weather_demand.

Check that the final line contains plt.show(). Compare every parenthesis with the chart code above.

Help me troubleshoot the weather chart

Print the operational recommendation

The three grouped series contain the strongest scheduling signals from your analysis. The idxmax() method returns the label attached to the highest average in each series.

Add a code cell beneath the weather chart by using the notebook toolbar.
Populate the new cell by copying these peak calculations:

peak_workday_hour = int(workday_by_hour.idxmax())
peak_offday_hour = int(offday_by_hour.idxmax())
highest_demand_weather = weather_demand.idxmax()

What do these values represent?

The peak_workday_hour value stores the hour with the highest working-day average.
The peak_offday_hour value stores the hour with the highest weekend or holiday average.
The highest_demand_weather value stores the readable weather category with the highest average demand.

Run the peak calculation cell by clicking the play button to its left.

When the cell reaches its completed state, the three peak variables are ready for the final recommendation.

Peak calculation cell not completing?

Confirm that the working-day comparison cells have already created workday_by_hour and offday_by_hour. Confirm that the weather cell has created weather_demand.

Help me fix the peak calculations

Add one final code cell beneath the peak calculation cell by using the notebook toolbar.
Populate the final cell by copying this recommendation code:

print("Operational recommendation")
print(
    f"Prioritize bikes and staff around {peak_workday_hour}:00 on working days."
)
print(
    f"Use a separate off-day plan centered around {peak_offday_hour}:00."
)
print(
    "Average demand is highest during "
    f"{highest_demand_weather.lower()} conditions."
)

How is the recommendation assembled?

The first line gives the output a clear heading.
The next line inserts peak_workday_hour into the working-day staffing recommendation.
The third line inserts peak_offday_hour into a separate off-day plan.
The final line uses highest_demand_weather to name the weather conditions associated with the highest average demand.

Before you run this cell, do you expect the working-day peak and the off-day peak to occur at the same hour?

Run the recommendation cell by clicking the play button to its left.

You'll see Operational recommendation followed by three recommendation lines. The lines contain the calculated working-day hour, off-day hour, and highest-demand weather category.

Confirm that the visible bar chart is titled Average Bike Rentals by Weather.
Confirm that the final output contains three calculated recommendation lines beneath its heading.

That's the core analysis complete. Your notebook now turns time and weather patterns into a scheduling recommendation an operator can use.

Recommendation output missing or incomplete?

Run the peak calculation cell before the print cell. The recommendation needs all three peak variables to exist.

Compare the braces inside each formatted string with the code above. Each brace must contain the matching peak variable.

Help me troubleshoot the recommendation output

Choose the tab that matches how you want to check your completed analysis.

✔️ Awesome, I've got everything!

Your notebook contains the three charts plus the printed operational recommendation. Make sure the latest notebook changes are saved.

ⓧ I'd like to double check the full code

Compare your sequential notebook cells with this complete core analysis.

import pandas as pd
import matplotlib.pyplot as plt
from ucimlrepo import fetch_ucirepo

bike_sharing = fetch_ucirepo(id=275)
data = pd.concat(
    [bike_sharing.data.features, bike_sharing.data.targets],
    axis=1,
)

print(f"Rows: {len(data):,}")
print(data.head())
print("Missing values:", int(data.isna().sum().sum()))
print("Duplicate rows:", int(data.duplicated().sum()))

overall_by_hour = data.groupby("hr")["cnt"].mean()
ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(overall_by_hour.index, overall_by_hour.values, marker="o")
ax.set(
    title="Average Bike Rentals by Hour",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
plt.show()

workday_by_hour = data[data["workingday"] == 1].groupby("hr")["cnt"].mean()
offday_by_hour = data[data["workingday"] == 0].groupby("hr")["cnt"].mean()

ax = plt.subplots(figsize=(10, 5))[1]
ax.plot(
    workday_by_hour.index,
    workday_by_hour.values,
    marker="o",
    label="Working day",
)
ax.plot(
    offday_by_hour.index,
    offday_by_hour.values,
    marker="o",
    label="Weekend or holiday",
)
ax.set(
    title="Working-Day vs Off-Day Demand",
    xlabel="Hour of day",
    ylabel="Average rentals",
)
ax.legend()
plt.show()

weather_labels = {
    1: "Clear or partly cloudy",
    2: "Mist or cloudy",
    3: "Light snow or rain",
    4: "Heavy rain or snow",
}
data["weather_label"] = data["weathersit"].map(weather_labels)
weather_demand = data.groupby("weather_label")["cnt"].mean()

ax = plt.subplots(figsize=(10, 5))[1]
ax.bar(weather_demand.index, weather_demand.values)
ax.set(
    title="Average Bike Rentals by Weather",
    xlabel="Weather category",
    ylabel="Average rentals",
)
plt.show()

peak_workday_hour = int(workday_by_hour.idxmax())
peak_offday_hour = int(offday_by_hour.idxmax())
highest_demand_weather = weather_demand.idxmax()

print("Operational recommendation")
print(
    f"Prioritize bikes and staff around {peak_workday_hour}:00 on working days."
)
print(
    f"Use a separate off-day plan centered around {peak_offday_hour}:00."
)
print(
    "Average demand is highest during "
    f"{highest_demand_weather.lower()} conditions."
)

How to use this reference

This reference mirrors the order of your sequential notebook cells. Its final sections add readable weather labels, display the weather chart, calculate the peak labels, and print the recommendation.

Secret mission

Compare Casual and Registered Riders

Total rentals can hide different customer behaviors. Compare casual and registered riders by hour to reveal whether each audience needs a different operating plan.

Clean Up Your Resources

Your analysis uses free Google Colab resources with no ongoing billable cloud infrastructure. Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

The Bike Rental Demand Analysis notebook is stored in Google Drive.
A temporary Google Colab managed runtime is connected to the notebook.

Keep everything running

No action is needed. Choose this if you are still working on your bike rental analysis.

Keep the Bike Rental Demand Analysis notebook in Google Drive.
Leave the Safari tab open while you continue working in the connected runtime.
Rerun the installation cell whenever Colab assigns a new runtime.
Rerun the analysis cells to recreate your charts plus recommendations.

Pause - I'll come back to this later

Pausing keeps your notebook in Google Drive. An idle managed runtime is eventually removed by Colab.

Close the Google Colab tab in Safari.
Return to the notebook later from Google Drive.
Rerun the installation cell after Colab assigns a new runtime.
Rerun the analysis cells to restore the quality checks, charts, plus recommendations.

Delete - I don't want to use this again

Deletion removes the notebook from Google Drive. Resetting the managed runtime removes the current temporary environment.

Open Google Drive in a new Safari tab to find the Bike Rental Demand Analysis notebook.
Delete the Bike Rental Demand Analysis notebook from Google Drive.
Return to the connected Google Colab notebook in your original Safari tab.
Click Runtime in the top menu.
Click Disconnect and delete runtime.

Nice Work!

You did it! Your shareable Google Colab notebook now gives a bike-sharing operator evidence for an allocation schedule.

You've learned how to:

Build a reproducible pandas workflow that fetches the official Bike Sharing dataset from the UCI Machine Learning Repository. Check the resulting DataFrame for missing values plus duplicate rows.
Use grouped averages to expose hourly demand. Segment the pattern by day type. Visualize weather-related demand with Matplotlib charts.
Turn calculated peak hours plus the highest-demand weather category into an operational recommendation for bike allocation. Extend the recommendation to staff scheduling.
Secret Mission: Compare casual riders with registered riders by hour. Add an audience-specific operating adjustment based on the different patterns.

Ready to quiz yourself?