Setting up a Django Project • A Django project is the main container for your web application's settings. • It defines the overall structure and configuration for your entire project. • Use django-admin startproject command to quickly generate initial files. • It's essential for organizing your web application and its components. • Run this command once at the beginning of your project's development. • Create a dedicated virtual environment before starting your project setup. • Manage project-wide settings like database configurations and installed apps here. • This provides a solid foundation before adding any specific application logic.

Key points: - Project is the root container. - Use django-admin startproject. - Virtual environments are crucial. - Configure project-wide settings here. - Run runserver to test.

Example: Navigate to your desired directory and run: python -m venv myenv source myenv/bin/activate pip install django django-admin startproject myproject . python manage.py runserver

Understanding Django's MTV Architecture • MTV stands for Model, Template, and View, Django's core architectural pattern. • It separates concerns, making your code more organized and maintainable. • Models define data structure, Templates display data, Views handle logic. • Use this pattern for clarity and scalability in all Django applications. • Think of Models for data, Views for actions, Templates for presentation. • This structure promotes reusable and testable code components. • Each part plays a distinct role in handling web requests. • Understanding MTV is fundamental to building robust Django sites.

Key points: - Model, Template, View separation. - Enhances organization and maintainability. - Models for data. - Views for logic. - Templates for presentation. - Scalable and testable code.

Example: Model: Defines your data (e.g., User model with fields). View: Processes requests, interacts with Models, and selects a Template (e.g., user_detail view). Template: Presents data from the View in HTML (e.g., user_detail.html).

Creating Apps and Models • An app is a self-contained module within your Django project. • Apps encapsulate specific features, promoting modularity and reusability. • Use python manage.py startapp <app_name> to create new apps. • Models define the structure of your database tables and data. • Define models in models.py within each app. • Models are essential for interacting with your application's data. • Always register your new app in settings.py's INSTALLED_APPS list. • Run makemigrations and migrate to create/update your database schema.

Key points: - Apps are modular components. - Use startapp to create apps. - Models define database structure. - Define models in models.py. - Register apps in settings.py. - Use migrate for schema changes.

Example: In myapp/models.py: from django.db import models class Article(models.Model): title = models.CharField(max_length=100) content = models.TextField() published_date = models.DateTimeField(auto_now_add=True)

Then run: python manage.py makemigrations myapp python manage.py migrate

Working with the Django Admin • The Django admin is a built-in interface for managing data. • It provides a powerful way to CRUD (Create, Read, Update, Delete) your models. • Register models in admin.py to make them accessible. • It's incredibly useful for early development and content management. • Create a superuser with createsuperuser to access the admin. • This interface saves immense development time for basic data handling. • Customize admin displays for better usability and information access. • Leverage the admin for debugging and direct data manipulation.

Key points: - Built-in data management interface. - Register models in admin.py. - Superuser needed for access. - Speeds up development and content management. - Enables CRUD operations easily. - Customizable for better UX.

Example: In myapp/admin.py: from django.contrib import admin from .models import Article

admin.site.register(Article)

Then access via /admin/ (after createsuperuser).

Basic Views and URL Routing • Views are Python functions or classes that handle requests and return responses. • They contain the business logic for a specific feature or page. • URL routing maps URLs to specific views in your application. • Use urls.py in your project and apps to define these mappings. • Views are the 'brains' connecting user requests to application logic. • Routing ensures that the correct view function is called for a given URL. • Start with simple function-based views for basic requests. • This is how Django determines what content to show the user.

Key points: - Views contain request handling logic. - URL routing connects URLs to views. - Define routes in urls.py. - Views return HttpResponse objects. - Function-based views are a good start. - Maps user requests to actions.

Example: In myapp/views.py: from django.http import HttpResponse def home(request): return HttpResponse('Hello, World!')

In myapp/urls.py: from django.urls import path from . import views

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

Template Rendering and Context • Templates define how data is presented to the user, typically as HTML. • They are separate files containing static content mixed with dynamic data. • Views render templates, passing data through a 'context' dictionary. • This separation of presentation logic from business logic is key. • Context provides the dynamic variables that templates can display. • Use render shortcut in views for easy template rendering. • Template tags and filters allow logic within the templates. • This creates dynamic, user-friendly web pages.

Key points: - Templates define presentation (HTML). - Views pass data via context. - Use render shortcut. - Context is a dictionary of variables. - Separates presentation from logic. - Allows dynamic content display.

Example: In myapp/views.py: from django.shortcuts import render def about(request): context = {'page_title': 'About Us', 'message': 'Welcome!'} return render(request, 'myapp/about.html', context)

In myapp/templates/myapp/about.html: <h1>{{ page_title }}</h1> <p>{{ message }}</p>

Django Forms and Data Validation • Forms handle user input, providing validation and data sanitization. • They simplify the process of collecting and processing data from web pages. • Django's form classes validate data against defined fields and rules. • Use forms to create secure and robust user interfaces for data submission. • Forms automatically prevent common security vulnerabilities like CSRF. • Validate submitted data before saving it to the database. • Define custom validation rules for specific field requirements. • Always use Django forms for any user-submitted data.

Key points: - Forms manage user input. - Built-in validation and security. - Define forms in forms.py. - Check is_valid() method. - Access validated data via cleaned_data. - Crucial for secure data handling.

Example: In myapp/forms.py: from django import forms class ContactForm(forms.Form): name = forms.CharField(max_length=100) email = forms.EmailField() message = forms.CharField(widget=forms.Textarea)

In a view, instantiate form, check is_valid(), access cleaned_data.

Quick quiz: 1. When setting up a new Django project, which command creates the fundamental directory structure and configuration files? 2. In Django's MTV (Model-Template-View) architecture, what is the primary responsibility of the 'View' component? 3. Consider a Django project with an app named 'blog'. You've defined a 'Post' model in blog/models.py. To use this model in other parts of your project, what is the most common and robust way to interact with it? 4. You are creating a Django form for user registration, and you want to ensure the 'email' field is a valid email address and is required. What is the most appropriate way to achieve this validation? 5. When a user navigates to a specific URL, Django needs to determine which Python function (view) should handle that request. What component is responsible for mapping URLs to views?