Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. If you’re new to web development and eager to create dynamic web applications, Django is a fantastic option. This guide will take you from a beginner to building your first Django web application.

Table of Contents

• 1. Introduction
• 2. Setting Up Your Development Environment
• 3. Creating Your First Django Project
• 4. Understanding the Django Project Structure
• 5. Creating a Django App
• 6. Building Models and Database Migrations
• 7. Creating Views and Templates
• 8. URLs and Routing
• 9. Static and Media Files
• 10. Testing Your Application
• 11. Deployment and Production
• 12. Conclusion

1. Introduction

Django was designed to help developers take applications from concept to completion as swiftly as possible. This is achieved with built-in features that take care of the common web development tasks, such as user authentication, an administrative interface, and robust database management. In this guide, we’ll cover the basics of Django and walk through building a simple web application.

2. Setting Up Your Development Environment

Before diving into Django, you need to set up your development environment. Below are the steps to get started:

Install Python

Django is a Python framework, so ensure you have Python installed on your machine. Download it from the official website.

Install Django

Once Python is installed, you can install Django using pip, Python’s package manager. Open your terminal and run:

pip install django

Verify the Installation

To confirm that Django is installed correctly, run the following command:

django-admin --version

This command should display the installed version of Django.

3. Creating Your First Django Project

A Django project is a collection of settings and configurations for a particular web application. Let’s create your first project:

Create a Project

Run the following command in your terminal, replacing myproject with your desired project name:

django-admin startproject myproject

Navigate into Your Project Directory

cd myproject

Run the Development Server

You can start your Django application and see it in action by running:

python manage.py runserver

Open your web browser and go to http://127.0.0.1:8000/. You should see the Django welcome page!

4. Understanding the Django Project Structure

Your Django project will have a standard structure:

myproject/

    manage.py

    myproject/

        __init__.py

        settings.py

        urls.py

        wsgi.py

• manage.py – A command-line utility that lets you interact with your project.
• settings.py – Contains all configurations for your project.
• urls.py – Defines the URL patterns for your project.
• wsgi.py – Contains the WSGI configuration for your project.

5. Creating a Django App

A Django project can contain multiple apps, which are designed to be modular. This allows for easier development and management. Let’s create a simple app:

Create a New App

python manage.py startapp myapp

Your project now contains a new directory myapp with several files, including models, views, and tests.

6. Building Models and Database Migrations

Models in Django are Python classes that define the fields and behaviors of the data you’re storing. Django provides a powerful ORM (Object-Relational Mapping) system to interact with the database.

Create Your First Model

Edit myapp/models.py to define a simple model:

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

    name = models.CharField(max_length=200)

    description = models.TextField()

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

        return self.name

Make Migrations

To create the database schema for your model, run:

python manage.py makemigrations

Apply Migrations

Now, apply the migrations:

python manage.py migrate

7. Creating Views and Templates

With your models set up, the next step is to create views and templates to display data.

Create a View

Edit myapp/views.py to add a view that retrieves all items:

from django.shortcuts import render

from .models import Item
def item_list(request):

    items = Item.objects.all()

    return render(request, 'myapp/item_list.html', {'items': items})

Create a Template

Create a directory called templates inside your myapp folder, and then create another directory called myapp inside it. Now create the file item_list.html:

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>Item List</title>

</head>

<body>

    <h1>Items</h1>

    <ul>

        {% for item in items %}

            <li>{{ item.name }}: {{ item.description }}</li>

        {% endfor %}

    </ul>

</body>

</html>

8. URLs and Routing

To access your view, you need to create a URL mapping. Open myproject/urls.py and include your app’s URLs:

from django.contrib import admin

from django.urls import path

from myapp.views import item_list
urlpatterns = [

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

    path('', item_list, name='item_list'),

]

9. Static and Media Files

Static files are assets such as stylesheets, JavaScript, and images. In Django, you can handle static files using the STATIC_URL setting in settings.py.

Set Up Static Files

Add a directory called static in your myapp folder for your CSS and JavaScript files. Ensure you modify your settings.py like so:

STATIC_URL = '/static/'

10. Testing Your Application

Testing is crucial in web development. Django includes a testing framework that allows you to create and run tests easily.

Create a Simple Test

Create a test in myapp/tests.py:

from django.test import TestCase

from .models import Item
class ItemModelTest(TestCase):

    def setUp(self):

        Item.objects.create(name="Test Item", description="A description")
def test_item_content(self):

        item = Item.objects.get(id=1)

        expected_object_name = f'{item.name}'

        self.assertEqual(expected_object_name, 'Test Item')

Run Your Tests

Execute the following command to run your tests:

python manage.py test myapp

11. Deployment and Production

Deploying a Django application to production involves more steps than simply running the development server. Ensure you follow best practices, such as:

• Use a production-ready web server (like Gunicorn or uWSGI).
• Configure your database securely.
• Set DEBUG = False in your settings.
• Utilize environment variables for sensitive information.

For deployment, platforms like Heroku or DigitalOcean offer straightforward routes to get your Django application online.

12. Conclusion

Congratulations! You’ve built your first web application using Django. You started with the basics—understanding the framework, setting up the environment, creating projects and apps, and finally deploying your application. While this tutorial provided a foundation, Django’s extensive features offer endless possibilities for expanding your application.

As you continue to develop your skills, explore more complex topics such as user authentication, form handling, REST APIs, and integrating third-party packages. Django has a vibrant community and extensive documentation to help guide you through your learning journey.

Happy coding, and welcome to the great world of web development with Django!