# Django 6.0.7 documentation

# Paginator

Django tillhandahåller några klasser som hjälper dig att hantera paginerad data - det vill säga data som är uppdelad på flera sidor, med ”Föregående/Nästa”-länkar. Dessa klasser finns i django/core/paginator.py.

För exempel, se Pagination topic guide.

## klassen `Paginator`

class Paginator(object_list, per_page, orphans=0, allow_empty_first_page=True, error_messages=None)

  En paginator fungerar som en sekvens av `Page` när du använder `len()` eller itererar den direkt.

Paginator.object_list

  Krävs. En lista, tupel, `QuerySet` eller annat objekt som kan skäras med en `count()` eller `__len__()` metod. För konsekvent paginering bör `QuerySet` beställas, t.ex. med en `order_by()` klausul eller med en standard `ordering` på modellen.

  Prestandaproblem vid paginering av stora `QuerySet`

  Om du använder en `QuerySet` med ett mycket stort antal objekt kan det gå långsamt att begära höga sidnummer i vissa databaser, eftersom den resulterande `LIMIT`/`OFFSET`-frågan måste räkna antalet `OFFSET`-poster, vilket tar längre tid när sidnumret blir högre.

Paginator.per_page

  Obligatoriskt. Det maximala antalet objekt som ska inkluderas på en sida, exklusive föräldralösa barn (se det valfria argumentet `orphans` nedan).

Paginator.orphans

  Optional. Use this when you don’t want to have a last page with very few items. If the last page would normally have a number of items less than or equal to `orphans`, then those items will be added to the previous page (which becomes the last page) instead of leaving the items on a page by themselves. For example, with 23 items, `per_page=10`, and `orphans=3`, there will be two pages; the first page with 10 items and the second (and last) page with 13 items. `orphans` defaults to zero, which means pages are never combined and the last page may have one item. `orphans` should be less than the `per_page` value.

  Ersatt sedan version 6.0: Support for the `orphans` argument being larger than or equal to the `per_page` argument is deprecated.

Paginator.allow_empty_first_page

  Optional. Whether or not the first page is allowed to be empty. If `False` and `object_list` is empty, then an `EmptyPage` error will be raised.

Paginator.error_messages

  Med argumentet `error_messages` kan du åsidosätta de standardmeddelanden som paginatorn kommer att ge. Skicka in en ordbok med nycklar som matchar de felmeddelanden som du vill åsidosätta. Tillgängliga nycklar för felmeddelanden är: `invalid_page`, `min_page` och `no_results`.

  Här är till exempel standardfelmeddelandet:

      >>> from django.core.paginator import Paginator
      >>> paginator = Paginator([1, 2, 3], 2)
      >>> paginator.page(5)
      Traceback (most recent call last):
        ...
      EmptyPage: That page contains no results

  Och här är ett anpassat felmeddelande:

      >>> paginator = Paginator(
      ...     [1, 2, 3],
      ...     2,
      ...     error_messages={"no_results": "Page does not exist"},
      ... )
      >>> paginator.page(5)
      Traceback (most recent call last):
        ...
      EmptyPage: Page does not exist

### Metoder

Paginator.get_page(number)

  Returnerar ett `Page`-objekt med det angivna 1-baserade indexet och hanterar även sidnummer utanför intervallet och ogiltiga sidnummer.

  Om sidan inte är en siffra returneras den första sidan. Om sidnumret är negativt eller större än antalet sidor, returneras den sista sidan.

  Utlöser ett `EmptyPage`-undantag endast om du anger `Paginator(..., allow_empty_first_page=False)` och `object_list` är tom.

Paginator.page(number)

  Returnerar ett `Page`-objekt med det angivna 1-baserade indexet. Utlöser `PageNotAnInteger` om `number` inte kan konverteras till ett heltal genom att anropa `int()`. Raises `EmptyPage` om det angivna sidnumret inte existerar.

Paginator.get_elided_page_range(number, *, on_each_side=3, on_ends=2)

  Returnerar en 1-baserad lista med sidnummer som liknar `Paginator.page_range`, men kan lägga till en ellips på endera eller båda sidorna av det aktuella sidnumret om `Paginator.num_pages` är stort.

  Antalet sidor som ska inkluderas på varje sida av det aktuella sidnumret bestäms av argumentet `on_each_side`, som har standardvärdet 3.

  Antalet sidor som ska inkluderas i början och slutet av sidintervallet bestäms av argumentet `on_ends`, som har standardvärdet 2.

  Med standardvärdena för `på_varje_sida` och `på_slut` blir till exempel sidintervallet `[1, 2, '...', 7, 8, 9, 10, 11, 12, 13, '...', 49, 50]` om den aktuella sidan är 10 och det finns 50 sidor. Detta resulterar i sidorna 7, 8 och 9 till vänster om och 11, 12 och 13 till höger om den aktuella sidan samt sidorna 1 och 2 i början och 49 och 50 i slutet.

  Utlöser `InvalidPage` om det angivna sidnumret inte existerar.

