Python Django for web development

Introduction to Django Django is a high-level Python web framework that follows the Model-View-Template (MVT) architectural pattern. It simplifies the development of secure and maintainable websites by providing a comprehensive set of features out-of-the-box, including an Object-Relational Mapping (ORM) layer, URL routing, and a template engine.

Setting up a Django Project To start a new Django project, you need to create a project directory and initialize the project using the django-admin command-line utility. Here's an example:

$ django-admin startproject myproject
$ cd myproject
$ python manage.py runserver

This will create a new Django project named "myproject" and start the development server at http://127.0.0.1:8000/.

Models In Django, models are Python classes that represent database tables. They define the structure of the data, including field types and validation rules. Here's an example of a simple Blog model:

from django.db import models

class Blog(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    pub_date = models.DateTimeField('date published')

Views Views in Django are Python functions or class-based views that handle HTTP requests and return responses. They interact with models to fetch or modify data, and render templates to display the data. Here's an example of a simple view:

from django.shortcuts import render
from .models import Blog

def blog_list(request):
    blogs = Blog.objects.all()
    return render(request, 'blog_list.html', {'blogs': blogs})

Templates Templates in Django are text files that define the structure and presentation of HTML pages. They use a template language to dynamically generate content based on the data passed from views. Here's an example of a simple template:

<!DOCTYPE html>
<html>
<head>
    <title>Blog List</title>
</head>
<body>
    <h1>Blog Posts</h1>
    <ul>
    {% for blog in blogs %}
        <li>{{ blog.title }} - {{ blog.pub_date }}</li>
    {% endfor %}
    </ul>
</body>
</html>

URL Routing Django's URL routing system maps URLs to Python functions (views) that handle the corresponding requests. URLs are defined in a urls.py file using regular expressions. Here's an example:

from django.urls import path
from . import views

urlpatterns = [
    path('', views.blog_list, name='blog_list'),
    path('blog/<int:blog_id>/', views.blog_detail, name='blog_detail'),
]

Forms Django provides a powerful forms library that handles form rendering, validation, and processing. Forms can be defined as Python classes and rendered in templates. Here's an example of a simple form:

from django import forms

class BlogForm(forms.ModelForm):
    class Meta:
        model = Blog
        fields = ['title', 'content']

Authentication and Authorization Django provides a built-in authentication system that handles user accounts, groups, permissions, and cookie-based user sessions. Here's an example of how to log in a user:

from django.contrib.auth import authenticate, login

def user_login(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        user = authenticate(request, username=username, password=password)
        if user is not None:
            login(request, user)
            # Redirect to a success page

Admin Interface Django comes with a built-in admin interface that allows authorized users to manage the application's data through a web-based interface. Here's an example of how to register a model with the admin site:

from django.contrib import admin
from .models import Blog

admin.site.register(Blog)

Static Files Django provides a convenient way to serve static files (CSS, JavaScript, images) during development and in production. Static files are stored in a designated directory and referenced in templates using the {% static %} tag. Here's an example:

{% load static %}
<!DOCTYPE html>
<html>
<head>
    <title>My Blog</title>
    <link rel="stylesheet" href="{% static 'css/styles.css' %}">
</head>
<!-- ... -->

Testing Django includes a built-in testing framework that allows you to write and run unit tests for your applications. Tests are defined as Python classes that inherit from django.test.TestCase. Here's an example:

from django.test import TestCase
from .models import Blog

class BlogTestCase(TestCase):
    def setUp(self):
        Blog.objects.create(title='Test Blog', content='This is a test blog post.')

    def test_blog_content(self):
        blog = Blog.objects.get(title='Test Blog')
        self.assertEqual(blog.content, 'This is a test blog post.')

Deployment When you're ready to deploy your Django application to a production server, you'll need to follow these steps:

Collect static files
Set DEBUG = False in your settings.py
Configure a production-ready web server (e.g., NGINX, Apache)
Set up a database server (e.g., PostgreSQL, MySQL)
Run Django migrations to apply database changes
Start the Django application using a process manager (e.g., Gunicorn)

Slide 13 (Optional): Third-Party Packages Django's functionality can be extended through the use of third-party packages available on the Python Package Index (PyPI). Here's an example of how to install and use the django-crispy-forms package for better form rendering:

$ pip install django-crispy-forms

# settings.py
INSTALLED_APPS = [
    # ...
    'crispy_forms',
]

# template.html
{% load crispy_forms_tags %}
{{ form|crispy }}

Django REST Framework Django REST Framework (DRF) is a powerful and flexible toolkit for building web APIs. It provides features such as serialization, authentication, and browsable API documentation. Here's an example of a simple API view:

from rest_framework import generics
from .models import Blog
from .serializers import BlogSerializer

class BlogList(generics.ListCreateAPIView):
    queryset = Blog.objects.all()
    serializer_class = BlogSerializer

Meta

More in Web and APIs