Python Flask Tutorial for Beginners: Build Your First Web App
Are you a Python enthusiast curious about web development? Do you want to build dynamic websites without diving deep into complex frameworks? If yes, Flask Tutorial is the perfect starting point for you. In this beginner-friendly tutorial, we’ll walk you through everything you need to know to build and run your very first web application using Flask — a lightweight yet powerful Python web framework.
By the end of this tutorial, you’ll have a functional web app running on your local machine, along with a solid understanding of Flask’s core features like routing, templates, and request handling.
What is Flask?
Flask is a micro web framework written in Python. It’s called “micro” not because it lacks power, but because it keeps the core simple and extensible. With minimal setup, you can create powerful web apps, and when needed, you can plug in additional components like form handling, databases, and user authentication.
Why choose Flask?
- Lightweight and minimalistic
- Easy to learn and use
- Ideal for small to medium-sized applications
- Highly flexible and customizable
- Great documentation and community support
Flask is widely used in startups, academic projects, and even in production at large companies when rapid development is a priority.
Getting Started: Prerequisites
To follow along with this tutorial, you should have:
- Basic understanding of Python
- Python 3 installed on your machine
- A code editor like VS Code or PyCharm
Step 1: Set Up Your Environment
First, create a project directory:mkdir flask_app cd flask_app
Now, it’s a good practice to create a virtual environment:python -m venv venv source venv/bin/activate # macOS/Linux venv\Scripts\activate # Windows
Install Flask using pip:pip install flask
Step 2: Create a Simple Flask App
Create a file named app.py and add the following code:from flask import Flask app = Flask(__name__) @app.route(’/’) def home(): return “Hello, Flask!” if __name__ == ’__main__’: app.run(debug=True)
Explanation:
- Flask(__name__): Creates an instance of the Flask application.
- @app.route(’/’): Defines a route for the home page.
- debug=True: Automatically reloads the server when code changes and provides helpful error messages.
Run your app:python app.py
Open your browser and go to http://127.0.0.1:5000. You should see:Hello, Flask!
Congrats! Your first web app is up and running.
Step 3: Add More Routes
Let’s add another route to display an “About” page.
Update your app.py:@app.route(’/about’) def about(): return “This is the About page.”
Visit http://127.0.0.1:5000/about in your browser to test it.
Step 4: Use HTML Templates
Flask allows you to use templates with the help of Jinja2, a templating engine.
Create a folder named templates, and inside it, create a file called index.html:<!– templates/index.html –> <!DOCTYPE html> <html> <head> <title>My Flask App</title> </head> <body> <h1>Welcome to My Flask App!</h1> <p>This is your first dynamic web page.</p> </body> </html>
Now modify your home route in app.py:from flask import render_template @app.route(’/’) def home(): return render_template(‘index.html’)
Reload the page at http://127.0.0.1:5000/ — now you’ll see the rendered HTML!
Step 5: Add Dynamic Content
You can pass variables to your templates:@app.route(’/user/<name>’) def user(name): return render_template('user.html’, username=name)
Create templates/user.html:<!DOCTYPE html> <html> <head> <title>User Page</title> </head> <body> <h1>Hello, {{ username }}!</h1> </body> </html>
Now, visiting http://127.0.0.1:5000/user/Alex will display:
“Hello, Alex!”
Step 6: Handle Forms
Let’s create a simple form.
First, add a form to your index.html:<form method=“POST” action=“/submit”> <input type=“text” name=“name” placeholder=“Enter your name”> <input type=“submit” value=“Submit”> </form>
Now, update app.py to handle the form submission:from flask import request @app.route(’/submit’, methods=['POST’]) def submit(): name = request.form['name’] return f"Hello, {name}! Thanks for submitting the form.“
Now you have a working form that responds to user input!
What’s Next?
Now that you’ve built a basic web app with Flask, you can explore more advanced topics:
- Working with Flask Blueprints for modular code
- Connecting to databases using SQLAlchemy
- Adding user authentication
- Creating RESTful APIs with Flask
- Deploying Flask apps on platforms like Heroku, Render, or AWS
Conclusion
Flask is the perfect starting point for Python developers stepping into the world of web development. With just a few lines of code, you can build powerful web applications, handle user input, and render dynamic content. Whether you’re creating personal projects, prototypes, or production-ready web apps, Flask is a framework that grows with your needs.
In this tutorial, we covered:
- Setting up Flask
- Creating routes and views
- Using HTML templates
- Passing dynamic data
- Handling forms
This foundational knowledge puts you in a great position to go deeper with Flask or transition into full-stack development. So go ahead — experiment, build, break things, and create something awesome with Python and Flask.
Ready to keep building? Stay tuned for more tutorials where we’ll show you how to build CRUD apps, integrate databases, and deploy your Flask apps to the cloud.
Happy coding! With Tpoint tech
