Django is a high-level Python web framework that encourages rapid development and clean, pragmatic design. It was created by a team of developers at the Lawrence Journal-World newspaper and has been released under an open-source license. This guide aims to help beginners get started with Django by discussing its installation, basic concepts, and building a simple web application.

What is Django?

Django is a web framework that allows developers to build web applications quickly and efficiently. It follows the Model-View-Template (MVT) architectural pattern, which helps to separate business logic from the user interface. This separation makes the code modular, easier to maintain, and reusable.

Features of Django

• Rapid Development: Django emphasizes the concept of “don’t repeat yourself” (DRY), resulting in reduced redundancy and simplification in coding.
• Robust Admin Interface: Django includes a powerful and customizable admin interface built directly from the models you define.
• Scalability: It’s designed to handle high traffic and scale accordingly.
• Security: Django has built-in protection against many web vulnerabilities, such as SQL injection, cross-site scripting, and cross-site request forgery.
• An Ecosystem of Third-Party Packages: The Django community has created a multitude of reusable apps and libraries.

Installing Django

The first step in building a web application with Django is to install the framework. We’ll go through the installation process step-by-step.

Prerequisites

• Python 3.x installed on your system. You can download it from python.org.
• A package manager such as pip (comes pre-installed with Python 3.x).

Step 1: Install Django

To install Django using pip, open your terminal or command prompt and run the following command:

pip install django

This command will download and install the latest version of Django. After installation, you can verify the installation by checking the Django version:

django-admin --version

Creating Your First Django Project

With Django installed, the next step is to create a new project. Follow these instructions:

Step 1: Create a Django Project

Navigate to the directory where you want to create your project and run the following command:

django-admin startproject myproject

This command creates a new directory called myproject with the necessary files for a Django project.

Step 2: Understanding Project Structure

Your new project directory will contain several files:

• manage.py: A command-line utility for managing your project.
• myproject: A directory containing settings and configurations for your project. It contains:

• __init__.py: Indicates that this directory should be treated as a Python package.
• settings.py: Configuration for your Django project, including database settings and allowed hosts.
• urls.py: URL declarations for your project.
• wsgi.py: Entry point for WSGI-compatible web servers to serve your project.

Step 3: Running the Development Server

To see your project in action, navigate into your project directory and run the following command:

python manage.py runserver

This command will start the development server. Open a web browser and enter http://127.0.0.1:8000/. You should see the Django welcome page, indicating that your project is up and running.

Creating Your First Django App

In Django, a project can contain one or multiple apps. Each app serves a specific purpose and contains its own logic and functionality. Let’s create our first app!

Step 1: Create a New App

While in your project directory, run the following command:

python manage.py startapp myapp

This command creates a new directory called myapp with the following structure:

• admin.py: Settings for the admin interface.
• apps.py: Configuration for the app.
• models.py: Define your data models here.
• tests.py: Write tests for your app.
• views.py: Contains your app’s business logic and views.

Step 2: Register the App

To include your new app in the project, you need to register it. Open settings.py in the myproject directory and add your app to the INSTALLED_APPS list:

INSTALLED_APPS = [

    ...

    'myapp',

]

Step 3: Creating a Simple View

Next, let’s create a simple view to display a message. Open views.py in myapp and add the following code:

from django.http import HttpResponse
def home(request):

    return HttpResponse("Hello, Django! This is my first app.")

Step 4: Mapping a URL to the View

To make this view accessible, you need to create a URL mapping. In your app directory, create a new file called urls.py and include the following code:

from django.urls import path

from . import views
urlpatterns = [

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

]

Next, include this app’s URLs in your project’s main urls.py. Open urls.py in the myproject directory and modify it as follows:

from django.contrib import admin

from django.urls import include, path
urlpatterns = [

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

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

]

Step 5: Test Your App

Run the development server again:

python manage.py runserver

Visit http://127.0.0.1:8000/ in your web browser, and you should see the message “Hello, Django! This is my first app.”

Working with Models

Models are essential in Django; they define the structure of your data. You can create a model by defining a Python class that inherits from django.db.models.Model.

Step 1: Define a Model

Edit models.py in your app and add the following code to create a simple model that represents a blog post:

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

Step 2: Create the Database Migration

After defining your models, you need to create a database migration. Run the following commands:

python manage.py makemigrations

python manage.py migrate

Step 3: Register the Model in Admin

To manage your model via the Django admin interface, register it in admin.py:

from django.contrib import admin

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

Step 4: Create an Admin User

Run the following command to create a superuser account:

python manage.py createsuperuser

Follow the prompts to create the account. You can then access the admin interface by visiting http://127.0.0.1:8000/admin/ and logging in with your superuser credentials.

Step 5: Adding Posts

Once logged in to the admin interface, you can add new blog posts and manage existing ones.

Building Templates

Django uses templates to separate the presentation layer from the business logic. This allows you to create dynamic HTML pages.

Step 1: Setting up a Template Directory

Inside your app directory, create a folder named templates, and within that folder, create another folder named myapp. This is where you’ll store your HTML templates.

Step 2: Creating a Template

Create a file named home.html in templates/myapp/ and add the following code:

<!DOCTYPE html>

<html lang="en">

<head>

    <meta charset="UTF-8">

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

    <title>Welcome to My Blog</title>

</head>

<body>

    <h1>Welcome to My Blog</h1>

    <p>This is my first post!</p>

</body>

</html>

Step 3: Rendering the Template

Update your view to render this template instead of returning a simple HTTP response. Modify the home view in views.py:

from django.shortcuts import render
def home(request):

    return render(request, 'myapp/home.html')

Testing the Template

Load the homepage at http://127.0.0.1:8000/ again and verify that you see your new template content.

Conclusion

Django is a powerful web framework that allows developers to build web applications quickly and efficiently. In this guide, we have covered the installation process, the creation of a new project and app, creating models, setting up an admin interface, and rendering templates. While this guide provides a foundational understanding of Django, there’s still much more to explore! Consider diving deeper into Django’s features like forms, authentication, and REST APIs as you continue your web development journey.

As with any framework, practice is key to building your expertise. Keep experimenting with different functionalities, building apps, and getting familiar with Django’s ecosystem. Happy coding!