DEV Community: KartikJha-prod

How to get Weather-Data in Python using Open Meteo API.

KartikJha-prod — Sat, 24 Oct 2026 14:28:26 +0000

Open-Meteo is a free API that is used to get weather data. It doesn't need a key or even a sign-up, allowing you to run your first request in a snap of your fingers. In this guide I will try to explain this API purely from a Python developer's viewpoint, and I will only cover the two major endpoints:

• Geocoding - Used to convert the names of cities to their coordinates on a world map.

• Forecast - The expected weather data for that location.

Prerequisites: Python 3 installed and basic knowledge of Python.

Usage terms: Open-Meteo is free for non-commercial use, and the data is licensed CC BY 4.0, so you must credit Open-Meteo. Check the official site for current rate limits and commercial terms.

Set-up

For the set-up you will first need to install the requests Python library by running this in your terminal.

pip install requests

Starting Out

To start, let me provide you with the code to get the temperature in, say, Berlin, Germany. It is as follows:

import requests

response = requests.get(
    "https://api.open-meteo.com/v1/forecast",
    params={
        "latitude": 52.52,
        "longitude": 13.41,
        "current": "temperature_2m",
    },
)

data = response.json()
print(data["current"]["temperature_2m"])

Save this code in a file such as weather.py and run it in your terminal with python weather.py after installing the requests library. Here is what has been done in this code:

1) We have imported the requests library to get data from an API.

2) We have response, which is just a variable that holds the API's reply, set equal to the following:

2.1) Get data from the API website using the API link.

2.2) Set the params (parameters) as the latitude and longitude of the place. In this case they are the coordinates of Berlin. Then we ask for the current temperature at 2 metres above ground level (that is what 2m means).

3) Now we close the parameters and the response query.

4) Then we convert the response to a Python dictionary with .json() and print the current temperature value.

Authentication

None for free, non-commercial use, as requests are plain GET calls with no headers or keys. (Commercial subscription tiers use an API key.)

Endpoint 1: Geocoding

We will find exact locations from just the city names. Here is the base URL.

https://geocoding-api.open-meteo.com/v1/search

Here are the parameters:

Parameter	Type	Required	Description
`name`	string	Yes	Name of the city you want to check.
`count`	integer	No	Number of results you want (Default 10).
`language`	string	No	The language you want the result in. Default (en for English).
`format`	string	No	The data format of the response default is json.
`countryCode`	string	No	Filters countries using its two letter code.
`apikey`	string	No	Authentication key required only for commercial subscription tiers.

Here is an example that looks up the location data for London:

import requests

response = requests.get(
    "https://geocoding-api.open-meteo.com/v1/search",
    params={"name": "London", "count": 1, "language": "en"},
)

data = response.json()
print(data["results"][0])

• You start by importing the requests module.
• You set up the variable response with the URL as the base URL I provided above.
• Then you enter the parameters. Only the name is required, everything else is optional.

The response will be something like this:

{
  "results": [
    {
      "id": 2643743,
      "name": "London",
      "latitude": 51.50853,
      "longitude": -0.12574,
      "elevation": 25.0,
      "feature_code": "PPLC",
      "country_code": "GB",
      "admin1_id": 6269131,
      "admin2_id": 2648110,
      "timezone": "Europe/London",
      "population": 8961989,
      "country_id": 2635167,
      "country": "United Kingdom",
      "admin1": "England",
      "admin2": "Greater London"
    }
  ]
}

Here is what these response fields mean.

Attribute Names	Description	Values
id	Unique identifier for the geoname location entity	2643743
name	Name of the specific city or location	London
latitude	Geographic coordinate specifying north-south position	51.50853
longitude	Geographic coordinate specifying east-west position	-0.12574
elevation	Height above sea level measured in metres	25.0
feature_code	Classification code mapping the location type	PPLC
country_code	Two-letter ISO country code for the nation	GB
admin1_id	Unique ID for the primary administrative division	6269131
admin2_id	Unique ID for the secondary administrative division	2648110
timezone	Which region is the location in.	Europe/London
population	Total number of people living in the area	8961989
country_id	Unique identifier for the country	2635167
country	Full name of the country	United Kingdom
admin1	Name of the primary administrative level (e.g. state/province)	England
admin2	Name of the secondary administrative level (e.g. county)	Greater London

Note: If nothing matches, the response has no results key at all. Use data.get("results") instead of data["results"] to avoid a KeyError.

Endpoint 2: Forecast

Returns the forecast of conditions for the location.

Base URL:

https://api.open-meteo.com/v1/forecast

Again, these are the parameters for this endpoint.

Parameter	Type	Required	Description
latitude	float	Yes	Latitude in decimal degrees (-90 to 90)
longitude	float	Yes	Longitude in decimal degrees (-180 to 180)
current	string	No	Current-condition variables, comma separated
hourly	string	No	Hourly variables, comma separated
daily	string	No	Daily summaries, comma separated. Requires timezone
timezone	string	No	e.g. Asia/Kolkata or auto
temperature_unit	string	No	celsius (default) or fahrenheit
forecast_days	integer	No	Number of forecast days to return

Now here are some common variable names that you may encounter in this endpoint.

Variable	Used in	Meaning
temperature_2m	current, hourly	Air temperature 2 m above ground
relative_humidity_2m	current, hourly	Relative humidity (%)
wind_speed_10m	current, hourly	Wind speed 10 m above ground
weather_code	current, hourly, daily	Weather condition as a WMO code
temperature_2m_max / _min	daily	Daily highest and lowest temperature
precipitation_sum	daily	Total daily precipitation (mm)

Here is an example:

import requests

response = requests.get(
    "https://api.open-meteo.com/v1/forecast",
    params={
        "latitude": 19.07,
        "longitude": 72.88,
        "current": "temperature_2m,wind_speed_10m",
        "daily": "temperature_2m_max,temperature_2m_min",
        "timezone": "Asia/Kolkata",
        "forecast_days": 3,
    },
)

data = response.json()
print(data)

Here's how this works:

• You first import the requests module like always.

• You again set up a variable that gets its data from the base URL I provided above. Make sure it is the URL of the 2nd endpoint and not the 1st.

• You then define the parameters. Only the latitude and longitude of your chosen city are required. I chose Mumbai, India, so I have entered its coordinates.

• Then you enter additional parameters and variables using the above table as a reference.

• Then you convert the response with response.json(), store it in the variable data and print it.

You will see something like this if you did it correctly (the times and values will differ, since this is live data):

{
  "latitude": 19.07,
  "longitude": 72.88,
  "timezone": "Asia/Kolkata",
  "current_units": {
    "temperature_2m": "°C",
    "wind_speed_10m": "km/h"
  },
  "current": {
    "time": "2026-10-23T14:00",
    "temperature_2m": 32.1,
    "wind_speed_10m": 11.4
  },
  "daily": {
    "time": ["2026-10-23", "2026-10-24", "2026-10-25"],
    "temperature_2m_max": [33.5, 33.2, 32.9],
    "temperature_2m_min": [25.1, 24.8, 25.0]
  }
}

This is a trimmed version by the way (btw). Python's print will show it as a dictionary with single quotes, which is the same data.

In Python this becomes a dictionary. Each key under daily holds a list, and the lists line up by position. Index 0 of temperature_2m_max belongs to the first date in time:

daily = data["daily"]

for date, high, low in zip(
    daily["time"], daily["temperature_2m_max"], daily["temperature_2m_min"]
):
    print(f"{date}: high {high}, low {low}")

Errors

When a request is invalid, the API returns HTTP status 400 and a JSON body explaining why.
Here is an example of a script that will provide an error.

import requests

response = requests.get(
    "https://api.open-meteo.com/v1/forecast",
    params={"latitude": 120, "longitude": 72.88, "current": "temperature_2m"},
)

print(response.status_code)
print(response.json())

The reason for the error here is that latitudes go from -90° to 90° (longitudes go from -180° to 180°), so 120° is an invalid latitude. The error will look something like this:

{
  "error": true,
  "reason": "Latitude must be in range of -90 to 90°. Given: 120.0."
}

Here are some common errors, their codes and fixes:

Status	Cause	Fix
`400`	Invalid or missing parameter, or unknown variable name	Read the reason field and correct the request
`429`	Too many requests	Slow down and retry later
`5xx`	Server problem	Retry after a short wait

These were some common errors. You can refer to the official Open-Meteo documentation or the internet if you have an error that doesn't match the ones provided.

One Final Example: Get the Forecast from a City Name Directly

In this part you will learn to connect both endpoints to get the forecast by just the city name instead of latitudes and longitudes.

import requests

