Weather Forecasting App

Abstract

Weather Forecasting App is a Python project that forecasts weather using APIs and machine learning. The application features data retrieval, prediction, and a CLI interface, demonstrating best practices in data science and automation.

Prerequisites

• Python 3.8 or above
• A code editor or IDE
• Basic understanding of APIs and ML
• Required libraries: requests, pandas, scikit-learn

Before you Start

Install Python and the required libraries:

Install dependencies

pip install requests pandas scikit-learn

Getting Started

Create a Project

1. Create a folder named weather-forecasting-app.
2. Open the folder in your code editor or IDE.
3. Create a file named weather_forecasting_app.py.
4. Copy the code below into your file.

Write the Code

Weather Forecasting App

pch.viewSource

Weather Forecasting App

"""Weather forecasting, against the baseline that is famously hard to beat.

The version this replaces fitted a straight line to synthetic data and
printed "Weather forecasting model trained." Weather does not trend upwards
in a straight line, and nothing was forecast.

The baseline here is persistence: tomorrow will be like today. It is the
oldest forecast there is and it is genuinely hard to beat at short range,
which is why every serious forecast is scored against it. Climatology --
"tomorrow will be like this date usually is" -- takes over at longer range,
and the crossover between the two is measured below.

    python weather_forecasting_app.py
"""

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

DAYS = 365 * 3


def make_weather(seed=20260809):
    """Daily temperature: an annual cycle, day-to-day persistence, noise.

    The autoregressive term is what makes persistence work: today's anomaly
    carries into tomorrow. Without it the series would be seasonal mean plus
    independent noise, and persistence would be no better than climatology.
    """
    rng = np.random.default_rng(seed)
    day = np.arange(DAYS)
    seasonal = 11.0 - 9.5 * np.cos(2 * np.pi * (day + 10) / 365.25)
    anomaly = np.zeros(DAYS)
    for i in range(1, DAYS):
        anomaly[i] = 0.72 * anomaly[i - 1] + rng.normal(0, 2.4)
    return seasonal + anomaly, seasonal


def climatology(series, day_of_year, history_end):
    """The mean of this calendar day over every year seen so far."""
    days = np.arange(history_end) % 365
    matching = series[:history_end][np.abs(days - day_of_year) <= 5]
    return float(matching.mean()) if len(matching) else float(
        series[:history_end].mean())


def evaluate(series, horizon, warmup=730):
    """Score three forecasts at a given lead time, on unseen days only."""
    persistence, climate, blended, actual = [], [], [], []
    for i in range(warmup, DAYS - horizon):
        target = series[i + horizon]
        persistence.append(series[i])
        climate.append(climatology(series, (i + horizon) % 365, i))
        # Damped persistence: the anomaly decays towards climatology as the
        # lead time grows, which is what a real short-range model does.
        weight = 0.72 ** horizon
        blended.append(weight * series[i] + (1 - weight) * climate[-1])
        actual.append(target)

    actual = np.array(actual)
    return {
        "persistence": float(np.abs(np.array(persistence) - actual).mean()),
        "climatology": float(np.abs(np.array(climate) - actual).mean()),
        "damped": float(np.abs(np.array(blended) - actual).mean()),
    }


