Stack Basics: LIFO Explained with Real‑World Examples and Python Code

What Is a Stack?

Remember the rule: Last In, First Out (LIFO) . The most recent element added is the first one removed.

Everyday Analogy

Imagine a bucket of chips: the first chip placed sits at the bottom and can only be taken out after all chips placed later are removed; the last chip placed sits on top and is taken out first.

Core Stack Operations

Push : add data to the top of the stack.

Pop : remove and return the data from the top of the stack.

Common Real‑World Stack Scenarios

Document editors – Ctrl+Z undo.

Web browsers – back to the previous page.

Mobile apps – back‑button navigation history.

Program execution – function call stack and recursion.

Expression evaluation – parentheses matching (a frequent interview question).

Stack vs. Array / Linked List

Array : free random access and modification.

Linked List : flexible insertion and deletion anywhere.

Stack : operations are restricted to the top; it enforces a strict single‑direction flow.

Complete Stack Implementation (Python)

The following class implements a stack using a Python list and provides six methods:

class Stack:
    def __init__(self):
        # Initialize an empty stack stored in a list
        self.stack = []

    # 1. Push: add data to the top
    def push(self, data):
        self.stack.append(data)

    # 2. Pop: remove and return the top element
    def pop(self):
        if self.is_empty():
            return "Stack is empty, cannot pop"
        return self.stack.pop()

    # 3. Get top element without removing it
    def get_top(self):
        if self.is_empty():
            return "Stack is empty"
        return self.stack[-1]

    # 4. Check if the stack is empty
    def is_empty(self):
        return len(self.stack) == 0

    # 5. Get the number of elements
    def get_length(self):
        return len(self.stack)

    # 6. Clear the stack
    def clear(self):
        self.stack = []

# ===== Simple test =====
if __name__ == "__main__":
    s = Stack()
    s.push("A page")
    s.push("B page")
    s.push("C page")
    print("Current stack:", s.stack)
    print("Top element:", s.get_top())
    print("Stack length:", s.get_length())
    print("Pop result:", s.pop())
    print("Stack after pop:", s.stack)
    s.clear()
    print("Is empty after clear:", s.is_empty())

Execution Result

Current stack: ['A page', 'B page', 'C page']

Top element: C page

Stack length: 3

Pop result: C page

Stack after pop: ['A page', 'B page']

Is empty after clear: True

Practical Mini‑Case: Simulating Undo

A short script shows how a stack can model a text editor's undo feature:

# Simulate typing and undo
text_stack = Stack()
text_stack.push("H")
text_stack.push("Hi")
text_stack.push("Hello")
print("Typed content:", text_stack.stack)
# Perform two undo operations
text_stack.pop()
text_stack.pop()
print("After two undos:", text_stack.stack)

Result:

Typed content: ['H', 'Hi', 'Hello']

After two undos: ['H']

Common Beginner Pitfalls

1. A stack can only operate on the top element; you cannot directly access middle items.

2. Calling pop on an empty stack raises an error; always check is_empty first.

3. Remember the LIFO rule to avoid reversing the pop order.

Next Episode Preview

The upcoming fourth episode will cover queues, the sibling of the stack, which follow a First In, First Out (FIFO) order and are essential for task scheduling, message queues, and server request handling.