What is Python Flask?

In this tutorial, we will learn what is Python Flask and how to build web applications using it. We will cover the basics of Flask, including how to set up a Flask application, how to handle routes, how to use templates, and how to work with databases. Let’s start!!!

What is Python Flask?

Flask is a lightweight web framework that enables developers to create web applications in Python. It was created by Armin Ronacher in 2010 and is widely used by developers worldwide. Flask is a micro framework that allows developers to build web applications with minimal boilerplate code, making it easy to get started with web development in Python.

WSGI

The Web Server Gateway Interface (WSGI), also known as the Web Server Gateway, is a specification for a common interface between web servers and Python online applications or frameworks. No matter which web framework was used to create the Python applications, WSGI specifies a straightforward and universal interface that enables web servers and Python applications to interact. As a result, developers can easily transition between them without having to make significant changes to their code thanks to the WSGI specification, which promotes compatibility and portability between various web servers and frameworks.

Additionally, it offers an abstraction layer between the application and server layers, which facilitates the development and testing of web apps. Overall, WSGI has developed into a significant standard for Python web development, allowing communication between various web stack components.

Jinja2

The Jinja2 Python library offers a template engine for creating HTML, XML, or other markup forms on the fly. It enables the creation of templates by developers that contain placeholders for dynamic content that can be quickly populated with data during runtime. For creating dynamic content in Python web applications, Jinja2 is a potent and adaptable utility that supports template inheritance, built-in filters, and custom extensions. It’s extensively used in well-known web frameworks like Flask and Django, and web developers like it because of how simple it is to use and how easily it can be extended.

Python Flask Installation

Before we can start using Flask, we need to install it. The easiest way to do this is to use pip, the package manager for Python. Open your terminal and enter the following command:

pip install flask

This will install Flask on your system, and you can now start building web applications using Flask.

Creating a Flask Application

To create a Flask application, we need to create a Python file and import the Flask module. Let’s create a file called app.py and enter the following code:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'DataFlair!'

In this code, we imported the Flask module and created an instance of the Flask class called app. We also defined a route using the @app.route() decorator. The route we defined is the root route (/), and it returns the string ‘Hello, World!’ when the route is accessed.

To run this application, we need to add the following lines of code to the end of the file:

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

Output:

This code checks if the current file is being run as the main program, and if it is, it starts the Flask development server using the app.run() method.

To run the application, save the app.py file and run the following command in your terminal:

python app.py

This will start the development server, and you can access the application by visiting http://localhost:5000 in your web browser.

Handling Routes in Python Flask

In Flask, routes are handled using the @app.route() decorator. This decorator is used to specify the URL that should trigger the function that follows it. Let’s look at an example:

@app.route('/hello')
def hello():
    return 'Hello, World!'

In this example, we defined a route /hello and a function hello() that returns the string ‘Hello, World!’ when the route is accessed.

We can also use variables in our routes using angle brackets (<variable_name>). These variables can then be used in our functions. Let’s look at an example:

@app.route('/user/<username>')
def user(username):
    return f'Hello, {username}!'

In this example, we defined a route /user/<username> and a function user() that takes a variable username and returns the string Hello, <username>!. When we visit the URL /user/john, the function will return the string Hello, john!.

Using Templates in Flask

In Flask, templates are used to create dynamic HTML pages. We can use templates to display data from our Flask application in a web page. To use templates in Flask, we need to create a templates folder in our project directory and add our HTML files to this folder.

Let’s create a template called index.html in our templates folder:

<!DOCTYPE html>
<html>
<head>
    <title>My Flask Application</title>
</head>
<body>
    <h1>Hello, {{ name }}!</h1>
</body>
</html>

In this template, we use the double curly braces ({{ }}) to define a placeholder for our data. We can pass data to this template from our Flask application using the render_template() function.

from flask import render_template

@app.route('/hello/<name>')
def hello_name(name):
    return render_template('index.html', name=name)

In this example, we defined a new route /hello/<name> and a function hello_name() that takes a variable name and passes it to the index.html template using the render_template() function. When we visit the URL /hello/john, the function will pass the string john to the template, and it will display the message Hello, john!.

Key features of Python Flask

1. Routing:

Routing refers to the process of mapping URLs to functions that handle HTTP requests. Flask provides a simple and flexible way to define routes using the @app.route() decorator. Here’s an example

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