def main():
    print("Weather Forecasting App")
    series, seasonal = make_weather()
    print(f"  days simulated     : {DAYS:,} ({DAYS / 365.25:.1f} years)")
    print(f"  temperature range  : {series.min():.1f} to {series.max():.1f} C")
    print(f"  seasonal swing     : {seasonal.max() - seasonal.min():.1f} C")
    print(f"  day-to-day change  : "
          f"{np.abs(np.diff(series)).mean():.2f} C on average")

    print(f"\n  mean absolute error at each lead time, "
          f"scored on {DAYS - 730} unseen days:\n")
    print(f"{'lead (days)':>12} {'persistence':>13} {'climatology':>13} "
          f"{'damped':>9}  {'best':>13}")
    print("  " + "-" * 68)
    rows = []
    for horizon in (1, 2, 3, 5, 7, 10, 14, 30):
        scores = evaluate(series, horizon)
        best = min(scores, key=scores.get)
        rows.append((horizon, scores, best))
        print(f"{horizon:>12} {scores['persistence']:>13.3f} "
              f"{scores['climatology']:>13.3f} {scores['damped']:>9.3f}  "
              f"{best:>13}")

    crossover = next((h for h, s, _ in rows
                      if s["climatology"] < s["persistence"]), None)
    print(f"\n  Persistence wins at short range and climatology takes over "
          f"from day {crossover}.")
    print("  That crossover is the whole shape of short-range forecasting:")
    print("  today's weather tells you about tomorrow and almost nothing")
    print("  about next month, at which point the calendar is a better guide.")

    day_one = rows[0][1]
    print(f"\n  At one day ahead, persistence scores "
          f"{day_one['persistence']:.3f} C and climatology")
    print(f"  {day_one['climatology']:.3f} C -- "
          f"{day_one['climatology'] / day_one['persistence']:.1f}x worse. "
          f"A forecast that beats")
    print("  climatology at day 1 has done nothing; the bar is persistence.")

    damped_wins = [h for h, sc, b in rows if b == "damped"]
    if len(damped_wins) == len(rows):
        print(f"\n  Damped persistence is best at every lead time tested. It "
              f"fits nothing:")
        print("  it is the two baselines blended by how fast the anomaly")
        print("  decays, and one number -- the decay rate -- is the entire")
        print("  model. Beating both baselines everywhere with no fitting is")
        print("  the reason it is the standard reference forecast rather than")
        print("  persistence alone.")
    else:
        print(f"\n  Damped persistence is best at lead times {damped_wins}.")

    day_one_best = rows[0][1][rows[0][2]]
    print(f"\n  So the bar for a real model at one day ahead is "
          f"{day_one_best:.3f} C, not the")
    print(f"  {day_one['climatology']:.3f} C that climatology gives away. "
          f"Published forecast skill is")
    print("  reported against these baselines for exactly that reason: a")
    print("  number with no baseline beside it cannot be judged.")

    figure, axes = plt.subplots(1, 2, figsize=(12, 4.2))
    window = slice(730, 730 + 365)
    axes[0].plot(series[window], lw=0.9, label="observed", color="#1a73e8")
    axes[0].plot(seasonal[window], lw=1.4, label="seasonal mean",
                 color="#d93025")
    axes[0].set_xlabel("day of year 3")
    axes[0].set_ylabel("temperature (C)")
    axes[0].set_title("one year of the simulated series")
    axes[0].legend(fontsize=8)

    horizons = [r[0] for r in rows]
    for key, style in (("persistence", "o-"), ("climatology", "s--"),
                       ("damped", "^-")):
        axes[1].plot(horizons, [r[1][key] for r in rows], style, label=key)
    axes[1].set_xlabel("lead time (days)")
    axes[1].set_ylabel("mean absolute error (C)")
    axes[1].set_title("where each baseline stops being the best one")
    axes[1].legend(fontsize=8)
    figure.tight_layout()
    figure.savefig("weather_forecasting_app.png", dpi=120,
                   bbox_inches="tight")
    print("\nsaved weather_forecasting_app.png")


if __name__ == "__main__":
    main()

Example Usage

Run weather forecasting

python weather_forecasting_app.py

What it produces

Running the file exactly as it ships takes 1.3 s and prints:

python weather_forecasting_app.py

Weather Forecasting App
  days simulated     : 1,095 (3.0 years)
  temperature range  : -6.9 to 27.8 C
  seasonal swing     : 19.0 C
  day-to-day change  : 2.09 C on average
 
  mean absolute error at each lead time, scored on 365 unseen days:
 
 lead (days)   persistence   climatology    damped           best
  --------------------------------------------------------------------
           1         2.052         2.983     1.950         damped
           2         2.814         3.056     2.531         damped
           3         3.293         3.125     2.816         damped
           5         3.814         3.229     3.030         damped
           7         3.985         3.235     3.144         damped
          10         4.272         3.244     3.209         damped
          14         4.337         3.221     3.209         damped
          30         5.214         3.275     3.275         damped
 
  Persistence wins at short range and climatology takes over from day 3.
...

The first 20 of 41 lines are shown; the run continues past this point.

