What is Flask in Python

Flask is one of the Python web frameworks that you can use for your first application that you ever build, or if you are building microservices at an enterprise level. It is a mix of simplicity and power, and many other features that make it beginner-friendly. In this article, we will take a look at what Flask is, what makes it preferable for developers, and how this framework can make it easier for you to build awesome web applications. It will also provide a simple, real-world implementation example that can get you started by applying your understanding of Flask. You will see your simple program come into action, and by the time you finish, you can begin your efforts at web development.

Table of Contents:

• What is Flask in Python?
• Benefits of Flask in Python
  • Lightweight
  • Flexible
  • Development Server Included
  • Built-in Support for Unit Testing
  • RESTful Request Handling
• Why Use Flask in Python?
• Practical Implementation of Flask
  • Handling HTML Forms in Flask
  • Routing in Flask
• Django vs Flask in Python
• Real-Life Use Cases of Flask
• Conclusion

What is Flask in Python?

Flask in Python is a micro web framework, or a minimalist framework, created by Armin Ronacher in 2010. It is used for building web applications and APIs. A micro web framework is different from larger frameworks, called full-stack, because, unlike full-stack frameworks in Python, a micro framework acts just as the base framework, like building blocks around routing, request dispatch, and handling of responses. It is meant to get you started in web development in a quick way, but also allows for flexibility in building complicated applications.

Full-stack frameworks come with built-in tools for database management, user authentication, admin panels, and more. However, a micro framework, like Flask, gives developers the core toolset to build web applications, allowing them to pick and choose the additional pieces. A micro framework is clean and minimal, and allows developers the freedom to build based on requirements instead of rigid boilerplate code or directives.

Flask is built on two main components:

• Werkzeug: A WSGI (Web Server Gateway Interface) toolkit that handles the low-level aspects of web communication (like requests and responses).
• Jinja2: A modern templating engine for Python used by default for rendering dynamic web pages.

Other notable components that are used are:

• Microframework: This framework also has its own library that ties these components together and provides a high-level API that developers interact with, such as @app.route decorators, the request context, and more.
• Click: It also uses Click as its command-line interface (CLI), which is useful for developers. Remember, it is not directly involved in the web server aspect, like Werkzeug, or templating, like Jinja2.

Become a Certified Python Developer!

Enroll Now and earn your certificate to unlock coding roles as Python Developer and fields like data science.

Explore Program

Benefits of Flask in Python

Let us look at some key features of Flask in Python that make it a good choice for beginners to web development frameworks. 

1. Lightweight

• Flask has a very small codebase and very few dependencies that you need to download for it to work properly without throwing any errors. This makes it fast to install and easy to understand, making it especially good for beginners, as it does not overwhelm them. 
• The entire framework can be learned in a few hours, making it perfect for beginners and experienced developers who want to move quickly.

2. Flexible

• Flexibility is one of the biggest strengths or advantages of Flask. It allows you to structure your application however you want, choose your own database, authentication system, and other components.
• This freedom allows you to build exactly what you need without unnecessary overhead. For example, if you are building a simple blog, you could choose a lightweight database like SQLite and add a Login for user accounts. But for a large e-commerce site, you might opt for PostgreSQL and a full-featured payment gateway. This way, you pick components only when truly needed.

3. Development Server Included

• Flask has a built-in development server that automatically reloads when you make changes to your code. This feature speeds up development and makes testing your applications effortless.
• It is also very easy to start this server, meaning you don’t need to install or set up complex web server software just to test your application. This lets you focus on building your app right away.

4. Built-in Support for Unit Testing

• Flask provides built-in support for unit testing to its users. This makes it very easy for you as a developer to write tests for your applications in the project itself and run them whenever you want. You can do software testing to make sure the software you build and the new features you add are reliable, and then your system is still working as it should after the addition.
• This helps you modify or adjust the new features in your application, then and there. This is because blocks of code can be easily tested independently, and you will be able to tell if your change breaks something else before it occurs and avoid any surprises later on.

5. RESTful Request Handling

• Flask supports building RESTful APIs that help you with URL routing and HTTP method handling. URL routing is responsible for directing the web addresses to the correct code in your app. Whereas HTTP methods tell the server what action you want to perform on the address given in the URL. You can efficiently create endpoints that support GET, POST, PUT, DELETE, and other HTTP methods.
• This makes it easy to build web services that interact easily with other applications, such as mobile applications or web pages, using web standards inside the app using the APIs provided that is provided by this framework.

Why Use Flask in Python?

Now that we have understood the features and what Flask is in Python, let us discuss the scenarios where it is best to use this micro web framework. 

Choose Flask Over Heavier Frameworks

Flask is a great choice in situations when you want to focus on:

• Quick Development: This lightweight framework allows you to create a functioning web application in minutes instead of hours. So, you can use it for fast prototyping and fast software development cycles where the speed of completion is critical.
• Custom Solutions: If you want to have full control over your application’s architecture, it gives you the choice of your databases, authentication system, and any other components you need to customize the solution to your specific needs.
• Learning Web Development: It is a minimalist framework that is ideal for beginners to learn the fundamental principles of web development concepts, without being overwhelmed by too many complex features.

