Django: Связка URLs и Views для новичков

Аналогия с рестораном: понимаем связь URL, View и Template

Привет! Если ты только начинаешь путь в Django, то, скорее всего, уже столкнулся с тем, что для отображения одной простой надписи на экране нужно отредактировать сразу несколько файлов. Почему нельзя просто создать hello.html и открыть его? Потому что Django — это мощный веб-фреймворк, а не просто сервер статических файлов.

Сегодня мы разберем фундаментальный механизм Django: MVT (Model-View-Template), но сосредоточимся на самой активной его части — связке URL и View.

Ресторан Django: Как это работает?

Чтобы понять, зачем нам столько файлов, давай представим, что твой сайт — это ресторан.

Клиент (Браузер). Это голодный посетитель. Он приходит и делает заказ (отправляет Request).

Меню (URLconf / urls.py). Посетитель не ломится сразу на кухню. Он смотрит в меню. Если он просит «Борщ», менеджер зала (Django) смотрит в меню: «Ага, для Борща у нас есть инструкция на странице 5».

Шеф-повар (View / views.py). Это мозг ресторана. Менеджер передает заказ шефу. Шеф знает как готовить. Он берет ингредиенты (данные из базы), режет, варит и пробует. В итоге у него получается готовое блюдо.

Тарелка и сервировка (Template / html). Шеф не вываливает еду в руки клиенту. Он кладет её на красивую тарелку (HTML-шаблон). Это то, как еда выглядит.

Официант (Response). Готовое блюдо на тарелке торжественно выносится клиенту.

!Схематичное изображение потока данных: от URL к View и затем к пользователю.

В этой статье мы сосредоточимся на Меню (URLs) и Шеф-поваре (Views). Тарелки (Templates) мы пока заменим на простую салфетку (обычный текст), чтобы понять суть логики.

Маршруты (URLs): Настраиваем меню

Файл urls.py — это входная дверь вашего приложения. Когда пользователь вводит адрес в браузере, Django бежит именно сюда, чтобы понять, что делать.

Типичная запись в urls.py выглядит так:

Разберем функцию path() по косточкам:

* Первый аргумент ('hello/'): Это строчка, которую пользователь пишет в браузере после адреса сайта (например, mysite.com/hello/). Это пункт в меню. * Второй аргумент (views.say_hello): Это ссылка на функцию-шефа, которую нужно вызвать. Мы говорим: «Если заказали 'hello/', зови шефа say_hello». * Третий аргумент (name='hello_page'): Это краткое имя для маршрута, чтобы нам было удобно ссылаться на него внутри кода (как код блюда в чеке).

> Важно: В Django принято ставить слеш / в конце URL. Если пользователь введет адрес без слеша, Django (при стандартных настройках) сам перенаправит его на адрес со слешем.

Представления (Views): Работа Шеф-повара

Теперь перейдем в файл views.py. Здесь живут функции, которые принимают заказ и отдают результат.

Минимальная функция-представление (View) обязана делать две вещи:

Принимать объект request (запрос).

Возвращать объект HttpResponse (ответ).

* request: Это вся информация о заказе. Кто пришел, с какого браузера, какие данные передал. * HttpResponse: Это специальный контейнер, в который мы упаковываем наш текст (или HTML), чтобы отправить его обратно в браузер.

Сквозной пример: Делаем страницу /hello/

Давай соединим всё вместе. Представим, что у тебя уже создан проект и приложение с названием pages.

Шаг 1: Пишем логику (views.py)

Сначала обучим шефа готовить блюдо. Открой pages/views.py:

Шаг 2: Добавляем в меню (urls.py)

Теперь сообщим Django, по какому адресу доступна эта функция. Открой pages/urls.py (если файла нет, создай его):

Шаг 3: Подключаем меню приложения к главному меню

В Django есть главный urls.py (в папке с настройками проекта), который управляет всеми приложениями. Нужно убедиться, что он знает о нашем файле pages/urls.py.

В главном urls.py:

Теперь, если ты запустишь сервер (python manage.py runserver) и перейдешь по адресу http://127.0.0.1:8000/hello/, Django сделает следующее:

Увидит префикс hello/ в главном файле.

Передаст управление в pages.urls.

Там найдет пустой путь '' (который стыкуется с hello/).

Вызовет функцию views.index.

Ты увидишь текст: «Я работаю! Это моя первая страница на Django.».

Передача данных: Динамические URL

Часто нам нужно не просто показать статичную страницу, а отобразить что-то конкретное. Например, профиль пользователя. Мы не будем создавать отдельную функцию для Ивана, Марии и Петра. Мы сделаем одну универсальную функцию.

Как это выглядит в URL?

Мы используем специальные скобки < > в urls.py, чтобы сказать Django: «Сюда подставят какое-то значение, поймай его и передай в функцию».

В pages/urls.py добавим новый путь:

Как это выглядит во View?

Теперь наша функция должна принимать не только request, но и ту самую переменную name.

В pages/views.py:

Проверяем

* Заходим на .../hello/user/Ivan/ -> Видим «Привет, Ivan! Рады тебя видеть.» * Заходим на .../hello/user/Anna/ -> Видим «Привет, Anna! Рады тебя видеть.»

Мы использовали один и тот же код (одного шеф-повара) для обслуживания разных клиентов. В этом и есть магия динамических сайтов.

Итог

URL (urls.py) — это карта вашего сайта. Она связывает красивый адрес с Python-функцией.

View (views.py) — это функция, которая принимает request, делает работу и возвращает HttpResponse.

Чтобы передать данные через адрес, используем синтаксис <тип:имя_переменной>.

В следующей статье мы уберем наши простые текстовые ответы и научимся подключать настоящие HTML-шаблоны, чтобы наш «ресторан» подавал еду на красивых тарелках, а не на салфетках.

Маршруты и Представления: связываем адрес с кодом

Привет! Ты уже знаешь, что Django — это мощный веб-фреймворк. Но как именно он понимает, что нужно показать пользователю, когда тот вводит адрес сайта? Как связать строчку в браузере с твоим Python-кодом?

Сегодня мы разберем этот механизм «на пальцах». Наша цель — научиться строить маршрут от запроса пользователя до ответа сервера. Никакой лишней теории, только алгоритм действий.

Аналогия: Ресторан Django

Чтобы понять, как работают URLs и Views, давай вернемся к аналогии с рестораном. Представь, что ты пришел поужинать.

URL (Адрес в браузере) — это строчка в меню. Ты тыкаешь пальцем в меню и говоришь: «Хочу пасту Карбонара». Ты сделал запрос.

urls.py (Диспетчер URL) — это официант. Он смотрит в меню, слышит твой заказ и понимает: «Ага, клиент хочет Карбонару». Он знает, какому повару нужно передать этот заказ.

View (Представление) — это Шеф-повар. Официант прибегает на кухню и кричит: «Заказ на Карбонару!». Шеф-повар (функция Python) начинает готовить: варит макароны, жарит бекон (выполняет код).

HttpResponse (Ответ) — это готовое блюдо. Повар отдает тарелку официанту, а тот несет её тебе.

Итог: Твоя задача как разработчика — составить меню (urls.py) и обучить повара готовить блюда (views.py).

Шаг 1: Маршруты (URLs)

В Django за «меню» отвечает файл urls.py. Именно здесь мы прописываем, какие адреса существуют на нашем сайте.

Основной инструмент здесь — функция path(). Она связывает красивый адрес с суровым кодом.

Типичная запись выглядит так:

Давай разберем аргументы этой функции:

1. Первый аргумент: route (Маршрут)

Это часть адреса, которая идет после домена сайта. Если твой сайт mysite.com, то:

* Для адреса mysite.com/hello/ маршрут будет 'hello/'. * Для главной страницы mysite.com маршрут будет пустой строкой ''.

Важное правило: Всегда ставь слэш / в конце. Это стандарт Django. Если пользователь введет адрес без слэша, Django сам вежливо перенаправит его на правильный адрес.

