DEV Community: Gopal Ghate

🧱 Django Class-Based Views (CBVs) – Building APIs for the Frontend

Gopal Ghate — Mon, 13 Oct 2025 17:52:21 +0000

In this article, we’ll explore how Class-Based Views (CBVs) can be used to build clean, reusable APIs instead of rendering templates.

💡 What Are Class-Based Views?

Class-Based Views (CBVs) allow you to organize request-handling logic using Python classes instead of functions. They provide structure and reusability for common API operations such as fetching lists, retrieving single records, creating, updating, and deleting data.

Example – converting FBV to CBV:
Function Based View

from django.http import JsonResponse

def home(request):
    return JsonResponse({"message" : Welcome to My Blog API"})

Class Based view

from django.views import View
from django.http import JsonResponse

class HomeView(View):
    def get(self, request):
        return JsonResponse({"message": "Welcome to My Blog API!"})

And in urls.py

from django.urls import path
from .views import HomeView


urlpatterns = [
    path('', HomeView.as_view(), name='home'),
]

as_view() converts the class into a callable function that Django can handle.

⚙️ Example: API CRUD Using CBVs

Let's say we have a simple Post models:

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

We’ll create CBVs for each CRUD operation and return JSON responses.

1️⃣ ListView – Get All Posts

class PostListView(View):
    def get(self, request):
        posts = list(Post.objects.values())
        return JsonResponse({"posts": posts})

2️⃣ DetailView – Get a Single Post

class PostDetailView(View):
    def get(self, request, pk):
        try:
            post = Post.objects.values().get(id=pk)
            return JsonResponse({"post": post})
        except Post.DoesNotExist:
            return HttpResponseNotFound(JsonResponse({"error": "Post not found"}))

3️⃣ CreateView – Add a New Post

@method_decorator(csrf_exempt, name='dispatch')
class PostCreateView(View):
    def post(self, request):
        data = json.loads(request.body)
        post = Post.objects.create(title=data.get('title'), content=data.get('content'))
        return JsonResponse({"id": post.id, "message": "Post created successfully"}, status=201)

4️⃣ UpdateView – Edit an Existing Post


@method_decorator(csrf_exempt, name='dispatch')
class PostUpdateView(View):
    def put(self, request, pk):
        try:
            post = Post.objects.get(id=pk)
            data = json.loads(request.body)
            post.title = data.get('title', post.title)
            post.content = data.get('content', post.content)
            post.save()
            return JsonResponse({"message": "Post updated successfully"})
        except Post.DoesNotExist:
            return JsonResponse({"error": "Post not found"}, status=404)

5️⃣ DeleteView – Remove a Post


@method_decorator(csrf_exempt, name='dispatch')
class PostDeleteView(View):
    def delete(self, request, pk):
        try:
            post = Post.objects.get(id=pk)
            post.delete()
            return JsonResponse({"message": "Post deleted successfully"})
        except Post.DoesNotExist:
            return JsonResponse({"error": "Post not found"}, status=404)

🧠 Why CBVs Are Great for APIs

Cleaner, more structured code.
Each HTTP method has its own function (get, post, put, delete).
Easy to extend and reuse logic using inheritance.
Plays nicely with Django REST Framework if you decide to scale up.

⚡ Best Practices

Always return JSON for frontend consumption.
Use csrf_exempt carefully or rely on proper CSRF tokens for POST/PUT requests.
Validate input data before saving.
Use Django REST Framework for complex APIs with authentication, pagination, and serializers.

🏆 Summary

CBVs can be used not only for HTML rendering but also for clean API design.
Each request type (GET, POST, PUT, DELETE) can be handled within a single class.
Use CBVs for modular, maintainable, and testable backend APIs.

🎨 Django Templates & Static Files – Building Dynamic HTML

Gopal Ghate — Sun, 05 Oct 2025 10:52:48 +0000

In the last article, we learned how to handle views and return different types of responses. Now, let’s make those responses beautiful and dynamic using Django Templates and Static Files.

Templates allow you to mix HTML with Python-like logic, and static files (CSS, JS, images) make your pages come alive.

🧩 What Are Django Templates?

Django uses the Django Template Language (DTL) to help you embed dynamic content inside HTML.
Example (blog/templates/blog/home.html):

<!DOCTYPE html>
<html>
    <head>
        <title>{{ title }}</title>
    </head>
    <body>
        <h1>Welcome, {{ user }}</h1>
        <p>{{ message }}</p>
    </body>
</html>

You can pass variables from your view:

def home(request):
    context = {
    'title': 'My Blog',
    'user': 'Gopal',
    'message': 'Learning Django Templates is fun!'
    }
    return render(request, 'blog/home.html', context)

Result -> Welcome, Gopal

🧠 Template Tags and Filters

You can use logic in templates using special tags.
Example:

{% if user %}
    <h2>Hello, {{ user }}!</h2>
{% else %}
    <h2>Welcome, Guest!</h2>
{% endif %}

Loops:

<ul>
    {% for post in posts %}
        <li>{{ post.title }}</li>
    {% empty %}
    <li>No posts available.</li>
    {% endfor %}
</ul>

Filters:

<p>{{ post.content|truncatewords:10 }}</p>
<p>{{ post.published_at|date:"F j, Y" }}</p>

Filters format or modify data inside templates.

🧱 Template Inheritance (DRY Principle)

Avoid repeating code like headers and footers using template inheritance.

base.html

<!DOCTYPE html>
<html>
    <head>
        <title>{% block title %}My Site{% endblock %}</title>
    </head>
    <body>
        <header><h1>My Blog</h1></header>
        <main>
            {% block content %}{% endblock %}
        </main>
        <footer>© 2025 My Blog</footer>
    </body>
</html>

home.html

{% extends 'blog/base.html' %}


{% block title %}Home Page{% endblock %}
{% block content %}
    <h2>Welcome to my blog!</h2>
{% endblock %}

This structure keeps your HTML modular and maintainable.

🖼️ Static Files (CSS, JS, Images)

Static files are assets that don't change dynamically.
Folder structure:

blog/
├── static/
│    └── blog/
│    ├── css/
│    │    └── style.css
│    ├── js/
│    │    └── script.js
│    └── images/
│         └── logo.png

settings.py Configuration

STATIC_URL = '/static/'

During development, Django automatically serves static files if DEBUG=True.

Loading Static Files

In your templates:

{% load static %}
<link rel="stylesheet" href="{% static 'blog/css/style.css' %}">
<img src="{% static 'blog/images/logo.png' %}" alt="Logo">

Example style.css

body {
    background-color: #fafafa;
    font-family: Arial, sans-serif;
    margin: 40px;
}

⚡ Best Practices

Always use load static at the top of the templates.
Keep static files organized per app (app_name/static/app_name/).
Use template inheritance for reusable layouts.
Avoid putting business logic inside templates.

🏆 Summary

Templates render dynamic HTML using context variables.
Template tags and filters add logic and formatting.
Template inheritance keeps layouts DRY.
Static files add design, interactivity, and branding.

🌐 Django Views – Function-Based Views (FBVs) Explained

Gopal Ghate — Sun, 05 Oct 2025 09:45:09 +0000

In Django, views are the heart of your application. They control what data is shown and how it’s displayed. A view takes a request from the user and returns a response. In this article, we’ll explore Function-Based Views (FBVs), how they work, and how to handle different request methods (GET, POST).

🏗 What is a View?

A view is a Python function (or class) that receives a web request and returns a web response.

Simplest view (blog/views.py):

from django.http import HttpResponse


def home(request):
    return HttpResponse("Hello, Django Views!")

Then connect it in blog/urls.py:

from django.urls import path
from . import views


urlpatterns = [
    path('', views.home, name='home'),
]

Visiting http://127.0.0.1:8000/ will now show: Hello, Django Views!

📦 Rendering Templates in Views

Instead of plain text, we usually render HTML templates

def home(request):
    return render(request, 'blog/home.html', {"message": "Welcome to the Blog"})

Now in blog/templates/blog/home.html

<h1>{{ message }}</h1>

This will display: Welcome to the Blog

🔄 Handling GET and POST Requests

Views can handle multiple request methods:

def contact(request):
    if request.method == "POST":
        name = request.POST.get("name")
        return HttpResponse(f"Thanks for contacting us, {name}!")
    return HttpResponse("Contact Form Page")

If it’s a GET request, it shows the form page.
If it’s a POST request, it processes submitted data.

🛠 Returning Different Response Types

1️⃣ JSON Response

from django.http import JsonResponse


def api_data(request):
    return JsonResponse({"status": "success", "data": [1, 2, 3]})

2️⃣ Redirect

from django.shortcuts import redirect


def redirect_home(request):
    return redirect('home')

⚡ Advantages of FBVs

Easy to understand and quick to write.
Perfect for simple views like forms, API endpoints, or basic pages.
Direct control over request/response handling.

⚠️ When FBVs Become Complex

As logic grows, FBVs can become messy with many if/else conditions. Example:


def post_handler(request):
    if request.method == "GET":
        return HttpResponse("Show posts")
    elif request.method == "POST":
        return HttpResponse("Create post")
    elif request.method == "PUT":
        return HttpResponse("Update post")
    else:
        return HttpResponse("Unsupported method")

This works or we can create a separate functions and urls, but it gets harder to maintain. That’s why Django also provides Class-Based Views (CBVs) (coming in a later article).

🏆 Summary

Views take a request and return a response.
FBVs are functions that handle logic directly.
You can return HTML, JSON, or redirects.
FBVs are great for simple use cases, but can get messy for complex ones.

🗄️ Django Models & ORM Deep Dive

Gopal Ghate — Tue, 30 Sep 2025 18:23:08 +0000

In the previous article, we set up our first app and rendered a template successfully. Now, it’s time to make our app dynamic by adding a database. Django’s ORM (Object Relational Mapper) allows us to work with databases using Python classes — no SQL required!

In this article, we will cover:

What are models and the Django ORM?
Defining fields and creating migrations.
Performing CRUD operations.
Relationships: One-to-One, One-to-Many, Many-to-Many.
Querying the database.
Quickly testing with sample data.

🏗 What is a Django Model?

A model is a Python class that maps to a database table. Each attribute in the class becomes a column in the table.

Example (blog/models.py):

from django.db import models


class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_at = models.DateTimeField(auto_now_add=True)


    def __str__(self):
        return self.title

Django will create a table named blog_post for this model.

🛠 Creating Migrations

Migrations apply model changes to the database:

python manage.py makemigrations
python manage.py migrate

makemigrations → Creates migration files.
migrate → Applies changes to the database.

✍️ CRUD Operations

** Create **

from blog.models import Post

Post.objects.create(title="My First Post", content="This is awesome!")

** Read **

Post.objects.all() # Get all posts
Post.objects.first() # First post
Post.objects.filter(title__icontains="First")

** Update **

post = Post.objects.get(id=1)
post.title = "Updated Title"
post.save()

** Delete **

post = Post.objects.get(id=1)
post.delete()

🔗 Relationships Between Models

One-to-Many (ForeignKey)

class Comment(models.Model):
    post = models.ForeignKey(Post, related_name="comments", on_delete=models.CASCADE)
    text = models.TextField()

Each comment belongs to one post.
Access comments: post.comments.all()

One-to-One

from django.contrib.auth.models import User

class AuthorProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField()

Many-to-Many

class Tag(models.Model):
    name = models.CharField(max_length=50)
    posts = models.ManyToManyField(Post, related_name="tags")

🔍 Querying the Database

# Exact match
Post.objects.filter(title="My First Post")


# Case-insensitive search
Post.objects.filter(title__icontains="first")


# Order results
Post.objects.order_by('-published_at')


# Access related objects
post = Post.objects.get(id=1)
comments = post.comments.all()

🧪 Testing with Sample Data

You can test models directly in the Django shell:

python manage.py shell # Make sure in the project directory

Inside the shell :

from blog.models import Post

Post.objects.create(title="Sample 1", content="Hello World")
Post.objects.create(title="Sample 2", content="Learning Django ORM")


for post in Post.objects.all():
    print(post.title)

Or load fixtures from a JSON file:

python manage.py loaddata sample_posts.json

🏆 Summary

Models map Python classes to database tables.
Use migrations to apply schema changes.
ORM provides easy CRUD operations.
Relationships (ForeignKey, OneToOne, ManyToMany) connect models.
Querysets allow powerful filtering.
Use Django shell or fixtures to test with sample data.

Django Project & App Structure Explained

Gopal Ghate — Sat, 27 Sep 2025 18:57:40 +0000

Django is built with a clear separation of concerns, which makes your code easier to maintain. In this article, we’ll go deeper into projects, apps, models, views, URLs, templates, and migrations with a fully working example. By the end, you will have a running project with a correctly rendered template.

Django Project vs App

Project → The overall Django setup, holding settings, URL routing, and configurations.

App → A module inside your project designed for a specific purpose. You can have multiple apps inside one project.
For example

mysite/ # Project
├── manage.py
├── mysite/ # Project settings folder
└── blog/ # App folder

You might have multiple apps like users, payments, or products under the same project.

Project Structure Explained

When you run django-admin startproject mysite, you get:

mysite/
├── manage.py
└── mysite/
├── __init__.py
├── asgi.py
├── settings.py
├── urls.py
└── wsgi.py

Let’s break these files down:

manage.py → Command-line tool to run server, create apps, apply migrations, open Django shell, etc.

settings.py → Central configuration (DB, installed apps, middleware, security keys).

urls.py → Main URL router; maps paths to views.

wsgi.py / asgi.py → Entry point for deployment (used by production servers).

Creating Your First App

Run :

python manage.py startapp blog #(blog -> app name, you can add your app name here)

This creates following folder structure

blog/
├── admin.py
├── apps.py
├── migrations/
├── models.py
├── tests.py
├── views.py

Add newly created app to INSTALLED_APPS in settings.py:

INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'blog', # add your app name here.
]

Adding Views & URLs

In blog/views.py

from django.shortcuts import render

def home(request):
return render(request, 'blog/home.html')

Create blog/urls.py

from django.urls import path
from . import views


urlpatterns = [
path('', views.home, name='home'),
]

Include app urls in project urls (mysite/urls)

from django.contrib import admin
from django.urls import path, include


urlpatterns = [
path('admin/', admin.site.urls),
path('', include('blog.urls')),
]

Templates Setup

Folder Structure (App-Level Templates)

blog/
├── templates/
  │ └── blog/
      │ └── home.html

home.html example:

<!DOCTYPE html>
<html>
<head>
<title>My First Django Page</title>
</head>
<body>
<h1>Welcome to My Blog!</h1>
<p>This page is powered by Django templates.</p>
</body>
</html>

settings.py Configuration:

Make sure APP_DIRS=True:

TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [], # leave empty for app-level templates
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
           'django.template.context_processors.debug',
           'django.template.context_processors.request',
           'django.contrib.auth.context_processors.auth',
           'django.contrib.messages.context_processors.messages',
        ],
     },
  },
]

