No history yet

Environment and Routing

Setting Up Your Workspace

Every web application project needs a clean, dedicated workspace. In Python, this is handled using a virtual environment an isolated directory that contains a specific version of Python and all the necessary packages for a single project. This prevents conflicts between different projects that might rely on different versions of the same library.

# 1. Create a virtual environment named 'venv'
python3 -m venv venv

# 2. Activate the environment
# On macOS and Linux:
source venv/bin/activate

# On Windows:
.\venv\Scripts\activate

# 3. Install Flask
pip install Flask

With Flask installed, you can create a minimal application. This is the simplest possible Flask app, often called a "Hello, World!" example. It shows the basic structure: importing the Flask class, creating an instance of the app, defining a route, and running the application.

# app.py

from flask import Flask

# Create an instance of the Flask application
app = Flask(__name__)

# Define a route and the function to handle it
@app.route('/')
def home():
    return 'Hello, World!'

# This block allows you to run the app directly
if __name__ == '__main__':
    app.run(debug=True)

Save this code in a file named app.py. To run it, make sure your virtual environment is active and then execute flask --app app run in your terminal. You'll see a message indicating the server is running, usually at http://127.0.0.1:5000.

How Flask Handles Requests

When you visit that URL in your browser, you're kicking off the request-response cycle. Your browser (the client) sends an HTTP request to your Flask application (the server). Flask receives the request, determines which code to run based on the URL, executes that code, and sends an HTTP response back to the browser. The browser then renders the response, displaying "Hello, World!" on the page.

The magic happens with the @app.route('/') line. This is a Python decorator a special syntax that modifies or enhances a function. In Flask, the @app.route() decorator links a URL path to a specific Python function, known as a view function. When Flask gets a request for the path /, it knows to execute the home() function and return its result.

Dynamic Routes and Methods

Static routes like / are useful, but web applications need to handle dynamic data. For example, you might want a profile page for each user, like /user/alice or /user/bob. Flask handles this with variable rules in the URL.

# app.py

# ... (previous code)

@app.route('/user/<username>')
def show_user_profile(username):
    # The 'username' variable from the URL is passed
    # as an argument to the function.
    return f'User: {username}'

Now, if you go to /user/anyname in your browser, the show_user_profile function will run, and the username variable will contain whatever string you put in the URL.

Flask can also use converters to specify the type of the variable, like <int:post_id>. This ensures that the URL segment is an integer before it even reaches your view function.

Web applications also need to handle different types of requests, known as HTTP methods. The two most common are GET and POST.

  • GET requests are used to retrieve data. When you type a URL into your browser, you're making a GET request.
  • POST requests are used to submit data to a server, like filling out a contact form or logging in.

By default, Flask routes only respond to GET requests. To handle POST requests, you must explicitly allow it in the decorator.

# app.py
from flask import Flask, request

app = Flask(__name__)

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # Logic for handling the login form submission
        return 'Handling a POST request'
    else:
        # Logic for showing the login form
        return 'Showing the login form (GET request)'

Here, the /login route can handle both methods. If a user visits the page, they make a GET request and see the form. When they submit the form, their browser sends a POST request, and our if block handles the submitted data. The request object, imported from Flask, gives us access to all the details of the incoming HTTP request.

Quiz Questions 1/6

What is the primary purpose of using a virtual environment in a Python web application project?

Quiz Questions 2/6

In a Flask application, the @app.route('/') line is a special Python syntax known as a __________.

With a solid grasp of environments and routing, you have the foundational skills to build the core structure of any web application in Flask.