Additional Data Structures

Hello. Let's discuss a quite useful Python tool: the Collections module. It's like a toolkit of customized containers offering some interesting substitutes for the default ones we typically employ. Consider it as having a Swiss Army knife for coding: every tool in the module has a specific purpose to greatly simplify or speed up certain chores.

This module has your back covered with five different data structures catered to any current work. You have namedtuple(), deque, ChainMap, Counter, OrderedDict, defaultdict, UserDict, User List, User String. Everybody carries unique set of skills and techniques. We'll break these down together, so if you're still finding your footing, relax.

We next will be delving into the first child on the block, namedtuple(). Being a subclass of tuple, this little guy allows you to access items with names rather than only positions. Pretty cool, right? Stay around to learn how this might simplify and clarify your code.

Understanding Namedtuples in Python

Alright, let's start with namedtuples—like ordinary tuples but dressed somewhat more elegantly with names. See them as your standard tuples that underwent an upgrade allowing you to access elements using names rather than numbers. This handy trick wins-all since it makes your code quite readable. Starting with namedtuples requires importing them from the collections module. Right? Easy peasy?

Here is the guide for including them into your project:

from collections import namedtuple

Once you have them imported, you can go right to define a namedtuple by choosing a name for it and choosing what fields it will possess. Say, for example, you wish for a namedtuple with fields including "name" and "age":

Person = namedtuple('Person', 'name age')

You can now create instances of this Person named tuple and get anything you need using the handy dot notation. Have a look at:

p = Person(name='John', age=30)
print(p.name)  # Outputs: John
print(p.age)   # Outputs: 30

Some interesting aspects of namedtuples:

Like usual tuples, namedtuples are established in stone. Once they are produced, then, they cannot be changed.
Since they don't require additional storage for attribute names, they are more memory-savvy than your usual classes or dictionaries.
Namedtuples are loaded with all the typical tuple techniques like indexing, iteration, unpacking, and more; they can be swapped anywhere you would use conventional tuples.

Stay around for the following section in which we will reveal the mysteries of another great feature in the collections module: the deque. Like a supercharged variation of stacks and queues, this one is a wiz at managing operations at both ends of a sequence.

Exploring Deque in Python

Alright, let's discuss something known as a deque—pronounced "deck"—which stands for double-ended queue. Without any effort, this clever tool lets you add or remove items from both the front and rear. For many kinds of data handling tasks, it's quite helpful. Just grab deque from the collections module to begin using.

from collections import deque

Feed an iterable directly straight into the deque() constructor to create a deque. for instance:

d = deque('abc')
print(d)  # Outputs: deque(['a', 'b', 'c'])

Deques are filled with many techniques to aid with element shuffling.

Investigate these:

d.append('d') # Toss 'd' on the right end
d.appendleft('z')  # Plop 'z' on the left end
d.pop()  # Snatch and remove an element from the right end
d.popleft()  # Snatch and remove an element from the left end

Here are some excellent notes about deque:

Deque is a versatile buddy unlike lists and tuples since it makes adding and deleting from both ends simple.
You're all set to create stacks and queues or even track the last N things with a sliding window with deque.
Deque guarantees memory-savvy, thread-safe appending and popping from either end, zipping in O(1) time both directions.

ChainMap in Python

Let us now explore something interesting known as ChainMap. Imagine you wish to consider numerous dictionaries as one large happy family even though you have several. ChainMap accomplishes just that, then. This class ties several dictionaries so you may treat them as one entity. Ideal for when you want to view several mappings in one glance and are juggling many mappings. Allow us to observe it in action.

from collections import ChainMap

# Defining dictionaries
dict1 = {'a': 1, 'b': 2}
dict2 = {'c': 3, 'b': 4}

# Creating a ChainMap
chain_map = ChainMap(dict1, dict2)

print(chain_map)

We created a ChainMap including two dictionaries in the fragment above. Printing it will produce what follows:

ChainMap({'a': 1, 'b': 2}, {'c': 3, 'b': 4})

Observe something neat? Should a key appear in multiple dictionaries, ChainMap chooses the value from the first listed dictionary. In this scenario, then, the number for 'b' will be 2 rather than 4.

Several factors to keep in mind concerning Chain Map:

Though it lets you view many mappings as one, ChainMap functions as a dictionary.
It essentially creates a list form from several dictionaries stitched together.
If you have repeated keys, just the value from the first occurrence stays around.

Counter in Python

Let's start using Python's Counter from the fantastic collections module. See it as a supercharged dictionary ideal for hashable object counting. It rapidly counts how often each element shows up in a container, compiling the data into a dictionary with elements as keys and counts as values. Not sure how it's done? Allow us to investigate this.

