Adventures in Machine Learning

Building Your Portfolio: Creating a Projects App with Django

Django: A Comprehensive Guide for Beginners

Django is a popular web framework for Python developers. It is an open-source framework that follows the Model-View-Controller (MVC) pattern, which divides an application into three separate components.

The MVC pattern helps simplify the development process and makes complex applications easier to manage. With Django, developers can build scalable, robust, and secure web applications.

What is Django?

Django is a web framework for Python that makes it easier to build web applications. It follows the MVT pattern, where the Model represents the data structure, the View handles user requests and generates responses, and the Template renders HTML code.

A Django site consists of several apps that have their own functionality. Each app follows the MVC or MVT pattern.

The apps are responsible for managing a specific functionality within a larger web application.

Architecture of a Django Site

Django site architecture follows the MVT pattern. The Model represents the data structure, and it defines how the data will be stored in a database.

The View handles user requests and serves the required responses. It receives data from the Model and, based on user input, calls necessary methods.

The Template is used for rendering HTML code. It takes the data received from the View and formats it into HTML.

Every Django site consists of several apps that help to manage specific functionalities. Each app follows the MVC or MVT pattern.

The Model is responsible for handling data storage, and the View handles user requests and responses. The Template renders HTML code.

Why Learn Django?

Python as a Programming Language

Python is a high-level, dynamically-typed language that is easy to read and write. The syntax is simple, and the code is more readable compared to other languages.

Python code uses indentation to represent blocks of code, which makes it more user-friendly. Python is beginner-friendly, and it has a lot of libraries and frameworks that make it easier to write code.

Scope of Features

Django has several features that make it a popular choice for web development. Features like URL routing, templating engine, authentication, and database access make it an excellent choice for building complex web applications.

It also supports external libraries that help developers to extend the functionality of their application. Django also keeps updating its libraries to fix bugs and add new features.

In-Depth Documentation and Community of Developers

Django has comprehensive documentation that covers all aspects of the framework, including installation, configuration, app development, and deployment. The documentation is easy to understand and offers several examples.

Django also has an active community of developers who contribute to the frameworks development and share knowledge among themselves. The community of developers also provides a lot of tutorials and learning resources that help beginners to learn Django.


In conclusion, Django is an excellent web framework for Python developers looking to build complex web applications. It follows the MVT pattern, which makes it easier to manage and maintain large web applications.

The framework has several features that make it a popular choice for web developers, including URL routing, templating engine, and authentication. It also supports external libraries that help to extend its functionality.

Pythons simplicity and readability, comprehensive documentation, and active community of developers make it easier for beginners to learn Django. With Django, developers can build scalable, robust, and secure web applications.

What You’re Going to Build

Now that we’ve covered what Django is, let’s talk about what you can build with it. We’re going to build a blog with features like creating, updating, and deleting posts.

We’ll also add categories to our posts and allow readers to leave comments. Additionally, we’ll create a portfolio to showcase our work.

Before we begin, you may either download the source code or write your own code. If you’re downloading the source code, make sure to read through it and understand what it does.

If you’re writing your own code, use the source code as a guide and reference.

Creating a Django Project

Django follows a project and app structure. A project is a self-contained function that contains one or more apps.

Each app can handle a separate functionality. For example, a website may have a blog app, a portfolio app, and a contact app.

To create a new Django project, you first need to install Django. To do so, you can use pip, a package manager for Python.

pip install Django

Next, open your terminal or command prompt and navigate to the directory where you want to create your project. You can use the cd command to change directories.

cd Documents

Once you’re in the directory where you want to create your project, run the following command:

django-admin startproject myproject

This will create a new Django project named ‘myproject’ in the current directory. Django creates a project folder with the same name as your project, which contains the project settings and configuration files.

It also creates a file, which is used to perform several management operations for the project. Next, set up your virtual environment.

A virtual environment isolates your project’s Python environment from your system’s Python environment. This ensures that your project has access to the specific versions of Python and installed packages it needs.

python -m venv venv

This will create a virtual environment named ‘venv’ inside your project directory. To activate the virtual environment, run the following command:

source venv/bin/activate

Your virtual environment is now activated, and any packages you install via pip will be installed in this environment.


In conclusion, we’ve covered what you’re going to build, the features of your blog application, and the importance of selecting whether you’re downloading or writing your own code. Moreover, we’ve discussed creating a new Django project and the relationship between projects and apps in a Django site.

Furthermore, we’ve gone through how to set up a virtual environment for your Django project. By following these steps, you can build a scalable, robust and secure web application using Django.

Creating a View

A view in Django is a function or class-based representation of an HTML page. When a user types a URL into the browser, Django parses the URL and routes it to the appropriate view.

The view function takes an HttpRequest object as an argument, processes it, and returns an HttpResponse object. Let’s create a simple view function for “Hello, World!” In your app’s file, create a function called hello_world().

from django.shortcuts import render
from django.http import HttpResponse

def hello_world(request):
    return HttpResponse('Hello, World!')

