Django — веб-фреймворк на Python

Запрос → URLconf → View (Python) → Model (база данных)
                  ↕                    ↕
               Template (HTML) ← данных подставлены

# Windows (PowerShell)
python -m venv .venv
.venv\Scripts\activate        # активация окружения
pip install django

# Linux / macOS
python3 -m venv .venv
source .venv/bin/activate
pip install django

django-admin startproject mysite
cd mysite
python manage.py runserver

python manage.py startapp shop

# mysite/settings.py
INSTALLED_APPS = [
    "django.contrib.admin",
    "django.contrib.auth",
    ...
    "shop",  # наше приложение
]

# shop/models.py
from django.db import models

class Category(models.Model):
    name = models.CharField(max_length=100)

class Product(models.Model):
    name = models.CharField(max_length=200)
    price = models.DecimalField(max_digits=8, decimal_places=2)
    category = models.ForeignKey(
        Category,
        on_delete=models.CASCADE,
        related_name="products",
    )
    in_stock = models.BooleanField(default=True)
    created = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

python manage.py makemigrations
python manage.py migrate

python manage.py createsuperuser
# введи логин, email и пароль

# shop/admin.py
from django.contrib import admin
from .models import Category, Product

@admin.register(Category)
class CategoryAdmin(admin.ModelAdmin):
    list_display = ("name",)

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ("name", "price", "category", "in_stock")
    list_filter = ("category", "in_stock")
    search_fields = ("name",)

# для тонкой настройки списка можно добавить кастомные поля
class ProductAdmin(admin.ModelAdmin):
    list_display = ("name", "price", "sale_price", "in_stock")

    @admin.display(description="Цена со скидкой")
    def sale_price(self, obj):
        return f"{obj.price * 0.9:.2f}"

python manage.py shell

# создать объект
c = Category.objects.create(name="Обувь")

# массовое создание
Product.objects.create(name="Кроссовки", price="4990.00", category=c)
Product.objects.create(name="Ботинки", price="6990.00", category=c)

# выборка
Product.objects.all()                       # все
Product.objects.filter(price__gt=5000)      # дороже 5000
Product.objects.exclude(in_stock=False)     # кроме распроданных
Product.objects.order_by("-price")          # по убыванию цены
Product.objects.count()                     # количество

# фильтры через связи
obuv = Category.objects.get(name="Обувь")
obuv.products.all()                  # товары категории (related_name)

Product.objects.filter(category__name="Обувь")  # через связь

# агрегация
from django.db.models import Avg, Sum
Product.objects.aggregate(avg=Avg("price"), total=Sum("price"))

# shop/views.py
from django.shortcuts import render, get_object_or_404
from .models import Product, Category

def home(request):
    products = Product.objects.filter(in_stock=True)[:8]
    return render(request, "shop/home.html", {"products": products})

def product_detail(request, pk):
    product = get_object_or_404(Product, pk=pk)
    return render(request, "shop/detail.html", {"product": product})

def by_category(request, category_id):
    category = get_object_or_404(Category, pk=category_id)
    products = category.products.all()
    return render(request, "shop/catalog.html", {
        "category": category,
        "products": products,
    })

# shop/urls.py — создаём вручную
from django.urls import path
from . import views

urlpatterns = [
    path("", views.home, name="home"),
    path("product/<int:pk>/", views.product_detail, name="product-detail"),
    path("category/<int:category_id>/", views.by_category, name="by-category"),
]

# mysite/urls.py — подключаем приложение
from django.urls import include, path

urlpatterns = [
    path("admin/", admin.site.urls),
    path("", include("shop.urls")),
]

<!-- shop/templates/shop/catalog.html -->
<!DOCTYPE html>
<html lang="ru">
<head>
  <title>{{ category.name }} — магазин</title>
</head>
<body>
  <h1>Категория: {{ category.name }}</h1>
  {% for product in products %}
    <div>
      <a href="{% url 'product-detail' product.pk %}">
        {{ product.name }}
      </a> — {{ product.price }} руб.
      {% if not product.in_stock %}
        <b>(нет в наличии)</b>
      {% endif %}
    </div>
  {% empty %}
    <p>Товаров пока нет.</p>
  {% endfor %}
</body>
</html>

<!-- shop/templates/base.html — общий каркас -->
<html lang="ru">
<head><title>{% block title %}Магазин{% endblock %}</title></head>
<body>
  <header>Магазин{% if user.is_authenticated %} · {{ user.username }}{% endif %}</header>
  <main>{% block content %}{% endblock %}</main>
</body>
</html>

<!-- страница-потомок: -->
{% extends "base.html" %}
{% block content %}
  <h1>Категория: {{ category.name }}</h1>
  <!-- содержимое страницы -->
{% endblock %}

# shop/forms.py
from django import forms
from .models import Product

class ProductForm(forms.ModelForm):
    class Meta:
        model = Product
        fields = ["name", "price", "category", "in_stock"]
        widgets = {
            "name": forms.TextInput(attrs={"class": "form-input"}),
        }

# shop/views.py — обработка формы
from django.shortcuts import render, redirect
from .forms import ProductForm

def product_create(request):
    if request.method == "POST":
        form = ProductForm(request.POST)
        if form.is_valid():
            product = form.save()
            return redirect("product-detail", pk=product.pk)
    else:
        form = ProductForm()
    return render(request, "shop/form.html", {"form": form})

