How to Use Flask for Python Web Development

Flask is like a set of LEGOs for building websites with Python. It's simple and lets you pick only the pieces you need. Unlike bigger frameworks, Flask gives you the basics and lets you decide how to build your site. This is great for beginners and pros. You get power without the headache. Let's dive in and see how to use Flask for Python web development. I'll show you everything from setting up to launching your site.

Why Use Flask?

Why is Flask so popular? Good question. It has some big advantages:

• It's tiny. Flask only gives you what you need. No extra baggage.
• It's fast. Less code means quicker loading and easier upkeep.
• It's flexible. You get to choose your favorite tools. Databases? Forms? You pick.
• It's easy to learn. Flask is straightforward. Even if you're new to Python web development, you'll catch on fast.
• It's expandable. Need more features? Extensions are here to help.
• It uses Jinja2. Jinja2 makes creating dynamic HTML pages a breeze.
• It plays well with others. Flask works with different web servers.

Getting Started

First, you need to get your computer ready. This means installing Python, setting up a virtual environment, and then installing Flask.

1. Install Python

Don't have Python yet? Get it here: https://www.python.org/downloads/. Make sure to check the box that says "Add Python to PATH." This lets you use Python from your command line.

2. Make a Virtual Environment

Think of a virtual environment as a bubble for your project. It keeps your project's stuff separate from other projects. No conflicts! Use this command:

python -m venv venv

This makes a folder named "venv." You can name it something else if you want.

3. Turn On the Virtual Environment

Now, step into your bubble. The command depends on your computer:

• Windows:

venv\Scripts\activate

source venv/bin/activate

See that (venv) at the start of your command line? You're in the bubble!

4. Install Flask

Time to get Flask. Use this command:

pip install Flask

This grabs Flask and all its friends.

Your First Flask App

Let's make a simple "Hello, World!" app. This will show you the basic layout of a Flask app.

1. Create a Python File

Make a new file called app.py. This is where your Flask code will live.

2. Add the Code

Open app.py and paste this in:

from flask import Flask app = Flask(name) @app.route('/') def hello_world(): return 'Hello, World!' if name == 'main': app.run(debug=True)

What does it all mean?

• from flask import Flask: Gets the Flask tools.
• app = Flask(__name__): Creates your app.
• @app.route('/'): This links the hello_world function to the main page of your website (/).
• def hello_world():: This is what happens when someone visits the main page. It shows "Hello, World!"
• if __name__ == '__main__':: This makes sure the app runs only when you run the file directly.
• app.run(debug=True): Starts the Flask server. debug=True helps you find errors. Don't use this on a real website!

3. Run Your App

Go to your command line, find your project folder, and run this:

python app.py

You'll see some lines like this:

Serving Flask app 'app' Debug mode: on Running on http://127.0.0.1:5000/ Click Ctrl+C to quit

4. See It in Action

Open your browser and go to http://127.0.0.1:5000/. "Hello, World!" should be staring back at you. Congrats!

Making Pages (Routing)

Routing is how you create different pages on your site. You tell Flask what to do when someone visits a specific address (URL).

Simple Routes

Like the "Hello, World!" example, @app.route('/') links a function to the main URL. You can do this for other pages too:

@app.route('/about') def about(): return 'This is the about page.'

Now, if someone goes to /about, they'll see "This is the about page."

Dynamic Pages

Want a page that changes based on what the user types in? Use dynamic routes!

@app.route('/user/<username>') def show_user_profile(username): return f'User: {username}'

Here, <username> is a variable. If someone goes to /user/john, the page will show "User: john."

You can also specify what kind of data the variable should be:

• <int:post_id>: post_id must be a number.
• <float:price>: price must be a decimal number.
• <path:file_path>: file_path can have slashes (/).

@app.route('/post/<int:post_id>') def show_post(post_id): return f'Post ID: {post_id}'

Making Pages Look Nice (Templates)

Just showing plain text is boring. Let's use templates to create fancy HTML pages. Flask uses Jinja2 for this.

Making a Template

Flask looks for templates in a folder called templates. Create that folder and put an HTML file in it (like index.html).

Here's an example index.html file:

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

{{ name }} is a placeholder. Flask will replace it with a value.

Using the Template

To show a template, use render_template():

from flask import Flask, render_template app = Flask(name) @app.route('/hello/<name>') def hello(name): return render_template('index.html', name=name) if name == 'main': app.run(debug=True)

Now, if someone goes to /hello/john, the page will say "Hello, john!"

Making Templates Easier to Manage

Jinja2 lets you create a base template with common parts (like headers and footers). Other templates can then build on this base. This keeps your site looking consistent.

Create a base template (base.html):

<!DOCTYPE html> <html> <head> <title>{% block title %}{% endblock %}</title> </head> <body> <nav> <a href="/">Home</a> <a href="/about">About</a> </nav> <div class="content"> {% block content %}{% endblock %} </div> </body> </html>

The {% block ... %} tags are like placeholders that child templates can fill in.

Create a child template (home.html):

