llist module in Python

Introduction

The list data type that comes with Python is very flexible and useful in a wide range of situations. These lists, however, can become resource-intensive when working with enormous datasets, greatly slowing down programmes. The Python llist module can be used in this situation. Linked list data structures are provided for Python by the llist module, a third-party extension that offers greater efficiency for particular use-cases. This post will examine this useful module, explain its components, and demonstrate how to use it using real-world applications.

Understanding llist Module

Prior to exploring the llist module, it's critical to comprehend what a linked list is. Each data piece in a linked list points to the one after it, making the list linear. It is a data structure made up of nodes that collectively stand for a series. This structure makes insertions and deletions efficient.

Use the pip installer command to set up the llist module:

pip install llist

Single-linked lists and doubly-linked lists are the two forms of linked lists that are available in the llist module. Let's examine each of these and learn how to use them.

Sllist - Singly Linked List

Each node in a single linked list, as the name says, points to the node after it in the list. Let's build a single linked list and execute the following commands:

from llist import sllist

# Create a singly linked list
sll = sllist()

# Add elements
sll.append('Python')
sll.append('Java')
sll.append('JavaScript')

print(sll) # sllist(['Python', 'Java', 'JavaScript'])

In this example, we've made a singly linked list and used the append method to add three members.

Use the remove function to remove a member from a singly linked list:

sll.remove(sll.nodeat(1))  # removes 'Java'
print(sll)  # sllist(['Python', 'JavaScript'])

Dllist - Doubly Linked List

Each node in a doubly linked list is aware of both of its neighbours' locations. Let's construct a doubly linked list and include the following items:

from llist import dllist

# Create a doubly linked list
dll = dllist()

# Add elements
dll.append('C')
dll.append('C++')
dll.append('C#')

print(dll)  # dllist(['C', 'C++', 'C#'])

We can eliminate items from a doubly linked list in a manner similar to the single linked list:

dll.remove(dll.nodeat(2))  # removes 'C#'
print(dll)  # dllist(['C', 'C++'])

Comparison: Python List vs llist

The llist data structure and the common Python list function roughly equally when dealing with tiny data. The llist data structure, however, excels at handling a lot of data.

How long does it take to insert an element in the middle of a long list or a long llist?

import time
from llist import sllist

# Python list
py_list = [i for i in range(1000000)]

start = time.time()
py_list.insert(len(py_list)//2, 'middle')
end = time.time()

print('Python list insert time:', end - start)


# llist
ll = sllist(range(1000000))

start = time.time()
ll.insertbefore('middle', ll.nodeat(len(ll)//2))
end = time.time()

print('llist insert time:', end - start)

Running the code will show you that inserting an element into the centre of the list takes much less time than doing so for a typical Python list. llist is a great option for managing huge amounts of data because this time difference becomes more noticeable as the data size grows.

Conclusion

The llist module in Python is an effective tool for managing and manipulating vast amounts of data quickly and effectively. It offers practical ways to optimise your code thanks to its excellent performance with huge data, making it a valuable addition to your Python toolset. It's important to know when to employ more effective data structures, such as those offered by the llist module, even though the built-in Python list will still be appropriate in many circumstances.