Главная » Языки программирования

Python from import views

Содержание
  1. Создание представлений (views) в Django
  2. 1. Создание представлений для каталога
  3. 2. URL-адреса
  4. Django Create App
  5. Django projects and applications
  6. Creating a blog application
  7. Registering an application
  8. Creating a view
  9. Adding more routes
  10. Summary

Создание представлений (views) в Django

В основном создание веб-страниц в Django состоит из трех стадий: определения URL-адреса, написания представления и написания шаблонов. Каждый URL-адрес связывается с конкретным представлением (view), которое обрабатывает данные и затем выводит шаблон страницы, которую в итоге увидят пользователи в браузере. Представление (view) в Django может представлять собой как функцию, так и класс. Для хранения кода представлений (views) изначально предназначается модуль views.py , создаваемый в каждом пакете приложения, но вам никто не мешает поместить код в другие модули. В документации по Django используется термин «view » (вид, представление), но многие их также называют обработчиками, контроллерами или просто вьюхами.

1. Создание представлений для каталога

Для отображения товаров создадим страницу со списком товаров и фильтрации их по категориям. Откройте файл views.py приложения shop и добавьте следующую функцию product_list :

from django.shortcuts import render , get_object_or_404
from .models import Category , Product

def product_list (request, category_slug=None):
«»»» Страница списка товаров»»»
category = None
categories = Category. objects.all ()
products = Product. objects.filter (available=True)
if category_slug:
category = get_object_or_404 (Category, slug=category_slug)
products = products.filter (category=category)
context =
return render (request, ‘shop/product/list.html’, context )

Функция render() генерирует ответ на основании данных, полученных от представлений (view). Также мы импортируем из файла models.py наши модели Category , Product , с данными которых мы планируем работать. Функции product_list мы передаем два параметра request и category_slug=None , так как мы фильтруем товары по категориям. В categories мы отправляем запрос к базе данных для получения всех категорий Category.objects.all() . В products мы фильтруем товары по условию available=True , для отображения товаров только из наличия.

Читайте также:  PHP - Hello, World!

В переменной context определяется контекст, который будет передаваться шаблону. Контекст представляет собой словарь, в котором ключами являются имена, используемые в шаблоне для обращения к данным, а значения словаря — данные, которые передаются шаблону.

При построение страницы используются данные функции render() , которая передает объект request , путь к шаблону ( ‘shop/product/list.html’ ), который мы позже создадим и переменную context . Переменную context можно и не создавать, а просто передать словарь в саму функцию render() .

Теперь напишем представление для отображения каждого товара с его подробным описанием. Добавим еще одну функцию product_detail в файл views.py приложения shop:

def product_detail (request, id, slug):
«»» Страница продукта»»»
product = get_object_or_404 (Product, slug=slug, available=True)
context =
return render (request, ‘shop/product/detail.html’, context)

Функции product_detail передаются параметры id и slug , для определения нужного товара. Помимо id мы передаем еще и slug , чтобы сгенерировать удобочитаемую ссылку с названием товара. Также это полезно и для SEO оптимизации сайта для поисковых систем.

К продукту мы будем обращаться с помощью вспомогательной функции Django get_object_or_404 . Эта функция получает запрошенный объект из базы данных, а если в случае его отсутствия инициирует исключение 404.

2. URL-адреса

Посетители сайта запрашивают страницы вводя URL-адреса или переходят по ссылкам на сайте. На данный момент базовый URL-адрес нашего сайта http://127.0.0.1:8000/ , который возвращает сайт, сгенерированный Django по умолчанию.

Откроем файл urls.py основного проекта my_site. Первые две строки импортируют функции и модули, управляющие URL-адресами проекта и административным сайтом. Переменная urlpatterns содержит список из приложений в проекте. Добавим в список наше приложение shop:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
path(‘admin/’, admin.site.urls),
path(», include (‘shop.urls’)) ,

Теперь в папке приложения shop создадим файл urls.py, где разместим url-адреса представлений которые мы написали в первой части ( product_list и product_detail )

from django.urls import path
from . import views