{% extends 'base.html' %} {% block title %}Home Page{% endblock %} {% block content %} <h1>Welcome to the Home Page!</h1> <p>This is the home page content.</p> {% endblock %}

{% extends 'base.html' %} tells the template to use base.html as its base. The {% block ... %} tags fill in the placeholders.

In your Flask app, render the child template:

from flask import Flask, render_template app = Flask(name) @app.route('/') def home(): return render_template('home.html') if name == 'main': app.run(debug=True)

Getting Information From Users (Forms)

Forms let users enter information on your website. Flask has ways to handle forms, including using the request object and Flask-WTF.

Using the request Object

The request object gives you access to the data that users send to your site (like form data).

Create an HTML form (form.html):

<!DOCTYPE html> <html> <head> <title>Form Example</title> </head> <body> <form method="POST"> <label for="name">Name:</label> <input type="text" id="name" name="name"><br><br> <input type="submit" value="Submit"> </form> </body> </html>

In your Flask app, handle the form:

from flask import Flask, render_template, request app = Flask(name) @app.route('/form', methods=['GET', 'POST']) def form(): if request.method == 'POST': name = request.form['name'] return f'Hello, {name}!' return render_template('form.html') if name == 'main': app.run(debug=True)

@app.route('/form', methods=['GET', 'POST']) says that the form function handles both GET (showing the form) and POST (submitting the form) requests. When the user submits the form, request.form['name'] gets the value they typed in.

Using Flask-WTF

Flask-WTF makes form handling easier. It adds features like validation and security.

First, install it:

pip install Flask-WTF

Define a form class:

from flask_wtf import FlaskForm from wtforms import StringField, SubmitField from wtforms.validators import DataRequired class NameForm(FlaskForm): name = StringField('What is your name?', validators=[DataRequired()]) submit = SubmitField('Submit')

In your Flask app, handle the form:

from flask import Flask, render_template, request from flask_wtf import FlaskForm from wtforms import StringField, SubmitField from wtforms.validators import DataRequired app = Flask(name) app.config['SECRET_KEY'] = 'your_secret_key' # Replace with a strong secret key class NameForm(FlaskForm): name = StringField('What is your name?', validators=[DataRequired()]) submit = SubmitField('Submit') @app.route('/form', methods=['GET', 'POST']) def form(): form = NameForm() if form.validate_on_submit(): name = form.name.data return f'Hello, {name}!' return render_template('form.html', form=form) if name == 'main': app.run(debug=True)

Update your form.html template:

<!DOCTYPE html> <html> <head> <title>Form Example</title> </head> <body> <form method="POST"> {{ form.hidden_tag() }} <label for="name">{{ form.name.label }}:</label> {{ form.name() }}<br><br> {{ form.submit() }} </form> </body> </html>

Remember to replace 'your_secret_key' with a strong, random key! This keeps your site safe.

Saving Information (Databases)

Most websites need to save information. Flask can connect to databases like SQLite, MySQL, and PostgreSQL. SQLAlchemy is a popular tool that makes working with databases easier.

Using Flask-SQLAlchemy

Flask-SQLAlchemy makes it simple to use SQLAlchemy with Flask.

First, install it:

pip install Flask-SQLAlchemy

Connect to the database:

from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(name) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db' # Use an absolute path for production 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 f'<User %r>' % self.username with app.app_context(): db.create_all() if name == 'main': app.run(debug=True)

This code connects to an SQLite database called test.db. It also defines a User model with columns for id, username, and email. db.create_all() creates the tables in the database.

Doing Things With the Database

You can add, read, change, and delete data using SQLAlchemy.

from flask import Flask from flask_sqlalchemy import SQLAlchemy app = Flask(name) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.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 f'<User %r>' % self.username with app.app_context(): db.create_all() # Create a new user new_user = User(username='john_doe', email='[email protected]') db.session.add(new_user) db.session.commit() # Query all users users = User.query.all() for user in users: print(user.username, user.email) # Query a user by username user = User.query.filter_by(username='john_doe').first() if user: print(f'Found user: {user.username}') if name == 'main': app.run(debug=True)

This code shows how to create a new user, find all users, and find a user by username. Always use with app.app_context(): when working with the database outside of a request.

Putting Your Website Online (Deployment)

Once your Flask app is ready, you need to put it on a web server so people can see it. Here are some options:

• Heroku: Easy to use for deploying Flask apps.
• AWS Elastic Beanstalk: Amazon's service for deploying web apps.
• Google App Engine: Google's platform for web apps.
• DigitalOcean: Lets you rent virtual servers to deploy your app.
• Traditional Web Servers: You can also use servers like Apache or Nginx.

The best choice depends on your needs and your skills.

Wrapping Up

This guide showed you how to use Flask for Python web development. You learned how to set up, create apps, make pages, handle forms, use databases, and deploy your site. With these steps, you can build your own web applications with Flask. Its flexibility and ease of use make it a great choice for beginners and experienced developers. Don't forget to check out the Flask documentation and extensions to learn even more. Happy coding!