XQA
Back to Python
2026-02-055 min read

popitem() (Python Programming)

Learn popitem() (Python Programming) step by step with clear examples and exercises.

Why This Matters

In this full guide on Python's popitem() method, we aim to provide you with an in-depth understanding of its practical applications in real-world coding scenarios. By learning how to use popitem(), you will be able to effectively manipulate dictionaries and solve complex problems involving stacks or queues implemented as dictionaries.

Why This Matters

The popitem() method is a powerful tool for working with dictionaries in Python, allowing you to remove and return the last inserted key-value pair in Last In, First Out (LIFO) order. This functionality is particularly useful when dealing with data structures like stacks or queues that require LIFO behavior.

Prerequisites

Before diving into the core concept, it's essential to have a solid grasp of Python basics, including variables, data types, operators, and control structures. Additionally, familiarity with dictionaries in Python—creating, accessing, modifying, and deleting dictionary items—is crucial for understanding the popitem() method.

Core Concept

In Python, the popitem() method is used to remove and return a key-value pair from a dictionary. The pair removed is the last one inserted into the dictionary. If no pairs have been added yet, a KeyError exception will be raised.

person = {'name': 'Phill', 'age': 22, 'salary': 3500.0}
result = person.popitem()
print('Return Value = ', result)
print('person = ', person)

Inserting a new element pair

person['profession'] = 'Plumber'

result = person.popitem()

print('Return Value = ', result)

print('person = ', person)


In this example, we first create a dictionary containing information about a person. The `popitem()` method is then called to remove and return the last inserted key-value pair, which happens to be `'salary': 3500.0`. After removing that pair, we add a new pair `('profession', 'Plumber')` and call `popitem()` again to remove and return this new pair.

Worked Example

Let's consider a practical example where we use the popitem() method to implement a simple last-in, first-out (LIFO) stack using a dictionary:

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()

def peek(self):
if not self.is_empty():
return self.items[-1]

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

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

stack = Stack()
stack.push('item1')
stack.push('item2')
stack.push('item3')

print('Stack:', stack.items)
top_item = stack.pop()
print('Popped item:', top_item)
print('Stack after popping:', stack.items)

In this example, we define a Stack class that uses a dictionary to store items and provides methods for pushing, popping, peeking, checking if the stack is empty, and getting the size of the stack. We create an instance of the Stack class, push three items onto it, and then pop one item off using the pop() method.

Common Mistakes

  1. Using popitem() on an empty dictionary: If you call popitem() on an empty dictionary, a KeyError will be raised. To avoid this, always check if the dictionary is empty before calling popitem().
  1. Confusing LIFO with FIFO: The popitem() method removes and returns a key-value pair in Last In, First Out (LIFO) order. If you need to remove and return pairs in First In, First Out (FIFO) order, consider using the deque module instead of a dictionary.
  1. Not handling exceptions: When working with dictionaries, it's essential to handle exceptions such as KeyError. You can use a try-except block to catch and handle these errors gracefully.
  1. ### Common Mistakes (subheading)
  • Calling popitem() repeatedly on an empty dictionary: If you call popitem() multiple times on an empty dictionary, it will continue raising KeyError exceptions. To prevent this, check if the dictionary is empty after each call to popitem().
  1. ### Common Mistakes (subheading)
  • Trying to pop an item from a non-dictionary object: The popitem() method can only be called on dictionaries. If you try to use it on another type of object, a TypeError will be raised.

Practice Questions

  1. Implement a LIFO queue using a dictionary in Python. The queue should have methods for enqueue (add an item), dequeue (remove and return the oldest item), peek (return the oldest item without removing it), and check if the queue is empty.
  1. Write a program that uses the popitem() method to remove the smallest value from a dictionary containing numbers as values, where each key represents a unique identifier for the number.

FAQ

  1. What happens when I call popitem() on an empty dictionary in Python?
  • When you call popitem() on an empty dictionary, a KeyError is raised. To avoid this, always check if the dictionary is empty before calling popitem().
  1. Can I use popitem() to remove a specific key-value pair from a dictionary in Python?
  • No, the popitem() method removes and returns the last inserted key-value pair from the dictionary in LIFO order. If you need to remove a specific key-value pair, consider using the pop(key) method instead.
  1. What is the difference between pop() and popitem() in Python?
  • The pop() method removes and returns the value associated with a specified key, while the popitem() method removes and returns the last inserted key-value pair from the dictionary in LIFO order.
  1. ### FAQ (subheading)
  • Is it possible to use popitem() to remove a specific key-value pair in a way that preserves the order of other key-value pairs?
  • No, popitem() removes and returns the last inserted key-value pair regardless of the key. If you need to preserve the order while removing a specific key-value pair, consider using a list of tuples (key, value) or a different data structure like OrderedDict.
popitem() (Python Programming) | Python | XQA Learn