2. Второй аргумент: view (Ссылка на повара)

Здесь мы указываем, какую функцию нужно запустить, когда пользователь перейдет по этому адресу. Обрати внимание: мы пишем название функции без скобок.

* views.say_hello — Правильно. Мы говорим: «Используй вот эту функцию». * views.say_hello() — Неправильно. Это запустит функцию сразу при старте сервера, а нам нужно запустить её только в момент запроса.

Шаг 2: Представления (Views)

Теперь перейдем на «кухню». Файл views.py — это место, где живет логика. Представление (View) — это обычная функция Python, которая обязана делать две вещи:

Принять первым аргументом объект request (запрос).

Вернуть объект HttpResponse (ответ).

Пример простейшего «повара»:

* request: Это конверт с информацией от пользователя (какой браузер, какие данные отправил, авторизован ли он). * HttpResponse: Это то, что увидит пользователь в браузере. В данном случае — просто текст.

Сквозной пример: Создаем страницу /hello/

Давай соединим всё вместе и создадим работающую страницу. Следуй этому алгоритму.

1. Пишем логику (views.py)

Сначала научим повара готовить блюдо. Открой файл views.py в твоем приложении и добавь код:

2. Прописываем маршрут (urls.py)

Теперь добавим блюдо в меню. Открой файл urls.py (тот, что лежит внутри папки приложения, или основной, если ты пока работаешь в одном) и добавь:

3. Проверяем

Запусти сервер (python manage.py runserver) и открой в браузере адрес: http://127.0.0.1:8000/hello/.

Ты должен увидеть текст: Поздравляю! Это твоя первая страница на Django.

Передача данных: Динамические URL

Статические страницы — это скучно. Что, если мы хотим поприветствовать конкретного пользователя? Например, по адресу /user/ivan/ писать «Привет, Иван!», а по /user/anna/ — «Привет, Анна!»?

Мы не будем писать миллион путей для каждого имени. Мы используем параметры.

Как это работает

В urls.py мы используем специальные скобки < >, чтобы сказать Django: «Сюда подставится какое-то значение, поймай его и передай в функцию».

#### Шаг 1: Изменяем urls.py

#### Шаг 2: Изменяем views.py

Теперь наша функция должна уметь принимать не только request, но и ту самую переменную name, которую мы поймали в URL.

Что происходит в этот момент?

Ты вводишь: /user/maxim/.

Django видит шаблон user/<str:name>/.

Он понимает: «Ага, maxim — это строка». Он кладет строку "maxim" в переменную name.

Django вызывает функцию: greet_user(request, name="maxim").

Функция подставляет имя в текст и возвращает ответ.

Резюме

Чтобы создать новую страницу в Django, используй простой алгоритм:

View: Напиши функцию в views.py, которая принимает request и возвращает HttpResponse.

URL: Добавь строчку path() в urls.py, чтобы связать адрес с этой функцией.

Dynamic: Если нужны данные из адреса, используй <тип:имя> в path() и добавь этот аргумент в функцию.

Этого достаточно, чтобы начать строить структуру твоего будущего сайта. В следующих уроках мы заменим простой текст HttpResponse на красивые HTML-шаблоны.

Файл views.py: пишем функции, принимающие request и возвращающие ответ

Привет! В прошлой статье мы гуляли по «залу» нашего ресторана Django и изучали меню — файл urls.py. Мы научились направлять посетителя к нужному сотруднику. Теперь настало время зайти на кухню.

Сегодня мы будем работать с файлом views.py. Именно здесь происходит вся магия: принимаются заказы, нарезаются ингредиенты и отдаются готовые блюда. Если urls.py — это карта, то views.py — это территория, где происходит реальное действие.

Наша цель на сегодня — научиться писать функции, которые умеют разговаривать с браузером на одном языке.

Шеф-повар за работой: Логика View

Давай вспомним нашу аналогию. View (Представление) — это Шеф-повар. Его работа проста и сложна одновременно. Он не бегает к клиенту (это делает браузер) и не печатает меню (это делает URLconf). Он стоит на своем месте и ждет команду.