In this code, we import two modules render and HttpResponse. The hello_world() function takes an HttpRequest object as an argument and returns an HttpResponse with the “Hello, World!” message.

Now, let’s create an HTML template for “Hello, World!”. Create a directory called “templates” in your app directory.

In this “templates” directory, create a file called “hello.html”.

    Hello, World!


Hello, World!

In this code, we have an HTML file that contains a simple “Hello, World!” message.

Now, we need to render this HTML file from our view function. Add the following code to the ‘hello_world’ function:

def hello_world(request):
    return render(request, 'hello.html')

In this code, we use Django’s render() function to pass the ‘hello.html’ file to the HttpResponse object.

Finally, we need to configure a URL for our view. Open your app’s file and add the following code:

from django.urls import path
from . import views

urlpatterns = [
    path('hello-world/', views.hello_world, name='hello_world'),

In this code, we import Django’s path module and our app’s views module. We then define a URL pattern that maps to our ‘hello_world’ view.

Adding Bootstrap to Your App

Now that we have created our first view, let’s add some styling to our web page using Bootstrap. Bootstrap is a front-end CSS framework that provides pre-built classes and styles for designing responsive, mobile-first websites.

We’ll start by creating a base template that we can extend to other views. In your app’s ‘templates’ directory, create a file named ‘base.html’.

    {% block title %}{% endblock %}

{% block page_content %}{% endblock %}

In this code, we have created a base HTML template with a container class that encloses our page’s content. We also inserted a Bootstrap stylesheet link to add styling to our web page.

Next, we create a ‘hello.html’ file that extends the ‘base.html’ template.

{% endblock %}” aria-label=”Copy” data-copied-text=”Copied!” data-has-text-button=”textSimple” data-inside-header-type=”none” aria-live=”polite”>Copy
{% extends 'base.html' %}
{% block title %}Hello, World!{% endblock %}
{% block page_content %}

Hello, World!

{% endblock %}

In this code, we use the ‘extends’ tag to inherit the base template’s structure and style.

We have also defined a new block ‘title’ that overwrites the base template’s title tag. Finally, we create a new block called ‘page_content’, which is used to add content to the page.

To make the base template available to our app’s views, we need to register it to our project-level templates. In the file, add the following to the ‘TEMPLATES’ list:

'DIRS': [BASE_DIR / 'templates'],

This code adds our app’s ‘templates’ directory to the list of available templates.


In this article, we covered how to create a view in Django. We created a simple view function for ‘Hello, World!’, an HTML template for the view, and configured a URL pattern to map to our view.

Furthermore, we added styling to our application using Bootstrap. We created a base template and used it to style our ‘Hello, World!’ page.

Adding Bootstrap made our web page responsive and mobile-friendly. Our web page looks better now, and it is easier to read.

In the next article, we’ll cover how to create models in Django.

Showcase Your Projects

In this article, we’ll build an app that allows us to showcase our projects. We’ll create a new app called ‘projects’ and delete the ‘hello_world’ application we created earlier.

Our projects app will showcase our work and allow visitors to view our portfolio.

We’ll create a model to store information about each project, including its title, description, and an image. Then, we’ll create views to display all of our projects and detail views for individual projects.

First, we need to create the ‘projects’ app. In your terminal or command prompt, navigate to your project directory and run the following command:

python startapp projects

This will create a new app called ‘projects’ in your project directory.

We’ll now delete the ‘hello_world’ application since we don’t need it anymore. To delete the ‘hello_world’ application, remove its entry in the INSTALLED_APPS list, which is located in the file.

Additionally, delete its directory from your app folder and the pycache directory.

Deletion of hello_world Application

To remove the ‘hello_world’ application from your project, first remove its references from the INSTALLED_APPS list in the file. This file is located in the base project directory.

    # 'hello_world', remove this line

Next, delete the ‘hello_world’ directory in your app folder and the pycache directory if it exists. Finally, delete the URL reference to the ‘hello_world’ view function in the file of your app folder.

Conclusion: Next Steps Involve Creating the Projects App and Learning About Models in Django

In conclusion, we’ve covered the next steps involved in creating the projects app. We’ve introduced the app by discussing its purpose, which is to showcase our work through a portfolio.

Additionally, we’ve learned how to delete the ‘hello_world’ application from our project, making way for our projects app. In the next article, we’ll dive into models in Django.

We’ll create a model to store project information for our projects app. By following along with our articles, you will learn how to create scalable, robust, and secure web applications using Django.

Final Thoughts

In this series of articles, we covered the basics of Django web framework. Django is a powerful open-source framework for Python web developers.

We discussed the architecture of a Django site and the MVC and MVT patterns that simplify the development process. We also explored the scope of features provided by Django and the reasons why developers should consider learning it, such as Python’s simplicity, comprehensive documentation, and active developer community.

We created a view function that returned “Hello World!” and an HTML template using Bootstrap. Finally, we deleted our ‘Hello World!’ application and learned how to create a new Project’s app, which we’ll build out further in the next article.

By following along with these tutorials, beginner developers can learn valuable skills that will facilitate building scalable, robust, and secure web applications using Django.

Popular Posts