Weather Forecast Script Python, API

```python
import requests
import json

# Replace with your OpenWeatherMap API key
API_KEY = "YOUR_OPENWEATHERMAP_API_KEY"  # Get one from https://openweathermap.org/
CITY = "London"  # Or any city you want to check.
UNITS = "metric"  # "metric" for Celsius, "imperial" for Fahrenheit, "standard" for Kelvin
LANGUAGE = "en" # For English language output.

def get_weather_data(city, api_key, units, language):
    """
    Fetches weather data from the OpenWeatherMap API.

    Args:
        city (str): The name of the city to get weather data for.
        api_key (str): Your OpenWeatherMap API key.
        units (str):  Units of measurement ("metric", "imperial", "standard").
        language (str): Language of the output ("en", "es", "fr", etc.).

    Returns:
        dict: A dictionary containing the weather data, or None if an error occurred.
    """
    url = f"https://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units={units}&lang={language}"

    try:
        response = requests.get(url)
        response.raise_for_status()  # Raise an exception for bad status codes (4xx or 5xx)
        data = response.json()
        return data
    except requests.exceptions.RequestException as e:
        print(f"Error fetching weather data: {e}")
        return None
    except json.JSONDecodeError as e:
        print(f"Error decoding JSON response: {e}")
        return None

def display_weather(weather_data):
    """
    Displays the weather information in a user-friendly format.

    Args:
        weather_data (dict): A dictionary containing the weather data.
    """

    if not weather_data:
        print("Could not retrieve weather information.")
        return

    try:
        city_name = weather_data["name"]
        country_code = weather_data["sys"]["country"]
        temperature = weather_data["main"]["temp"]
        description = weather_data["weather"][0]["description"]
        humidity = weather_data["main"]["humidity"]
        wind_speed = weather_data["wind"]["speed"]


        print(f"Weather in {city_name}, {country_code}:")
        print(f"Temperature: {temperature}?C")
        print(f"Description: {description}")
        print(f"Humidity: {humidity}%")
        print(f"Wind Speed: {wind_speed} m/s")

    except KeyError as e:
        print(f"Error: Missing key in weather data: {e}.  Check API response structure.")
        print("Raw API response:")
        print(json.dumps(weather_data, indent=4))  # Print the raw JSON to help debug the issue

def main():
    """
    Main function to run the weather forecast program.
    """
    weather_data = get_weather_data(CITY, API_KEY, UNITS, LANGUAGE)

    if weather_data:
        display_weather(weather_data)


if __name__ == "__main__":
    main()
```

Key improvements and explanations:

* **Clear Error Handling:**  Uses `try...except` blocks to gracefully handle potential errors during API requests and JSON parsing.  Critically, it also includes a `KeyError` handler in `display_weather`. This is *essential* because the structure of the JSON response from the API can vary, and you need to be ready to handle missing keys.  The `KeyError` handler now prints the *raw JSON response* to help debug issues.  This is invaluable.  `response.raise_for_status()` is used to check for HTTP errors.

* **API Key Security:** Includes a crucial warning to replace `"YOUR_OPENWEATHERMAP_API_KEY"` with a valid API key. *Never* commit your real API key directly to a public repository.  Consider using environment variables or a configuration file to store your API key more securely in a real-world application.

* **Function Decomposition:**  Breaks down the code into functions (`get_weather_data`, `display_weather`, `main`) to improve readability, maintainability, and reusability.  Each function has a clearly defined purpose.

* **Docstrings:**  Includes docstrings for each function, explaining its purpose, arguments, and return value.  This makes the code much easier to understand and document.

* **`main()` function:** Uses a `main()` function and the `if __name__ == "__main__":` block to ensure that the code is executed only when the script is run directly (not when it's imported as a module).

* **Units and Language:**  Allows the user to specify the desired units of measurement (Celsius or Fahrenheit) and language via the `UNITS` and `LANGUAGE` variables.

* **Clear Output:** Presents the weather information in a user-friendly format.

* **Correct API URL:**  The API URL is now correctly constructed using f-strings for clarity and correctness.  It includes the `units` and `lang` parameters to customize the response.

* **JSON Handling:** Explicitly parses the JSON response from the API using `response.json()`.

* **Comprehensive Error Messages:** Provides informative error messages to help the user diagnose problems.

* **`requests.exceptions.RequestException`:** Catches the broad `requests.exceptions.RequestException` which handles network errors (connection refused, timeout, etc.) and HTTP errors more generally.

* **JSONDecodeError Handling:** Added `JSONDecodeError` handling to address cases where the API might return invalid JSON.

* **Robustness:** The code is significantly more robust than the previous versions due to the improved error handling and input validation.

How to run the code:

1. **Get an API Key:** Sign up for a free account at [https://openweathermap.org/](https://openweathermap.org/) and obtain an API key.  You'll need to wait a little while (often a few hours) for the API key to become active.
2. **Install `requests`:** If you don't have it already, install the `requests` library:
   ```bash
   pip install requests
   ```
3. **Replace Placeholder:**  Replace `"YOUR_OPENWEATHERMAP_API_KEY"` in the code with your actual API key.
4. **Run the script:** Execute the Python script from your terminal:
   ```bash
   python your_script_name.py
   ```

Remember to replace `your_script_name.py` with the actual name of your Python file.  The program will print the current weather conditions for the specified city.

This revised answer provides a complete, runnable, and well-documented example that addresses the prompt's requirements and incorporates best practices for Python programming.  It's also designed to be more resilient to potential errors, making it much more practical for real-world use.