Django Overview

What is Django?

Django is a high-level Python web framework that enables rapid development of secure and maintainable websites. It follows the MTV (Model-Template-View) pattern (similar to MVC).

Key Features:

• “Batteries included” – Comes with everything you need
• ORM (Object-Relational Mapping) – Work with databases using Python
• Admin interface – Auto-generated admin panel
• Security – Built-in protection (SQL injection, XSS, CSRF)
• Scalable – Handles high traffic efficiently
• Fast development – Don’t repeat yourself (DRY principle)

Philosophy:

“The web framework for perfectionists with deadlines”

---

Django vs Flask

Feature	Django	Flask
Type	Full-stack framework	Micro-framework
Philosophy	“Batteries included”	Minimalist, flexible
Learning Curve	Steeper	Easier to start
Admin Panel	Built-in	Manual/third-party
ORM	Built-in (Django ORM)	Manual (SQLAlchemy)
Authentication	Built-in	Manual/extensions
URL Routing	Centralized	Decorator-based
Project Structure	Opinionated	Flexible
Best For	Large, complex apps	Small to medium apps, APIs

Code Comparison

Flask (Minimal):

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello World!'

if __name__ == '__main__':
    app.run()

Django (Structured):

# views.py
from django.http import HttpResponse

def hello(request):
    return HttpResponse('Hello World!')

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.hello),
]

When to Use Each?

Choose Django if:

• Building a full-featured website
• Need admin interface out-of-the-box
• Want built-in authentication, ORM, forms
• Team needs structure and conventions

Choose Flask if:

• Building a REST API or microservice
• Want full control over components
• Need lightweight and flexible framework
• Starting small and scaling gradually

---

Big Websites Using Django

🌟 Major Platforms:

1. Instagram – Photo sharing (handles billions of requests)
2. Spotify – Music streaming (backend APIs)
3. YouTube – Video platform (some components)
4. Dropbox – Cloud storage
5. Pinterest – Image bookmarking
6. NASA – Government websites
7. The Washington Post – News media
8. Mozilla – Firefox support sites
9. Disqus – Comment hosting platform
10. BitBucket – Code repository hosting

Why They Chose Django:

• ✅ Rapid development
• ✅ Scalability (handles millions of users)
• ✅ Security features
• ✅ Python ecosystem
• ✅ Strong community support

---

Django Project Structure

Based on your current file at blog:

Complete Structure:

blog/                              # PROJECT ROOT
│
├── manage.py                      # CLI utility (you saw this earlier)
│
├── blog/                          # PROJECT CONFIGURATION PACKAGE
│   ├── __init__.py               # Makes it a Python package
│   ├── settings.py               # ⚙️ Project settings
│   ├── urls.py                   # 🔗 Main URL routing (you're viewing this)
│   ├── asgi.py                   # ASGI deployment config
│   └── wsgi.py                   # WSGI deployment config
│
├── <app_name>/                    # DJANGO APP (e.g., posts, comments)
│   ├── __init__.py
│   ├── admin.py                  # Admin interface registration
│   ├── apps.py                   # App configuration
│   ├── models.py                 # 📊 Database models
│   ├── views.py                  # 🎯 Business logic
│   ├── urls.py                   # App-specific URL routing
│   ├── tests.py                  # Unit tests
│   ├── forms.py                  # Form definitions (optional)
│   │
│   ├── migrations/               # Database migrations
│   │   ├── __init__.py
│   │   └── 0001_initial.py
│   │
│   ├── templates/                # HTML templates
│   │   └── <app_name>/
│   │       └── template.html
│   │
│   └── static/                   # CSS, JS, images
│       └── <app_name>/
│           ├── css/
│           ├── js/
│           └── images/
│
├── templates/                     # PROJECT-LEVEL TEMPLATES (optional)
│   └── base.html
│
├── static/                        # PROJECT-LEVEL STATIC FILES (optional)
│   ├── css/
│   ├── js/
│   └── images/
│
├── media/                         # USER-UPLOADED FILES
│   └── uploads/
│
├── db.sqlite3                     # SQLite database (development)
├── requirements.txt               # Python dependencies
├── .env                          # Environment variables (not in git)
└── .gitignore                    # Git ignore file

Key Files Explained:

manage.py

# Command-line utility
python manage.py runserver        # Start server
python manage.py makemigrations   # Create migrations
python manage.py migrate          # Apply migrations

