Stack in Python: Definition, Implementations and Examples

Introduction

Most programs require a reliable way to manage data in which the order of operations matters. In such situations, a stack in Python provides a simple structure that stores elements in a defined sequence. It follows the Last In, First Out rule, which makes it suitable for handling execution flow, temporary data storage, and operations that rely on recent inputs.

The primary operations performed on a Python Stack include:

• Adding elements to the stack using push
• Removing elements from the stack using pop
• Accessing the element currently at the top
• Verifying whether the stack is empty
• Identifying the total number of elements stored

In this article, we’ll explain what stack in Python is and how it works in practice. You’ll learn stack operations, common ways to implement stacks in Python, and practical examples that show how stacks are applied in programming.

What is a Stack?

A stack is a linear data structure that follows the Last In, First Out (LIFO) principle. This means the last element added to the stack is the first one to be removed. Elements are accessible only from the top, and the stack maintains the order in which items are added.

You can think of a stack like a stack of plates, where each new plate is placed on top, and only the top plate can be taken off first. The undo feature in text editors works similarly, storing recent actions so the most recent one can be reversed before earlier actions.

To better understand how elements are added to and removed from a stack, check out the diagram below.

Deep-dive into Python programming with the expert-led Python training. Join now and transform your skills into career opportunities!

Why Use Stack in Python?

Now that you know what a stack in Python is, let’s look at why it’s so widely used in programming:

1. Expression Evaluation

Stacks are commonly used to evaluate expressions while maintaining the correct order of operations. For instance, when calculating “3 + (2 * 4)”, a stack can temporarily store numbers and operators so that multiplication occurs before addition.

2. Backtracking (DFS)

Stacks are also essential in backtracking problems, such as Depth-First Search. Each time you explore a new node, the current state is pushed onto the stack. If you reach a dead end, you pop back to the previous state and continue, allowing the algorithm to explore all possible paths without losing track of where it has been.

3. Function Call Management

Every time a function is called in Python, its context is stored on the call stack. The most recent function completes first, then returns to earlier calls. This ensures that recursive functions work correctly and local variables are maintained without interference.

4. Undo Mechanisms

Stacks are also utilized to realize the undo function in text editors and applications. Each action is placed on the stack, and undoing it pops the most recent item. This preserves the order of previous actions and facilitates handling of multiple consecutive undos.

Stacks are preferred in these scenarios not just because of their LIFO behavior, but also because push and pop operations are highly efficient, running in constant time. Compared with alternatives such as lists or queues, stacks handle temporary data and nested operations with lower overhead and fewer errors.

Learn in-demand Python skills including, Web scraping, Operators, Django, Sets, and Conditional statements, with this Python Certification. Get hands-on development experience and prepare yourself for an exciting career as a professional Python programmer.

Stack Operations in Python

While using a stack in Python, several essential operations allow you to manage elements efficiently:

• Push (Add Element)

Push operation adds a new element to the top of the stack. This ensures that the most recent item is always the first to be accessed or removed.

• Pop (Remove Element)

Pop operation removes the element from the top of the stack and returns it. Only the uppermost element can be taken out at any moment since the stacks adhere to the Last In, First Out principle.

• Peek / Top (View Element)

Peek, also known as top, lets you view the element at the top of the stack without removing it. This operation is essential when you need to make decisions based on the latest item while keeping it available for future use.

• isEmpty / Size

The isEmpty function determines if the stack is empty or not, while size gives the count of the elements that are presently in the stack. These functions are essential for managing program flow and preventing errors, such as attempting to remove an element from an empty stack.

• Big-O Time and Space Complexity

All the essential operations of the stack, like push, pop, peek, isEmpty, and size, have constant time complexity, denoted by O(1). It indicates that the operation time is independent of the stack size.

On the same note, a constant amount of space is required for every single element in the stack; hence, stacks are fast and memory-efficient in a predictable way.

This might surprise you: The TIOBE Index for September 2025 shows Python holding the top spot with a 25.98% market share, up +8.72% year‑over‑year, far ahead of C++ (8.80%) and C (8.65%).

How to Implement a Stack in Python?

By now, you have seen why stacks are useful in Python and understood the core operations. Let’s move on to how stacks can be implemented in Python using different approaches.

#1: Stack Implementation Using Python List

A Python list provides a simple way to implement a stack and perform the main stack operations efficiently. Here’s a closer look at how a stack works in Python.

I. Push and Pop Demonstration

Lists allow you to add elements at the end using append (push) and remove elements from the end using pop (pop), following the Last In, First Out (LIFO) principle. This ensures that the most recently added element is always the first to be removed, preserving the stack’s order.

II. Limitations 

Although using a list is simple and effective for small stacks, it has limitations. Removing the first element from a list using pop(0) is inefficient because the remaining elements must be shifted. 

