A Weather Application is a practical Python project that allows users to check weather information for a particular city. The application can connect to a weather API, send a request for a city, receive weather data in JSON format, and display useful information such as temperature, humidity, and weather conditions. This project is useful for beginners because it combines Python programming with APIs, HTTP requests, JSON data, user input, and error handling.

Table of Contents

What is a Weather Application?

A Weather Application is a program that retrieves weather information for a particular location.

1. Instead of storing weather data manually, the application obtains updated information from an online weather service through an API.
2. The application can display information such as the current temperature, humidity, atmospheric pressure, and weather description.
3. The exact information available depends on the weather API being used.

Why Build a Weather Application in Python?

A Weather Application is a useful project for learning how Python interacts with external services.

1. API Integration: The project teaches how Python programs can communicate with external APIs.
2. HTTP Requests: The requests module can be used to send requests to a weather service.
3. JSON Data: Weather APIs commonly return information in JSON format, which Python can process easily.
4. User Input: The user can enter a city name to request weather information.
5. Error Handling: The application can handle invalid cities, network problems, and API errors.
6. Practical Learning: The project combines several Python concepts into a real-world application.

How Does a Weather Application Work?

The Weather Application follows a simple process for retrieving and displaying weather information.

1. Enter the City: The user enters the name of a city.
2. Create the API Request: The program creates a URL containing the city name and API key.
3. Send the Request: Python sends an HTTP request to the weather API.
4. Receive the Response: The API returns weather information, usually in JSON format.
5. Check the Response: The program checks whether the request was successful.
6. Extract Weather Data: Python extracts required information such as temperature, humidity, and description.
7. Display the Result: The weather information is displayed to the user.

Getting a Weather API Key

Most online weather services require an API key to access their data. An API key is a unique value provided by the service to authenticate requests.
For example, a weather service may provide a URL structure similar to:

https://api.example.com/weather?q=city&appid=YOUR_API_KEY

Replace YOUR_API_KEY with the API key provided by the weather service.
The API key should not be directly exposed in public source code. For real projects, it is better to store the key in an environment variable.

Installing the requests Module

The requests module can be used to send HTTP requests from Python.
Install it using the following command:

pip install requests

After installation, the module can be imported into the Python program.

# Python program to import the requests module
import requests
print("Requests module imported successfully.")

Output:

Requests module imported successfully.

Taking City Input

The input() function can be used to allow the user to enter a city name.

# Python program to take a city name from the user
city = input("Enter city name: ")
print("Selected city:", city)

Output:

Enter city name: Pune
Selected city: Pune

The entered city can then be included in the weather API request.

Sending a Weather API Request

The requests.get() function can be used to send a GET request to a weather API.
A basic request can be created using the city name and API key.

# Python program to send a weather API request
import requests
api_key = "YOUR_API_KEY"
city = "Pune"
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
response = requests.get(url)
print("Status Code:", response.status_code)

Output:

Status Code: 200

A status code of 200 generally indicates that the request was successful. Replace the placeholder API key with a valid key from the weather service being used.

Reading Weather Data

Weather APIs commonly return data in JSON format. The .json() method of a requests response can convert the JSON response into Python data structures.

# Python program to read weather data from an API response
import requests
api_key = "YOUR_API_KEY"
city = "Pune"
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}"
response = requests.get(url)
weather_data = response.json()
print(weather_data)

The response may contain information such as the city name, temperature, humidity, pressure, and weather description.

Displaying Weather Information

After receiving the JSON response, specific values can be extracted from it.
For example, the temperature and humidity can be accessed from the main object, while the weather description can be accessed from the weather data.

# Python program to display weather information
import requests
api_key = "YOUR_API_KEY"
city = "Pune"
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
response = requests.get(url)
if response.status_code == 200:
    data = response.json()
    temperature = data["main"]["temp"]
    humidity = data["main"]["humidity"]
    description = data["weather"][0]["description"]
    print("City:", city)
    print("Temperature:", temperature, "°C")
    print("Humidity:", humidity, "%")
    print("Weather:", description)
else:
    print("Unable to retrieve weather information.")

Output:

City: Pune
Temperature: 25.4 °C
Humidity: 72 %
Weather: clear sky

The actual weather values will change depending on the location and current weather conditions.

Handling API Errors

A weather application should handle errors properly. For example, the user may enter an invalid city, the API key may be incorrect, or the network connection may fail.
The try-except statement can be used to handle request-related errors.

