Building a Blog with Flask

Flask is a lightweight Python web framework that allows developers to easily build web applications and websites. One popular use case for Flask is building a blog. This article will go through the steps to build a simple blog using Flask.

First, we must install Flask and set up our project structure. To install Flask, use the following command:

pip install flask

Next, create a folder for your project and create a file called app.py inside it. This will be the main entry point for our Flask app.

In app.py, import Flask and create a new instance of the Flask class:

from flask import Flask

app = Flask(__name__)

Now, we can create a route for our homepage. A route is a URL that our app listens to and responds to with a specific function. In our case, we will create a route for the homepage at the URL /.

@app.route('/')
def homepage():
    return 'Welcome to my blog!'

To run our app, we can use the flask run command. This will start a development server at localhost:5000. If we visit this URL in our web browser, we should see the message "Welcome to my blog!" displayed.

Next, we will need to set up a database to store our blog posts. For this example, we will use SQLite, which is a simple, file-based database. First, we will need to install the Flask-SQLAlchemy extension, which provides an interface to SQLite for Flask. Use the following command to install it:

pip install flask-sqlalchemy

Next, in app.py, import Flask-SQLAlchemy and create a new instance of the SQLAlchemy class:

Copy codefrom flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
db = SQLAlchemy(app)

We will also need to configure Flask-SQLAlchemy to use our SQLite database. In app.py, add the following code to set the database URI:

Copy codeapp.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///blog.db'

Now, we can create a model for our blog posts. A model is a class that represents a table in the database. In, create a class called Post with the following code:

Copy codeclass Post(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(100), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)

This model has four fields: id, title, content, and created_at. The id the field is the primary key, which is a unique identifier for each post. The title and content fields are the title and content of the post, respectively. The created_at field is the date and time the post was created.

Next, we can create a route to display a list of all the blog posts. In `app.py, add the following code:

Copy code@app.route('/posts')
def posts():
    posts = Post.query.all()
    return render_template('posts.html', posts=posts)

This route will use the Post model to retrieve all the posts from the database and pass them to the posts.html template.

We will also need to create the posts.html template. In the templates folder, create a new file called posts.html and add the following code:

Copy code{% for post in posts %}
    <h2>{{ post.title }}</h2>
    <p>{{ post.content }}</p>
{% endfor %}

This template will loop through the posts list and display the title and content of each post.

We can also create a route to display a single post. In app.py, add the following code:

Copy code@app.route('/posts/<int:post_id>')
def post(post_id):
    post = Post.query.get(post_id)
    return render_template('post.html', post=post)

This route will use the Post model to retrieve a single post by its id and pass it to the post.html template.

Create the post.html template in the templates folder and add the following code:

Copy code<h2>{{ post.title }}</h2>
<p>{{ post.content }}</p>

This template will display the title and content of the post.

Finally, we can create a route to create new blog posts. In, add the following code:

Copy code@app.route('/create', methods=['GET', 'POST'])
def create():
    if request.method == 'POST':
        title = request.form['title']
        content = request.form['content']
        post = Post(title=title, content=content)
        db.session.add(post)
        db.session.commit()
        return redirect('/posts')
    return render_template('create.html')

This route will handle both GET and POST requests. If it is a GET request, it will render the create.html template. If it is a POST request, it will create a new Post object with the submitted title and content, add it to the database, and then redirect to the /posts route to display the list of posts.

Create the create.html template in the templates folder and add the following code:

Copy code<form action="/create" method="post">
    <label for="title">Title:</label><br>
    <input type="text" id="title" name="title"><br>
    <label for="content">Content:</label><br>
    <textarea id="content" name="content"></textarea><br>
    <input type="submit" value="Submit">
</form>

This template will display a form for the user to submit a new blog post.

With these steps, we have created a simple blog using Flask. We can now create, view, and list blog posts using our app.

There are many other features we can add to our blog, such as authentication for creating and editing posts, pagination for long lists of posts, and tagging posts for easier organization. However, the steps outlined in this article provide a solid foundation for building a basic blog with Flask.

In summary, to build a blog with Flask, we need to:

Install Flask and set up the project structure
Create routes for the homepage and post lists and templates to render the content
Set up a database using Flask-SQLAlchemy and create a model for our blog posts
Create a route and template for creating new posts
Add any additional features, such as authentication and pagination.

With these steps, we can easily build a functional blog using Flask.

Building a Blog with Flask

Table of contents

No headings in the article.