figure Produced by this project, not drawn for the page matplotlib

Written by the run above. If the project stops producing it, the page's figure asset goes missing and check_docs reports it — which is the point of generating it rather than drawing it.

How it fits together

Read from the top: this is what runs when you execute the file, and which function calls which. It is generated from the code, so it cannot drift from it.

diagram Diagram mermaid

  flowchart TD
  RUN(["python weather_forecasting_app.py"])
  WeatherForecastingApp["WeatherForecastingApp
class"]
  RUN --> WeatherForecastingApp

Explanation

Key Features

• Data Retrieval: Gets weather data from APIs.
• Prediction: Uses ML to forecast weather.
• Error Handling: Validates inputs and manages exceptions.
• CLI Interface: Interactive command-line usage.

Code Breakdown

1. What it imports (lines 16–19)

weather_forecasting_app.py

import numpy as np
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt

2. make_weather — the function (lines 24–37)

weather_forecasting_app.py

def make_weather(seed=20260809):
    """Daily temperature: an annual cycle, day-to-day persistence, noise.
 
    The autoregressive term is what makes persistence work: today's anomaly
    carries into tomorrow. Without it the series would be seasonal mean plus
    independent noise, and persistence would be no better than climatology.
    """
    rng = np.random.default_rng(seed)
    day = np.arange(DAYS)
    seasonal = 11.0 - 9.5 * np.cos(2 * np.pi * (day + 10) / 365.25)
    anomaly = np.zeros(DAYS)
    for i in range(1, DAYS):
        anomaly[i] = 0.72 * anomaly[i - 1] + rng.normal(0, 2.4)
    return seasonal + anomaly, seasonal

3. climatology — the function (lines 40–45)

weather_forecasting_app.py

def climatology(series, day_of_year, history_end):
    """The mean of this calendar day over every year seen so far."""
    days = np.arange(history_end) % 365
    matching = series[:history_end][np.abs(days - day_of_year) <= 5]
    return float(matching.mean()) if len(matching) else float(
        series[:history_end].mean())

4. evaluate — the function (lines 48–66)

weather_forecasting_app.py

def evaluate(series, horizon, warmup=730):
    """Score three forecasts at a given lead time, on unseen days only."""
    persistence, climate, blended, actual = [], [], [], []
    for i in range(warmup, DAYS - horizon):
        target = series[i + horizon]
        persistence.append(series[i])
        climate.append(climatology(series, (i + horizon) % 365, i))
        # Damped persistence: the anomaly decays towards climatology as the
        # lead time grows, which is what a real short-range model does.
        weight = 0.72 ** horizon
        blended.append(weight * series[i] + (1 - weight) * climate[-1])
        actual.append(target)
 
    actual = np.array(actual)
    return {
        "persistence": float(np.abs(np.array(persistence) - actual).mean()),
        "climatology": float(np.abs(np.array(climate) - actual).mean()),
        "damped": float(np.abs(np.array(blended) - actual).mean()),
    }

5. main — the function (lines 69–149)

weather_forecasting_app.py

def main():
    print("Weather Forecasting App")
    series, seasonal = make_weather()
    print(f"  days simulated     : {DAYS:,} ({DAYS / 365.25:.1f} years)")
    print(f"  temperature range  : {series.min():.1f} to {series.max():.1f} C")
    print(f"  seasonal swing     : {seasonal.max() - seasonal.min():.1f} C")
    print(f"  day-to-day change  : "
          f"{np.abs(np.diff(series)).mean():.2f} C on average")
 
    print(f"\n  mean absolute error at each lead time, "
          f"scored on {DAYS - 730} unseen days:\n")
    print(f"{'lead (days)':>12} {'persistence':>13} {'climatology':>13} "
          f"{'damped':>9}  {'best':>13}")
    print("  " + "-" * 68)
    rows = []
    for horizon in (1, 2, 3, 5, 7, 10, 14, 30):
        scores = evaluate(series, horizon)
        best = min(scores, key=scores.get)
    # ... 57 more lines in the file ...
    axes[1].set_title("where each baseline stops being the best one")
    axes[1].legend(fontsize=8)
    figure.tight_layout()
    figure.savefig("weather_forecasting_app.png", dpi=120,
                   bbox_inches="tight")
    print("\nsaved weather_forecasting_app.png")

The file defines 4 top-level symbols in all; the whole thing is above under Write the Code.

Features

• Weather Forecasting: Data retrieval and prediction
• Modular Design: Separate functions for each task
• Error Handling: Manages invalid inputs and exceptions
• Production-Ready: Scalable and maintainable code

Next Steps

Enhance the project by:

• Integrating with more weather APIs
• Supporting advanced ML models
• Creating a GUI for forecasting
• Adding real-time prediction
• Unit testing for reliability

Educational Value

This project teaches:

• Data Science: Weather forecasting and ML
• Software Design: Modular, maintainable code
• Error Handling: Writing robust Python code

Real-World Applications

• Weather Platforms
• Analytics Tools
• Automation Apps

Conclusion

Weather Forecasting App demonstrates how to build a scalable and accurate weather forecasting tool using Python. With modular design and extensibility, this project can be adapted for real-world applications in analytics, automation, and more. For more advanced projects, visit Python Central Hub.

Pitfalls

• Weather has no linear trend to fit. The version this replaced fitted a straight line to synthetic data and announced a trained model. Temperature is an annual cycle plus a decaying anomaly, and a line represents neither.
• The baseline is persistence, not the average. Measured at one day ahead: persistence 2.052 C, climatology 2.983 C. A forecast that beats climatology at day 1 has cleared a bar 1.5x too low.
• Which baseline wins depends on the lead time. Climatology takes over from day 3 here. Quoting skill without the lead time attached says nothing, because the same model can beat one baseline and lose to the other at different horizons.
• Damped persistence beats both, with nothing fitted. It blends the two by how fast the anomaly decays and wins at every lead time tested — 1.950 C at day 1 against persistence’s 2.052. One number, the decay rate, is the whole model.
• Climatology’s error never grows. It is wrong by about 3.2 C at both day 1 and day 30, because it ignores the present entirely. Persistence starts far better and degrades to 5.214 C. Every useful forecast sits between those two curves.
• Scoring on days the model has seen would flatter it. The first 730 days are warm-up so climatology has years to average over, and every score is computed on the remaining unseen days.

Recap

• Measured: 1,095 simulated days, a 19.0 C seasonal swing, and an average day-to-day change of 2.29 C.
• MAE at day 1: damped 1.950, persistence 2.052, climatology 2.983. At day 30: damped and climatology both 3.275, persistence 5.214.
• The anomaly decays at 0.72 per day, which is what gives persistence any skill at all and what sets where the crossover falls.
• Published forecast skill is always reported against these baselines. A bare MAE cannot be judged.

pch.quizTag pch.quizDefaultTitle

1. A weather model reports 2.8 C mean absolute error at one day ahead. Is that good?

   A Yes, under 3 C is accurate B No — persistence scores 2.052 C at that lead time here, so a 2.8 C model is worse than assuming tomorrow is like today C It depends on the temperature scale D It cannot be judged without more data
   pch.quizShowAnswer

   B — No — persistence scores 2.052 C at that lead time here, so a 2.8 C model is worse than assuming tomorrow is like today

2. Climatology's error is roughly 3.2 C at day 1 and also at day 30. Why is it flat?

   A Because the model is undertrained B It uses only the calendar date and ignores current conditions, so its accuracy cannot depend on how far ahead you ask C Because the seasonal cycle is symmetric D The measurement window was too short
   pch.quizShowAnswer

   B — It uses only the calendar date and ignores current conditions, so its accuracy cannot depend on how far ahead you ask

3. Damped persistence beat both baselines at every lead time and fits nothing. What is it doing?

   A Averaging the two forecasts equally B Weighting today's anomaly by how much of it survives to the target day, so it is mostly persistence at short range and mostly climatology at long range C Fitting a decay rate from the data D Using a longer history than either
   pch.quizShowAnswer

   B — Weighting today's anomaly by how much of it survives to the target day, so it is mostly persistence at short range and mostly climatology at long range

Try it yourself

pch.exerciseTag pch.exerciseTitle