Django is a high-level Python web framework that follows the Model-View-Template (MVT) architectural pattern. It emphasizes rapid development and clean, pragmatic design.

Key features include:

• Batteries included: Comes with built-in features like ORM, admin interface, authentication
• DRY principle: Don't Repeat Yourself philosophy
• Security: Built-in protection against common vulnerabilities
• Scalability: Can handle high-traffic sites
• Versatility: Suitable for various types of web applications
• Strong community: Large ecosystem and extensive documentation

MVT is Django's architectural pattern:

• Model: Represents data structure and business logic. Handles database operations through Django ORM.
• View: Contains business logic and acts as a bridge between Model and Template. Processes requests and returns responses.
• Template: Handles presentation layer (HTML). Defines how data is displayed to users.

The flow: URL dispatcher routes requests to appropriate View → View processes request and interacts with Model → View renders Template with data → Response sent to user.

Django ORM (Object-Relational Mapping) is a layer that allows you to interact with databases using Python code instead of SQL. It maps database tables to Python classes and rows to objects.

Advantages:

• Database abstraction: Works with multiple database backends
• Security: Prevents SQL injection attacks
• Portability: Easy to switch between databases
• Pythonic: Write database queries using Python syntax
• Automatic SQL generation: ORM generates optimized SQL queries
• Migrations: Automatic schema management

• urls.py: Contains URL patterns that map URLs to view functions. Acts as a router determining which view should handle specific URLs.
• views.py: Contains view functions/classes that process HTTP requests and return HTTP responses. Contains the actual business logic.

Example:

# urls.py
urlpatterns = [
    path('articles/', views.article_list, name='article_list'),
]

# views.py
def article_list(request):
    articles = Article.objects.all()
    return render(request, 'articles/list.html', {'articles': articles})

• Project: The entire Django application containing settings, configurations, and multiple apps
• App: A sub-module within a project that handles specific functionality

A project can contain multiple apps, and apps can be reused across different projects. Apps should follow the single responsibility principle - each app should have one clear purpose.

Example structure:

myproject/          # Project
├── blog/          # App
├── users/         # App
├── settings.py    # Project settings
└── urls.py        # Project URLs

Django model fields define the data types and constraints for database columns.

Common field types:

class Article(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)
    is_published = models.BooleanField(default=False)
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag)
    email = models.EmailField()
    slug = models.SlugField(unique=True)

Function-based views (FBV): Simple functions that take request and return response

def article_list(request):
    articles = Article.objects.all()
    return render(request, 'articles/list.html', {'articles': articles})

Class-based views (CBV): Classes that inherit from Django's view classes

from django.views.generic import ListView

class ArticleListView(ListView):
    model = Article
    template_name = 'articles/list.html'
    context_object_name = 'articles'

CBVs provide more structure and reusability, while FBVs are simpler and more explicit.