Additionally, when a list grows too large, Python resizes it internally, which can make some push operations temporarily slower. For stack operations in which elements are added to or removed from the top, these limitations usually do not cause significant problems.

III. Example

Let’s take an example to understand how elements are pushed onto the stack and popped from the top:

stack = []
# Push elements
stack.append(10)
stack.append(20)
# Pop element
top = stack.pop()
print(top) # Output: 20
print(stack) # Output: [10]

#2: Stack Implementation Using collections.deque

If you have larger stacks or are concerned about performance, using a list can be inefficient for push and pop operations. Collections.deque solves these issues. Here’s how: 

I. Why deque is Better than List for Stack Operations?

Unlike lists, deques are designed to add and remove elements quickly from both ends. This avoids the slow shifting caused by pop(0) in lists and the resizing overhead when lists grow large. As a result, push and pop operations remain fast even with many elements.

II. Code Example

Let’s take an example to see how elements can be pushed onto a stack and popped from the top using a deque:

from collections import dequestack
= deque()
# Push elements
stack.append(10)
stack.append(20)
# Pop element
top = stack.pop()
print(top) # Output: 20
print(stack) # Output: deque([10])

#3: Stack Implementation Using a Custom Class

For more control and better organization, you can implement a stack using a Python class. Using a class allows you to manage the stack’s data safely, define your own methods, and prevent errors when performing stack operations.

I. Define a Stack Class

A stack class encapsulates the stack’s elements and provides methods to perform standard stack operations such as push, pop, peek, and check if the stack is empty. Here’s how you can define it:

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

II. Encapsulation & Validation

By keeping the stack’s internal list private within the class, you ensure that the stack data is not accidentally modified from outside the class. Methods such as pop and peek include checks to prevent errors when the stack is empty, thereby maintaining data integrity and making the stack easier to use in larger programs.

III. Examples of Usage

Let’s take an example to see how this stack class works in practice:

stack = Stack()
# Push elements
stack.push(10)
stack.push(20)
# Pop the top element
top = stack.pop()
print(top) # Output: 20
print(stack.items) # Output: [10]

Stack vs Other Data Structures

When deciding which data structure to use, it is helpful to understand how stacks differ from other common data structures. Let’s compare stacks with queues and linked lists to see where each performs best:

• Stack vs Queue

Stacks operate on a LIFO principle, meaning the most recently added element is removed first. On the other hand, Queues are based on the First In, First Out (FIFO) principle, in which elements are processed in the order in which they were entered.

Stacks are most effective when the latest item must be handled first, such as in undo operations, function calls, or backtracking. Queues are appropriate for cases where order matters, such as task scheduling or breadth-first traversal. Knowing the difference helps you choose the proper structure for your workflow.

• Stack vs Linked List

Stacks and linked lists both store sequences of elements, but their design priorities differ. The Python stack data structure is optimized for adding or removing elements from one end, making operations such as push and pop very fast.

Linked lists allow insertions and deletions at any position, offering more flexibility at the cost of slightly more complex handling.

If your program requires temporary storage with strict ordering, a stack is simpler and more efficient. When frequent insertions or deletions at arbitrary positions are needed, a linked list is the better choice.

To summarize these differences, the following table compares their behaviors, time complexity, and memory usage:

Boost your career with the Full Stack Developer Certification! Gain in-depth expertise in development and testing with the latest technologies. Enroll today and become a skilled Full Stack Developer.

Common Stack Problems in Python

By comparing stacks with other data structures, it is clear that stacks are well-suited to specific operations. Now, let us explore a few practical problems in Python where stacks are generally applied:

1. Reverse a String Using Stack

Reversing a string is a classic problem that demonstrates how stacks store elements temporarily. By pushing each character onto a stack and then popping them one by one, the characters are retrieved in reverse order. This method leverages the last-in, first-out property of stacks.

In Python, you can implement it like this:

stack = []
for char in "hello":
stack.append(char)
reversed_string = ""
while stack:
reversed_string += stack.pop()
print(reversed_string) # Output 'olleh'

2. Check Balanced Parentheses

Stacks are ideal for validating expressions with nested brackets. When an opening bracket is encountered, it is pushed onto the stack. When a closing bracket appears, the top element is popped and checked for a matching opening bracket. If all brackets match and the stack is empty at the end, the expression is balanced.

Here’s how it can be done in Python:

stack = []
expression = "([{}])"
balanced = True
for char in expression:
if char in "({[":
stack.append(char)
elif char in ")}]":
if not stack:
balanced = False
break
top = stack.pop()
if (top, char) not in [("(", ")"), ("[", "]"), ("{", "}")]:
balanced = False
break
print(balanced) # Output True

