Python Data Structures Cheat Sheet

Lower curves = faster operations. Choose data structures based on your most common operations

lst = [1, 2, 3, 4, 5]

# Access & Slice
lst[0]       # 1
lst[-1]      # 5 (last element)
lst[1:3]     # [2, 3]
lst[::2]     # [1, 3, 5] (every 2nd)

# Methods
lst.append(6)      # Add to end
lst.insert(0, 0)   # Insert at index
lst.extend([7,8])  # Add multiple
lst.remove(3)      # Remove by value
lst.pop()          # Remove & return last
lst.pop(0)         # Remove & return at index
lst.index(2)       # Find index of value
lst.sort()         # Sort in place
lst.reverse()      # Reverse in place
lst.clear()        # Remove all

# Copy (important!)
copy_lst = lst.copy()  # Shallow copy
import copy
deep_copy = copy.deepcopy(lst)

t = (1, 2, 3)

# Access (like lists)
t[0]         # 1
t[-1]        # 3
t[1:3]       # (2, 3)

# Packing & Unpacking
coords = (10, 20)
x, y = coords      # x=10, y=20
a, *rest, z = (1,2,3,4,5)  # a=1, rest=[2,3,4], z=5

# Tuple methods (limited)
t.count(1)   # Count occurrences
t.index(2)   # Index of element

# Named Tuples
from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(10, 20)
print(p.x)   # 10

d = {"name": "Raj", "age": 16, "city": "Delhi"}

# Access & Modify
d["name"]           # "Raj"
d.get("name")       # "Raj" (safer)
d.get("country", "India")  # Default value

d["age"] = 17       # Update
d["school"] = "DPS" # Add new key

# Dictionary methods
d.keys()            # dict_keys(['name', 'age', ...])
d.values()          # dict_values(['Raj', 17, ...])
d.items()           # [('name','Raj'), ('age',17), ...]

d.pop("age")        # Remove & return
d.pop("unknown", None)  # Safe pop
d.clear()           # Remove all

d.update({"city": "Mumbai", "state": "MH"})

# Iteration
for key in d:
    print(key, d[key])

for key, value in d.items():
    print(key, value)

s = {1, 2, 3, 3}  # {1, 2, 3}

# Add & Remove
s.add(4)
s.discard(3)        # Remove if present
s.remove(3)         # Error if not present
s.pop()             # Remove & return random
s.clear()

# Set operations
s1 = {1, 2, 3}
s2 = {2, 3, 4}

s1 | s2             # Union: {1,2,3,4}
s1 & s2             # Intersection: {2,3}
s1 - s2             # Difference: {1}
s1 ^ s2             # Symmetric diff: {1,4}

# Membership
2 in s              # True
5 not in s          # True

# Checking subsets/supersets
s1 <= s2            # Is subset?
s1 >= s2            # Is superset?
s1.isdisjoint(s2)   # No common elements?

from collections import defaultdict, Counter, deque

# defaultdict (missing keys return default)
dd = defaultdict(list)
dd["languages"].append("Python")
# Returns [] for missing keys, not KeyError

# Counter (count occurrences)
c = Counter("mississippi")
# Counter({'i': 4, 's': 4, 'p': 2, 'm': 1})

c.most_common(2)    # [('i',4), ('s',4)]
c["m"]              # 1

# Combine counters
c1 = Counter(['a','b','a'])
c2 = Counter(['a','c'])
c1 + c2             # Counter({'a': 3, 'b': 1, 'c': 1})

# deque (double-ended queue)
d = deque([1,2,3])
d.append(4)         # Add to right
d.appendleft(0)     # Add to left
d.pop()             # Remove from right
d.popleft()         # Remove from left
d.rotate(1)         # Rotate right

import heapq

# heapq works on lists (min heap)
h = [3, 1, 4, 1, 5]
heapq.heapify(h)    # Heapify in place

heapq.heappush(h, 2)  # Add element
min_val = heapq.heappop(h)  # Remove & return min

# Get n smallest
heapq.nsmallest(2, h)  # [1, 1]
heapq.nlargest(2, h)   # [5, 4]

# Priority queue (use tuple: priority, item)
pq = []
heapq.heappush(pq, (2, "medium"))
heapq.heappush(pq, (1, "high"))
heapq.heappush(pq, (3, "low"))

while pq:
    priority, item = heapq.heappop(pq)
    print(item)  # high, medium, low

from collections import OrderedDict, defaultdict

# OrderedDict preserves insertion order
od = OrderedDict()
od["first"] = 1
od["second"] = 2
# Maintains insertion order (Python 3.7+ regular dicts also do)

# defaultdict patterns
# Group by key
students_by_grade = defaultdict(list)
students_by_grade["A"].append("Raj")
students_by_grade["B"].append("Priya")

# Count with default 0
word_count = defaultdict(int)
for word in text.split():
    word_count[word] += 1

# Nested structure
nested = defaultdict(lambda: defaultdict(int))
nested["delhi"]["population"] += 1000000

*Python 3.7+