Introduction
Python's collections module is a treasure trove of specialized container datatypes that provide alternatives to the built-in containers like dict, list, set, and tuple. In this blog post, we'll explore some of the powerful tools offered by the collections module and how they can enhance your Python programming experience.
Namedtuples: Adding Meaning to Tuples
Namedtuples are a lightweight and readable alternative to regular tuples. They assign names to each position, making the code more self-documenting.
Example:
from collections import namedtuple
# create a namedtuple with its class name as string and its fields as string
# fields have to be separated by comma or space in the given string
Point = namedtuple('Point','x, y')
pt = Point(1, -4)
print(pt)
print(pt._fields)
print(type(pt))
print(pt.x, pt.y)
Person = namedtuple('Person','name, age')
friend = Person(name='Tom', age=25)
print(friend.name, friend.age)
Counter: Counting Elements with Ease
The Counter class is a handy tool for counting elements in a container. It stores elements as dictionary keys and their counts as dictionary values.
Example:
from collections import Counter
a = "aaaaabbbbcccdde"
my_counter = Counter(a)
print(my_counter)
print(my_counter.items())
print(my_counter.keys())
print(my_counter.values())
my_list = [0, 1, 0, 1, 2, 1, 1, 3, 2, 3, 2, 4]
my_counter = Counter(my_list)
print(my_counter)
# most common items
print(my_counter.most_common(1))
# Return an iterator over elements repeating each as many times as its count.
# Elements are returned in arbitrary order.
print(list(my_counter.elements()))
OrderedDict: Remembering Insertion Order
OrderedDicts are dictionaries that remember the order in which items were inserted. They are particularly useful when the order of elements matters.
Example:
from collections import OrderedDict
ordinary_dict = {}
ordinary_dict['a'] = 1
ordinary_dict['b'] = 2
ordinary_dict['c'] = 3
ordinary_dict['d'] = 4
ordinary_dict['e'] = 5
# this may be in orbitrary order prior to Python 3.7
print(ordinary_dict)
ordered_dict = OrderedDict()
ordered_dict['a'] = 1
ordered_dict['b'] = 2
ordered_dict['c'] = 3
ordered_dict['d'] = 4
ordered_dict['e'] = 5
print(ordered_dict)
# same functionality as with ordinary dict, but always ordered
for k, v in ordinary_dict.items():
print(k, v)
defaultdict: Handling Missing Keys Gracefully
The defaultdict is a convenient extension of the dict class, providing default values for keys that have not been set yet.
Example:
from collections import defaultdict
# initialize with a default integer value, i.e 0
d = defaultdict(int)
d['yellow'] = 1
d['blue'] = 2
print(d.items())
print(d['green'])
# initialize with a default list value, i.e an empty list
d = defaultdict(list)
s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 5)]
for k, v in s:
d[k].append(v)
print(d.items())
print(d['green'])
deque: The Double-Ended Queue
The deque class, short for double-ended queue, allows efficient appends and pops from both ends, making it a versatile choice for various scenarios.
Example:
from collections import deque
d = deque()
# append() : add elements to the right end
d.append('a')
d.append('b')
print(d)
# appendleft() : add elements to the left end
d.appendleft('c')
print(d)
# pop() : return and remove elements from the right
print(d.pop())
print(d)
# popleft() : return and remove elements from the left
print(d.popleft())
print(d)
# clear() : remove all elements
d.clear()
print(d)
d = deque(['a', 'b', 'c', 'd'])
# extend at right or left side
d.extend(['e', 'f', 'g'])
d.extendleft(['h', 'i', 'j']) # note that 'j' is now at the left most position
print(d)
# count(x) : returns the number of found elements
print(d.count('h'))
# rotate 1 positions to the right
d.rotate(1)
print(d)
# rotate 2 positions to the left
d.rotate(-2)
print(d)
Conclusion
The collections module in Python offers a rich set of tools for handling various data structures efficiently. Whether you're counting elements, ensuring order, or handling default values, the collections module has you covered.
Explore these tools, experiment with their features, and elevate your Python programming to new heights with the capabilities provided by the collections module.