Now render(request, 'blog/home.html') will find the template

Migrations & Database

python manage.py migrate

Run the server

python manage.py runserver

Summary

In this article, we:

Understood the difference between projects and apps.
Learned about project files and what they do.
Created an app and added views, urls, and templates.
Correctly configured settings.py and rendered a template.
Ran migrations and started the server.

🚀 Getting Started with Django – A Beginner-Friendly Guide

Gopal Ghate — Thu, 25 Sep 2025 17:03:39 +0000

If you’ve ever wondered how to build powerful, scalable web applications without reinventing the wheel, Django is your best friend. Django is a high-level Python web framework that allows you to build web apps quickly, securely, and with less code. In this article, we’ll walk through the basics of Django, its project structure, and get you ready to write your first app.

🎯 Why Django?

Django is popular because it follows the "batteries-included" philosophy, meaning it comes with everything you need to build web apps:

✅ ORM (Object-Relational Mapper): Work with databases using Python instead of writing SQL.
✅ Admin Panel: Auto-generated backend to manage your data.
✅ Security: Protection against common vulnerabilities (SQL injection, CSRF, XSS).
✅ Scalability: Used by Instagram, Pinterest, and Disqus.

In short — Django makes web development fast, secure, and fun.

🛠 Installing Django

python3 -m venv venv # creates virtual environment for project

