~ 4 min read

Determining Dictionary Length in Python Using len() Function

By: Adam Richardson

Introduction to Dictionary Length and its Importance

Dealing with dictionaries is a common task in Python programming. It’s a versatile data structure that comes in handy when organizing and retrieving data efficiently. Understanding how to determine the length of a dictionary is not only essential for controlling the data structure’s size but also for analyzing and optimizing your code. In this article, we will explore how to find the length of dictionaries in Python using the built-in len() function and share some advanced use cases.

Properties and Usage of the len() Function

The len() function is a built-in Python function that returns the number of elements in an object. It accepts one parameter:

  • object (required): The object whose length you want to get. It can be a dictionary, list, tuple, or other types.

In the context of dictionaries, len() returns the number of key-value pairs. The len() function is efficient, as it runs in constant time (O(1)) regardless of the size of the dictionary.

Here are some important points to consider when using the len() function with dictionaries:

  1. The function only considers the items directly inside the dictionary, but not nested dictionaries within it.
  2. Dictionaries are unordered, so the order of the key-value pairs is not guaranteed.
  3. If a key-value pair is removed or added, the result of the len() function will change accordingly.

To find the length of a dictionary using the len() function, call the function and pass the dictionary as an argument.

Simplified Real-Life Example

Below is an example of how to use the len() function to determine the length of a dictionary containing information about a person. This includes their name, age, city, and profession:

person = {
    "name": "John Smith",
    "age": 30,
    "city": "New York",
    "profession": "Software Developer"

person_length = len(person)
print("Length of person dictionary:", person_length)


Length of person dictionary: 4

The output shows the dictionary’s length is 4 because it contains 4 key-value pairs.

Complex Real-Life Example

In this example, let’s assume we have a list of dictionaries containing information about a group of people. Our goal is to calculate the average age of people living in a specific city.

people = [
    {"name": "John Smith", "age": 30, "city": "New York", "profession": "Software Developer"},
    {"name": "Jane Lee", "age": 27, "city": "New York", "profession": "Data Scientist"},
    {"name": "Sarah Davis", "age": 35, "city": "Los Angeles", "profession": "Marketing Manager"},
    {"name": "Paul Allen", "age": 21, "city": "New York", "profession": "Intern"},

target_city = "New York"
filtered_people = [p for p in people if p["city"] == target_city]

avg_age = sum(p["age"] for p in filtered_people) / len(filtered_people)
print(f"Average age of people in {target_city}: {avg_age:.1f}")


Average age of people in New York: 26.0

In this case, the len() function helps calculate the average age of people in a specified city. It determines the total number of filtered people and then computes the average age accordingly.

Personal Tips on Calculating Dictionary Length

  1. While nesting dictionaries can be great for organization, remember that the len() function doesn’t include nested dictionaries in its calculations. If you need the number of items in nested dictionaries or the total items in a nested structure, you’ll need to use a custom function or a loop.

  2. When working with dictionaries and len(), it’s essential to be aware of dictionaries being mutable objects. Changes to the dictionary will affect the output of the len() function.

  3. Always use the len() function instead of manually iterating over the dictionary to count elements, as the former is more efficient and easier to read.

Learning how to get the length of dictionaries using the len() function is an essential skill when working with this data structure. By understanding the function’s properties and knowing its limitations, you can optimize your code, analyze your data efficiently, and solve real-life problems effectively.

Subscribe to our newsletter

Stay up to date with our latest content - No spam!

Related Posts