Жизненный цикл работы Шеф-повара выглядит так:

Получить заказ (Request). Официант приносит бумажку, на которой написано: «Столик №5, хочет страницу /hello/, браузер Chrome, язык русский».

Подумать и приготовить (Logic). Шеф читает заказ, лезет в холодильник (базу данных) или просто берет заготовку.

Отдать блюдо (Response). Шеф ставит еду на тарелку и звонит в колокольчик, чтобы официант унес её клиенту.

!Визуализация процесса: Запрос входит в функцию, обрабатывается, и возвращается Ответ.

В коде Django этот процесс выглядит как обычная функция Python, но с двумя строгими правилами.

Анатомия функции-представления

Открой файл views.py в своем приложении. Скорее всего, он почти пуст. Давай напишем самую примитивную функцию.

Разберем этот код по винтикам. Здесь важна каждая деталь.

1. Аргумент request

Посмотри на определение функции: def my_first_view(request):.

Правило №1: Любая функция-представление в Django обязана принимать первым аргументом объект запроса. По традиции его называют request.

Этот объект request создает сам Django. В нем лежит всё, что браузер передал серверу: * Какой URL запросили. * Какой метод использовали (GET или POST). * Кто пользователь (если он вошел в систему). * Cookies и многое другое.

Даже если ты не собираешься использовать эти данные, ты обязан принять этот аргумент. Иначе Django попытается вызвать твою функцию, передаст ей данные, а функция скажет: «Эй, я ничего не ждала!» — и вылетит с ошибкой.

2. Возврат HttpResponse

Посмотри на возврат: return HttpResponse(...).

Правило №2: Функция-представление обязана вернуть объект ответа. Ты не можешь просто написать return "Привет". Строка — это просто текст, а браузеру нужен полноценный HTTP-ответ с заголовками, статусом (200 OK) и содержимым.

Для этого мы используем специальный класс HttpResponse, который нужно импортировать из django.http.

> Представь, что HttpResponse — это тарелка. Ты не можешь налить суп прямо в руки клиенту (вернуть просто строку). Ты должен налить суп в тарелку (обернуть строку в HttpResponse) и только потом отдать.

Сквозной пример: Создаем страницу «Привет, Django!»

Давай закрепим теорию практикой. Мы создадим страницу, которая доступна по адресу /hello/ и выводит приветствие.

Предположим, у тебя есть приложение pages.

Шаг 1: Пишем View (Кухня)

Открываем pages/views.py и пишем код:

Шаг 2: Прописываем Маршрут (Меню)

Теперь нужно сказать Django, по какому адресу вызывать этого шефа. Открываем pages/urls.py:

Шаг 3: Проверка

Запускаем сервер (python manage.py runserver) и переходим в браузере по адресу http://127.0.0.1:8000/hello/.

Если ты всё сделал правильно, браузер покажет белый экран с текстом: Привет, Django! Это моя первая рабочая страница.

Передача данных: Динамические Views

Статичный текст — это скучно. Сила Django в том, что страницы могут меняться в зависимости от того, что запросил пользователь.

В прошлой статье мы говорили про динамические URL, например user/ivan/ или user/maria/. В urls.py мы использовали конструкцию <str:name>. Но как получить это имя name внутри функции?

Всё очень просто: Django передаст пойманное значение как второй аргумент функции.

Пример: Персональное приветствие

1. Настраиваем urls.py:

2. Настраиваем views.py:

Теперь наша функция должна быть готова принять не только request, но и username. Имя аргумента должно в точности совпадать с тем, что мы написали в скобках <...> в URL.

Что происходит:

Пользователь заходит на .../user/Alex/.

Django видит шаблон user/<str:username>/.

Он извлекает строку Alex.

Он вызывает функцию: greet_user(request, username='Alex').

Функция формирует строку «Привет, Alex!...» и возвращает её.

Частые ошибки новичков

Забыл аргумент request.

Ошибка:* def my_view(): ... Результат:* TypeError. Django попытается передать аргумент, а функции некуда его принять.

