How To Do Pagination In Python

In this article, we’ll walk you through the steps of setting up pagination in Python. We’ll explain each step clearly and straightforwardly. To help you understand the idea of pagination in Python, we’ll show you how to create a pagination system using the Tkinter library. We’ll start by explaining the key syntax used in Python for pagination. After that, we’ll go into the actual process of setting up pagination, breaking down each step to make it easier for you to grasp the concept.

What is Pagination?

Pagination is a technique used in computing and web development to divide a large set of data into smaller, more manageable segments called pages. This is particularly common in the context of displaying data in user interfaces, such as web pages, where showing all data at once might be impractical or overwhelming.

Required Packages

pip install ttkthemes
pip install tk

How To Do Pagination In Python?

Below, we will explain Python Pagination with its syntax and provide two examples in Python. The first example demonstrates the practical implementation of pagination, while the second one illustrates how to implement pagination in a web application.

Syntax :

Python3

def paginate(items, page_size, page_number):
    start_index = (page_number - 1) * page_size
    end_index = start_index + page_size
    return items[start_index:end_index]

Example 1: Practical Implementation of Pagination

In this example, in the below code Python function, `paginate`, takes a list of items, a page size, and a page number as input and returns the subset of items corresponding to the specified page. In the example usage, a list of numbers from 1 to 100 is created, and the function is used to retrieve and print the items for the first page (page number 1) with a page size of 10 and result displays the content of the first page, showcasing the simplicity of the pagination functionality.

Python3

def paginate(items, page_size, page_number):
    start_index = (page_number - 1) * page_size
    end_index = start_index + page_size
    return items[start_index:end_index]

# Example usage
# Example: a list of numbers from 1 to 100
all_items = list(range(1, 101))

page_size = 10  # Number of items per page
page_number = 1  # Page number to retrieve

current_page = paginate(all_items, page_size, page_number)
print(f"Page {page_number}: {current_page}")

Output :

Page 1: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Example 2: Implement Pagination in Web Application

In this example Python script utilizes the Tkinter library to create a simple pagination application with themed styling. The app displays a Treeview widget and allows navigation between pages using “Previous” and “Next” buttons. It includes a dynamic number of pagination buttons, and each button corresponds to a page of items. The script defines a PaginationApp class, showcasing the implementation of page navigation and updating the Treeview accordingly. The example usage at the end demonstrates creating an instance of the app with a list of numbers and a specified page size.

Pagination in Python:

• The pagination method used in this code involves dividing a list of items into smaller pages based on a specified page size.
• The update_treeview method calculates the start and end indices for the current page, retrieves the corresponding items, and updates the Treeview.
• The “Previous” and “Next” buttons adjust the current page, ensuring it stays within the valid range, and trigger the Treeview update.

In essence, this method provides a clear and user-friendly way to navigate through a dataset or list of items, displaying a manageable subset at a time.

Python3

import tkinter as tk
from tkinter import ttk
from ttkthemes import ThemedStyle

class PaginationApp:
    def __init__(self, master, items, page_size):
        self.master = master
        self.master.title("Pagination Example")

        self.items = items
        self.page_size = page_size
        self.current_page = 1

        style = ThemedStyle(self.master)
        style.set_theme("plastik")  # You can choose other available themes

        self.label = ttk.Label(master, text="Pagination Example", font=('Helvetica', 16, 'bold'))
        self.label.pack(pady=10)

        self.treeview = ttk.Treeview(master, columns=("Number",),
                                     show="headings", style="Treeview")
        self.treeview.heading("Number", text="Number")
        self.treeview.pack()

        self.page_buttons = []
        self.update_treeview()
        self.create_pagination_buttons()

        self.prev_button = ttk.Button(master, text="Previous", command=self.prev_page)
        self.prev_button.pack(side=tk.LEFT, padx=10)

        self.next_button = ttk.Button(master, text="Next", command=self.next_page)
        self.next_button.pack(side=tk.RIGHT, padx=10)

    def update_treeview(self):
        # Clear existing items
        self.treeview.delete(*self.treeview.get_children())

        # Get items for the current page
        start_index = (self.current_page - 1) * self.page_size
        end_index = start_index + self.page_size
        current_page_items = self.items[start_index:end_index]

        # Insert items into the treeview
        for number in current_page_items:
            self.treeview.insert("", "end", values=(number,))

    def create_pagination_buttons(self):
        max_pages = -(-len(self.items) // self.page_size)  # Ceiling division

        for page_number in range(1, max_pages + 1):
            button = ttk.Button(self.master, text=str(page_number),
                         command=lambda num=page_number: self.goto_page(num))
            button.pack(side=tk.LEFT, padx=5)
            self.page_buttons.append(button)

        self.highlight_current_page()

    def goto_page(self, page_number):
        self.current_page = page_number
        self.update_treeview()
        self.highlight_current_page()

    def highlight_current_page(self):
        for button in self.page_buttons:
            button.state(['!pressed'])
        self.page_buttons[self.current_page - 1].state(['pressed'])

    def prev_page(self):
        if self.current_page > 1:
            self.current_page -= 1
            self.update_treeview()
            self.highlight_current_page()

    def next_page(self):
         # Ceiling division
        if self.current_page < max_pages:
        max_pages = -(-len(self.items) // self.page_size)
            self.current_page += 1
            self.update_treeview()
            self.highlight_current_page()

# Example usage
root = tk.Tk()

# Create a list of numbers from 1 to 100
all_numbers = list(range(1, 101))

# Set the number of items per page
page_size = 10
app = PaginationApp(root, all_numbers, page_size)

root.mainloop()

Output:

Conclusion

Implementing Pagination in Python is a valuable skill, especially when dealing with large datasets or creating user-friendly interfaces. By understanding the main syntax and following the step-by-step guide provided in this article, you can easily incorporate pagination into your Python projects. Whether you’re working with lists, databases, or web applications, the principles of pagination remain consistent and adaptable to various scenarios.