3. Next Greater Element (Stack Pattern)

Stacks are also used in algorithmic problems like finding the next greater element in an array. The stack keeps track of elements that haven’t yet found a greater number. As we iterate through the array, elements are popped from the stack when a larger number is found, and the result is updated.

For example, in Python:

arr = [4, 5, 2, 25]
stack = []
result = [-1] * len(arr)
for i, value in enumerate(arr):
while stack and value > arr[stack[-1]]:
index = stack.pop()
result[index] = value
stack.append(i)
print(result) # Output [5, 25, 25, -1]

When NOT to Use Stack

While stacks are helpful in many scenarios, there are situations in which they are not the optimal choice. Let us examine some limitations and cases where other data structures are more suitable.

• Limited Access to Elements

Stacks provide access only to the top element, which can be a limitation if you want to read or modify elements that are deeper in the structure. Retrieving middle items or searching a stack often takes much more time than accessing the same items in an array or a linked list, where direct access is possible. 

• Sequential Processing Requirements

Stacks operate on the Last In First Out principle (LIFO), which is not the best for situations where elements have to be processed in their arrival order. Tasks scheduling, event queues, and streaming data, for example, require First In First Out (FIFO) behavior, thus making queues the right alternative.

• Hierarchical or Branching Data

Stacks don’t work well for data that branches into multiple paths. When dealing with structures such as family trees, folders, or organizational charts, multiple paths must be tracked simultaneously. Trees in data structure perform better because they store parent–child relationships and enable efficient traversal between levels.

Stack Best Practices in Python

Once you understand how Python stack in data structures works and where it is most useful, it’s essential to follow best practices to make your code efficient and reliable:

1. Choose the Proper Implementation

For minor tasks, a list is the right choice. If you need larger datasets or faster operations, then collections.deque will be more efficient.

2. Take Into Account Memory Consumption

Lists may consume more memory than they require, whereas deques are more memory-efficient. To save memory, do not keep unnecessary references in your custom stacks.

3. Stay Away From Frequent Mistakes

Do not take or look at an empty stack. Enclose operations within methods, and always verify the presence of elements in the stack.

Key Takeaways

• Stacks in Python store data in LIFO (last-in, first-out) order, making them useful for function calls, undo actions, and backtracking
• They can be built using lists, collections.deque, or custom classes, depending on data size and performance needs
• Stacks facilitate expression evaluation, balanced parentheses, reversing data, and the Next Greater Element problem
• Good stack usage means managing memory well and checking for empty stacks to avoid errors in larger programs

Recommended Resources

• Learn Deque in Data Structure From Scratch
• Stack Implementation Using Arrays in Data Structures

FAQs

1. What is a stack and its types?

A stack in Python is a LIFO data structure. Types include list-based, deque-based, and linked-list stacks, all of which store and access elements efficiently.

2. What does stack[-1] mean in Python?

In a Python stack data structure, stack[-1] represents the top element. It lets you see the latest item without removing it, preserving LIFO order.

3. What is Python full-stack called?

Python full-stack developers handle both the front end and the back end. It is unrelated to the Python stack data structure concept.

4. What is stack in Python?

A Python stack keeps its elements in LIFO (last-in, first-out) order. Thus, additions and removals can occur only from the top.

5. How do you implement a stack using a list in Python?

You can implement a stack using a Python list, with append for pushing and pop for removing elements, thereby efficiently following LIFO principles.

6. Why use deque for stack operations?

A deque permits rapid insertion and deletion of elements at both ends. It provides consistent performance on large datasets and does not suffer from resizing issues in efficient stack-based Python operations.

7. What is the time complexity of stack operations in Python?

In a Python stack data structure, push, pop, peek, and size operations run in O(1) time, ensuring predictable, memory-efficient performance.

8. Can Python stack overflow?

Yes, recursion or excessive push operations can cause a Python stack overflow because Python has limits on memory and call stack depth.

9. What is the difference between stack and queue in Python?

A stack in Python is LIFO, whereas a queue is FIFO. Stacks are well-suited for undoing actions or for recursion; queues are ideal for sequential processing tasks.

10. How to reverse a string using stack in Python?

A stack in Python can be used to reverse a string by pushing each character onto the stack and popping them in reverse order.

11. How to check balanced parentheses using stack?

A Python stack stores opening brackets and removes them on encountering closing brackets. Matching all ensures balanced expressions, making validation reliable and efficient.

12. What are real-world examples of stack usage? 

Stacks are used in undo mechanisms, browser history, function call management, expression evaluation, and backtracking, all of which leverage the Python stack data structure for LIFO operations.

13. Stack vs recursion - when to use what?

Recursion uses the call stack implicitly. A custom stack class is preferred when explicit control, validation, or safe operations are required in Python stack workflows.