Забыл вернуть HttpResponse.

Ошибка:* return "Hello" (без обертки). Результат:* ValueError. Django ожидает объект ответа, а получает строку.

Несовпадение имен переменных.

Ошибка:* В URL написано <str:name>, а во view def view(request, username):. Результат:* TypeError. Django попытается передать аргумент name, а функция ждет username.

Итог

Мы научились создавать сердце веб-приложения — функции-представления.

* View — это просто Python-функция. * Она всегда принимает request первым аргументом. * Она всегда возвращает HttpResponse. * Если в URL есть параметры (например, ID товара или имя пользователя), они передаются в функцию как дополнительные аргументы.

Пока что мы возвращаем простой текст. Это работает, но выглядит не очень красиво. В реальном ресторане еду не просто кладут на тарелку, её еще и украшают. В следующей статье мы подключим Templates (Шаблоны) и научимся отдавать полноценный HTML-код с дизайном.

Сквозной пример: создаем страницу /hello/ с текстом «Привет, Django!»

Привет! Мы уже разобрали теорию: знаем, что URL — это меню, View — это шеф-повар, а Template — это тарелка. Но теория без практики мертва. Сегодня мы засучим рукава и пройдем весь путь от чистого листа до работающей страницы в браузере.

Наша цель проста: сделать так, чтобы при переходе по адресу http://127.0.0.1:8000/hello/ мы увидели надпись «Привет, Django!». А затем мы усложним задачу и научим сайт здороваться с конкретным пользователем.

Подготовка: Где мы находимся?

Предположим, у тебя уже создан проект Django (пусть он называется config или mysite) и создано приложение pages. Структура папок выглядит примерно так:

Если файла pages/urls.py нет, создай его вручную. Это частая практика: Django не создает этот файл автоматически при команде startapp.

Шаг 1: Готовим логику (views.py)

Начинаем всегда с «кухни». Прежде чем вписывать блюдо в меню, нужно научить повара его готовить. Нам нужна функция, которая просто отдаст текст.

Открой файл pages/views.py и напиши следующий код:

Что здесь происходит?

Импорт: Мы достаем HttpResponse из кладовки Django. Без него мы не сможем отправить ответ браузеру.

Функция: Мы назвали её hello_view. Имя может быть любым (хоть cook_soup), но лучше давать понятные названия.

Аргумент request: Мы обязаны принять этот аргумент, даже если не используем его внутри. Это правило протокола.

Возврат: Мы возвращаем готовый ответ.

Шаг 2: Создаем меню приложения (pages/urls.py)

Теперь, когда повар обучен, нужно записать это блюдо в локальное меню приложения pages.

Открой (или создай) файл pages/urls.py:

Разберем path('hello/', ...): * Мы говорим Django: «Если внутри этого приложения запросят адрес hello/, то зови функцию hello_view». * Обрати внимание: мы не пишем слэш в начале (/hello/ — ошибка). Но пишем в конце.

Шаг 3: Подключаем к главному меню (config/urls.py)

Это самый важный шаг, который часто забывают новички. У нас есть меню в приложении pages, но главный швейцар (основной файл urls.py в папке конфигурации) о нем ничего не знает.

Нам нужно использовать функцию include, чтобы «подшить» наше маленькое меню к главному.

Открой файл config/urls.py (или mysite/urls.py — тот, что лежит рядом с settings.py):

Внимание на строку с include: path('', include('pages.urls')) означает: «Бери всё, что написано в файле pages/urls.py, и добавляй это сразу после домена сайта».

!Путь запроса от браузера через главный диспетчер URL к конкретному приложению и функции.

Шаг 4: Проверка связи

Теперь всё готово. Запускай сервер разработки:

Открывай браузер и переходи по адресу: http://127.0.0.1:8000/hello/.

Если ты видишь белый экран с текстом «Привет, Django! Я работаю!», поздравляю! Ты только что собственноручно настроил полный цикл обработки запроса.

Что произошло под капотом?

Браузер постучался на .../hello/.