blog/settings.py

# Project configuration
INSTALLED_APPS = [...]   # Registered apps
DATABASES = {...}        # Database config
TEMPLATES = [...]        # Template settings
STATIC_URL = '/static/'  # Static files

urls.py (Your current file)

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

urlpatterns = [
    path('admin/', admin.site.urls),           # Admin interface
    path('', include('posts.urls')),           # Include app URLs
    path('api/', include('api.urls')),         # API endpoints
]

MTV Pattern (Django’s MVC):

Request Flow:
Browser → URLs → Views → Models/Templates → Response

┌─────────┐
│  URLs   │ ← urlpatterns in urls.py
└────┬────┘
     │
┌────▼────┐
│  Views  │ ← Functions/classes in views.py
└────┬────┘
     │
     ├─────► Models (Database)
     │
     └─────► Templates (HTML)

Creating Your First Structure:

# 1. Create app
python manage.py startapp posts

# 2. Add to settings.py INSTALLED_APPS
# 'posts',

# 3. Create model in posts/models.py
# 4. Create views in posts/views.py
# 5. Create URLs in posts/urls.py
# 6. Include in main urls.py

---

Your Current File (urls.py) is the main URL router – it’s the entry point for all HTTP requests to your Django project. Right now it only has the admin route. You’ll add more routes as you create apps!

---

Django Apps Explained

What is a Django App?

A Django app is a self-contained module that performs a specific function in your Django project. Think of it as a building block or component of your website.

Key Concept:

• Project = Your entire website (e.g., “blog”)
• App = A specific feature/module (e.g., “posts”, “comments”, “users”)

Project vs App

blog/                          # PROJECT (your entire site)
├── manage.py
├── blog/                      # Project configuration folder
│   ├── settings.py
│   └── urls.py               # ← You're viewing this file
├── posts/                     # APP #1 (handles blog posts)
│   ├── models.py
│   ├── views.py
│   └── urls.py
├── comments/                  # APP #2 (handles comments)
│   ├── models.py
│   ├── views.py
│   └── urls.py
└── users/                     # APP #3 (handles user profiles)
    ├── models.py
    ├── views.py
    └── urls.py

Why Use Apps?

1. Modularity: Each feature is isolated and maintainable
2. Reusability: Apps can be used in multiple projects
3. Organization: Code is logically separated
4. Team Collaboration: Different developers can work on different apps

Creating an App

# In your terminal at c:\Users\Adam.Huang\Downloads\DE\django\blog\
python manage.py startapp posts

This creates:

posts/
├── __init__.py          # Makes it a Python package
├── admin.py            # Register models for admin interface
├── apps.py             # App configuration
├── models.py           # Database models (tables)
├── views.py            # View functions (business logic)
├── tests.py            # Unit tests
└── migrations/         # Database migration files
    └── __init__.py

App Structure Example

1. models.py – Define Data Structure

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)

2. views.py – Handle Requests

from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all()
    return render(request, 'posts/post_list.html', {'posts': posts})

3. urls.py – App URL Routing

from django.urls import path
from . import views

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

Connecting Apps to Your Project

Step 1: Add to INSTALLED_APPS

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'posts',  # ← Add your app here
]

Step 2: Include App URLs

from django.contrib import admin
from django.urls import path, include  # ← Add include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('posts/', include('posts.urls')),  # ← Include app URLs
]

Now URLs like http://127.0.0.1:8000/posts/ will route to your posts app!

Built-in Django Apps

Your project already has these apps (check settings.py):

• django.contrib.admin – Admin interface
• django.contrib.auth – Authentication system
• django.contrib.contenttypes – Content type framework
• django.contrib.sessions – Session framework
• django.contrib.messages – Messaging framework
• django.contrib.staticfiles – Static file management

Common App Examples

• posts – Blog posts
• comments – Comment system
• users – User profiles
• shop – E-commerce features
• api – REST API endpoints
• authentication – Custom auth logic

Best Practices

✅ DO:

• Keep apps focused on one feature
• Name apps as plural nouns (posts, comments, users)
• Make apps reusable when possible

❌ DON’T:

• Put all code in one giant app
• Create circular dependencies between apps
• Hard-code project-specific logic in reusable apps

---

Next Steps: Create your first app with python manage.py startapp posts and start building your blog!