Practical Implementation of Flask

Now that we have learned a little about the benefits of Flask for big companies, let’s proceed to create a small web app. This example will demonstrate how to create a quick webpage that asks for your name and greets you. It will show you how this framework handles HTML forms and templates to create fairly clean web pages.

What you need:

• Python: First, you need to make sure that you have Python installed on your computer.
• Flask: You will need to install the Flask library. Open your terminal (or Command Prompt) and type “pip install Flask“. If it is not installed on your system, it will install it. If it is already present, it will give you the “requirement fulfilled” message display.

Note that Flask3.x requires Python 3.8 or newer versions as only they are compatible. You can check your version using "flask --version".

Project Setup:

It would make sense to structure your files for the application. So, create a main folder for your project, calling it my_simple_app or something else. Then, inside that folder, create a folder called templates.

If you are copying this project as it is, then this is how your folder structure should look:

The Python Code (app.py):

Create a file named app.py inside your my_simple_app folder and put this code inside it:

Handling HTML Forms in Flask

Inside the templates folder, create a file named index.html and paste this HTML code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>My Simple Flask App</title>
</head>
<body>
    <h1>{{ greeting }}</h1>

    <form method="POST">
        <label for="name_input">Your Name:</label><br>
        <input type="text" id="name_input" name="name_input" required><br><br>
        <input type="submit" value="Say Hello">
    </form>
</body>
</html>

How to Run It:

1. Open your terminal (or Command Prompt).
2. Navigate to your my_simple_app folder. You can do this with the following command “cd my_simple_app“.
3. Run the application by typing “python app.py“.

After you run the command, you will see a message in your terminal, usually including a link like given below. The 5000 here is the port number on which the web application is hosted.

Running on http://127.0.0.1:5000/

Open your web browser and go to that address.

• First, you will see a page asking for your name.
• Type your name into the box and click “Say Hello”.
• The page will then change to display “Hello, [Your Name]! Welcome to Intellipaat.“

From this example of a Flask application, we understood the following features, which are given below.

• Get user input from forms and use it in your Python code.
• Define routes (web addresses like /).
• Handle different types of requests (like when you first visit a page, or when you submit a form).
• Use HTML templates to build your web pages dynamically.

Now that we have seen a simple Flask application in action and briefly mentioned the concept of routes, it’s time to understand one of the most important parts of any such application, which is Routing. It determines how users navigate through your web application and how different URLs trigger specific functions in your Python code.

Routing in Flask

Routing in Flask refers to mapping URLs to specific functions in your application. Each route represents a unique web address that users can visit, such as the home page (/) or a custom page (/about). In this micro-framework, routes are defined using the @app.route() decorator, which tells the application which function should run when a particular URL is accessed. This is how it handles navigation and user interaction within a web application.

Routing not only allows you to organize your application into meaningful pages, but it also helps in handling different HTTP methods like GET and POST. For example, a GET request is used to retrieve information, whereas a POST request is used to submit data through forms.

A simple example of routing in Flask looks like this:

@app.route('/about')
def about_page():
    return "This is the About Page"

In the above example, visiting http://127.0.0.1:5000/about in your browser would trigger the about_page() function and display the message.

Django vs Flask in Python

Both Flask and Django are excellent Python web frameworks, yet they serve very different purposes. Flask is a minimalist framework, offering maximum flexibility and control for building custom applications. It is perfect for starting small and adding features precisely as needed. On the other hand, Django is a detailed framework that provides everything you need, like an admin panel and ORM. It is ideal for larger applications with standard requirements and faster development cycles. 

For a more comprehensive dive into the differences between Django and Flask, check out this Django vs. Flask article. It is completely beginner-friendly and will give you a better understanding of the two. 

Real-Life Use Cases of Flask

You might think Flask is just for small projects, but many successful companies and famous websites use it as a part of their systems. It’s capable of supporting large, high-traffic applications when used effectively.

• Netflix: They use Flask for many internal tools, like programs for their own team and microservices. It is usually used for small, specific parts of their huge online video system that help deliver movies and shows to millions of people.
• Reddit: This popular social media site originally built some of its platform using this microframework. It helped them handle specific API endpoints. These endpoints are ways other programs talk to their system and other internal tools.
• Airbnb: They use it for different microservices and internal applications to run their big platform for booking places to stay.
• Pinterest: This image-sharing platform uses it for API services, as other apps connect to their pictures and internal tools that help manage all their images.
• LinkedIn: The professional networking site uses it for some microservices and programs that handle data processing within its very large computer systems.

These examples clearly show that Flask is not just for small, simple, startup projects. It is a strong tool that can grow and handle the big demands of major online platforms, especially when companies break down their big systems into smaller, manageable parts.

Conclusion

Flask is a popular framework for Python web development because you can focus on building and developing. As you think about building your first web application, simplicity is often a key feature to allow you to build quickly and possibly even as small, separate systems. The strength of Flask is rooted in its philosophy (start simple, only add as you need). This allows you to avoid over-engineering anything while gaining the power to develop something that can be quite complex as your needs develop.

Working in Flask is easy, and the best part is that the framework is flexible enough to support you in growing your skills and your applications over time.

What is Flask in Python – FAQs