<!-- шаблон формы с выводом ошибок -->
<form method="post">
  {% csrf_token %}
  {{ form.as_p }}
  <button type="submit">Сохранить</button>
</form>

# mysite/urls.py
from django.contrib.auth import views as auth_views

urlpatterns = [
    path("login/", auth_views.LoginView.as_view(), name="login"),
    path("logout/", auth_views.LogoutView.as_view(), name="logout"),
]

from django.contrib.auth.decorators import login_required

@login_required
def profile(request):
    return render(request, "shop/profile.html", {"user": request.user})

# mysite/settings.py
STATIC_URL = "static/"
STATIC_ROOT = BASE_DIR / "staticfiles"
MEDIA_URL = "media/"
MEDIA_ROOT = BASE_DIR / "media"

<!-- в шаблоне -->
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">

# mysite/settings.py
DEBUG = False
ALLOWED_HOSTS = ["mydomain.ru"]

python manage.py collectstatic --noinput
pip install gunicorn          # WSGI-сервер (Linux)
gunicorn mysite.wsgi:application --bind 0.0.0.0:8000

# конфиг Nginx: отдача статики и прокси на gunicorn
location /static/ { root /home/me/mysite/; }
location /media/  { root /home/me/mysite/; }
location / {
    proxy_pass http://127.0.0.1:8000;
    proxy_set_header Host $host;
}

pip install django-redis

CACHES = {
    "default": {
        "BACKEND": "django_redis.cache.RedisCache",
        "LOCATION": "redis://127.0.0.1:6379/1",
        "OPTIONS": {"CLIENT_CLASS": "django_redis.client.DefaultClient"},
    }
}

from django.views.decorators.cache import cache_page

@cache_page(60 * 15)        # 15 минут для анонимных запросов
def catalog(request): ...

{% load cache %}
{% cache 300 latest_news %}
  ... тяжелая выборка новостей ...
{% endcache %}

pip install celery

# tasks.py
from celery import shared_task

@shared_task
def send_welcome_email(user_id):
    user = User.objects.get(pk=user_id)
    send_mail("Добро пожаловать", "…", user.email)

def register(request):
    user = User.objects.create_user(...)
    send_welcome_email.delay(user.id)   # в очередь, не блокирует ответ
    return render(request, "done.html")

celery -A mysite worker -l info    # запуск воркера

pip install pytest pytest-django

# tests/test_orders.py
import pytest
from django.urls import reverse
from .models import Product

@pytest.mark.django_db
def test_catalog_page_shows_products(client):
    Product.objects.create(title="Ноутбук", price=1000)
    resp = client.get(reverse("catalog"))
    assert resp.status_code == 200
    assert "Ноутбук" in resp.content.decode()

SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000

def uppercase_names(apps, schema_editor):
    Product = apps.get_model("shop", "Product")
    for p in Product.objects.all():
        p.title = p.title.title()
        p.save()

class Migration(migrations.Migration):
    dependencies = [("shop", "0002_alter_product_price")]
    operations = [migrations.RunPython(uppercase_names)]

python manage.py squashmigrations shop 0005

# serializers.py
from rest_framework import serializers
from .models import Product

class ProductSerializer(serializers.ModelSerializer):
    class Meta:
        model = Product
        fields = ["id", "title", "price"]

# views.py
from rest_framework.viewsets import ModelViewSet
from .serializers import ProductSerializer

class ProductViewSet(ModelViewSet):
    queryset = Product.objects.all()
    serializer_class = ProductSerializer

# shop/templatetags/money.py
from django import template
register = template.Library()

@register.simple_tag
def format_price(value):
    return f"{value:,.2f} ₽".replace(",", " ")

# в шаблоне
{% load money %}
<span>Цена: {% format_price product.price %}</span>

# settings.py
"context_processors": [
    "cart.context_processors.cart_total",
]

LOGGING = {
    "version": 1,
    "disable_existing_loggers": False,
    "handlers": {"console": {"class": "logging.StreamHandler"}},
    "root": {"handlers": ["console"], "level": "INFO"},
}

# Sentry в entrypoint-коде
import sentry_sdk
sentry_sdk.init(dsn="https://...@sentry.io/1", traces_sample_rate=0.1)

# consumers.py
class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.channel_layer.group_add("room", self.channel_name)
        await self.accept()

    async def receive(self, text_data):
        await self.channel_layer.group_send(
            "room", {"type": "msg", "data": text_data})

class ProductFilter(filters.FilterSet):
    name = filters.CharFilter(lookup_expr="icontains")
    price_min = filters.NumberFilter(field_name="price", lookup_expr="gte")

qs = Product.objects.filter(Q(category="books") | Q(tags__name=term))

def update_slugs(apps, schema_editor):
    Product = apps.get_model("shop", "Product")
    for p in Product.objects.all():
        p.slug = slugify(p.name)
        p.save(update_fields=["slug"])

operations = [
    migrations.RunPython(update_slugs,
                         reverse_code=migrations.RunPython.noop),
]

products = Product.objects \
    .select_related("category") \
    .prefetch_related(Prefetch("reviews",
        queryset=Review.objects.order_by("-created")))

with connection.cursor() as c:
    c.execute("EXPLAIN ANALYZE SELECT ...")