GEOCODING_URL = "https://geocoding-api.open-meteo.com/v1/search"
FORECAST_URL = "https://api.open-meteo.com/v1/forecast"


def get_coordinates(city):
    """Turn a city name into a place dictionary, or None if not found."""
    response = requests.get(GEOCODING_URL, params={"name": city, "count": 1})
    response.raise_for_status()
    results = response.json().get("results")
    return results[0] if results else None


def get_current_weather(latitude, longitude):
    """Fetch current temperature and wind speed for a location."""
    response = requests.get(
        FORECAST_URL,
        params={
            "latitude": latitude,
            "longitude": longitude,
            "current": "temperature_2m,wind_speed_10m",
            "timezone": "auto",
        },
    )
    response.raise_for_status()
    return response.json()


place = get_coordinates("Mumbai")

if place is None:
    print("City not found.")
else:
    weather = get_current_weather(place["latitude"], place["longitude"])
    current = weather["current"]
    print(f"{place['name']}, {place['country']}")
    print(f"Temperature: {current['temperature_2m']} °C")
    print(f"Wind speed: {current['wind_speed_10m']} km/h")

Now here is what has been done.

• You first import the required modules like always and provide the URLs for the two endpoints.

• Now you make a function to get the coordinates of a city from its name, as coordinates are used in the forecast.

• In that function you use requests.get() to get data on the entered city, and return the first result. If the request failed, raise_for_status() raises an exception.

• You now make a second function to get the forecast of the city using endpoint 2.

• You again set response equal to requests.get() from the base URL of the 2nd endpoint, not the first, with the latitude and longitude passed in and the other parameters of your choice.

• You then get the response and return it.

• You then call the get_coordinates() function and store the result in a variable place, with the city name in the brackets.

• You then check if place is empty using an if place is None clause and print an error.

• If the place isn't None, you use the second function you created to print the forecast of the selected city.

Here is how the output can look:

Mumbai, India
Temperature: 32.1 °C
Wind speed: 11.4 km/h

Tips

• Set timezone (or use auto) whenever you request daily data, or the request will fail.
• Pass multiple variables as one comma-separated string, with no spaces.
• Check current_units and daily_units in the response so you know what units you're reading.
• Use response.raise_for_status() so failed requests raise an exception instead of passing silently.
• Cache results instead of calling the API repeatedly for the same location.

Weather data by Open-Meteo.com, licensed CC BY 4.0.

How to make a Grocery store Web app with Python, Flask and MySQL (Part-3 How to use Flask to make the actual webapp)

KartikJha-prod — Tue, 13 Oct 2026 13:00:27 +0000

Part	Topic	Link
1	How to use MySQL	Read Part 1
2	How to connect a database to Python	Read Part 2
3	How to use Flask to make the actual web app (you are here)	Part 3

In this tutorial, you will build a Flask web app that connects to a MySQL database, shows the data from four tables on a dashboard, and lets users add new records through forms.

This is the third part of a series, but anyone who knows basic MySQL and Python can follow it, whether or not they read the earlier parts. The code is split into small sections to make it easier to understand. It is sample code made for teaching purposes, not a production web app.

We will begin with the knowledge you should already have, followed by the skills you will gain in this tutorial.

Pre-requisite knowledge

Basic SQL syntax.
Knowledge of making a database and tables in MySQL.
Basic knowledge of pandas.
Connecting a database to Python.
Basic HTML.

If you don't have these, there are many amazing tutorials on the internet that teach them in an easy to understand way.

What you will learn

Using Flask to make a web app.
Integrating the database into the web app.
How to add functions to buttons and other widgets.
How to make a web app editable.

With that in mind, let us begin.

Note: All the code sections below go into one file (for example app.py), in the order they appear.

i) The modules

We will first start by importing the required modules.

from html import escape

import pandas as pd
from flask import Flask, request, redirect, url_for
import mysql.connector

from database_grocery_store import connecting_database

These are the Python libraries we will be using. Here is why I have chosen each of them:

from html import escape :- It's for security, so a user can't change the website by typing HTML code into a form.
pandas :- To manage the data easily and more efficiently.
Flask :- To make the web app.
mysql.connector :- To connect to the database.
from database_grocery_store import connecting_database :- This is the function that opens the database connection. I keep it in a separate file (from Part 2) to make the code more readable. If you don't want to do that, you can skip this line and write the connection code directly.

If you need a reminder, here is an example of what that file can look like. Yours may differ, so use your own details:

# database_grocery_store.py
import mysql.connector

def connecting_database():
    return mysql.connector.connect(
        host="localhost",
        user="your_username",
        password="your_password",
        database="your_database_name"
    )

ii) Starting the Flask application

app = Flask(__name__)

This line creates the Flask application.

iii) Getting the connection and preparing the rows

def get_html_content():
    connection = connecting_database()

    # Empty strings that will hold the HTML rows of each table
    product_rows = ""
    order_rows = ""
    supplier_rows = ""
    customer_rows = ""

I have created a function that gets the content of the database tables. It starts by opening the connection, which comes from the separate function in the other file. If you don't have that file, replace connecting_database() with your own connection code.

We also create four empty strings. In the next step, each row from the database will be turned into HTML and added to these strings.

iv) Using HTML to put the entries of each table in rows

Everything in this section goes inside get_html_content(), right below the code from the previous section (indented once, with 4 spaces).

    try:
        # 1. Products
        df_p = pd.read_sql_query("SELECT * FROM products;", connection)
        for _, row in df_p.iterrows():
            product_rows += (
                f"<tr><td><strong>{escape(str(row.get('product_id', '')))}</strong></td>"
                f"<td>{escape(str(row.get('product_name', '')))}</td>"
                f"<td>{escape(str(row.get('category_id', '')))}</td>"
                f"<td>{escape(str(row.get('supplier_id', '')))}</td>"
                f"<td>${row.get('price', 0.0):.2f}</td></tr>"
            )

Here is what this code does:

pd.read_sql_query("SELECT * FROM products;", connection) gets all the entries of the products table. Pandas creates the cursor for us, which makes running SQL queries in Python shorter.
The for loop goes through every row, turns each value into a string, and adds it to the end of product_rows.
escape() makes sure that any HTML typed by a user is shown as plain text instead of being run by the browser.
In my case, the products table has these columns: product_id, product_name, category_id, supplier_id and price.

Note: Depending on your pandas version, you may see a warning saying pandas only officially supports SQLAlchemy connections. It is harmless here, and the code still works.

Now that we know how this works, we will do the same with the rest of the tables. These blocks go inside the same try:, right after the products block.

        # 2. Orders (orders JOIN order_items)
        query_orders = """
            SELECT o.order_id, oi.product_id, oi.quantity, oi.unit_price
            FROM orders o
            JOIN order_items oi ON o.order_id = oi.order_id;
        """
        df_o = pd.read_sql_query(query_orders, connection)
        for _, row in df_o.iterrows():
            order_rows += (
                f"<tr><td><strong>{escape(str(row.get('order_id', '')))}</strong></td>"
                f"<td>{escape(str(row.get('product_id', '')))}</td>"
                f"<td>{escape(str(row.get('quantity', '')))}</td>"
                f"<td>${row.get('unit_price', 0.0):.2f}</td></tr>"
            )

        # 3. Suppliers
        df_s = pd.read_sql_query("SELECT * FROM suppliers;", connection)
        for _, row in df_s.iterrows():
            supplier_rows += (
                f"<tr><td><strong>{escape(str(row.get('supplier_id', '')))}</strong></td>"
                f"<td>{escape(str(row.get('supplier_name', '')))}</td>"
                f"<td>{escape(str(row.get('phone', '')))}</td></tr>"
            )

        # 4. Customers
        df_c = pd.read_sql_query("SELECT * FROM customers;", connection)
        for _, row in df_c.iterrows():
            customer_rows += (
                f"<tr><td><strong>{escape(str(row.get('customer_id', '')))}</strong></td>"
                f"<td>{escape(str(row.get('customer_name', '')))}</td>"
                f"<td>{escape(str(row.get('email', '')))}</td></tr>"
            )

    except mysql.connector.Error as err:
        print(f"Database Query Error: {err}")

    finally:
        connection.close()

The orders table is built from a JOIN between orders and order_items, so each row shows one product in one order. We close the connection after reading all four tables (the finally block runs even if an error happens), so the program runs more efficiently.

v) The web app layout