Главный urls.py посмотрел: «Так, у меня есть path('', include('pages.urls')). Значит, отправляю запрос в pages.urls».

Файл pages/urls.py получил запрос hello/. Он посмотрел в свой список: «О, у меня есть path('hello/', ...)! Вызываю функцию hello_view».

Функция hello_view вернула HttpResponse.

Django отправил этот ответ обратно в браузер.

Усложняем задачу: Передача имени (Динамические URL)

Просто выводить статичный текст скучно. Давай сделаем так, чтобы сайт мог поздороваться с кем угодно. Например, по адресу /user/Ivan/ он должен писать «Привет, Ivan!», а по /user/Maria/ — «Привет, Maria!».

Нам не нужно писать 100 функций для 100 имен. Мы используем параметры пути.

1. Обновляем views.py

Добавим новую функцию, которая умеет принимать имя.

Заметь: теперь функция принимает два аргумента: request и name.

2. Обновляем pages/urls.py

Теперь нужно объяснить Django, что часть адреса может меняться. Для этого используем угловые скобки < >.

Важно: Имя переменной в urls.py (внутри скобок <...:name>) должно в точности совпадать с именем аргумента в функции views.py (def greet_user(request, name)).

3. Проверяем

Сохрани файлы (сервер перезагрузится сам). Попробуй перейти по адресам:

* http://127.0.0.1:8000/user/Alex/ -> Вывод: Привет, Alex! Рады тебя видеть. * http://127.0.0.1:8000/user/Boss/ -> Вывод: Привет, Boss! Рады тебя видеть.

Резюме

Мы создали простейшее веб-приложение на Django. Вот алгоритм, который ты будешь использовать тысячи раз:

View: Напиши функцию в views.py, которая принимает request и возвращает HttpResponse.

App URL: Добавь маршрут path() в urls.py твоего приложения.

Project URL: Убедись, что urls.py приложения подключен к главному urls.py через include().

В следующем уроке мы уберем этот некрасивый текст и начнем отдавать полноценные HTML-страницы с помощью шаблонов.

Динамические URL: как передавать и обрабатывать параметры в адресной строке

Привет! В прошлой статье мы научились создавать простую страницу /hello/, которая всегда отвечает одинаково: «Привет, Django!». Это здорово, но современные сайты так не работают. Представь себе интернет-магазин. Если в нем 10 000 товаров, неужели программист вручную прописал 10 000 маршрутов в urls.py и создал 10 000 функций? Конечно, нет.

Сегодня мы узнаем, как сделать один маршрут и одну функцию, которые смогут обрабатывать тысячи разных запросов. Мы научимся передавать данные прямо через адресную строку.

Проблема статических адресов

Давай вернемся к нашей аналогии с рестораном.

В прошлом уроке мы добавили в меню позицию «Борщ». Когда клиент заказывает «Борщ», повар готовит его по строгому рецепту. Но что, если клиент хочет стейк? Стейк может быть разной прожарки: Rare, Medium, Well Done.

Если использовать подход из прошлого урока, нам пришлось бы писать в меню три разные строчки:

Стейк Rare

Стейк Medium

Стейк Well Done

А если добавить соусы? Количество вариантов станет бесконечным. Нам нужен способ сказать официанту: «Я хочу стейк, а параметр прожарки — Medium».

В Django этот механизм называется динамические URL.

Синтаксис захвата параметров

Чтобы превратить часть адреса в переменную, в Django используются угловые скобки < >. Внутри этих скобок мы указываем имя переменной, которую хотим «поймать».

Как это выглядит в urls.py

Открой файл urls.py своего приложения. Допустим, мы хотим сделать страницу профиля пользователя, адрес которой выглядит как /user/ivan/, /user/maria/ и так далее.

Разберем конструкцию <str:username>:

str (конвертер) — это тип данных. Мы говорим Django: «Ожидай здесь любую строку, кроме символа /».

username (имя переменной) — это название ящика, в который Django положит пойманное значение.

!Как Django извлекает данные из URL

Как это выглядит в views.py

