Multiple object mixins
Django Docs · نسخهٔ 33d2e5948a0b · BSD-3-Clause
======================
Multiple object mixins
`MultipleObjectMixin`
A mixin that can be used to display a list of objects.
If `paginate_by` is specified, Django will paginate the results returned by this. You can specify the page number in the URL in one of two ways:
- Use the `
page` parameter in the URLconf. For example, this is what
your URLconf might look like::
path("objects/page<int:page>/", PaginatedView.as_view()),
- Pass the page number via the `
page` query-string parameter. For
example, a URL would look like this:
/objects/?page=3
These values and lists are 1-based, not 0-based, so the first page would be
represented as page ``1``.
For more on pagination, read the :doc:`pagination documentation
</topics/pagination>`.
As a special case, you are also permitted to use ``last`` as a value for
``page``:
.. code-block:: text
/objects/?page=last
This allows you to access the final page of results without first having to
determine how many pages there are.
Note that ``page`` *must* be either a valid page number or the value
``last``; any other value for ``page`` will result in a 404 error.
**Extends**
* :class:`django.views.generic.base.ContextMixin`
**Methods and Attributes**
.. attribute:: allow_empty
A boolean specifying whether to display the page if no objects are
available. If this is ``False`` and no objects are available, the view
will raise a 404 instead of displaying an empty page. By default, this
is ``True``.
.. attribute:: model
The model that this view will display data for. Specifying ``model
= Foo`` is effectively the same as specifying ``queryset =
Foo.objects.all()``, where ``objects`` stands for ``Foo``’s
.. attribute:: queryset
A ``QuerySet`` that represents the objects. If provided, the value of
``queryset`` supersedes the value provided for :attr:`model`.
.. warning::
``queryset`` is a class attribute with a *mutable* value so care
must be taken when using it directly. Before using it, either call
its :meth:`~django.db.models.query.QuerySet.all` method or
retrieve it with :meth:`get_queryset` which takes care of the
cloning behind the scenes.
.. attribute:: ordering
A string or list of strings specifying the ordering to apply to the ``queryset``.
Valid values are the same as those for :meth:`~django.db.models.query.QuerySet.order_by`.
.. attribute:: paginate_by
An integer specifying how many objects should be displayed per page. If
this is given, the view will paginate objects with
``paginate_by`` objects per page. The view will
expect either a ``page`` query string parameter (via ``request.GET``)
or a ``page`` variable specified in the URLconf.
.. attribute:: paginate_orphans
An integer specifying the number of "overflow" objects the last page
can contain. This extends the :attr:`paginate_by` limit on the last
page by up to ``paginate_orphans``, in order to keep the last page from
having a very small number of objects.
.. attribute:: page_kwarg
A string specifying the name to use for the page parameter.
The view will expect this parameter to be available either as a query
string parameter (via ``request.GET``) or as a kwarg variable specified
in the URLconf. Defaults to ``page``.
.. attribute:: paginator_class
The paginator class to be used for pagination. By default,
class doesn't have the same constructor interface as
provide an implementation for :meth:`get_paginator`.
.. attribute:: context_object_name
Designates the name of the variable to use in the context.
.. method:: get_queryset()
Get the list of items for this view. This must be an iterable and may
be a queryset (in which queryset-specific behavior will be enabled).
.. method:: get_ordering()
Returns a string (or iterable of strings) that defines the ordering that
will be applied to the ``queryset``.
Returns :attr:`ordering` by default.
.. method:: paginate_queryset(queryset, page_size)
Returns a 4-tuple containing (``paginator``, ``page``, ``object_list``,
``is_paginated``).
Constructed by paginating ``queryset`` into pages of size ``page_size``.
If the request contains a ``page`` argument, either as a captured URL
argument or as a GET argument, ``object_list`` will correspond to the
objects from that page.
.. method:: get_paginate_by(queryset)
Returns the number of items to paginate by, or ``None`` for no
pagination. By default this returns the value of :attr:`paginate_by`.
.. method:: get_paginator(queryset, per_page, orphans=0, allow_empty_first_page=True)
Returns an instance of the paginator to use for this view. By default,
instantiates an instance of :attr:`paginator_class`.
.. method:: get_paginate_orphans()
An integer specifying the number of "overflow" objects the last page
can contain. By default this returns the value of
.. method:: get_allow_empty()
Return a boolean specifying whether to display the page if no objects
are available. If this method returns ``False`` and no objects are
available, the view will raise a 404 instead of displaying an empty
page. By default, this is ``True``.
.. method:: get_context_object_name(object_list)
Return the context variable name that will be used to contain
the list of data that this view is manipulating. If
``object_list`` is a queryset of Django objects and
the context name will be the ``model_name`` of the model that
the queryset is composed from, with postfix ``'_list'``
appended. For example, the model ``Article`` would have a
context object named ``article_list``.
.. method:: get_context_data(**kwargs)
Returns context data for displaying the list of objects.
**Context**
* ``object_list``: The list of objects that this view is displaying. If
``context_object_name`` is specified, that variable will also be set
in the context, with the same value as ``object_list``.
* ``is_paginated``: A boolean representing whether the results are
paginated. Specifically, this is set to ``False`` if no page size has
been specified, or if the available objects do not span multiple
pages.
* ``paginator``: An instance of
paginated, this context variable will be ``None``.
* ``page_obj``: An instance of
this context variable will be ``None``.`MultipleObjectTemplateResponseMixin`
A mixin class that performs template-based response rendering for views that operate upon a list of object instances. Requires that the view it is mixed with provides `self.object_list, the list of object instances that the view is operating on. self.object_list may be, but is not required to be, a ~django.db.models.query.QuerySet`.
Extends
~django.views.generic.base.TemplateResponseMixin
Methods and Attributes
The suffix to append to the auto-generated candidate template name. Default suffix is `_list`.
Returns a list of candidate template names. Returns the following list:
- the value of `
template_name` on the view (if provided) - `
<app_label>/<model_name><template_name_suffix>.html`