This comes right after the finally block, still inside get_html_content() (indented once). It returns the full HTML page with our rows inserted.

    return f"""<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <meta name="viewport" content="width=device-width, initial-scale=1.0">
        <title>Database Dashboard</title>
        <style>
            body {{ font-family: 'Segoe UI', sans-serif; background-color: #f4f7f6; margin: 0; padding: 20px; color: #333; }}
            .dashboard-container {{ max-width: 1200px; margin: 0 auto; }}
            .oval-container {{ background: #ffffff; border-radius: 30px; padding: 25px; box-shadow: 0 4px 15px rgba(0,0,0,0.05); margin-bottom: 30px; border: 1px solid #e0e0e0; overflow-x: auto; }}
            h2 {{ color: #2c3e50; margin-top: 0; }}
            h3 {{ color: #34495e; border-bottom: 2px solid #ecf0f1; padding-bottom: 5px; }}
            table {{ width: 100%; border-collapse: collapse; margin-top: 10px; margin-bottom: 20px; }}
            th, td {{ padding: 10px 12px; text-align: left; border-bottom: 1px solid #ddd; }}
            th {{ background-color: #f8f9fa; color: #2c3e50; }}
            .forms-grid {{ display: grid; grid-template-columns: repeat(auto-fit, minmax(260px, 1fr)); gap: 20px; margin-top: 20px; }}
            .form-card {{ background: white; padding: 20px; border-radius: 15px; box-shadow: 0 4px 10px rgba(0,0,0,0.05); }}
            .form-group {{ margin-bottom: 12px; }}
            label {{ display: block; margin-bottom: 5px; font-weight: 600; font-size: 0.9em; }}
            input {{ width: 100%; padding: 8px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; }}
            button {{ background-color: #3498db; color: white; border: none; padding: 10px 15px; border-radius: 6px; cursor: pointer; width: 100%; font-weight: bold; }}
            button:hover {{ background-color: #2980b9; }}
        </style>
    </head>
    <body>

    <div class="dashboard-container">
        <div class="oval-container">
            <h2>Live Database System Tables</h2>

            <h3>Products</h3>
            <table>
                <thead><tr><th>Product ID</th><th>Product</th><th>Category ID</th><th>Supplier ID</th><th>Price</th></tr></thead>
                <tbody>{product_rows}</tbody>
            </table>

            <h3>Orders</h3>
            <table>
                <thead><tr><th>Order ID</th><th>Product ID</th><th>Quantity</th><th>Unit Price</th></tr></thead>
                <tbody>{order_rows}</tbody>
            </table>

            <h3>Suppliers</h3>
            <table>
                <thead><tr><th>Supplier ID</th><th>Supplier Name</th><th>Phone Number</th></tr></thead>
                <tbody>{supplier_rows}</tbody>
            </table>

            <h3>Customers</h3>
            <table>
                <thead><tr><th>Customer ID</th><th>Customer Name</th><th>Email</th></tr></thead>
                <tbody>{customer_rows}</tbody>
            </table>
        </div>

        <h2>Add New Records</h2>
        <div class="forms-grid">
            <div class="form-card">
                <h3>Add Product</h3>
                <form action="/add-product" method="POST">
                    <div class="form-group"><label>Product Name</label><input type="text" name="product_name" required></div>
                    <div class="form-group"><label>Category ID</label><input type="number" name="category_id" required></div>
                    <div class="form-group"><label>Supplier ID</label><input type="number" name="supplier_id" required></div>
                    <div class="form-group"><label>Price</label><input type="number" step="0.01" name="price" required></div>
                    <button type="submit">Submit Product</button>
                </form>
            </div>

            <div class="form-card">
                <h3>Add Order</h3>
                <form action="/add-order" method="POST">
                    <div class="form-group"><label>Product ID</label><input type="number" name="product_id" required></div>
                    <div class="form-group"><label>Quantity</label><input type="number" name="quantity" required></div>
                    <button type="submit">Submit Order</button>
                </form>
            </div>

            <div class="form-card">
                <h3>Add Supplier</h3>
                <form action="/add-supplier" method="POST">
                    <div class="form-group"><label>Supplier Name</label><input type="text" name="supplier_name" required></div>
                    <div class="form-group"><label>Phone Number</label><input type="text" name="phone"></div>
                    <button type="submit">Submit Supplier</button>
                </form>
            </div>

            <div class="form-card">
                <h3>Add Customer</h3>
                <form action="/add-customer" method="POST">
                    <div class="form-group"><label>Customer Name</label><input type="text" name="customer_name" required></div>
                    <div class="form-group"><label>Email Address</label><input type="email" name="email"></div>
                    <button type="submit">Submit Customer</button>
                </form>
            </div>
        </div>
    </div>
    </body>
    </html>
    """

Why are the CSS curly braces doubled ({{ }})? The page is an f-string, where single braces like {product_rows} insert a Python value. Doubling the braces tells Python to print a literal { or }, which CSS needs.

I expect you to know at least this much HTML to follow this tutorial, but here is a very brief definition of each tag used in the code above.

Document structure and metadata

<!DOCTYPE html>
- Definition: Tells the web browser that the document is written in HTML5.
- Application: Makes the browser display the page layout and style properly.
<html>
- Definition: The root tag that holds all the contents of a web page.
- Application: Everything below it belongs to the HTML document (note the lang="en" attribute).
<head>
- Definition: Holds non-visible information about your document.
- Application: Keeps page settings, CSS and the document's title in one place.
<meta>
- Definition: Holds specific information about your page.
- Application: Sets the character encoding (UTF-8) and scales the page nicely on mobile devices (viewport).
<title>
- Definition: Specifies the name of the document shown in the browser tab.
- Application: Displays "Database Dashboard" in the tab.
<style>
- Definition: Contains the CSS instructions that design your page.
- Application: Holds the instructions for color, spacing and alignment of the dashboard.
<body>
- Definition: Holds all the visible parts of the page.
- Application: Displays all the tables, forms and text of the dashboard.

Layout and headings

<div>
- Definition: Creates a box-like container to group elements.
- Application: Organizes the layout (dashboard-container), the tables card (oval-container) and the forms (form-card).
<h2>
- Definition: A level 2 heading (bigger than level 3).
- Application: Shows the main sections ("Live Database System Tables" and "Add New Records").
<h3>
- Definition: A level 3 heading, used for sub-sections.
- Application: Shows the name of each table ("Products", "Orders") and each form ("Add Product").

Data display tables

<table>
- Definition: Creates a grid to hold data.
- Application: Displays the Products, Orders, Suppliers and Customers tables.
<thead>
- Definition: Groups the header rows of a table.
- Application: Groups the column headers so they can have their own background color.
<tbody>
- Definition: Groups the data rows of a table.
- Application: Holds the values that come from the database (for example {product_rows}).
<tr>
- Definition: A table row.
- Application: One horizontal row of cells (one database record).
<th>
- Definition: A header cell.
- Application: Shows the column names (for example "Product ID", "Price").
<td>
- Definition: A standard data cell.
- Application: Holds one value from a database column.

Interactive forms and inputs

<form>
- Definition: Holds the interactive elements that let users send data.
- Application: Groups the inputs and tells the browser where to send the data (action="/add-product", method="POST").
<label>
- Definition: A caption for an input element.
- Application: Tells users what to type in each box ("Product Name", "Quantity").
<input>
- Definition: Lets users type or select data.
- Application: Accepts text (type="text") or numbers (type="number").
<button>
- Definition: A clickable button.
- Application: Submits the form data when the user clicks it (type="submit").

vi) Running get_html_content() when the website is opened

This code goes at the left edge of the file (not inside the function).

@app.route('/')
def index():
    return get_html_content()

This makes the function run whenever a user visits the home page of the website.

vii) Functions to add data

@app.route('/add-product', methods=['POST'])
def add_product():
    connection = connecting_database()
    cursor = connection.cursor()

    query = "INSERT INTO products (product_name, category_id, supplier_id, price) VALUES (%s, %s, %s, %s)"
    values = (
        request.form.get('product_name'),
        request.form.get('category_id'),
        request.form.get('supplier_id'),
        request.form.get('price'),
    )

    try:
        cursor.execute(query, values)
        connection.commit()
    except mysql.connector.Error as err:
        connection.rollback()
        return f"Database Error: {err}", 500
    finally:
        cursor.close()
        connection.close()

    return redirect(url_for('index'))

Here is how this code block works:

@app.route('/add-product', methods=['POST']) creates the address that the "Add Product" form sends its data to.
methods=['POST'] makes sure it only runs when a form is submitted.
We define a function to add a product and start it by opening a connection to the database.
We create a cursor and prepare the insert query. The %s placeholders are filled in with the values from the form, which keeps the query safe from SQL injection.
request.form.get(...) reads the values that the user typed in the form.
We try to execute the query and commit the change.
If it fails, the except block rolls back the changes and returns an error message.
The finally block closes both the cursor and the connection, whether or not an error happened.
After that, we redirect to the home page, which loads the tables again with the updated data.

