Python Stacks

Python Stacks: A LIFO Data Structure

A Stack is a linear data structure that follows a particular order in which operations are performed. The order is LIFO (Last-In, First-Out). This means the last element added to the stack will be the first element to be removed.

A great real-world analogy is a stack of plates. You add a new plate to the top, and when you need a plate, you take one from the top. You don't pull a plate from the bottom of the stack!

Core Stack Operations

A stack has two primary operations:

1. push: Adds an element to the top of the stack.
2. pop: Removes the element from the top of the stack.

It also has some common helper operations:

• peek (or top): Returns the top element of the stack without removing it.
• isEmpty: Checks if the stack is empty.
• size: Returns the number of elements in the stack.

Implementing a Stack in Python

In Python, you can easily implement a stack using the built-in list type. The list's append() method acts as push, and its pop() method (without an index) acts as pop.

// Initialize an empty stack
my_stack = []

// Push items onto the stack
my_stack.append("Plate 1")
my_stack.append("Plate 2")
my_stack.append("Plate 3")
print("Stack after pushes:", my_stack)
// Peek at the top item
top_item = my_stack[-1]
print("Top item is:", top_item)
// Pop an item from the stack
removed_item = my_stack.pop()
print("Popped item:", removed_item)
print("Stack after pop:", my_stack)

A More Robust Implementation (Class-based)

For more structured code, you can wrap the stack logic in a class.

class Stack:
    def __init__(self):
        self.items = []
    def is_empty(self):
        return not self.items
    def push(self, item):
        self.items.append(item)
    def pop(self):
        if not self.is_empty():
            return self.items.pop()
        return "Stack is empty"
    def peek(self):
        if not self.is_empty():
            return self.items[-1]
        return "Stack is empty"
    def size(self):
        return len(self.items)

s = Stack()
s.push(10)
s.push(20)
print("Top item:", s.peek()) // 20
print("Popped item:", s.pop()) // 20
print("Stack size:", s.size()) // 1

Common Use Cases for Stacks

• Function Call Management: The "call stack" keeps track of active function calls in a program.
• Undo/Redo Features: Text editors and other software use stacks to track changes.
• Expression Evaluation: Converting infix expressions (like 3 + 4) to postfix and evaluating them.
• Backtracking Algorithms: Such as navigating a maze or solving a Sudoku puzzle.