source venv/bin/activate # activate virtual environment

pip install django # installing django

Check if it’s installed:

django-admin --version # Checking django version

🏗 Creating Your First Project

django-admin startproject mysite 
cd mysite

# your folder structure should look like this.
mysite/
├── manage.py
├── mysite/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   ├── asgi.py
│   └── wsgi.py

1️⃣ manage.py – Your Project’s Remote Control This file is used to run commands related to your project.

python manage.py runserver     # Start development server
python manage.py startapp blog # Create a new app
python manage.py makemigrations # Look at models and creates migration files that describe those changes.
python manage.py migrate       # Apply database changes

2️⃣ settings.py This file contains all the configuration settings:

Database setup: Which database you’re using (default: SQLite).

Installed apps: Which Django apps are active.

Security keys: Secret key for cryptography, allowed hosts.

Static files: CSS, JavaScript, images.

You can think of it as your project’s control center.

3️⃣ urls.py - routing This file decides which view handles which URL.

from django.urls import path
from django.http import HttpResponse

def home(request):
    return HttpResponse("Welcome Home!")

urlpatterns = [
    path('', home),
    path('about/', lambda r: HttpResponse("About Page")),
]

4️⃣ wsgi.py & asgi.py – The Gatekeepers

These files allow your project to talk to web servers in production:

WSGI: For traditional synchronous servers like Gunicorn.

ASGI: For asynchronous servers like Daphne, great for WebSockets.

You rarely modify these files, but they’re essential for deployment.

▶ Running the Development Server

python manage.py runserver

Open your browser at http://127.0.0.1:8000/. 🎉 You just ran your first Django project!

📌 Key Takeaways

Django is a full-stack framework with built-in tools.
Your project structure has specific files for config, routing, and deployment.
manage.py is your main command-line tool.
urls.py maps URLs to views.