A Step-by-Step Guide to Setting Up a Django Project

Complete Django Tutorial: Build Your First Django Project Step by Step

Django is one of the most powerful and widely used Python web frameworks in the world. It enables developers to create secure, scalable, maintainable, and high-performance web applications with significantly less code compared to many alternatives.

Whether you're building a personal blog, an eCommerce platform, a SaaS application, an enterprise dashboard, a social networking platform, or a machine learning web interface, Django provides the tools necessary to accelerate development while maintaining code quality.

---

📚 Table of Contents

• Introduction to Django
• Why Django?
• Django Architecture
• Mathematics Behind Web Requests
• Installing Django
• Creating a Django Project
• Creating an Application
• Configuring Settings
• Creating Views
• Configuring URLs
• Running Development Server
• Request Response Cycle
• Best Practices
• Frequently Asked Questions

---

Introduction to Django

Django is a high-level Python web framework that follows the philosophy:

The web framework for perfectionists with deadlines.

It was originally developed by developers working in a newsroom environment who needed to create robust web applications rapidly. Since then, Django has evolved into one of the most respected frameworks in the software development ecosystem.

Large organizations including Instagram, Pinterest, Mozilla, and many enterprise platforms have utilized Django in various capacities because of its productivity-focused design.

💡 Key Takeaway

• Django is written in Python.
• Follows DRY (Don't Repeat Yourself).
• Includes built-in security features.
• Comes with ORM, Admin Panel, Authentication.
• Supports rapid development.

---

Why Learn Django?

Many web frameworks require extensive configuration before development can begin. Django takes a different approach by providing batteries-included functionality.

Major Benefits

• Fast development cycle
• Built-in ORM
• Authentication system
• Admin dashboard
• Session management
• CSRF protection
• SQL injection protection
• Scalable architecture
• Strong community support

Read More: Why Companies Prefer Django

Organizations choose Django because it reduces development time significantly. Instead of writing repetitive infrastructure code, developers focus on business logic.

This translates into faster releases, lower maintenance costs, and improved reliability.

---

Django Architecture Explained

Django follows the MVT architecture:

• Model
• View
• Template

Model

Models define database structure.

View

Views process requests and generate responses.

Template

Templates handle user interface rendering.

MVT Flow

1. User sends request.
2. URL dispatcher receives request.
3. View processes request.
4. Model accesses database.
5. Template renders output.
6. Response returns to browser.

---

📐 Mathematics Behind Web Requests

Although web development is not heavily mathematical, understanding performance calculations helps optimize applications.

Request Throughput Formula

Theoretical requests per second:

Requests Per Second = Total Requests / Total Time

Example:

1000 Requests / 20 Seconds = 50 RPS

Meaning your application can serve approximately 50 requests every second.

Response Time Formula

Average Response Time = Total Processing Time / Number of Requests

Example:

5000 ms / 100 requests = 50 ms

Lower response times generally improve user experience.

💡 Performance Insight

• Lower latency improves UX.
• Higher throughput improves scalability.
• Caching reduces processing time.
• Database indexing improves query speed.

---

Step 1: Installing Django

Before creating a Django project, install Django using pip.

Command

pip install django

CLI Output Sample

Collecting django
Downloading Django-5.x.x-py3-none-any.whl
Installing collected packages: django
Successfully installed django

Verify Installation

django-admin --version

Expected Output

5.x.x

---

Step 2: Creating a Django Project

A Django project acts as the container for your entire web application.

Command

django-admin startproject firstProject

CLI Output Sample

Project created successfully.

Generated Structure

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

Understanding Each File

File	Purpose
manage.py	Project management utility
settings.py	Configuration settings
urls.py	URL routing
wsgi.py	Deployment gateway
asgi.py	Async server gateway

---

Step 3: Creating an Application

A Django project can contain multiple applications.

Think of a project as a company and applications as departments.

Command

python manage.py startapp firstApp

CLI Output Sample

Application created successfully.

Generated Structure

firstApp/

admin.py
apps.py
models.py
views.py
tests.py
migrations/

Purpose of Files

• views.py → business logic
• models.py → database structure
• admin.py → admin interface
• tests.py → testing
• apps.py → app configuration

---

Step 4: Add Application to INSTALLED_APPS

Django must know your application exists.

Open settings.py

Code Example

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'firstApp',
]

After saving, Django will register your application.

---

Step 5: Creating Your First View

A view receives requests and returns responses.

Code Example

from django.http import HttpResponse