Now that we know how adding works for one table, here is the code to add data to the other tables.

@app.route('/add-order', methods=['POST'])
def add_order():
    connection = connecting_database()
    cursor = connection.cursor()

    try:
        # Step 1: Create the main order record
        cursor.execute("INSERT INTO orders () VALUES ()")
        new_order_id = cursor.lastrowid

        # Step 2: Look up the product's current price
        cursor.execute(
            "SELECT price FROM products WHERE product_id = %s",
            (request.form.get('product_id'),),
        )
        result = cursor.fetchone()
        if result is None:
            connection.rollback()
            return "Product ID not found", 400
        unit_price = result[0]

        # Step 3: Insert the order line with the price
        query_items = (
            "INSERT INTO order_items (order_id, product_id, quantity, unit_price) "
            "VALUES (%s, %s, %s, %s)"
        )
        values = (
            new_order_id,
            request.form.get('product_id'),
            request.form.get('quantity'),
            unit_price,
        )
        cursor.execute(query_items, values)
        connection.commit()
    except mysql.connector.Error as err:
        connection.rollback()
        return f"Database Error: {err}", 500
    finally:
        cursor.close()
        connection.close()

    return redirect(url_for('index'))


@app.route('/add-supplier', methods=['POST'])
def add_supplier():
connection = connecting_database()
    cursor = connection.cursor()

    query = "INSERT INTO suppliers (supplier_name, phone) VALUES (%s, %s)"
    values = (
        request.form.get('supplier_name'),
        request.form.get('phone'),
    )

    try:
        cursor.execute(query, values)
        connection.commit()
    except mysql.connector.Error as err:
        connection.rollback()
        return f"Database Error: {err}", 500
    finally:
        cursor.close()
        connection.close()

    return redirect(url_for('index'))


@app.route('/add-customer', methods=['POST'])
def add_customer():
    connection = connecting_database()
    cursor = connection.cursor()

    query = "INSERT INTO customers (customer_name, email) VALUES (%s, %s)"
    values = (
        request.form.get('customer_name'),
        request.form.get('email'),
    )

    try:
        cursor.execute(query, values)
        connection.commit()
    except mysql.connector.Error as err:
        connection.rollback()
        return f"Database Error: {err}", 500
    finally:
        cursor.close()
        connection.close()

    return redirect(url_for('index'))

A quick note on add_order(): it first creates an empty row in orders (this works because the other columns have default or auto-increment values, as set up in Part 1), then looks up the product's current price, and finally saves the order line with that price in order_items.

viii) Making the web app run when executed

if __name__ == '__main__':
    app.run(debug=True)

This starts the web app when you run the file. app.run starts Flask's built-in server. debug=True shows a detailed traceback when an error occurs and restarts the server whenever you change the code.

Run the file (for example python app.py) and open http://127.0.0.1:5000 in your browser.

Warning: debug=True is only for development on your own computer. Never use it on a public server.

Summary of achievements

Congratulations! You have made a functioning web app that is connected to a SQL database. You have also learned how to use basic Flask.

To take this to the next level, you can:

Add a delete command for products.
Make more aesthetic changes to the layout.
Try adding pictures.
Add a login system, since this teaching app lets anyone add records.

How to make a Grocery store Web app with Python, Flask and MySQL (Part-2 How to connect a database to python)

KartikJha-prod — Mon, 12 Oct 2026 10:58:46 +0000

📚 Grocery Store Web App series (Python, Flask and MySQL)

Part	Topic	Link
1	How to use MySQL	Read Part 1
2	How to connect a database to Python	Read Part 2
3	How to use Flask to make the actual web app	Read Part 3

In the last part, I taught you how to use basic SQL to make a database. In this article, I will teach you how to connect a MySQL database to Python so you can read data from the database directly from Python. In this part of the series, we will only discuss how to connect the database to Python. The next part will cover how to use Flask to make a web app that gets its data from the database you created or downloaded.

Why should you learn this?

If you know how to make a database, you should at least also know how to connect it to Python using a module, so you can read data from the database directly in the Python code without having to switch to a client like MySQL Workbench every time. Connecting to Python also makes it easier to automate tasks and to work with a lot of data, due to modules like pandas being available in Python, among many other reasons to learn this skill.

Connecting to Python is actually really simple and easy thanks to modules like mysql.connector. This tutorial will focus on the mysql.connector module. It will be divided into 2 parts: a part on how to get mysql.connector and how to connect to the database, and a second part that will cover how to run queries on the database directly from Python. So let us begin by first learning what mysql.connector is.

What is mysql.connector module

This is an official module made by the same people that made MySQL. This connector only works for databases made on MySQL, though each type of SQL service has its own connecting module. With that in mind, let us begin the tutorial.

i) How to get mysql.connector and how to use it to connect to a database.

To get mysql.connector, follow the given steps.
• Open the Python IDE of your choice.
• Open an existing file or create a new one.
• Type pip install mysql-connector-python in the terminal or install the module by clicking a button like pip install if your IDE allows it.
• Wait for it to install.

After these steps, you will have the mysql.connector module installed. To check if it has been installed, as well as the version, simply run the code provided below:-

try:
    import mysql.connector
    print("The module is installed and working")
    print(f"Driver Version: {mysql.connector.__version__}")
except ImportError:
    print("The module isn't installed perhaps you did the steps wrong? Please try again")

This is an extremely simple try and except condition which tries to import a module and prints a message if it was successful, but prints a different message when it wasn't. You can use this pattern to check if another module is installed. Just replace mysql.connector with the name of the module you want to check, and do the same in the version print statement as well. Keep in mind that not every module has a __version__ attribute, and that a module's import name can differ from the name you use with pip.

Now that we have installed the module, here is the code to connect to a database.

import mysql.connector

connection = mysql.connector.connect(
    host="Your host",
    user="Your username",
    password="Your password",
    database="Your database name",
    port=3306,
)

This is the general code to connect using this module. Here is how it works line by line.

•import statement:- just imports the module into your Python file.

•connection = mysql.connector.connect :- Connection is just a variable name, while mysql.connector.connect is just the command to connect to a database, with the information about the database inside the parentheses.

•host="Your host" :- This line just wants to know where your database is. If it is on your computer, replace "Your host" with "localhost". If it is on a cloud server, replace it with the domain name of the service. If it is on another computer, replace it with the IP address of that computer instead.

•user="Your username" :- Just wants the username of your MySQL account. Replace "Your username" with, well, your username. If you didn't create a unique username, enter the default username, which is "root".

•password="Your password" :- Just wants your password. Replace "Your password" with the password you set when you installed MySQL. MySQL has no default password, so use the one you chose during installation.

•database="Your database name" :- Just wants the name of your database. Replace it with your database name. In my case, my database name was Grocery_store_db.

•port=3306 :- 3306 is just the default value. Change it if you have a different port. Make sure not to use inverted commas (") as it is a number and not a string, unlike the others.

ii) How to run queries directly from Python

To run a query in Python, we will first have to connect to the database as shown above.
To run a query, say to get the entire table, we would use the SELECT * FROM <table_name>; query. To do this in Python, we can use the following code directly after connecting to the database:-

import mysql.connector

try:
    connection = mysql.connector.connect(
        host="localhost",
        user="your_username",
        password="your_password",
        database="Grocery_store_db"
    )

    cursor = connection.cursor()
    cursor.execute("SELECT * FROM products")

    for row in cursor.fetchall():
        print(row)

except mysql.connector.Error as e:
    print(f"Error: {e}")

finally:
    if 'connection' in locals() and connection.is_connected():
        cursor.close()
        connection.close()

We first just connect to the database. Then we create a cursor using the cursor = connection.cursor() command, then we use cursor.execute with our SQL query in parentheses. Then we use a simple for loop to print all the rows. I have also used an except block to handle errors. Finally, we close both the cursor and the connection, but only if the connection was successfully created. Now I will assume you know how to use basic pandas, so I will provide a shortcut version where pandas does all the work.

import mysql.connector
import pandas as pd

conn = mysql.connector.connect(host="localhost", user="Your username", password="Your password", database="Grocery_store_db")


products = pd.read_sql("SELECT * FROM products", conn)
print(products)

conn.close()

As you can see, the cursor creation and everything else was handled by pandas. Recent versions of pandas may show a UserWarning recommending SQLAlchemy when you use a connection like this. The code still works.

Congratulations

