Django - Overview

Django - Overview

Django is a high-level Python web framework designed for rapid development of secure and maintainable websites. Built by experienced developers, it follows the “Don’t Repeat Yourself” (DRY) principle and provides a robust set of tools and libraries out-of-the-box.

Understanding Architecture: MVC vs. MVT

Many web frameworks use the Model-View-Controller (MVC) architectural pattern. MVC separates an application into three interconnected components:

• Model: Manages the application’s data, logic, and rules. It interacts with the database.
• View: Responsible for presenting the data to the user (the user interface).
• Controller: Handles user input, interacts with the Model, and selects the appropriate View to render.

Django’s Model-View-Template (MVT) Pattern

Django generally follows the MVC pattern but with its own terminology, often referred to as the Model-View-Template (MVT) pattern. The key difference lies in how the components map and what Django handles for you:

• Model: Represents the data structure. This is essentially the same as the Model in MVC. Django provides a powerful Object-Relational Mapper (ORM) to define models as Python classes and interact with the database.
• View: In Django, the ‘View’ handles the request logic. It receives an HTTP request, processes it (e.g., interacts with Models to fetch data), and returns an HTTP response. This is closer to the Controller in the traditional MVC pattern.
• Template: This is the presentation layer. It defines the structure of the output (usually HTML), embedding template tags and variables to display data dynamically. This corresponds more closely to the View in traditional MVC.

So, where is the ‘Controller’ in Django’s MVT?

The framework itself acts as the controller, handling much of the logic that bridges the user request to the appropriate view. This includes:

• URL Dispatcher: Django’s URL configuration (urls.py) maps incoming URLs to specific view functions or classes.
• Request/Response Handling: The core framework manages the HTTP request and response objects.
• Middleware: Processes requests and responses globally.

The Request Handling Flow in Django (MVT):

1. A user makes a request to a specific URL.
2. Django’s URL dispatcher checks urls.py to find a matching pattern.
3. If a match is found, the corresponding Django View function/class is called, receiving the request details.
4. The View executes its logic. This often involves interacting with Django Models to query or modify data in the database.
5. The View then typically loads a Template.
6. The Template is rendered with the data provided by the View (the ‘context’).
7. The View returns the rendered Template as an HTTP response back to the user’s browser.

In essence, as a Django developer, you primarily focus on defining the Models (data structure), writing the Views (request logic), and creating the Templates (presentation), while leveraging Django’s built-in URL routing and framework components to tie everything together.