# Python program to handle weather API errors
import requests
api_key = "YOUR_API_KEY"
city = input("Enter city name: ")
url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"
try:
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    data = response.json()
    print("City:", data["name"])
    print("Temperature:", data["main"]["temp"], "°C")
    print("Humidity:", data["main"]["humidity"], "%")
    print("Weather:", data["weather"][0]["description"])
except requests.exceptions.HTTPError:
    print("Unable to find weather information for this city.")
except requests.exceptions.RequestException:
    print("A network error occurred.")
except KeyError:
    print("Unexpected weather data received.")

The timeout prevents the program from waiting indefinitely for a response. The raise_for_status() method raises an exception when the HTTP response indicates an error.

Complete Weather Application

The following program combines user input, API requests, JSON processing, temperature conversion, and error handling into a complete Weather Application.

# Python program to create a complete weather application
import requests
API_KEY = "YOUR_API_KEY"
BASE_URL = "https://api.openweathermap.org/data/2.5/weather"
city = input("Enter city name: ").strip()
if not city:
    print("City name cannot be empty.")
else:
    parameters = {
        "q": city,
        "appid": API_KEY,
        "units": "metric"
    }
    try:
        response = requests.get(
            BASE_URL,
            params=parameters,
            timeout=10
        )
        if response.status_code == 404:
            print("City not found. Please check the city name.")
        else:
            response.raise_for_status()
            data = response.json()
            city_name = data["name"]
            country = data["sys"]["country"]
            temperature = data["main"]["temp"]
            feels_like = data["main"]["feels_like"]
            humidity = data["main"]["humidity"]
            pressure = data["main"]["pressure"]
            description = data["weather"][0]["description"]
            print("\n===== Weather Information =====")
            print("Location:", city_name, country)
            print("Temperature:", temperature, "°C")
            print("Feels Like:", feels_like, "°C")
            print("Humidity:", humidity, "%")
            print("Pressure:", pressure, "hPa")
            print("Condition:", description)
    except requests.exceptions.RequestException:
        print("Unable to connect to the weather service.")
    except KeyError:
        print("Unexpected weather data received.")

How the complete program works:

1. Store the API Key: The API key is stored in the API_KEY variable.
2. Take the City Name: The user enters the city for which weather information is required.
3. Create Parameters: The city name, API key, and metric unit are stored in a dictionary.
4. Send the Request: The requests.get() method sends the request to the weather service.
5. Check for Errors: The program checks the response and handles HTTP and network errors.
6. Convert the Response: The .json() method converts the API response into Python data.
7. Extract Information: Required weather values are extracted from the response.
8. Display the Weather: The application displays the location, temperature, humidity, pressure, and weather condition.

Advantages of a Weather Application

1. Practical Project: The application demonstrates how Python can be used to build a real-world application.
2. API Experience: It provides practical experience with consuming external APIs.
3. JSON Processing: It helps beginners understand how structured JSON data can be processed in Python.
4. User Interaction: Users can enter different cities and retrieve their weather information.
5. Easy to Extend: The application can be expanded with forecasts, graphical interfaces, weather icons, location detection, or data storage.

Common Beginner Mistakes

1. Exposing the API Key: Beginners may directly publish their API key in a public repository. API keys should be stored securely using environment variables or another suitable secret-management method.
2. Forgetting to Install requests: The program will not work if the requests module has not been installed in the Python environment.
3. Ignoring API Errors: The application should check the response before attempting to access weather data.
4. Using Incorrect JSON Keys: Weather API responses have a specific structure, so the correct keys must be used when extracting information.
5. Not Handling Network Problems: API requests can fail because of connection problems or timeouts, so appropriate exception handling should be included.

Conclusion

The Weather Application is a practical Python project that demonstrates how to communicate with an external API and process JSON data. It combines user input, HTTP requests, API authentication, conditional statements, dictionaries, and exception handling in one project. Beginners can further improve the application by adding a graphical interface, multi-day forecasts, weather icons, search history, and secure environment-variable configuration.

Frequently Asked Questions

1. What is a Weather Application in Python?

A Weather Application is a Python program that retrieves weather information for a location from a weather API and displays it to the user.

2. Which Python module can be used to call a weather API?

The requests module can be used to send HTTP requests to a weather API.

3. What is an API key?

An API key is a value provided by an API service to identify and authenticate requests made by an application.

4. Why is JSON used in a Weather Application?

JSON provides a structured format for returning weather information, making it convenient for Python programs to read and process the data.

5. How can the Weather Application be improved?

The application can be improved by adding weather forecasts, a graphical user interface, weather icons, multiple locations, search history, and secure API-key management.