Build Your First Web Application in Flask
Job-ready Online Courses: Click for Success - Start Now!
Flask is a popular micro web framework which is written in Python. It is known for its simplicity, lightweight and ability to scale up as the requirements grow. Flask makes it easy to get started with web development and build web applications quickly. In this tutorial, we will be building our first Flask application from scratch, which will introduce you to the basics of Flask and help you understand how to build web applications using this framework. We will be covering all the essential concepts, including setting up a development environment, routing, templates, and database integration.
Building your first Flask application can be an exciting and rewarding experience. Flask is a popular, lightweight micro web framework that is easy to learn and use, making it a great choice for those just starting out with web development. In this article, we will be walking through the process of building our first Flask application from start to finish.
Setting up Flask Development Environment
The first step in building your Flask application is to set up your development environment. We need to install python on our computer/system, which we can download from the official website of Python. After installing Python,we need to iinstall Flask using the following command in your terminal/command prompt.
pip install Flask
The first step in building your Flask application is to set up your development environment.
from flask import Flask
app = Flask(__name__)
@app.route("/")
def index():
return "Hello, World!"
if __name__ == "__main__":
app.run()
This code creates a newly created Flask application and defines a single route, the root route, which returns the string “Hello, World!” when invoked.
Running the Application
Using the following command/terminal We can run our Flask Application
python app.py
You should see the following output:
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
By navigating to http://127.0.0.1:5000/ we can see it running
Output:
The code creates a Flask application that listens for incoming requests to the root route (“/”) and returns an HTML template using the render_template function.
If you run this code, it will start a local web server and listen for incoming requests on port 5000. When you navigate to http://localhost:5000/ in your web browser, Flask will render the HTML template associated with the route and return it as a response.
Since there is no index.html template provided in this code, Flask will raise a TemplateNotFound error when the render_template function is called. You need to create an index.html file in the templates directory of your Flask project and define its content there.
Adding Templates in Flask Application
So far, we have only defined a single route that returns a simple string. In most web applications, you will want to return more complex HTML pages that are generated using templates. Flask makes it easy to use templates by allowing you to define your templates in a separate directory.
To add templates to your Flask application, you need to create a new directory named “templates” in your project directory. In this directory, you can create a new HTML file, for example, “index.html” and add the following code to it:
<html>
<head>
<title>My First Flask Application</title>
</head>
<body>
<h1>Hello, World!</h1>
</body>
</html>
You can now modify your “app.py” file to render this template when the root route is accessed:
from flask import Flask, render_template
app = Flask(__name__)
@app.route("/")
def index():
return render_template("index.html")
if __name__ == "__main__":
app.run()
When we try to run our Flask application, we should see the “Hello, World!” message being displayed in our browser, but this is being shown using the generator.
Database Integration
Most web applications require some kind of database to store data, such as user accounts, blog posts, and more. Flask makes it easy to integrate with databases, including relational databases such as PostgreSQL and SQLite, as well as NoSQL databases such as MongoDB.
One of the most popular and easy to use database extensions for Flask is Flask-SQLAlchemy, which provides a convenient wrapper around SQLAlchemy, a popular SQL toolkit. To use Flask-SQLAlchemy, you need to install it using the following command in your terminal or command prompt:
pip install flask-sqlalchemy
With Flask-SQLAlchemy installed, you can create a new database and define your database models in your Flask application. For example:
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///database.db"
db = SQLAlchemy(app)
class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
def __repr__(self):
return "<User %r>" % self.username
db.create_all()
In this example, we are using SQLite as our database, but you can easily switch to a different database by changing the SQLALCHEMY_DATABASE_URI configuration value.
Handling Forms in Flask
Handling user inputs, such as form submissions, is a common requirement in web applications. Flask makes it simple to handle forms with the request object, which is automatically available in your Flask application.
Let’s look at an example of handling a login form in Flask. First, we’ll create a new route in our Flask application to handle the form submission:
from flask import Flask, request, redirect, render_template
app = Flask(__name__)
@app.route("/")
def index():
return render_template("index.html")
@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
# Check if the username exists in the database
username = request.form["username"]
# code to check if the username exists
if username_exists:
return redirect("/welcome")
else:
return redirect("/")
return render_template("login.html")
@app.route("/welcome")
def welcome():
return "Welcome!"
if __name__ == "__main__":
app.run(debug=True)
In this example, we have three routes: index, login, and welcome. The index route simply returns the index.html template, which contains a login form. The login route handles the form submission and checks if the submitted username exists. If it does, the user is redirected to the welcome route, which simply returns the message “Welcome!”. If the username does not exist, the user is redirected back to the index route.
The form submission is done using the POST method, which is why we check the value of request.method in the login route. The GET method is used when the user initially visits the login page.
In this example, we use the redirect function from Flask to redirect the user to different pages based on the form submission. The render_template function is used to render HTML templates in Flask.
User authentication and authorization
User authentication and authorization are essential components of many web applications. They control who can access certain pages or perform certain actions within the application.
In Flask, user authentication and authorization can be implemented using a variety of methods, including sessions, tokens, and databases.
One popular method is to use sessions. A session is a persistent connection between a user and the server that allows the user’s state to be saved across multiple requests. Flask provides the session object, which allows you to store information about a user’s session and retrieve it later.
For example, you can store the user’s identity in the session after they log in, and then check the session on subsequent requests to determine if the user is still logged in:
@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
# code to verify the username and password
if valid_username_and_password:
session["username"] = username
return redirect("/welcome")
else:
# show an error message
return redirect("/")
return render_template("login.html")
@app.route("/welcome")
def welcome():
if "username" in session:
return "Welcome, " + session["username"]
else:
return redirect("/")
Another method is to use tokens, such as JSON Web Tokens (JWTs), to store the user’s identity and authorization information.Flask provides the pyjwt library, which makes it easy to encode and decode JWTs in Flask.
You can also store user authentication and authorization information in a database and use it to control access to certain pages or actions in your application. Flask provides the SQLAlchemy extension, which makes it easy to interact with a database in Flask.
Regardless of the method you choose, Flask makes it easy to add user authentication and authorization to your application.
Error handling in Flask
Error handling is one of the most important aspect of any web application. It allows us to gracefully handle unexpected errors and provide helpful error messages to our users. In Flask, you can add error handling using the @app.errorhandler decorator.
The @app.errorhandler decorator allows you to register a function that will be called whenever a specific error occurs in your application. For example, you can register a function to handle 404 (Not Found) errors as follows:
@app.errorhandler(404)
def page_not_found(error):
return render_template("404.html"), 404
In the above example, the page_not_found function returns a custom 404 error page when a 404 error occurs in the application. The second argument to the render_template function, 404, sets the HTTP status code for the response.
You can also register error handlers for other errors, such as 500 (Internal Server Error) or 403 (Forbidden) errors. For example:
@app.errorhandler(500)
def internal_server_error(error):
return render_template("500.html"), 500
@app.errorhandler(403)
def forbidden(error):
return render_template("403.html"), 403
In addition to registering error handlers, it’s also a good practice to log errors in your application so that you can diagnose and fix problems more easily. Flask provides the logging module, which allows you to log messages to a file or the console.
Error handling is a critical component of a robust and reliable web application, and Flask makes it easy to add error handling to your application. By registering error handlers and logging errors, you can provide a better user experience and more easily diagnose and fix problems in your application.
App routing in Flask
In Flask, routing refers to the process of mapping a URL to a specific function in the Flask application. The @app.route decorator is used to define routes in Flask. When a user makes a request to a specific URL, Flask checks the URL against the defined routes in the application, and calls the appropriate function to handle the request. The routing system allows Flask to create dynamic web applications that can respond to a variety of user requests and inputs. By defining routes and functions in the application, Flask can generate dynamic content and provide personalized user experiences based on user input and interaction.
Conclusion
In conclusion to this article by DataFlair, we can say that Flask is a powerful and flexible web framework that makes it easy to build and deploy web applications. With its simple and straightforward syntax, Flask allows you to quickly build and test your applications, while also providing a robust set of features and extensions to support more complex applications.
In this article, we covered the basics of building your first Flask application, including setting up the environment, defining routes and templates, handling forms, and adding user authentication and authorization. We also discussed error handling, which is an important aspect of any web application.
Flask is an excellent choice for any developer. With its simple and intuitive design, Flask makes it easy to get started and get results quickly. So why not start building your first Flask application today?
Did you know we work 24x7 to provide you best tutorials
Please encourage us - write a review on Google
