Python - Data Structures - Stack

Stack Data Structures in Python 

In Python, like any other programming language, the stack is a linear data structure that operates on the LIFO principle. This means that the element added last will be removed from the stack first.

Understand Stack with a Scenario:

Think of it like a stack of plates, where the only actions you can take are to add or remove the top plate. Common operations include "push," which adds an item, "pop," which removes the top item, and "peek," which allows you to see the top item without removing it.

Common Operation on Stack

There are the following common operations on the stack:

• Push: Adds an element to the top of the stack.
• Pop: Removes and returns the top element from the stack.
• Peek: Returns the top element without removing it.
• is_empty: Checks if the stack is empty.
• size: Returns the number of elements in the stack.

How to Create a Stack

To create a stack in Python, we can use various approaches, depending on our needs. Here's how you can create and work with a stack using different methods:

Using List

Lists in Python can act as a stack because they support append() for adding elements and pop() for removing the last element.

# Stack implementation using a list
stack = []

# Push elements onto the stack
stack.append(1)
stack.append(2)
stack.append(3)

print("Stack after pushing elements:", stack)

# Pop an element from the stack
popped_element = stack.pop()
print("Popped element:", popped_element)
print("Stack after popping:", stack)

# Peek the top element
if stack:
    print("Top element:", stack[-1])
else:
    print("Stack is empty.")

from collections import deque

stack = deque()

# Push elements
stack.append(1)
stack.append(2)
stack.append(3)

print("Stack after pushing elements:", stack)

# Pop an element
popped_element = stack.pop()
print("Popped element:", popped_element)
print("Stack after popping:", stack)

# Peek the top element
if stack:
    print("Top element:", stack[-1])
else:
    print("Stack is empty.")

Using a Custom Class

If you want more control over stack operations, you can create a custom stack class.

class Stack:
    def __init__(self):
        self.stack = []

    def push(self, item):
        self.stack.append(item)

    def pop(self):
        if not self.is_empty():
            return self.stack.pop()
        else:
            return "Stack is empty!"

    def peek(self):
        if not self.is_empty():
            return self.stack[-1]
        else:
            return "Stack is empty!"

    def is_empty(self):
        return len(self.stack) == 0

    def size(self):
        return len(self.stack)

# Usage
stack = Stack()
stack.push(1)
stack.push(2)
stack.push(3)

print("Top element:", stack.peek())
print("Popped element:", stack.pop())
print("Stack size:", stack.size())

Use cases of Stack

There are the following use cases of the stack:

• Mechanisms for undoing activities: Stacks are used in programs to keep track of actions and enable users to undo them in the order that they were performed.
• Expression Evaluation: In compilers, stacks are essential for the evaluation and conversion of expressions, including the evaluation of postfix expressions and the conversion of infix to postfix expressions.
• Algorithms that backtrack: Stacks in algorithms such as maze solving can preserve the prior state and revert to it if a dead end is encountered.
• Function Call Management: In programming languages, function calls are arranged in call stacks, with the last function called being the first to be finished and eliminated.