urlpatterns = [
«»»Домашняя страница»»»
path(», views. product_list , name= ‘product_list‘ ),
«»»Страница по категориям»»»
path(‘< slug:category_slug >/’, views. product_list , name= ‘product_list_by_category‘ ),
«»»Страница продукта»»»
path(‘< int:id>//’, views. product_detail , name= ‘product_detail’ ),
]

Для удобства в начало файла добавляется переменная app_name = ‘shop’ , чтобы было понятно с каким приложением мы работаем.

Шаблон ‘product_list’ вызовет функцию product_list без дополнительных параметров и будет являться домашней страницей. Шаблон ‘product_list_by_category’ вызовет функцию product_list и передаст в качестве аргумента слаг, category_slug. Шаблон ‘product_detail’ вызовет функцию product_detail для отображения страницы товара.

Источник

Django Create App

Summary: in this tutorial, you’ll learn how to create a new application in a Django project, how to define views, and map the views with URLs.

This tutorial begins where the Getting started with Django tutorial left off.

Django projects and applications

  • A project is a Django installation with some settings.
  • An application is a group of models, views, templates, and URLs.

A Django project may have one or more applications. For example, a project is like a website that may consist of several applications such as blogs, users, and wikis.

Typically, you design a Django application that can be reusable in other Django projects. The following picture shows the structure of a Django project and its applications:

Creating a blog application

To create an application, you use the startapp command as follows:

python manage.py startapp app_nameCode language: CSS (css)

For example, you can create an application called blog using the startapp command like this:

python manage.py startapp blogCode language: CSS (css)

The command creates a blog directory with some files:

├── blog | ├── admin.py | ├── apps.py | ├── migrations | ├── models.py | ├── tests.py | ├── views.py | └── __init__.py ├── db.sqlite3 ├── django_project | ├── asgi.py | ├── settings.py | ├── urls.py | ├── wsgi.py | ├── __init__.py | └── __pycache__ └── manage.pyCode language: plaintext (plaintext)

Registering an application

After creating an application, you need to register it to the project especially when the application uses templates and interacts with a database.

The blog app has the apps.py module which contains the BlogConfig class like this:

from django.apps import AppConfig class BlogConfig(AppConfig): default_auto_field = 'django.db.models.BigAutoField' name = 'blog'

To register the blog app, you add the blog.apps.BlogConfig class to the INSTALLED_APPS list in the settings.py of the project:

INSTALLED_APPS = [  # .  'blog.apps.BlogConfig', ] Code language: Python (python)

Alternatively, you can use the app name like blog in the INSTALLED_APPS list like this:

INSTALLED_APPS = [ # . 'blog', ]Code language: PHP (php)

Creating a view

The views.py file in the blog directory comes with the following default code:

from django.shortcuts import render # Create your views here.Code language: Python (python)

A view is a function that takes an HttpRequest object and returns an HttpResponse object.

To create a new view, you import the HttpResponse from the django.http into the views.py file and define a new function that accepts an instance of the HttpRequest class:

from django.shortcuts import render from django.http import HttpResponse def home(request): return HttpResponse('
Blog Home
') Code language: Python (python)

In this example, the home() function returns a new HttpResponse object that contains a piece of HTML code. The HTML code includes an h1 tag.

The home() function accepts an instance of an HttpRequest object and returns an HttpResponse object. It is called a function-based view. Later, you’ll learn how to create class-based views.

To map a URL with the home() function, you create a new file urls.py inside the blog directory and add the following code to the urls.py file:

from django.urls import path from . import views urlpatterns = [ path('', views.home, name='posts'), ] Code language: Python (python)

First, import the path from django.urls module:

from django.urls import pathCode language: Python (python)

Second, import the views.py module from the current directory.

from . import viewsCode language: Python (python)

Note that this is a relative import that imports the views module from the current directory.

Third, define a route that maps the blog URL with the home() function using the path() function.

urlpatterns = [  path('', views.home, name='posts'), ] Code language: Python (python)

The name keyword argument defines the name of the route. Later, you can reference the URL using the posts name instead of using the hard-code URL like blog/ .

By using the name for the path, you can change the URL of the path to something else like my-blog/ in the urls.py instead of changing the hard-coded URL everywhere.

Note that the final argument of the path must be a keyword argument like name=’posts’ . If you use a positional argument like this:

from django.urls import path from . import views  urlpatterns = [  path('', views.home, 'posts'), # Error ]  Code language: Python (python)

you’ll get the following error:

TypeError: kwargs argument must be a dict, but got str.Code language: plaintext (plaintext)

To make the blog’s routes work, you need to include the urls.py of the blog application in the urls.py file of the Django project:

from django.contrib import admin from django.urls import path, include  urlpatterns = [  path('admin/', admin.site.urls),  path('blog/', include('blog.urls')), ] Code language: Python (python)

In the urls.py of the project, we import the include function from the django.urls and map the path of the blog to the blog.urls .

By doing this, when you navigate to http://127.0.0.1:8000/blog/ , Django will run the home() function of the views.py module and returns a webpage that displays a h1 tag.

Before opening the URL, you need to start the Django development web server:

python manage.py runserverCode language: Python (python)

When you navigate to http://127.0.0.1:8000/blog/ , you’ll see a webpage that displays the Blog Home heading.

  • First, the web browser sends an HTTP request to the URL http://127.0.0.1:8000/blog/
  • Second, Django executes the urls.py in the django_project directory. It matches the blog/ with the URL in the urlpatterns list in the urls.py . As a result, it sends » to the urls.py of the blog app.
  • Third, Django runs the urls.py file in the blog application. It matches the » URL with the views.home function and execute it, which returns an HTTP response that outputs a h1 tag.
  • Finally, Django returns a webpage to the web browser.

Adding more routes

First, define the about() function in the views.py of the blog application:

from django.shortcuts import render from django.http import HttpResponse  def home(request):  return HttpResponse('
Blog Home
')  def about(request):  return HttpResponse('
About
') Code language: Python (python)

Second, add a route to the urls.py file:

from django.urls import path from . import views urlpatterns = [ path('', views.home, name='posts'), path('about/', views.about, name='about'), ]Code language: Python (python)

Third, open the URL http://127.0.0.1:8000/blog/about/ , and you’ll see a page that displays the about page.

Now, if you open the home URL, you’ll see a page that displays a page not found with a 404 HTTP status code.

The reason is that the urls.py in the django_project doesn’t have any route that maps the home URL with a view.

To make the blog application the homepage, you can change the route from blog/ to » as follows:

from django.contrib import admin from django.urls import path, include  urlpatterns = [  path('admin/', admin.site.urls),  path('', include('blog.urls')), ] Code language: Python (python)

If you open the URL http://127.0.0.1:8000 , you’ll see the blog home page. And navigating to the URL http://127.0.0.1:8000/about/ will take you to the about page.

Summary

  • A Django project contains one or more applications.
  • A Django application is a group of models, views, templates, and URLs.
  • Use python manage.py startapp app_name command to create a new Django application.
  • Define a function in the views.py file to create a function-based view.
  • Define a route in the urls.py file of the application to map a URL pattern with a view function.
  • Use the include() function to include the urls.py of app in the urls.py of the project.

Источник

Оцените статью
© 2024 Программирование