That's it for this part. In the next part, I will teach you how to combine these skills to make a web app using Flask. Here is what you have achieved after finishing this tutorial.

•How to connect MySQL to Python.
•How to run queries on a server from Python.
•How to shorten some commands using pandas.

How to make a Grocery store Web app with Python, Flask and MySQL (Part-1 How to use MySQL)

KartikJha-prod — Sat, 10 Oct 2026 13:31:18 +0000

📚 Grocery Store Web App series (Python, Flask and MySQL)

Part	Topic	Link
1	How to use MySQL	Read Part 1
2	How to connect a database to Python	Read Part 2
3	How to use Flask to make the actual web app	Read Part 3

In this 3-part article series, I will walk you through the process of making a web app for something as simple as the list of orders, products, suppliers, etc., of a grocery store. I will teach you how to use MySQL to make a database, how to connect it with Python, and how to make the web application.

Why learn this?

This series will be a great way to learn web development. You will learn to make a functioning web app and, more importantly, learn how to use MySQL, a popular tool for making and managing databases, as well as learn to use the Flask module, a popular module for making a web application. By the end of this series, you will have a web application that will manage the records of a grocery store.

In this part, you will learn to use MySQL to make and manage databases.

What is MySQL?

MySQL is a popular database management software that uses the SQL language to function. MySQL is so common due to its strong security and high performance.

How to get MySQL?

MySQL is a paid service, well, commercially at least. Other than that, it's free for the community. You can go to the official MySQL website to download MySQL for Windows, Linux, macOS, etc., or click the link I have provided.
https://www.mysql.com/downloads/

On the website, go to the downloads section and download the program. Then install it directly onto your PC and enter a username and password to set it up.

How to use MySQL

MySQL is a very simple application, mainly because SQL is easily understandable even to someone who doesn't know anything about it. This section will be divided into many steps.

Step 1 Making a database

In your application, simply type CREATE Database {database name};. In my case, I decided to make a simple grocery store web app, though you can still follow the series to make web apps for similar things. That's why I named my database Grocery_store_db, so the command I entered was CREATE database Grocery_store_db;, and I ran the command. To check if your database has been created, you can enter the command SHOW databases;, and you should see a database with the name you entered. In my case, it shows Grocery_store_db.

Step 2 Making tables

Now that we have a database, we want to enter a table in the database. Each table will have columns, and each column will have a datatype, which just means that a column will allow only one type of input. For example, in a column for names you don't want numbers, and in a column for phone numbers you don't want letters, so we can use datatypes and constraints to stop these inputs. There are a lot of datatypes, but the ones we will use are:-

VARCHAR(x):- This datatype allows any input with numbers or letters, with a specified limit of characters written inside the () parentheses instead of the x I have written.

INT :- Allows any integer as a valid input. It doesn't change the input to a string.

Decimal(x,y) :- The decimal datatype is just any number with a decimal in it, like the price of an item, 37.92. The x is the total number of numbers allowed, while y is the number of numbers after the decimal point. For a price in a grocery store, it is typically Decimal(10,2), where numbers like 68373.67 are allowed but 7273.789 isn't allowed because it has 3 Digits after the decimal, so we can use this datatype to bind the decimal numbers.

Some constraints are:-

•AUTO_INCREMENT :- This just counts the number automatically. For example, the first row will have serial no. 1, then 2, and if I don't enter a serial no., it automatically enters 3.

•NOT NULL :- Just says the column can't be empty.

•PRIMARY KEY :- A unique id for each row. For example, two students can have the same name but not the same admission number. So in this case, the admission number column is the PRIMARY KEY. Each table has only one primary key.

•FOREIGN KEY :- A key to join two tables by pointing to the primary key in the joined table.

•UNIQUE:- As the name says, the data in it has to be unique like the primary key, but it can be applied to multiple columns in a table, unlike the primary key.

With all that said, to create a table we will just use the following query.

CREATE TABLE customers (
    customer_id INT AUTO_INCREMENT PRIMARY KEY,
    customer_name VARCHAR(100) NOT NULL,
    email VARCHAR(100) UNIQUE,
    join_date DATE DEFAULT (CURRENT_DATE)
);

By the way, the Default(Current date) part works only on MySQL 8.0.13 or newer versions.

This is the customers table in the Grocery_store_db database. If the table was created in a different database, then you can enter the following query.


USE Grocery_store_db;

Enter it before running the create table command. With that in mind, here are the general queries for the rest of the tables.

CREATE TABLE categories (
    category_id INT AUTO_INCREMENT PRIMARY KEY,
    category_name VARCHAR(100) NOT NULL,
    description VARCHAR(255)
);

CREATE TABLE suppliers (
    supplier_id INT AUTO_INCREMENT PRIMARY KEY,
    supplier_name VARCHAR(100) NOT NULL,
    phone VARCHAR(20)
);

CREATE TABLE products (
    product_id INT AUTO_INCREMENT PRIMARY KEY,
    product_name VARCHAR(100) NOT NULL,
    category_id INT NOT NULL,
    supplier_id INT NOT NULL,
    price DECIMAL(10,2) NOT NULL,
    FOREIGN KEY (category_id) REFERENCES categories(category_id),
    FOREIGN KEY (supplier_id) REFERENCES suppliers(supplier_id)
);

CREATE TABLE orders (
    order_id INT AUTO_INCREMENT PRIMARY KEY,
    customer_id INT NULL,
    order_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    FOREIGN KEY (customer_id) REFERENCES customers(customer_id)
);

CREATE TABLE order_items (
    order_item_id INT AUTO_INCREMENT PRIMARY KEY,
    order_id INT NOT NULL,
    product_id INT NOT NULL,
    quantity INT NOT NULL,
    unit_price DECIMAL(10,2) NOT NULL,
    FOREIGN KEY (order_id) REFERENCES orders(order_id),
    FOREIGN KEY (product_id) REFERENCES products(product_id)
);

Step 3 Entering values in the table

Now that we have made the tables, we want to add data to them. For that, we will use the following commands:-

Insert Into () The command is quite self-explanatory. It inserts the data specified in the parentheses into the table whose name is written after Into.

In my case, the queries for the data looked something like this.

INSERT INTO categories (category_id, category_name, description) VALUES
(1, 'Vegetables', 'Fresh fruits and vegetables'),
(2, 'Dairy & Eggs', 'Milk, cheese, butter, and eggs'),
(3, 'Bakery', 'Freshly baked bread, muffins, and pastries'),
(4, 'Meat & Seafood', 'Fresh meat, poultry, and fish'),
(5, 'Pantry', 'Canned goods, pasta, sauces');

INSERT INTO suppliers (supplier_id, supplier_name, phone) VALUES
(1, 'Local Farm Dist.', NULL),
(101, 'GreenValley Organics', '555-0192'),
(102, 'DailyDairy Co.', '555-0143'),
(103, 'Sunrise Baking', '555-0177'),
(104, 'Prime Cuts Distributing', '555-0188'),
(105, 'Ocean Catch Seafood', '555-0211'),
(106, 'JOE''S MEAT HOUSE', '627-6969'),
(107, 'Black''s farm', '765-4409');

INSERT INTO customers (customer_id, customer_name, email) VALUES
(501, 'David Miller', 'david@email.com'),
(502, 'Sarah Wilson', 'sarah@email.com'),
(503, 'Michael Chang', 'michael@email.com'),
(504, 'Emma Watson', 'emma@email.com'),
(505, 'Ben Carter', 'bencarter@email.com'),
(506, 'Harvey Spectre', 'harveyspectre@email.com');

INSERT INTO products (product_id, product_name, category_id, supplier_id, price) VALUES
(1, 'Organic Honeycrisp Apples', 1, 101, 2.99),
(2, 'Fresh Spinach (Bag)', 1, 101, 1.99),
(3, 'Whole Milk 1G', 2, 102, 3.49),
(4, 'Cheddar Cheese Block', 2, 102, 4.49),
(5, 'Sourdough Bread', 3, 103, 3.99),
(6, 'Ribeye Steak', 4, 104, 12.99),
(7, 'Atlantic Salmon Fillet', 4, 104, 9.99),
(8, 'Spaghetti Pasta', 5, 101, 1.29),
(11, 'Potatoes', 1, 1, 0.50),
(12, 'Pork Chops 16oz', 4, 104, 19.99),
(13, 'Salmon', 4, 104, 25.00);

INSERT INTO orders (order_id, customer_id) VALUES
(1001, 501), (1002, 502), (1003, 503), (1010, 504), (1011, 505);

