Python Data Structures

Lists, Tuples, Sets, Dictionaries

Lists

• Creating and accessing lists
• List methods (append, extend, insert, remove, pop, etc.)
• List slicing and indexing
• List comprehensions
• Nested lists
• Performance considerations

Tuples

• Creating tuples
• Immutability
• Tuple unpacking
• Named tuples (collections.namedtuple)
• When to use tuples vs lists

Sets

• Creating sets
• Set operations (union, intersection, difference, symmetric_difference)
• Set methods (add, remove, discard, update, etc.)
• Frozen sets
• Set comprehensions
• Use cases for sets

Dictionaries

• Creating dictionaries
• Accessing and modifying values
• Dictionary methods (keys, values, items, get, update, etc.)
• Dictionary comprehensions
• Nested dictionaries
• Default dictionaries (collections.defaultdict)
• Ordered dictionaries (collections.OrderedDict)

Collections Module

Counter

• Counting elements
• Most common elements
• Arithmetic operations on counters

defaultdict

• Default value factories
• Use cases for defaultdict

deque

• Double-ended queue operations
• append, appendleft, pop, popleft
• Performance advantages over lists

namedtuple

• Creating named tuples
• Accessing fields by name
• Converting to dictionary

ChainMap

• Combining multiple dictionaries
• Use cases for ChainMap

Custom Data Structures

Implementing Custom Containers

• Creating custom list-like objects
• Creating custom dictionary-like objects
• Implementing __getitem__, __setitem__, __len__

Data Structure Selection

• When to use which data structure
• Time complexity considerations
• Space complexity considerations

Interview Questions

1. What is the difference between a list and a tuple?
2. When would you use a set instead of a list?
3. Explain the time complexity of common list operations.
4. What is the difference between dict.get() and dict[key]?
5. How do you merge two dictionaries in Python?

Coding Practice

1. Implement a function that finds the most common element in a list using Counter.
2. Create a custom data structure that behaves like a list but only stores unique elements.
3. Write a function that groups a list of dictionaries by a specific key.
4. Implement a function that finds the intersection of multiple lists efficiently.
5. Create a data structure that maintains insertion order and allows O(1) lookup.

Resources

• Python Collections Module: https://docs.python.org/3/library/collections.html
• Data Structures Guide: https://realpython.com/python-data-structures/
• Time Complexity Cheat Sheet: https://wiki.python.org/moin/TimeComplexity