def home(request):
    return HttpResponse("Hello World")

Explanation

• request contains user information.
• HttpResponse sends data back.
• home() is executed whenever mapped URL is visited.

---

Step 6: Configuring URLs

URLs tell Django which view should run.

Create app-level urls.py

from django.urls import path
from .views import home

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

Main Project URLs

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

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

---

Step 7: Running Development Server

python manage.py runserver

CLI Output Sample

Watching for file changes with StatReloader

System check identified no issues

Starting development server at

http://127.0.0.1:8000/

Quit the server with CTRL+C

Visit:

http://127.0.0.1:8000/

You should see:

Hello World

---

Understanding Request Response Cycle

1. User enters URL.
2. Browser sends HTTP request.
3. Django URL router checks patterns.
4. Matching view executes.
5. View processes business logic.
6. Database query executes if required.
7. Response generated.
8. Browser displays result.

Deep Dive into Request Lifecycle

Every request starts with the browser establishing a connection to the web server. The web server forwards the request to Django. Django loads middleware, performs authentication checks, resolves URLs, executes views, and returns a response object.

Understanding this lifecycle is essential for debugging and optimization.

---

🎯 Django Best Practices

• Use virtual environments.
• Separate settings for development and production.
• Write reusable applications.
• Use environment variables.
• Follow DRY principle.
• Write tests regularly.
• Use migrations correctly.
• Optimize database queries.
• Use caching when necessary.
• Keep dependencies updated.

💡 Important Learning Summary

• Django follows MVT architecture.
• A project can contain multiple apps.
• Views handle business logic.
• URLs connect requests to views.
• Templates render HTML.
• Models manage database operations.
• The development server helps local testing.
• Django provides strong security out of the box.

---

Frequently Asked Questions

1. What is Django?

Django is a Python web framework designed for rapid application development.

2. Is Django frontend or backend?

Django is primarily a backend framework.

3. Does Django use SQL?

Yes. Django uses an ORM that translates Python code into SQL queries.

4. Can Django handle large traffic?

Yes. Many large-scale platforms use Django in production.

5. Why is Django popular?

Because it provides security, scalability, maintainability, and rapid development.

---

Final Thoughts

Django remains one of the best frameworks for learning professional web development. By understanding project creation, application structure, views, URL routing, settings configuration, and request-response handling, you build a strong foundation for creating complex web applications.

The next logical topics after mastering this tutorial are:

• Django Models
• Django ORM
• Django Templates
• Django Forms
• Django Authentication
• Django Middleware
• Django REST Framework
• Django Deployment
• Django Security
• Django Performance Optimization

Master these concepts and you will be capable of building production-ready web applications using Django.

How to Use NumPy randint with Step Values in Python

Using NumPy randint with Step

In NumPy, the randint function does not directly support a step parameter like arange. However, you can simulate this behaviour by generating a random integer and scaling it using the step value.

---

Concept Overview

• randint generates random integers within a range.
• It does not support step size directly.
• You can divide the range by the step and multiply the result back.

---

Interactive Demo

Try changing the values below to simulate how NumPy logic works.

Start: Stop: Step:

Result

Click Generate

---

Basic NumPy Example

Step 1 — Import NumPy

import numpy as np

Step 2 — Define Start, Stop and Step

start = 0
stop = 20
step = 5

Step 3 — Generate Random Number

random_number = np.random.randint(start // step, stop // step) * step
print(random_number)

---

Python Console Example

>>> import numpy as np
>>> start = 0
>>> stop = 20
>>> step = 5

>>> np.random.randint(start // step, stop // step) * step
10

Possible outputs:

• 0
• 5
• 10
• 15

---

Full Example

Generate Multiple Random Numbers

import numpy as np

start = 10
stop = 100
step = 10

random_numbers = [
 np.random.randint(start // step, stop // step) * step
 for _ in range(5)
]

print(random_numbers)

---

Example Output

[70, 90, 10, 60, 40]

---

Explanation

Why divide by step?

Dividing by step shrinks the range so that randint generates an index instead of the actual stepped number.

Why multiply by step?

Multiplying restores the stepped values.

---

💡 Key Takeaways

• np.random.randint() does not support step values.
• You can simulate steps by scaling numbers.
• Divide the range using integer division.
• Multiply the result by the step value.
• This method works for any numeric interval.

---

Related Topics

• When to Use np.random.rand vs np.random.randn in Python
• Comparison of np.zeros and np.empty in NumPy