INSERT INTO order_items (order_id, product_id, quantity, unit_price) VALUES
(1001, 1, 2, 2.99),
(1001, 3, 1, 3.49),
(1001, 5, 1, 3.99),
(1002, 6, 1, 12.99),
(1002, 2, 2, 1.99),
(1002, 8, 3, 1.29),
(1003, 6, 1, 12.99),
(1010, 2, 6, 1.99),
(1011, 6, 9, 12.99);

Step 4 Joining tables

You may have noticed that some tables in the sample database I have provided feel quite empty. For example, the orders table is just one line. Well, the reason is that the other columns, for example the customer ID that the orders table uses, are written in the customers table. It is really inefficient and doesn't really work that well if we were to enter them separately, so we use the join command. By the way, the SELECT function just specifies what to get, and FROM tells the function where to get it from.

JOIN :- This joins two columns from different tables.

When entered, it should look something like this.

SELECT o.order_id, oi.product_id, oi.quantity, oi.unit_price
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id;

Using the JOIN command, we have to enter each column name for specification.

The rest of the code looks something like this.

SELECT o.order_id, p.product_name, oi.quantity, oi.unit_price,
       oi.quantity * oi.unit_price AS line_total
FROM orders o
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products p ON oi.product_id = p.product_id
ORDER BY o.order_id;

SELECT o.order_id, c.customer_name, c.email,
       p.product_name, oi.quantity, oi.unit_price
FROM orders o
JOIN customers c ON o.customer_id = c.customer_id
JOIN order_items oi ON o.order_id = oi.order_id
JOIN products p ON oi.product_id = p.product_id
ORDER BY o.order_id;

SELECT p.product_id, p.product_name, c.category_name,
       s.supplier_name, p.price
FROM products p
JOIN categories c ON p.category_id = c.category_id
JOIN suppliers s ON p.supplier_id = s.supplier_id;

If you are lazy like me and not actually using real data, feel free to just use sample databases like I did.

And that's it for this part.

What you learned

•Basic SQL syntax
•How to make databases
•How to make tables
•Just working with MySQL in general at an amateur level.

In the next part, I will teach you how to connect this database to Python so you can run commands directly from Python.

How to make a Currency Converter with tkinter and forex-python/currency converter.

KartikJha-prod — Tue, 29 Sep 2026 15:30:16 +0000

In software development, knowing how to build UIs (user interfaces) is really important. Ever wanted to make a UI for a project using a simple, high-level language like Python? The Tkinter module helps us do exactly that. Ever wanted to check the value of the currencies of different countries when compared to the currency of your own country? That can be done with another module called forex-python. In this tutorial, we will combine the forex-python module with the tkinter module to make a Currency Converter with a simple, minimalistic UI.

How the process will work.

Here's is how the program will work and in what order it will do so based on the user's input.
•Selecting Currencies:- First the user has to input both the input and output Currencies from the list provided by us.
•Selecting Amount:- Then the user has to select the amount to be converted into the output Currency.
•Clicking Convert:- After the convert button is clicked the entire script will fire up instantly.
Here I have provided a flowchart on how the script will work. The flowchart is explained below

This flowchart shows us the general idea the script should follow, whenever you are going to make a project it can be smart to make a flowchart on the general process of the script to get an idea for what you want to do. In this flowchart we can see that after the user clicks the concert button, we want our script to first check for both currencies aswell amount. Then we want our script to check for valid inputs in which we want the amount to be not negative so, amount>0 and we should convert the amount to str data type to avoid miscalculations. If these inputs are invalid we obviously want the script to reject these inputs and go back to the beginning. Next we should try to get live rates from forex-python if not possible then the script should give an error and go back the beginning aswell. Lastly if all checkpoints have been passed we want to give the result (obviously).
Now with the entire process in mind here is my code broken into smaller blocks of code with what each block does and why it's used. In a step-by-step manner.

Step-1 :- Importing the modules

import tkinter as tk
from tkinter import messagebox
from tkinter import ttk

Tkinter :- As discussed above tkinter is used for UI making.
Messagebox:- Just a subset of tkinter used to display a message in box in our case the result.
Ttk:- Used for making the widgets

Step 2:- Trying to import forex-python API

Now the reason we try to import the api is because we want the script to generate an error but if we just import it and the api is not available then the script would immediately crash for the user instead of a neat error box showed to the user.

# Requires installing the external library via terminal: pip install forex-python
try:
    from forex_python.converter import CurrencyRates

    currency_client = CurrencyRates()
# To print an error message if forex-python is not installed.
except ImportError:
    print("Please install forex-python using pip install forex-python")
    currency_client = None

Now if you are new to programming you might think why not just use if/else commands, well the reason we use try and excepts is primarily because try and except commands help us handle errors way better. Say if we used if/else commands it will look something like this

import importlib.util

# Check if the 'forex_python' module can be found in the system
if importlib.util.find_spec("forex_python") is not None:
    from forex_python.converter import CurrencyRates
    currency_client = CurrencyRates()
else:
    print("Please install forex-python using pip install forex-python")
    currency_client = None

Notice this is longer then before that is because the program wouldn't work with just replacing them, this block is longer and technically works but is still far inferior due to these reasons
•As you have probably noticed it's quite big longer because of an extra library
•If statement checks for the forex-python module twice while try command needs to check or 'try' to check it only once making it more efficient.

The rest of the code is quite self explanatory but here is what it does anyways
•First we try to get currency rates from forex python
•If the program doesn't get the currency rates the except part triggers which just generates an error which in this case is to simply print the following "Please install forex-python using pip install forex-python". Then it just sets currency client to none so the rest of the application doesn't crash.

Step 3 List of currencies supported.

Currencies = [
    "USD",
    "EUR",
    "GBP",
    "CAD",
    "AUD",
    "NZD",
    "CHF",
    "BRL",
    "MXN",
    "ZAR",
    "TRY",
    "RUB",
    "SEK",
    "NOK",
    "DKK",
    "INR",
    "JPY",
    "CNY",
    "HKD",
    "SGD",
    "KRW",
    "THB",
    "PHP",
    "IDR",
    "MYR",
    "ILS",
    "PLN",
    "CZK",
    "HUF",
    "RON",
    "HRK",
    "ISK",
]  # List of currencies that are supported by forex-python

Now we just enter the currencies we want to use into a list. You can change the variable name and add or remove currencies (make sure to only the add currencies are supported by forex-python)

Step 4:- Changing the text on the buttons

# Function to change the text on the input currency button to the selected currency.
def set_input_choice(item, button_widget):
    button_widget.config(text=item)
# To show a message box containing the text "you selected item" where item is the selected currency
    messagebox.showinfo("Selection", f"You selected: {item}")

def set_output_choice(item, button_widget):
    button_widget.config(text=item)
# To show a message box containing the text "you selected item" where item is the selected currency
    messagebox.showinfo("Selection", f"You selected: {item}")

This block of the script is responsible for changing the text on the input and output currency buttons to the name of the selected currency. We start by defining the function then just change the text to the {item} which is the selected currency. Now why we do this is to easily check if a currency has been chosen, if yes, then which currency has been chosen. It's is easiesr to get the text on a menubutton then to get the value of a menubutton.

Step 5 To get the input currencies

# Function to get what the input that the user has given for amount and currencies are.
def click():
    from_currency = Input_Currency.cget("text")
    to_currency = Output_Currency.cget("text")
    user_input = Entry_amount.get()

We will of course want to get the currencies the user has selected once they press the "convert" button. So we define a function as click() which just sets the from currency equal to the text that is displayed on the input_currency button which we will implement later. We do the same for the output_currency button. We also get the input for the amount using entry_amount.get().
(Note:- If you are having trouble understanding this I suggest you skip these steps for now and design the UI with the instructions on step 7 then comeback as it may be better for you to see the UI and the label names first in order to understand the script part to the UI.)

Step 6 To shows errors and give result.

# To check if the currencies have been selected if not then to display a selection error.
    if (
        from_currency == "Choose Input Currency"
        or to_currency == "Choose Output Currency"
    ):
        messagebox.showerror(
            "Selection Error", "Please select both currencies first."
        )
        return

# To check that the input amount is of the float datatype if not then display an invalid amount error.
    try:
        amount = float(user_input)
    except ValueError:
        messagebox.showerror("Invalid Input", "Please enter a valid amount")
        return
# To check whether the input amount is greater than zero display an error invalid amount otherwise.
    if amount <= 0:
        messagebox.showerror("Invalid Input", "Enter a number greater than zero")
        return

# To try to convert the currencies using live rates if live rates aren't available then display a connection error.
    try:
        result = currency_client.convert(from_currency, to_currency, amount)
        messagebox.showinfo(
            "Conversion Result",
            f"{amount} {from_currency} = {result} {to_currency}",
        )
    except Exception:
        messagebox.showerror(
            "Connection Error",
            "Couldn't get internet access to fetch live rates",
        )