This code defines a route for the root URL / that responds with the string ‘Hello, World!’.

2. Templates:

Templates allow you to generate dynamic HTML pages by filling in placeholders with data from your Python code. Flask uses the Jinja2 template engine, which provides a powerful and flexible way to generate HTML. Here’s an example:

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/hello/<name>')
def hello(name):
    return render_template('hello.html', name=name)

This code defines a route that takes a name parameter from the URL and passes it to a template called hello.html. The template might look something like this:

<!DOCTYPE html>
<html>
<head>
    <title>Hello, {{ name }}!</title>
</head>
<body>
    <h1>Hello, {{ name }}!</h1>
</body>
</html>

3. Request Handling:

Flask provides a simple way to handle incoming HTTP requests using the request object. This object contains information about the incoming request, such as the HTTP method, headers, and data. Here’s an example:

from flask import Flask, request

app = Flask(__name__)

@app.route('/login', methods=['POST'])
def login():
    username = request.form['username']
    password = request.form['password']
    # do some authentication
    return 'Welcome, {}!'.format(username)

This code defines a route that only responds to HTTP POST requests. When the form data is submitted to the /login URL, the request object is used to extract the username and password fields from the form data.

4. Sessions:

Sessions allow you to store user-specific data across multiple requests. Flask provides a simple way to manage sessions using the session object. Here’s an example:

from flask import Flask, session, redirect, url_for, request

app = Flask(__name__)
app.secret_key = 'super secret key'

@app.route('/login', methods=['POST'])
def login():
    session['username'] = request.form['username']
    return redirect(url_for('profile'))

@app.route('/profile')
def profile():
    username = session['username']
    return 'Welcome, {}!'.format(username)

This code defines a route that stores the username field from the login form in the session, then redirects to the /profile URL. The profile route then reads the username field from the session and displays a welcome message.

5. Debugging:

Debugging is an essential feature for any web framework. Flask provides a built-in debugger that allows you to inspect and modify variables, view stack traces, and more. Here’s an example:

from flask import Flask

app = Flask(__name__)
app.config['DEBUG'] = True

@app.route('/')
def hello():
    name = 'John'
    age = 30
    return 'Hello, {}. You are {} years old.'.format(name, age)

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

This code sets the DEBUG configuration option to True, which enables the built-in debugger. If an error occurs in the code, the debugger will display a detailed stack trace, allowing you to identify and fix the problem quickly.

Uses of Flask

Flask is a lightweight and flexible web framework for building web applications in Python. Here are some of the common uses of Flask

1. Building REST APIs:

Flask is a popular choice for building REST APIs because of its simplicity and flexibility. Here’s an example of how to create a simple REST API with Flask:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/api/users')
def get_users():
    users = [
        {'id': 1, 'name': 'John'},
        {'id': 2, 'name': 'Jane'},
        {'id': 3, 'name': 'Bob'}
    ]
    return jsonify(users)

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

2. Building web applications:

Flask is also a great choice for building web applications, including simple websites and more complex applications. Here’s an example of how to create a simple web application with Flask:

from flask import Flask, render_template

app = Flask(__name__)

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

@app.route('/about')
def about():
    return render_template('about.html')

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

3. Working with databases:

Flask makes it easy to work with databases, including popular choices like SQLite, MySQL, and PostgreSQL. Here’s an example of how to connect to a SQLite database and retrieve data with Flask:

from flask import Flask, jsonify
import sqlite3

app = Flask(__name__)

@app.route('/api/users')
def get_users():
    conn = sqlite3.connect('example.db')
    cur = conn.cursor()
    cur.execute('SELECT id, name FROM users')
    users = [dict(id=row[0], name=row[1]) for row in cur.fetchall()]
    conn.close()
    return jsonify(users)

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

Conclusion

In conclusion, Flask is a powerful and versatile web framework for building web applications in Python. It is lightweight and flexible, making it easy to get started with, but also capable of handling complex web development tasks.

In this tutorial, we have covered the basics of Flask, including how to create routes, use templates, work with databases etc. By understanding these concepts, you can start building your own web applications with Flask.

However, this tutorial is just scratching the surface of what is possible with Flask. There are many advanced features and libraries available for Flask that can help you build even more complex web applications

Overall, Flask is a great choice for web development in Python, and with the right knowledge and tools, you can create powerful and effective web applications.