Skip to content

Practical Examples of Dictionaries in Python

Updated: at 02:01 AM

Dictionaries are one of the most useful and powerful data structures in Python. They provide a flexible way to store, organize, and access data as key-value pairs, making them ideal for many programming tasks. This guide will provide a deep dive into practical examples and real-world use cases where dictionaries shine in Python code.

Table of Contents

Open Table of Contents


A dictionary in Python is an unordered collection of keys mapped to values, allowing for efficient lookup and insertion operations. Dictionaries are indexed by keys, which can be any immutable data type like strings, numbers, or tuples. Unlike sequences that are indexed by range of numbers, dictionaries are indexed by these keys which are used to access values stored in the dictionary.

Some key properties and advantages of dictionaries:

These characteristics make dictionaries incredibly useful for many programming tasks in Python.

Practical Use Cases

Here are some of the most common practical applications and examples of dictionary usage in Python:

1. Storing Configuration Settings

Dictionaries provide a natural way to store configuration settings or defaults in Python code. This example loads settings from a JSON file into a dictionary:

import json

with open('config.json') as f:
  config = json.load(f)


The dictionary keys like 'batch_size' make intuitive sense and map to the config values.

2. Caching Costly Results

Caching or memoization can optimize performance by storing results of costly function calls or API requests in a dictionary to avoid recalculating:

cache = {}

def fibonacci(n):
  if n in cache:
    return cache[n]

  if n == 0 or n == 1:
    value = n
    value = fibonacci(n-1) + fibonacci(n-2)

  cache[n] = value
  return value

Here previously computed Fibonacci values are cached, avoiding recomputation.

3. Counting Word Frequency

Dictionaries provide an easy way to count the frequency of words in text:

text = "This is some text to analyze for word frequency"

word_counts = {}
for word in text.split():
  if word in word_counts:
    word_counts[word] += 1
    word_counts[word] = 1


The words become keys while the counts are values, allowing building up the frequency table.

4. User Profiles in Web Apps

In web applications, dictionaries are commonly used to represent user profiles or accounts:

users = {
  "jondoe": {
    "name": "Jon Doe",
    "bio": "Software engineer",
    "followers": 5
  "janesmith": {
    "name": "Jane Smith",
    "bio": "Data scientist",
    "followers": 10

print(users["janesmith"]["bio"]) # Prints "Data scientist"

The user ids like 'jondoe' make ideal dictionary keys for lookup.

5. Passing Keyword Arguments

Functions can accept flexible keyword arguments using dictionary unpacking with **:

def configure_widget(color, size, style):
  # Create and configure widget

options = {
  'color': 'blue',
  'size': 36,
  'style': 'rounded'


This allows indirectly passing arguments from dictionaries.

6. Lookup Tables

Dictionaries can act as lookup tables, allowing efficient searching or filtering of data:

postcodes = {
  "Chicago": 60601,
  "New York": 10001,
  "Portland": 97201

def find_postcode(city):
  return postcodes.get(city, None)

print(find_postcode("Chicago")) # 60601
print(find_postcode("Boston")) # None

The city names serve as keys for quick lookups of postcodes.

7. Metadata or Properties

Metadata or properties can be stored in dictionaries, associated with files, objects, or other items:

file_metadata = {
  "file1.txt": {
    "size": 500,
    "created": "2020-03-30",
    "permissions": "rw"
  "file2.csv": {
    "size": 100000,
    "created": "2019-12-01",
    "permissions": "r"

for filename, info in file_metadata.items():
  print(f"{filename} has size {info['size']} bytes")

This keeps relevant data neatly coupled with the files.

There are many other examples like using dicts to maintain state in games, graphs and tree structures, sets for efficient operations, and more. The possibilities are endless!

Dictionary Operations and Methods

To leverage dictionaries effectively, it’s important to understand the basic dictionary operations and methods in Python:

These provide basic dictionary manipulation, along with many other methods like keys(), values(), setdefault(), etc.

Dictionary Comprehensions

Dictionaries support compact creation using dictionary comprehensions:

values = ['a', 'b', 'c']

{v: v*2 for v in values}
# {'a': 'aa', 'b': 'bb', 'c': 'cc'}

Dictionary comps are useful for transforming sequences into key-value dicts.

They can also generate counts on iterables:

sentence = "the quick brown fox jumps over the lazy dog"

{word: sentence.count(word) for word in sentence.split()}

Tips for Using Dictionaries

Here are some key tips for working with dictionaries effectively in Python:


Dictionaries are a versatile data structure in Python used widely for tasks ranging from configuration to caching and metadata storage. Their flexibility and performance characteristics make them ideal for many situations.

This guide covered some of the most common real-world use cases for dictionaries as well as tips for using them effectively. Key takeaways include using descriptive keys, being careful modifying dictionaries in-place, and leveraging dict comprehensions.

There are still many more dictionary techniques to master, but these examples and guidelines provide a solid starting point for harnessing the power of dicts in your own Python programming.