# Function to show the user that they have 'selected' the selected currency.
def select_currency(item):
    messagebox.showinfo("Selection", f"You selected: {item}")

This is the last part of the script and is responsible for giving the errors and the result. Here's is what this script does line by line
•First we check if the text on the menubutton has been changed from the default text. If the text remains the same then we display an error.

#To check if the currencies have been selected if not then to display a selection error.
         if (
        from_currency == "Choose Input Currency"
        or to_currency == "Choose Output Currency"
    ):
        messagebox.showerror(
            "Selection Error", "Please select both currencies first."
        )
        return

•Then we check whether the input amount is a float datatype or and we subsequently also check if the amount is greater than zero a.k.a. , positive. And we display an error if otherwise for this we use this miniblock of code

# To check that the input amount is of the float datatype if not then display an invalid amount error.
    try:
        amount = float(user_input)
    except ValueError:
        messagebox.showerror("Invalid Input", "Please enter a valid amount")
        return
# To check whether the input amount is greater than zero display an error invalid amount otherwise.
    if amount <= 0:
        messagebox.showerror("Invalid Input", "Enter a number greater than zero")
        return

• Now that we have dealt with all the possible invalid amounts we want to convert the currencies (obviously) for that we have used this part of the code

# To try to convert the currencies using live rates if live rates aren't available then display a connection error.
    try:
        result = currency_client.convert(from_currency, to_currency, amount)
        messagebox.showinfo(
            "Conversion Result",
            f"{amount} {from_currency} = {result} {to_currency}",
        )
    except Exception:
        messagebox.showerror(
            "Connection Error",
            "Couldn't get internet access to fetch live rates",
        )

We use an inbuilt function on forex-python which is the currency_client.convert()
This command converts the currencies with respect to the amount. We have trapped the result in the "result" variable for ease and then for convenience of the user we ideally also want to show the conversion taking place in a separate message box. We follow all that up with the exception part which just addresses that if the result passed through the previous checkpoints but failed this one the program just couldn't get internet access. We show this error in a separate error box like the previous ones.

Now finally we tell the user they have selected a currency and exactly which currency they chose through a message box using the following code

# Function to show the user that they have 'selected' the selected currency.
def select_currency(item):
    messagebox.showinfo("Selection", f"You selected: {item}")

Step 7 Making the UI

root = tk.Tk()  # To create the window for the GUI
root.geometry("300x350")  # Size of the window
root.config(background="#000000")  # Background colour in hex code in this case black
root.title("Currency Converter")  # Title of the window

label = tk.Label(
    root,
    text="Currency converter",
    font=("Arial", 20, "bold"),
    fg="#FFFFFF",
    bg="#000000",
)  # To create a label with text "currency converter" with background and foreground colour with font size and text format in this case the text is bolded.
label.pack(pady=10)  # To add padding to the y axis of the label.

Input_Currency = tk.Menubutton(
    root, text="Choose Input Currency", bd=10, bg="#FFFFFF"
)
Input_Currency.pack()  # To place a menu button with text, border and background color.

dropdown_menu = tk.Menu(Input_Currency, tearoff=0)
for currency in Currencies:
    dropdown_menu.add_command(
        label=currency,
        command=lambda c=currency: set_input_choice(c, Input_Currency),
    )
Input_Currency["menu"] = dropdown_menu
# To create and connect the menu with a list of the currencies to the menu button.

Entry_amount = tk.Entry(root, font=("Comic Sans MS", 15), bd=3, bg="#FFFFFF")
Entry_amount.insert(0, "100")
Entry_amount.place(x=150, y=140, anchor="center")
# To put an entry field with a default value of 100.

Output_Currency = tk.Menubutton(
    root, text="Choose Output Currency", bd=10, bg="#FFFFFF"
)
Output_Currency.place(x=150, y=225, anchor="s")
# New menubutton for the output currency.

dropdown_menu2 = tk.Menu(Output_Currency, tearoff=0)
for currency in Currencies:
    dropdown_menu2.add_command(
        label=currency,
        command=lambda c=currency: set_output_choice(c, Output_Currency),
    )
Output_Currency["menu"] = dropdown_menu2
# To create and connect a new menu with the output currency button the list of currencies is the same in both menus.

Convert = tk.Button(root, text="Convert", command=click, padx=20, bd=10)
Convert.place(x=150, y=320, anchor="sw")
# To add a button which when clicked triggers the click function which is defined above from line 37  till line 75

root.mainloop()  # To loop the window so that the GUI lasts until the user closes it.

Now here is what each command does

•root.geometry, root.title, root.config To change the size, title and settings like background colour of the window respectively.

•label To display text

•menubutton To create a button with an attachable menu for the possible values for the button.

•.pack and .place to place the widget pack just places it at the default point, while place has a coordinate system for you to choose from.

•tk.menu just the menu to be attached to the menubutton.

•tk.entry to make a box that accepts entry via typing

•tk.button to make a button with a function. If notice then only when the convert button is pressed is when the click() function is triggered and if you recall then the entire logic part of the script comes in the click function.

•root.mainloop() To make the window appear after the program is ran.

(Note:- you can customise this part as much as you want)

Congratulations

You have just learnt to make a
Currency converter using your now found knowledge of being able to understand both forex-python and tkinter modules. This is a very basic but an important project in order to understand these modules. Completing this project you have gained an understanding of:-
•tkinter
•forex-python
•UI making as a whole
•try and except commands

Note:- If you are having trouble using forex-python then you may consider waiting to switch to currency_converter library just replace them there won't be much of a change.

📊 How to build a Financial Dashboard on Python step-by-step

KartikJha-prod — Sun, 27 Sep 2026 11:53:52 +0000

Have you ever wanted to look up a stock's performance on a specific date, only to find out the market was closed that day because of a weekend or a holiday? In this tutorial, we will build a program that solves this problem using Python, Plotly and Dash.

Instead of only telling us the price for one date, this program starts a local web server and fetches historical prices from Yahoo Finance using the yfinance module. It takes the ticker symbol and date chosen by the user, opens a window of dates around the target date, handles market closures by showing the nearest trading days, and draws an interactive candlestick chart.

Note: yfinance is an unofficial library and this project is for learning purposes only. It is not financial advice.

💼 Project features and result

By the end of this guide, you will be able to build a program that does the following:

➔ Historical data extraction: It connects to Yahoo Finance through the yfinance module to fetch the Open, High, Low and Close prices.
➔ Relevant window: It creates a window of dates (10 days before and 5 days after your target date), which is useful for studying trends.
➔ Market closure alerts: It checks whether the stock exchange was open on your target date. If the market was closed, it alerts the user and shows the nearest trading days instead.
➔ Runs in different environments: It runs from a normal terminal (you open the dashboard in your browser) and also inline inside Jupyter and Google Colab notebooks.

📦 Step 1: All the imports and dependencies

First, install the libraries by running this line in your terminal (in a Jupyter or Colab notebook, put ! in front of it):

pip install dash pandas plotly yfinance

Then create a new file named app.py and add these imports at the top. They bring in the libraries that manage our layout, data and graph.

import dash
from dash import dcc, html
from dash.dependencies import Input, Output, State
import plotly.graph_objects as go
from datetime import datetime, timedelta
import yfinance as yf
import pandas as pd

Why these modules?

yfinance ➔ pulls the stock prices.
dash ➔ builds the dashboard and its user interface.
plotly.graph_objects ➔ makes the chart.
datetime and timedelta ➔ work with dates.
pandas ➔ structures the data in a more manageable form.

🌐 Step 2: Starting the server

Afterwards, type in the following line:

app = dash.Dash(__name__)

What it does: This single line sets up our app. The __name__ part tells Dash where the root folder of the project is, so it can find assets like styles and images.

✍️ Step 3: Designing the interface

Now we choose how we want the dashboard to look. I have provided my own style as an example, but feel free to change it and style the interface to your liking. Below the code block are explanations of what the components do.

