Venturing into web development can feel daunting, but with the right framework, the process becomes smoother and more manageable. Django, a high-level Python web framework, allows for clean, pragmatic design while keeping rapid development in mind. Whether you’re transitioning from a different framework or starting from scratch, Django is designed to help you effortlessly move from zero to hero. In this article, we’ll guide you through developing your first Django web application. By the end, you’ll have a foundational understanding and a basic web application to build upon.

Getting Started with Django

Django’s philosophy of “batteries-included” ensures that you have most of what you need out of the box, but before diving into code, let’s set up the necessary tools.

Setting Up Your Environment

First, you’ll need to install Python and ensure you have Django available on your system. Here’s a brief overview of what to do:

1. Install Python: Download the latest version of Python from the official Python website and follow the installation instructions.
2. Install Django: Once Python is installed, open your terminal and run:

   pip install django

   This command will install Django and its dependencies.

3. Create a Virtual Environment: It’s a good practice to create a virtual environment for each project:

   python -m venv myenv

   Activate it:

   source myenv/bin/activate

Creating Your Django Project

With Django installed, you can create a project. In your terminal, navigate to the directory where you want your project and execute:

django-admin startproject myproject

This command will generate the basic Django project structure in a folder named myproject.

Understanding the Django Project Structure

Before we start adding functionality, let’s explore what Django has created:

• manage.py: A command-line utility that lets you interact with your project in various ways.
• The project directory contains:

  • __init__.py: An empty file that tells Python this directory should be considered a Python package.
  • settings.py: Settings/configuration for this Django project.
  • urls.py: The URL declarations for this Django project; a “table of contents” of your Django-powered site.
  • asgi.py and wsgi.py: Entry-points for ASGI and WSGI-compatible web servers to serve your project.

Starting the Development Server

To verify your installation, let’s run the built-in server. Execute the following command in your terminal:

python manage.py runserver

Visit http://127.0.0.1:8000 in your web browser, and you should see a welcome message from Django! This means everything is set up correctly.

Creating a Django App

A Django project can contain many apps; each app is a package that can be easily distributed and reused in different projects. To create an app, run:

python manage.py startapp myapp

This command creates a directory called myapp, essential for managing everything related to that app.

Building the Application

Now, let’s add functionality to our app. We’ll create a simple blog where users can read posts. Here’s how you can proceed:

Defining Models

In Django, a model defines the structure of your data. Edit myapp/models.py to include:

from django.db import models
class Post(models.Model):

    title = models.CharField(max_length=200)

    content = models.TextField()

    created_at = models.DateTimeField(auto_now_add=True)
def __str__(self):

        return self.title

After defining your model, generate the necessary database schema with:

python manage.py makemigrations myapp

Then apply the migration to the database:

python manage.py migrate

Registering Models in Admin

Django provides an admin interface to manage your models. Register your model by editing myapp/admin.py:

from django.contrib import admin

from .models import Post
admin.site.register(Post)

Creating Views

Views are Python functions that process requests and return responses. Define a basic view in myapp/views.py:

from django.http import HttpResponse

from .models import Post
def index(request):

    posts = Post.objects.all()

    return HttpResponse(posts)

Configuring URLs

To map the URL to this view, add the following to myapp/urls.py (create this file if it doesn’t exist):

from django.urls import path

from . import views
urlpatterns = [

    path('', views.index, name='index'),

]

Link these app URLs to the project-level urls.py:

from django.contrib import admin

from django.urls import include, path
urlpatterns = [

    path('admin/', admin.site.urls),

    path('myapp/', include('myapp.urls')),

]

Creating Templates

Django allows you to separate the HTML from Python code using templating. Create a templates directory inside your app and add a new HTML file named index.html:

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <title>My Blog</title>

</head>

<body>

    <h1>Blog Posts</h1>

    {% for post in posts %}

        <div>

            <h2>{{ post.title }}</h2>

            <p>{{ post.content }}</p>

            <small>{{ post.created_at }}</small>

        </div>

    {% endfor %}

</body>

</html>

Updating the View to Use the Template

Edit your view function to render this template:

from django.shortcuts import render

from .models import Post
def index(request):

    posts = Post.objects.all()

    return render(request, 'myapp/index.html', {'posts': posts})

Conclusion

You’ve now created a basic web application using Django. We’ve explored how to set up a working environment, create a project and app, define models, create views, and render templates. While this application is simple, it provides a foundation for understanding how Django works and can be expanded upon to include more features and complexity.

Django is a powerful tool that can simplify many aspects of web development. With its robust ecosystem and community, there are countless directions you can take with your new skills. Keep exploring Django’s features, such as authentication, static files handling, or deploying applications to cloud platforms, to grow as a Django developer and transition from zero to hero in web application development.