Whether you‘re new to Python or have some experience, learning about data structures is key to leveling up your skills. The right data structures make your code more efficient, reusable and maintainable.
I‘m going to walk you through the 10 most essential in Python with actionable examples so you can quickly apply these concepts. Soon you‘ll be modeling real-world data and topics confidently.
Let‘s get started!
A Quick Summary of the Data Structures We‘ll Cover
Before jumping in, here‘s a high-level overview so you know what‘s coming:
- Linear data structures like arrays, lists, stacks and queues
- Associative arrays with key-value pairs like dictionaries and sets
- Graphs and trees for modeling connections and hierarchies
- Specialized structures like heaps, deques and named tuples
With foundational knowledge of these core structures, you‘ll be able to build complex systems and ace interviews!
Now let‘s unpack each one…
Dynamic Arrays with Python Lists
Ever struggled with pre-allocating fixed sized arrays? Python lists spare you the headache so you can focus on your program‘s logic.
Lists let you add, insert and remove elements efficiently with a simple syntax:
>>> nums = [5, 4, 3, 1]
>>> nums.insert(2, 100)
>>> nums
[5, 4, 100, 3, 1]You can combine lists with loops and other logic effortlessly. Much more flexible than arrays in other languages!
My top tip: Sort long lists faster with .sort() and reverse with .reverse(). No need to write your own sorting algorithms.
Example uses: Stacks, queues, matrix rows/columns, shuffled card decks
| Operation | Time Complexity |
|---|---|
| Indexing | O(1) |
| Append | O(1) |
| Insert/Delete by Index | O(n) |
Clearly, lists shine for speedy simple inserts and lookups.
Onto our next structure…
Memory Optimized Arrays
For pure number crunching and matrix operations, regular Python lists can consume excessive memory.
That‘s where the built-in array.array comes to the rescue for massive numeric data.
from array import array
matrix = array(‘f‘, [
[1.5, 3.2],
[4.7, 7.8]
])By storing primitives directly instead of objects, array.array uses way less memory with the same syntax.
Plus no worries about mixed data types – everything is kept uniform for doing math.
Pro Tip: Slice multi-dimensional arrays using list comprehension:
row_1 = matrix[0] # [1.5, 3.2]
col_2 = [sub[1] for sub in matrix] # [3.2, 7.8]Examples: Math/science matrices, image buffers, financial analysis, game grids
| Operation | Time Complexity |
|---|---|
| Indexing | O(1) |
| Insertion/Deletion by Index | O(n) |
So if you need speed and memory efficiency for numerical data, check out array.arrays…
Now we‘ll compare some critical tradeoffs to lists:
Immutable Sequences Using Tuples
Similar to lists, tuples allow you to sequence data types together. But they cannot be modified after creation:
colors = (‘red‘, ‘blue‘, ‘green‘)
colors[0] = ‘yellow‘ # TypeError! Tuples are immutable Use tuples when:
- Data should not be changed
- Data is static and accessed frequently
- Temporary grouping of values is needed
Use lists when:
- Adding and removing items dynamically
- Order and contents may change
- Holding data for later processing
So why tuples over lists? Immutability.
Tuples provide assurances your data won‘t change unexpectedly for critical segments of code. This prevents subtle bugs and unintended consequences!
You‘ll see tuples used to protect all sorts of shared data – from game configurations to sensor readings.
Give tuples a try for safer, simpler data handling next time processing gets complex!
Moving on to key-value data next…
Blazing Fast Dictionaries with Key-Value Storage
Dictionaries associate keys with values just like in the real world:
user = {
‘name‘: ‘John‘,
‘age‘: 20
}
print(user[‘name‘]) # Simple!This structure is known as a hash map or associative array in other languages.
Let me explain why they‘re so fast…
Behind the scenes, the key is translated into an array index via a hash function.
This allows dictionaries to insert and lookup elements without linearly scanning through all items!
Time Complexities:
- Lookup by Key – O(1) average
- Insert Key-Value – O(1) average
- Iterate All Keys – O(n)
The tradeoff is keys must be immutable and hashable to work properly. Lists and dicts won‘t function as keys for example.
However, tuples work great as keys since they never change.
Your programs will benefit from swift dictionaries so use them for consolidating related properties without sorting!
Let‘s explore sets next…
Unique Collections Using Python Sets
When working with lists in Python, removing duplicates can get messy:
colors = [‘red‘, ‘blue‘, ‘red‘, ‘green‘, ‘blue‘]
unique_colors = []
for color in colors:
if color not in unique_colors:
unique_colors.append(color)
print(unique_colors) # [‘red‘, ‘blue‘, ‘green‘] Sets provide a cleaner built-in way to eliminate duplicates and test membership:
colors = {‘red‘, ‘blue‘, ‘red‘, ‘green‘, ‘blue‘}
print(colors) # {‘red‘, ‘blue‘, ‘green‘} The main reasons to use sets over lists:
- Removal of duplicate elements
- Faster membership testing
- Mathematical operations like unions and intersections
Example use cases:
- Removing duplicate entries
- Blazing fast membership checks (O(1) avg)
- Text analysis – Unique words in a document
Make use of sets next time you need uniqueness without order!
Now let‘s shift gears to modeling behavior and connections…
Stacks for Reversing Order
Stack data structures operate in last in, first out order (LIFO):
books = []
books.append(‘Steve Jobs‘)
books.append(‘Bill Gates‘)
print(books.pop()) # ‘Bill Gates‘ came in last so leaves first!As one would expect, new items are put on top of the stack and removed from the top as well.
This ordering makes stacks perfect for use cases like:
- Undo/redo functionality in editors
- Processing elements in reverse order
- Reversing strings with ease!
Give stacks a try when you need reverse ordering behavior next time!
Onto the opposite ordering structure – queues…
Queues for First-In First-Out Ordering
While stacks mimic vertical piles, queues act more like horizontal waiting lines:
orders = []
orders.append(‘pizza‘)
orders.append(‘salad‘)
print(orders.pop(0))
# ‘pizza‘ was 1st in line so served 1st! Elements are added to the back of the queue and removed from the front – aka first-in first-out ordering (FIFO)!
Common queue use cases:
- Print job handling
- Server request processing
Queues simulate real-world behavior elegantly. Use them for ordered upfront scheduling logic flows next time!
Now let‘s discuss a tree-based structure – heaps…
Heaps for Accessing Extreme Values Quickly
Heaps are specialized tree structures optimizing access to largest and smallest elements.
Here‘s how to efficiently find the minimum with heapq:
import heapq
nums = [5, 7, 3, 9]
heapq.heapify(nums)
print(nums[0]) # 3
heapq.heappush(nums, 2)
print(nums[0]) # 2By default heapq implements min-heaps where parent nodes are smaller than children. This allows instantly grabbing the minimum element at nums[0].
Max-heaps work similarly by inverting signs or comparing magnitudes.
Top use cases:
- Priority queues
- Graph algorithms
- Fast min/max value access
Overall heaps are vital for quick extreme value access so be sure to remember them!
Deques for Ultimate Queue Flexibility
Earlier we used simple lists to demonstrate basic queue behavior. But Python‘s deque data structure supercharges queues with lightning fast appends and pops from both ends:
from collections import deque
tasks = deque()
tasks.append(‘A‘)
tasks.appendleft(‘B‘) # Left side allows fast prepends!
print(tasks) # deque([‘B‘, ‘A‘]) The deque (double ended queue) enables efficient ops not possible with regular Python lists:
- Adding/removing from both ends
- Capping at a maximum length
- Rotating elements
These features make deques perfect for:
- Complex job pipelines
- Circular buffers
- Browser history
So if you need ultimate queue flexibility and performance, check out Python‘s deque!
Named Tuples for Higher Readability
Tuples allow you to store related data together – but have a major readability downside. Elements are accessed solely by index instead of descriptive names!
student = (‘John‘, 20, ‘Computer Science‘)
print(student[0]) # Hard to remember indices!Named tuples add meaning to each value:
from collections import namedtuple
Student = namedtuple(‘Student‘, [‘name‘,‘age‘,‘major‘])
s1 = Student(‘John‘, 20, ‘Computer Science‘)
print(s1.name) # Clean!Now you can query code almost like an object. This keeps data meaning intact throughout pipelines – huge for readability.
So if you need clarity along with tuples, be sure to reach for named tuples!
Let‘s shift from data sequencing to modeling connections…
Graphs and Trees for Modeling Hierarchies
Many domains like social networks, transportation, biology necessitate representing complex relationship graphs.
Python provides endless flexibility for building custom graph classes – but often the built-in dictionary works great:
network = {
‘Alice‘: [‘Bob‘, ‘Claire‘],
‘Bob‘: [‘Alice‘, ‘Derek‘, ‘Emily‘],
‘Claire‘: [‘Alice‘],
‘Derek‘: []
} Then easily traverse connections with a search:
def search(name):
if name in network:
print(f‘{name} found!‘)
return network[name]
return None
print(search(‘Emily‘)) # Emily found! [‘Bob‘]This makes it a cinch to model all kinds of networks.
Trees are even simpler graphs for parent-child hierarchies. Built-in types like JSON handle family trees, org structures and more out-of-the-box!
I encourage you to explore graphs for capturing nuanced connections in upcoming projects.
Last but not least, let‘s talk priority…
Priority Queues for Processing High Priority Elements First
Regular queues operate purely in insertion order. Priority queues let you jump ahead in line based on importance rules.
Implement priority logic easily with heapq:
import heapq
tasks = []
heapq.heappush(tasks, (1, ‘Important‘))
heapq.heappush(tasks, (3, ‘Blue‘))
heapq.heappush(tasks, (2, ‘Green‘))
print(heapq.heappop(tasks))
# (1, ‘Important‘) - Highest priority processed first!This allows elegantly modeling critical real-world systems like emergency departments and customer service.
Don‘t let urgent items get stuck behind trivial work again – make use of priority queues next time!
Let‘s Apply These Core Data Structures
We‘ve covered a ton of ground learning these 10 essential Python data structures. Each solves specific problems efficiently so keep them in mind rather than defaulting to dictionaries, tuples and lists every time!
Here are some ideas help solidify these concepts:
- Build a phone call routing program with queues
- Implement topology sort logic using stacks
- Model product categories in an ecommerce store with trees
- Create a car race simulation using priority queues
- Use graphs to analyze vulnerability in a computer network
Diving deeper into use cases accelerates mastery.
You now have a solid foundation – go leverage it on meaningful projects! Knowledge coupled with experience will grow your capabilities faster than pure theory.
I‘m excited to see what you build next after adding these useful structures to your toolkit! Let me know if you have any other questions.