### Attribut

Paginator.ELLIPSIS

  En översättningsbar sträng som används som ersättning för sidnummer i sidintervallet som returneras av `get_elided_page_range()`. Standard är `...'`.

Paginator.count

  Det totala antalet objekt på alla sidor.

  Observera

  När `Paginator` ska bestämma antalet objekt som finns i `object_list`, kommer `Paginator` först att försöka anropa `object_list.count()`. Om `object_list` inte har någon `count()` metod, så kommer `Paginator` att falla tillbaka till att använda `len(object_list)`. Detta gör att objekt, som `QuerySet`, kan använda en mer effektiv `count()` metod när den finns tillgänglig.

Paginator.num_pages

  Det totala antalet sidor.

Paginator.page_range

  En 1-baserad intervalliterator för sidnummer, som t.ex. ger `[1, 2, 3, 4]`.

## `AsyncPaginator` class

New in Django 6.0.

class AsyncPaginator(object_list, per_page, orphans=0, allow_empty_first_page=True, error_messages=None)

  Asynchronous version of `Paginator`.

  `AsyncPaginator` has the same attributes and signatures as `Paginator`, with the following exceptions:

  - The attribute `Paginator.count` is supported as an asynchronous method `AsyncPaginator.acount()`.

  - The attribute `Paginator.num_pages` is supported as an asynchronous method `AsyncPaginator.anum_pages()`.

  - The attribute `Paginator.page_range` is supported as an asynchronous method `AsyncPaginator.apage_range()`.

  `AsyncPaginator` has asynchronous versions of the same methods as `Paginator`, using an `a` prefix - for example, use `await async_paginator.aget_page(number)` rather than `paginator.get_page(number)`.

## klass `Page`

Du konstruerar vanligtvis inte `Page`-objekt för hand - du får dem genom att iterera `Paginator`, eller genom att använda `Paginator.page()`.

class Page(object_list, number, paginator)

  En sida fungerar som en sekvens av `Page.object_list` när man använder `len()` eller itererar den direkt.

### Metoder

Page.has_next()

  Returnerar `True` om det finns en nästa sida.

Page.has_previous()

  Returnerar `True` om det finns en föregående sida.

Page.has_other_pages()

  Returnerar `True` om det finns en nästa eller föregående sida.

Page.next_page_number()

  Returnerar nästa sidnummer. Utlöser `InvalidPage` om nästa sida inte finns.

Page.previous_page_number()

  Returnerar föregående sidnummer. Utlöser `InvalidPage` om föregående sida inte finns.

Page.start_index()

  Returnerar det 1-baserade indexet för det första objektet på sidan, i förhållande till alla objekt i paginatorns lista. Till exempel:, vid paginering av en lista med 5 objekt med 2 objekt per sida, skulle den andra sidans `start_index()` returnera `3`.

Page.end_index()

  Returnerar det 1-baserade indexet för det sista objektet på sidan, i förhållande till alla objekt i paginatorns lista. Till exempel:, vid paginering av en lista med 5 objekt med 2 objekt per sida, skulle den andra sidans `end_index()` returnera `4`.

### Attribut

Page.object_list

  Listan över objekt på den här sidan.

Page.number

  Det 1-baserade sidnumret för den här sidan.

Page.paginator

  Det associerade `Paginator`-objektet.

## `AsyncPage` class

New in Django 6.0.

class AsyncPage(object_list, number, paginator)

  Asynchronous version of `Page`.

  `AsyncPage` has the same attributes and signatures as `Page`, as well as asynchronous versions of all the same methods, using an `a` prefix - for example, use `await async_page.ahas_next()` rather than `page.has_next()`.

  `AsyncPage` has the following additional method:

  aget_object_list()

    Returns `AsyncPage.object_list` as a list. This method must be awaited before `AsyncPage` can be treated as a sequence of `AsyncPage.object_list`.

## Undantag

exception InvalidPage

  En basklass för undantag som uppstår när en paginator får ett ogiltigt sidnummer.

Metoden `Paginator.page()` ger upphov till ett undantag om den begärda sidan är ogiltig (dvs. inte ett heltal) eller inte innehåller några objekt. I allmänhet räcker det med att fånga undantaget `InvalidPage`, men om du vill ha mer detaljerad information kan du fånga något av följande undantag:

exception PageNotAnInteger

  Uppstår när `page()` ges ett värde som inte är ett heltal.

exception EmptyPage

  Utlöses när `page()` ges ett giltigt värde men inga objekt finns på den sidan.

Båda undantagen är subklasser av `InvalidPage`, så du kan hantera dem båda med `except InvalidPage`.