Теперь самое интересное. Как повар узнает, какую прожарку заказали? Ему должны передать это вместе с заказом.

В файле views.py мы должны изменить нашу функцию. Раньше она принимала только request. Теперь она обязана принять еще и аргумент, имя которого совпадает с тем, что мы написали в urls.py.

Что происходит по шагам:

Пользователь заходит на .../user/admin/.

Django видит шаблон user/<str:username>/.

Он понимает: «Ага, admin — это строка. Значит, username = 'admin'».

Он вызывает функцию: user_profile(request, username='admin').

Функция возвращает текст: «Профиль пользователя: admin».

Типы конвертеров (Фильтры данных)

Django позволяет не просто ловить всё подряд, но и сразу проверять тип данных. Это очень удобно для валидации. Например, ID товара — это всегда число. Если кто-то напишет /product/apple/, это явно ошибка.

Основные конвертеры:

* str — (по умолчанию) любая непустая строка, исключая разделитель пути /. * int — ноль или любое положительное целое число. Возвращает объект типа int. * slug — строка, состоящая из букв ASCII, цифр, дефисов и знаков подчеркивания. Часто используется для красивых адресов статей (например, my-first-post). * uuid — уникальный идентификатор (например, 075194d3-6885-417e-a8a8-6c931e272f00).

Пример с ID товара

Давай создадим маршрут для просмотра товара по его числовому ID.

В urls.py:

В views.py:

Проверка: * Запрос /product/42/ -> Функция получит число 42. Ответ: «Вы смотрите товар с ID 42». * Запрос /product/apple/ -> Django увидит, что apple — это не int. Если других подходящих маршрутов нет, он автоматически вернет ошибку 404 (Страница не найдена). Функция get_product даже не будет вызвана.

> Это избавляет нас от необходимости писать проверки if type(id) == int внутри функции. Django делает это на входе.

Несколько параметров в одном URL

Иногда нужно передать сразу несколько значений. Например, мы хотим вывести архив новостей за определенный год и месяц.

В urls.py:

В views.py:

Порядок аргументов в функции Python не важен, если имена совпадают, но для чистоты кода лучше соблюдать тот же порядок, что и в URL.

Практика: Создаем калькулятор суммы

Давай закрепим знания и напишем View, который принимает два числа из URL и выводит их сумму. Это отличный пример того, как конвертеры int облегчают жизнь.

Шаг 1: Добавляем маршрут

В urls.py:

Шаг 2: Пишем логику

В views.py:

Шаг 3: Тестируем

Запусти сервер и перейди по адресу http://127.0.0.1:8000/sum/50/20/.

Ты увидишь: Сумма 50 + 20 = 70.

Заметь, нам не пришлось писать int(a) или int(b). Конвертер <int:...> сделал это за нас. Если бы мы использовали <str:...>, то результатом было бы 5020 (конкатенация строк), а не 70.

Частые ошибки новичков

Несовпадение имен.

* В URL: <int:user_id> * Во View: def view(request, id): * Результат: Ошибка TypeError. Django попытается передать аргумент user_id, а функция ждет id.

Забытый аргумент request.

* Во View: def view(user_id): * Результат: Ошибка. Первый аргумент всегда request, параметры идут следом.

Порядок маршрутов.

Django проверяет маршруты сверху вниз и останавливается на первом совпадении. Если поменять их местами, то адрес /user/new/ попадет под шаблон <str:username>, где username станет равно "new". Поэтому более конкретные маршруты всегда ставь выше общих.

Итог

Мы сделали огромный шаг вперед. Теперь наши URL — это не просто статичные вывески, а полноценный интерфейс передачи данных.

* Используй <тип:имя> в urls.py, чтобы ловить параметры. * Добавляй аргументы с такими же именами в функцию в views.py. * Используй int, чтобы автоматически получать числа и отсеивать мусор.

В следующей статье мы наконец-то избавимся от HttpResponse с простым текстом и научимся подключать красивые HTML-шаблоны, чтобы наш сайт выглядел профессионально.