from collections import Counter

# Creating a Counter
c = Counter('hello')

print(c)

Here in this little example, we are building a Counter from the text "hello." You will see the following:

Counter({'h': 1, 'e': 1, 'l': 2, 'o': 1})

Along with their counts, counters also provide a handy-dandy approach known as most_common() that allows one to identify the most often occurring items.

Allow us to spin this:

Getting the most common elements
common = c.most_common(2)

print(common)

These interesting facts regarding Counter:

Working much as hashtable objects, Counter maintains its data in an unordered collection. With their counts as values, the elements occupy the role of keys.
You turn to it first when counting objects from an iterable list.
Recall, the Counter doesn't care about any specific arrangement, much as dictionary keys do.

OrderedDict in Python

Alright, let us discuss OrderedDict, a neat subclass included into Python's collections package. Which makes it unique? Unlike your usual dictionary, an OrderedDict notes the sequence of your additions. Conversely, regular dictionaries ignore order and spit out objects in any which way as you iterate over them. Let us so learn how to create an ordered dictionary.

from collections import OrderedDict

# Creating an OrderedDict
od = OrderedDict()

# Adding elements
od['a'] = 1
od['b'] = 2
od['c'] = 3

print(od)

Here we have created an OrderedDict and popped some items into it. You will receive this type of output here:

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

See how your elements' sequence matches exactly what you added? OrderedDict has beauty in that sense!

Some information on OrderedDict should help you:

It preserves key order as you add them. You get what you get—which may be any order—with a standard dict.
An updated existing entry remains in its original location.
Pull anything out then put it back; it will slide down to the end.

DefaultDict in Python

Let us discuss DefaultDict, a variant on a standard dictionary. DefaultDict only calls a manufacturing function to offer a default value instead of freking out with a KeyError when you try to access a key that isn't there. It gets your back by automatically generating the key based on the type you specified for the defaultdict setup. About ready to see it in use? As follows:

from collections import defaultdict

# Creating a defaultdict
dd = defaultdict(int)

# Accessing a non-existent key
print(dd['non_existent_key'])

Here we created a defaultdict with int as the default factory function. Therefore, a key that isn't there won't blow up with an error when we check it. Rather, it yields 0 as the default value for an integer. Interesting, right? 0 will be the output.

Following are some salient features of defaultdict:

Though it keeps those annoying KeyErrors, DefaultDict is essentially a standard dictionary.
It generates a default value automatically when you search on a key that does not exist.
To do the same task, DefaultDict is faster than dict.set_default.

UserDict, UserList, and UserString in Python

You'll find buried within Python's handy collections package UserDict, UserList, and UserString. If you wish to construct your own subclasses and modify or improve how these objects operate, these classes provide a wonderful beginning point since they surround dictionary, list, and string objects. Inquiring about their methods? Let's review building a UserDict and play about with it.

from collections import UserDict

# Creating a UserDict
ud = UserDict()

# Adding elements
ud['a'] = 1
ud['b'] = 2

print(ud)

Here we are establishing a UserDict and including a few items. Print it off and you will find the following:

{'a': 1, 'b': 2}

You can thus create UserList and UserString objects and apply all your typical list and string magic on them.

Following are some salient features of UserDict, UserList, and UserString:

Among the more flexible built-in types are UserDict, UserList, and UserString.
They're ideal for creating your own subclasses to alter or increase the behavior of strings, lists, or dictionaries.
Every serves as a useful wrapper around its corresponding dictionary, list, or string object.

Real-world Applications of Collections Module

Python's collections module is like a secret treasure chest full with instruments to greatly increase the readability and efficiency of your code.

The collections module has several practical uses as follows:

1. Data Analysis: Especially for counting all the occurrences of every element, the Counter class is your friend in data analysis. Consider it tally of the times every word appears on paper.

2. Maintaining Order: Has to be able to regulate things. The OrderedDict class records your addition of objects in order. For algorithms in which following the original sequence counts, it's a lifeline.

3. Caching Mechanisms: Thanks to its super-efficient method of adding and removing objects from both ends, the deque class is ideal for constructing caching systems—including the Least Recently Used (LRU) cache.

4. Default Values: When you need a dictionary to offer absent keys a default value. It is quite useful in graph algorithms where you might first set all distances to infinite.

5. Bundling Data: Consider named tuples if you wish to methodically arrange relevant data. For situations like closely packed 2D point preservation of coordinates, it's great.

Previous Next

GyataAI