Django Paginator simplified

Let's break down the concepts using simplified pseudocode to illustrate the basic structure of a paginator and its usage:

# Simplified Pseudocode for Paginator Class

class Paginator:
    def __init__(self, queryset, items_per_page):
        self.queryset = queryset
        self.items_per_page = items_per_page
        self.total_items = len(queryset)
        self.num_pages = (self.total_items + items_per_page - 1) // items_per_page

    def page(self, page_number):
        start_index = (page_number - 1) * self.items_per_page
        end_index = start_index + self.items_per_page
        page_items = self.queryset[start_index:end_index]
        return Page(page_items, page_number, self)

class Page:
    def __init__(self, object_list, number, paginator):
        self.object_list = object_list
        self.number = number
        self.paginator = paginator

    def has_previous(self):
        return self.number > 1

    def has_next(self):
        return self.number < self.paginator.num_pages

    def previous_page_number(self):
        return self.number - 1 if self.has_previous() else None

    def next_page_number(self):
        return self.number + 1 if self.has_next() else None

Explanation:

• Paginator is a class that has an __init__ method to initialize its instance variables (queryset, items_per_page, total_items, and num_pages).

• The page method of the Paginator class returns a Page object, passing the relevant information to create the page.

• Page is another class representing a specific page of the paginated data. It has attributes (object_list, number, and paginator) and methods (has_previous, has_next, previous_page_number, and next_page_number).

Now, let's see how you would use these classes:

# Usage Example

# Creating an instance of the Paginator class
paginator = Paginator(my_queryset, 10)

# Getting the first page
page_one = paginator.page(1)

# Accessing attributes of the Page object
objects_on_page_one = page_one.object_list
current_page_number = page_one.number
paginator_reference = page_one.paginator

# Using methods of the Page object
has_previous_page = page_one.has_previous()
has_next_page = page_one.has_next()
previous_page_number = page_one.previous_page_number()
next_page_number = page_one.next_page_number()

In this example:

• paginator is an instance of the Paginator class.

• page_one is an instance of the Page class returned by the paginator.page(1) method.

• objects_on_page_one, current_page_number, and paginator_reference are attributes of the Page instance.

• has_previous_page, has_next_page, previous_page_number, and next_page_number are methods of the Page instance.

The calculation part of pagination can sometimes be a bit tricky. Let's break down the key calculations in the simplified pseudocode:

# In the Paginator class __init__ method
def __init__(self, queryset, items_per_page):
    self.queryset = queryset
    self.items_per_page = items_per_page
    self.total_items = len(queryset)
    self.num_pages = (self.total_items + items_per_page - 1) // items_per_page

• self.total_items: This is the total number of items in your original queryset.

• self.num_pages: This is the total number of pages needed to display all the items with the specified number of items per page. The calculation (self.total_items + items_per_page - 1) // items_per_page ensures that if there are any remaining items, an extra page is added. This uses integer division (//), which discards the remainder.

# In the Paginator class page method
def page(self, page_number):
    start_index = (page_number - 1) * self.items_per_page
    end_index = start_index + self.items_per_page
    page_items = self.queryset[start_index:end_index]
    return Page(page_items, page_number, self)

• start_index: This is the index of the first item on the current page in the original queryset. It's calculated by (page_number - 1) * self.items_per_page. For example, on the first page (page_number=1), start_index would be 0.

• end_index: This is the index of the item immediately after the last item on the current page in the original queryset. It's calculated by adding self.items_per_page to start_index. This effectively gives you a slice of the original queryset corresponding to the current page.

• page_items: This is the actual list of items for the current page, obtained by slicing the original queryset using the calculated start_index and end_index.