app.layout = html.Div(
    style={
        'fontFamily': '"Segoe UI", Helvetica, Arial, sans-serif',
        'padding': '30px',
        'maxWidth': '900px',
        'margin': 'auto',
        'backgroundColor': '#ffffff'
    },
    children=[
        html.H2(
            "Historical Stock Analysis Dashboard 📊",
            style={'textAlign': 'center', 'color': '#2c3e50', 'marginBottom': '10px'}
        ),
        html.P(
            "Enter a stock ticker and target date to analyze historical market performance.",
            style={'textAlign': 'center', 'color': '#7f8c8d', 'marginBottom': '30px'}
        ),

        html.Div(
            style={
                'backgroundColor': '#f8f9fa',
                'padding': '25px',
                'borderRadius': '8px',
                'marginBottom': '25px',
                'boxShadow': '0 4px 6px rgba(0,0,0,0.05)'
            },
            children=[
                html.Label(
                    "Stock Ticker Symbol:",
                    style={'fontWeight': 'bold', 'display': 'block', 'marginBottom': '8px', 'color': '#34495e'}
                ),
                dcc.Input(
                    id='ticker-input',
                    type='text',
                    value='AAPL',
                    style={
                        'width': '100%', 'padding': '10px', 'fontSize': '14px',
                        'marginBottom': '20px', 'borderRadius': '4px',
                        'border': '1px solid #ccc', 'boxSizing': 'border-box'
                    }
                ),

                html.Label(
                    "Select Date (YYYY-MM-DD):",
                    style={'fontWeight': 'bold', 'display': 'block', 'marginBottom': '8px', 'color': '#34495e'}
                ),
                dcc.Input(
                    id='date-input',
                    type='text',
                    value='2026-01-15',
                    style={
                        'width': '100%', 'padding': '10px', 'fontSize': '14px',
                        'marginBottom': '25px', 'borderRadius': '4px',
                        'border': '1px solid #ccc', 'boxSizing': 'border-box'
                    }
                ),

                html.Button(
                    "Get Market Summary",
                    id='submit-btn',
                    n_clicks=0,
                    style={
                        'width': '100%', 'padding': '12px', 'backgroundColor': '#007bff',
                        'color': 'white', 'border': 'none', 'borderRadius': '4px',
                        'fontSize': '16px', 'cursor': 'pointer', 'fontWeight': 'bold'
                    }
                )
            ]
        ),

        html.Div(
            id='status-output',
            style={'textAlign': 'center', 'fontWeight': 'bold', 'marginBottom': '20px', 'fontSize': '16px'}
        ),
        dcc.Graph(id='price-graph', config={'displayModeBar': False})
    ]
)

Explaining the UI components

html.Div :- Makes a box containing other elements. You choose what is inside the box using children=[...] and change how it looks using style={...} (color, font, size, bold and so on).
dcc.Input :- Creates a box where the user types data, in this case the ticker symbol and the target date.
dcc.Graph :- Creates the graph that shows the data. The setting config={'displayModeBar': False} removes the extra button tray for a clean, minimalist look.

Feel free to play around and experiment a lot with these components so you get the hang of them.

🔗 Step 4: The reactive callback

To give life to our interface, we use the Dash @app.callback() decorator. This part of the script listens for user input and updates the page.

First, add this small helper function. It builds the style of the status message, so the text stays centered and bold whatever color we choose:

def status_style(color):
    return {
        'textAlign': 'center',
        'fontWeight': 'bold',
        'marginBottom': '20px',
        'fontSize': '16px',
        'color': color
    }

Now add the callback and the start of the function it controls:

@app.callback(
    [Output('price-graph', 'figure'),
     Output('status-output', 'children'),
     Output('status-output', 'style')],
    [Input('submit-btn', 'n_clicks')],
    [State('ticker-input', 'value'),
     State('date-input', 'value')]
)
def update_dashboard(n_clicks, ticker, date_str):
    # This empty figure is a clean placeholder canvas
    empty_fig = go.Figure(layout=go.Layout(
        paper_bgcolor='rgba(0,0,0,0)',
        plot_bgcolor='rgba(0,0,0,0)',
        xaxis={'visible': False},
        yaxis={'visible': False}
    ))

Output points to the exact properties on the page that we want to change. Here we target the graph's figure, plus the children (text) and style of our status message.
Input tracks interactions. Whenever the button is clicked, n_clicks changes and the function runs. (Dash also runs it once when the page first loads, so you will see the default stock right away.)
State gives the function the current values of the input boxes without triggering it. For example, if the user is typing AAPL, the function won't run when they have only typed A. It waits until the button is clicked.

🧮 Step 5: The financial logic

Now we add our data, logic and graph code. This goes inside the update_dashboard function, directly under the empty_fig block, indented once (4 spaces) like the code above.

    # 1. Check for empty fields
    if not ticker or not date_str:
        return empty_fig, "Please input a ticker symbol and target date.", status_style('#e74c3c')

    try:
        # 2. Turn the input text into a date object (raises ValueError if the format is wrong)
        target_date = datetime.strptime(date_str.strip(), "%Y-%m-%d").date()
        target_str = target_date.strftime("%Y-%m-%d")

        # 3. Build the context window (10 days before and 5 days after the target date)
        start_date = target_date - timedelta(days=10)
        end_date = target_date + timedelta(days=5)

        # 4. Clean and normalize the ticker text
        ticker_clean = ticker.strip().upper()
        stock = yf.Ticker(ticker_clean)

        # 5. Get the historical prices for the window
        history = stock.history(
            start=start_date.strftime("%Y-%m-%d"),
            end=(end_date + timedelta(days=1)).strftime("%Y-%m-%d")
        )

        if history.empty:
            return empty_fig, f"No trading data found for symbol '{ticker_clean}' around {target_str}.", status_style('#e74c3c')

        # Turn the dates into plain text so we can look them up easily
        history.index = history.index.strftime('%Y-%m-%d')

        # 6. Build the candlestick chart
        fig = go.Figure(data=[go.Candlestick(
            x=history.index,
            open=history['Open'],
            high=history['High'],
            low=history['Low'],
            close=history['Close'],
            increasing_line_color='#2ecc71',  # soft green for gains
            decreasing_line_color='#e74c3c'   # clean red for losses
        )])

        fig.update_layout(
            title=f"{ticker_clean} Performance around Target Date: {target_str}",
            yaxis_title="Stock Value (USD)",
            xaxis_title="Trading Session Date",
            template="plotly_white",
            xaxis_rangeslider_visible=False,
            margin=dict(l=40, r=40, t=60, b=40)
        )

        # 7. Check whether the market was open on the target date
        if target_str in history.index:
            t_open = history.loc[target_str, 'Open']
            t_close = history.loc[target_str, 'Close']
            msg = f"➔ Success! Target date metrics found ({target_str}) -> Open: ${t_open:,.2f} | Close: ${t_close:,.2f}"
            return fig, msg, status_style('#27ae60')
        else:
            msg = f"⚠️ Target date ({target_str}) was a market closure day. Showing the nearest open sessions."
            return fig, msg, status_style('#f39c12')

    except ValueError:
        return empty_fig, "Invalid date format. Please use YYYY-MM-DD.", status_style('#e74c3c')
    except Exception as e:
        return empty_fig, f"Could not fetch data: {str(e)}", status_style('#e74c3c')

Main logic

Polishing input: We use .strip() and .upper() on the ticker so the user's input is accepted in any form. For example, to check Tesla shares (ticker TSLA), the user can write tsla or Tsla without the program rejecting it.
Pandas: With history.index.strftime('%Y-%m-%d'), we turn the dates into plain YYYY-MM-DD text. This lets us check whether the target date exists in the data with a simple if/else. If it isn't there, the market was closed.
API boundary: When we request the window, we add one extra day to the end date with timedelta(days=1). Yahoo Finance treats the end date as exclusive, so without this the last day would be missing.
Error handling: A wrong date format raises a ValueError, which we catch to show a friendly message. Any other problem (for example a network error) is caught by the last except.

🌐 Step 6: Running in different environments

To complete our script, add this at the very end of app.py (at the left edge, outside any function):

if __name__ == '__main__':
    app.run(
        debug=True,
        jupyter_mode='inline',
        jupyter_height=750
    )

This block starts the app. Here is how it behaves in each environment:

In a terminal: It starts a local server. Open http://127.0.0.1:8050 in your browser to see the dashboard.
In Jupyter or Google Colab: jupyter_mode='inline' shows the dashboard directly below the cell, and jupyter_height=750 sets its height.

jupyter_mode needs a recent version of Dash (2.11 or later). If you are not in a notebook, the setting is simply ignored.

🎉 Conclusion and summary of achievements

Congratulations! You have built an interactive, cross-environment financial dashboard using Python, Dash and Plotly. You have learned how to take user input, fetch historical stock data, handle market closure days, and draw a candlestick chart.

To take your dashboard to the next level, try these upgrades:

➔ Add a toggle-able dark mode directly in the program.
➔ Expand your callback to accept a second ticker, so you can compare two stocks in one window.

At the end of this tutorial, your dashboard should look something like this: