Python Stacks — Push, Pop & Real-World Use Cases

The Story That Explains a Stack

A stack is a linear data structure that enforces LIFO order. Two operations define it completely: push adds an item to the top, and pop removes the item from the top. Everything else — size, peek, isEmpty — is a convenience wrapper around those two primitives.

Push & Pop — Step-by-Step Walkthrough

Walk through each operation below to build an intuition before touching any code. The "stack" starts empty; items are added and removed one at a time.

Python Implementation — Three Approaches

Python does not ship a dedicated stack class, but three clean idiomatic approaches exist. Pick the right tool based on whether thread-safety or raw speed matters most.

# ── Approach 1: Python list as a stack ───────────────────────

stack = []

# push — O(1) amortised
stack.append(10)
stack.append(20)
stack.append(30)
print("After 3 pushes:", stack)          # [10, 20, 30]

# peek — look without removing
top = stack[-1]
print("Peek:", top)                        # 30

# pop — O(1)
val = stack.pop()
print("Popped:", val)                      # 30
print("Stack now:", stack)                 # [10, 20]

# safe pop — guard against underflow
def safe_pop(s):
    if not s:
        raise IndexError("pop from empty stack")
    return s.pop()

print(safe_pop(stack))                    # 20
print(safe_pop(stack))                    # 10

from collections import deque

stack = deque()

stack.append("frame_main")
stack.append("frame_foo")
stack.append("frame_bar")

print("Call stack:", stack)
print("Top frame :", stack[-1])           # peek

while stack:
    frame = stack.pop()
    print(f"Returning from {frame}")

class Stack:
    def __init__(self, capacity=None):
        self._data = []
        self._capacity = capacity

    def push(self, item):
        if self._capacity and len(self._data) >= self._capacity:
            raise OverflowError(f"Stack overflow — max capacity {self._capacity}")
        self._data.append(item)

    def pop(self):
        if self.is_empty():
            raise IndexError("pop from empty stack")
        return self._data.pop()

    def peek(self):
        if self.is_empty():
            raise IndexError("peek on empty stack")
        return self._data[-1]

    def is_empty(self): return len(self._data) == 0
    def size(self):     return len(self._data)
    def __repr__(self): return f"Stack({self._data})"


# ── usage ─────────────────────────────────────────────────────
s = Stack(capacity=5)
for n in [1, 2, 3]:
    s.push(n)

print(s)                    # Stack([1, 2, 3])
print("peek:", s.peek())    # peek: 3
print("pop :", s.pop())     # pop : 3
print("size:", s.size())    # size: 2

# overflow guard
try:
    for i in range(10): s.push(i)
except OverflowError as e:
    print(f"Caught: {e}")

Time & Space Complexity

Where Stacks Appear in the Real World

Stacks are one of the most ubiquitous structures in computer science. Every time you see "most recent first" or "reverse order", there is a very good chance a stack is behind it.

Worked Example — Bracket Validator

def is_valid(s: str) -> bool:
    """Return True if all brackets in s are correctly nested."""
    stack = []
    pairs = {')': '(', '}': '{', ']': '['}

    for ch in s:
        if ch in '([{':
            stack.append(ch)            # push opening bracket
        elif ch in ')]}':
            if not stack or stack[-1] != pairs[ch]:
                return False            # mismatch or underflow
            stack.pop()                 # matched — remove

    return len(stack) == 0            # empty stack = all closed


# ── test cases ────────────────────────────────────────────────
tests = [
    ("()[]{}",          True),
    ("([{}])",          True),
    ("(]",              False),
    ("{[}",             False),
    ("",                True),
    ("(((",             False),
]

for expr, expected in tests:
    result = is_valid(expr)
    status = "✓" if result == expected else "✗"
    print(f"{status}  is_valid({repr(expr):10s}) = {result}")

Worked Example — Iterative DFS with an Explicit Stack

def dfs_iterative(graph: dict, start):
    """Depth-first search using an explicit stack instead of recursion."""
    visited = set()
    stack   = [start]          # push start node
    order   = []

    while stack:
        node = stack.pop()    # LIFO — go deep first
        if node not in visited:
            visited.add(node)
            order.append(node)
            for neighbour in reversed(graph[node]):
                if neighbour not in visited:
                    stack.append(neighbour)

    return order


graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [], 'E': [], 'F': []
}

print(dfs_iterative(graph, 'A'))

Before & After — Naive vs Stack-Based Undo

One of the clearest demonstrations of why stacks matter is implementing undo. Compare the naive approach (re-running history from scratch) against the stack approach.

Common Pitfalls — The Four Traps

Golden Rules