Python Dictionaries allow you to store and organize extensive data collection with a few simple lines of code. As with other data types in Python, you can use the length function to determine the number of entries. However, once you’re dealing with nested dictionaries, you’ll have to tweak your code a little (which is exactly what we’ll do today!).
Before knowing the many ways you can use the length of dictionary python function in your code, we first have to understand what constitutes a Dictionary, what data types these comprehend, and how to structure them.
Dictionaries are one of Python’s Mapping Data Types. They are often referred to as composite data types or associative arrays, given how easy it is to associate keys with a specific value. A dictionary also lets you store data by pairing one item to another in any order you’d like. This process is known as mapping a key to a value, and it’s as simple as associating one item (the key) to another (the value).
What are Python Dictionaries?
Creating a dictionary in Python is just as easy as stating your dictionary’s name, followed by an assignment operator = and opening with curly bracers { } to store your keys and their values. You assign your first key and respective value by typing a colon : between them and a comma , at the end (the comma will separate your first key-value pair from the next one).
dictionary = {
<key>: <value>,
<key>: <value>,
<key>: <value>
}
You can also go for a linear presentation if that’s more to your liking.
dictionary = {<key>: <value>, <key>: <value>, <key>: <value>}
Let’s go for a more practical example. Say you’re organizing your kids’ birthday party and making a list of supplies you’ll need. You can put together a quick and easy list of items (keys) and their respective quantities (values).
Bday_Shopping_List = {
'cake':1,
'ice cream bowl':2,
'balloons':40,
'chips':5,
'napkin packs':4,
'Soft Drink Bottles':4,
'plastic cups': 30
}
Here’s the same dictionary presented in a linear fashion:
Bday_Shopping_List = {'cake':1, 'ice cream bowl':2, 'balloons':40, 'chips':5, 'napkin packs':4, 'Soft Drink Bottles':4, 'plastic cups': 30}
You can also make a dictionary containing your friend’s phone numbers (similar to your smartphone’s contact list). Granted, if you’d want your dictionary to have the same breadth and specificity as the one on your phone, you’d need to create a more complex version than the ones shown so far, but more on that later.
Friends_Contact_List = {
'Rachel':13056191239,
'Zack':12015678122,
'Dan':17258729935,
'Jamie':18556798436
}
As you enter more and more key:values, your dictionaries are bound to get crowded and lengthy. Eventually, keeping track of how many entries your dictionary has becomes a hassle (especially if you’re used to counting them manually). This is when the term length of a dictionary Python comes in clutch!
Python Dictionary Length
By calling in the python dictionary length function, we can quickly determine how many pairs of items (key and key:values) a dictionary contains.
Python dictionary length function is a built-in method that always returns the number of iterable items within a dictionary, its Python syntax being len ( ). The latter means that len ( ) acts as a counter, checking for items with a colon in between separated by a comma. Let’s try using it on our Birthday Shopping List and Friends Contact List.
We’ll call in a print function beneath our dictionary so the terminal can show us its length:
Bday_Shopping_List = {'cake':1, 'ice cream bowl':2, 'balloons':40, 'chips':5, 'napkin packs':4, 'Soft Drink Bottles':4, 'plastic cups': 30}
print(len(Bday_Shopping_List))
# Output:
7
Friends_Contact_List = {
'Rachel':13056191239,
'Zack':12015678122,
'Dan':17258729935,
'Jamie':18556798436
}
print(len(Friends_Contact_List))
# Output:
4
We’ll tweak our code to better illustrate our Python dictionary length function output. We’ll assign a variable to our len ( ) function and then use a more detailed print function command.
Bday_Shopping_List = {'cake':1, 'ice cream bowl':2, 'balloons':40, 'chips':5, 'napkin packs':4, 'Soft Drink Bottles':4, 'plastic cups': 30}
length =len(Bday_Shopping_List)
print(f'The Length of this dictionary is {length}')
# Output:
The Length of this dictionary is 7
Friends_Contact_List = {
'Rachel':13056191239,
'Zack':12015678122,
'Dan':17258729935,
'Jamie':18556798436
}
length =len(Friends_Contact_List)
print(f'The Length of this dictionary is {length}')
# Output:
The Length of this dictionary is 4
The Python dictionary length function counted 7 pairs of items on our Birthday Shopping List dictionary, and 4 in our Friends Contact List. Notice that len ( ) doesn’t count keys and key:values separately: it only counts the number of entries made in your data collection. Still, you could use the Python dictionary length function to count for the specific number of keys, and key:values by targeting each, respectively.
For instance, if we introduce the following variations of the Python dictionary length function in our Friends Contact List len(Friends_Contact_List.keys()) our terminal can specify the number of keys entered in this dictionary:
Friends_Contact_List = {
'Rachel':13056191239,
'Zack':12015678122,
'Dan':17258729935,
'Jamie':18556798436
}
print(len(Friends_Contact_List.keys()))
# Output:
4
Likewise, if we target values through the Python dictionary length function by typing len(Friends_Contact_List.values()), we’ll get the terminal to count how many values it contains.
Friends_Contact_List = {
'Rachel':13056191239,
'Zack':12015678122,
'Dan':17258729935,
'Jamie':18556798436
}
print(len(Friends_Contact_List.values()))
# Output:
4
You’ll notice that the output for values and keys are the same as when we called our first Python dictionary length function. Since there are 4 pairs of items in our Friends Contact List, it makes sense that we have 4 keys for each of our four key-value pairs in our dictionary.
Len () Function Notes for Keys and Key-Value Pairs
The len ( ) and len ( .keys( ) ) functions come with some initial limitations that you need to be aware of (specifically whenever there are duplicate keys).
- Duplicate keys are counted as a single key.
- Duplicate values are counted separately (several keys can have the same value pair).
- Using the length of dictionary python function to count keys with no assigned values will result in an error.
Length Dictionary Python And Nested Dictionaries
Let’s fantasize and imagine that you’ve just won the lottery and are now getting $100 million (after tax, of course). Naturally, you’d want to spread some love among your besties by wiring them $10,000 each through Cash App. You’ll need to update your Friends Contact List dictionary to include their numbers and Cash App registered emails.
Python dictionaries can do that for you by assigning their keys to an inner dictionary; the latter will work just fine as our previous (and simpler) key:values. Nested dictionaries are pretty handy, as you can pair a singular key to several values (in this case, our friend’s emails and contact numbers).
Let’s expand what each of our names (Keys) can retain in our Friends Contact List so we can store both their email addresses and their contact numbers:
Friends_Contact_List = {
'Rachel':{
'Phone Number':13056191239,
'Email':'Rachel2000@gmail.com',
},
'Zack':{
'Phone Number':12015678122,
'Email':'Zackman@gmail.com',
},
'Dan':{
'Phone Number':17258729935,
'Email':'DanielCorrado@gmail.com',
},
'Jimmy':{
'Phone Number':18556798436,
'Email':'JimmyMcGil@gmail.com',
}
}
Just like we did before, we’ll state the name of a friend (create a key) within our first curly bracers, and as soon as we type our colons to pair them with a value, we add yet another set of curly bracers that include a subset of paired items named Phone Number and Email. This subset of keys will have individual values (phone number and email) assigned to them.
Our code went from this:
'Rachel':13056191239,
To this:
'Rachel':{
'Phone Number':13056191239,
'Email':'Rachel2000@gmail.com',
},
What if we want to use the length dictionary Python function to verify how many paired items, keys, and values are present in our dictionary? Let’s run all three length dictionary Python functions at once while adding the length, keys and values variable to our print functions to better illustrate our results.
Friends_Contact_List = {
'Rachel':{
'Phone Number':13056191239,
'Email':'Rachel2000@gmail.com',
},
'Zack':{
'Phone Number':12015678122,
'Email':'Zackman@gmail.com',
},
'Dan':{
'Phone Number':17258729935,
'Email':'DanielCorrado@gmail.com',
},
'Jimmy':{
'Phone Number':18556798436,
'Email':'JimmyMcGil@gmail.com',
}
}
length =len(Friends_Contact_List)
keys= len(Friends_Contact_List.keys())
values= len(Friends_Contact_List.values())
print(f'The Length of this dictionary is {length}')
print(f'The number of keys in this dictionary is {keys}')
print(f'The number of values in this dictionary is {values}')
# Output:
The Length of this dictionary is 4
The number of keys in this dictionary is 4
The number of values in this dictionary is 4
Hold on a minute: our output is still 4. Why is it not counting the extra entries we added for each friend? As we mentioned before, the length dictionary Python function only counts the number of entries made for each pairing. This means each inner dictionary is counted as a single key:value entry, regardless of the data it contains.
You might be wondering: how can we get a more accurate result? In order to do that, we’ll need to tweak our code a bit. We’ll need to make the length dictionary Python function a bit more specific in our code, so it counts not just the pairings in our first level of curly bracers (main dictionary) but also each of those in our second level curly bracers (the nested dictionary).
Friends_Contact_List = {
'Rachel':{
'Phone Number':13056191239,
'Email':'Rachel2000@gmail.com',
},
'Zack':{
'Phone Number':12015678122,
'Email':'Zackman@gmail.com',
},
'Dan':{
'Phone Number':17258729935,
'Email':'DanielCorrado@gmail.com',
},
'Jimmy':{
'Phone Number':18556798436,
'Email':'JimmyMcGil@gmail.com',
}
}
Length=len(Friends_Contact_List)+len(Friends_Contact_List['Rachel'])+len(Friends_Contact_List['Zack'])+len(Friends_Contact_List['Dan'])+len(Friends_Contact_List['Jimmy'])
print(f'The Length of this dictionary is {length}')
# Output:
The Length of this dictionary is 12
We’ve adjusted our code to count whatever entries exist inside each of our main dictionary keys (our friend’s names). In our Length variable (the one we used to call our length dictionary Python function), we manually added a specific len ( ) for each of our keys to get an accurate count.
Length=len(Friends_Contact_List)+len(Friends_Contact_List['Rachel'])+len(Friends_Contact_List['Zack'])+len(Friends_Contact_List['Dan'])+len(Friends_Contact_List['Jimmy'])
The latter might have solved our accuracy issues, but it’s not a practical solution for every nested dictionary we’d like to use in the future. Whenever we need to get an accurate len ( ) result for any super extensive nested dictionary, we can use a nifty little function known as the isinstance method.
Python Length of Dictionary Function: The isinstance Method
Recursive functions such as loops are perfect for iterating over every line of our code. The goal here is to count how many inner dictionaries are used as key:values, and add each of them to the built-in Python Length of Dictionary Function’s counter len ( )
But how can our loop distinguish key:values from simple values and nested dictionaries? This is when the isinstance function comes to our aid. The isinstance( ) function returns True if its object is of a specific data type, including mapping data types such as dictionaries. Let’s test it with several data types to see how it works:
Checking if the isinstance function recognizes a string data type (str)
Test = isinstance("Hello", (str))
print(Test)
# Output:
True
What if we deliberately put a non-string value in the isinstance object when checking for strings? It should return us a False right?
Test = isinstance(22, (str)) print(Test) # Output: False
Awesome, let’s have the isinstance function try for floats in a similar manner:
Test = isinstance(1.2, (float)) print(Test) # Output: True
Great, now lets see if the isinstance function recognizes dictionary data types:
Dictionary = {"key":20}
Test = isinstance(Dictionary, (dict))
print(Test)
# Output:
True
How cool! Now we know for a fact that this function can be of use for checking if a dictionary parameter (in this case our key:values) is a dict (a dictionary data type). All that it’s left for us to do is to write a for loop that uses the isinstance function to check if our dictionary values are of dict data type and order it to add a count to len ( ) whenever that’s the case.
Friends_Contact_List = {
'Rachel':{
'Phone Number':13056191239,
'Email':'Rachel2000@gmail.com',
},
'Zack':{
'Phone Number':12015678122,
'Email':'Zackman@gmail.com',
},
'Dan':{
'Phone Number':17258729935,
'Email':'DanielCorrado@gmail.com',
},
'Jimmy':{
'Phone Number':18556798436,
'Email':'JimmyMcGil@gmail.com',
}
}
length=len(Friends_Contact_List)
for i in Friends_Contact_List.values():
if isinstance(i, dict):
length += len(i)
print(f'The Length of this dictionary is {length}')
# Output:
The Length of this dictionary is 12
Lets go a bit in detail with how our for loop is checking for dict data types and adding then to our Python Length of Dictionary Function’s counter len ( )
length=len(Friends_Contact_List)
for i in Friends_Contact_List.values():
if isinstance(i, dict):
length += len(i)
print(f'The Length of this dictionary is {length}')
First, we establish length as a variable for our len ( ) function:
length=len(Friends_Contact_List)
Since our dictionary is using inner dictionaries (nested dictionaries) as key:values, lets write a for loop that will iterate on our dictionary’s values using the isinstance function:
for i in Friends_Contact_List.values():
Our condition states that if the isinstance function detects a dict data type, then the len( ) counter must increase by 1.
if isinstance(i, dict):
length += len(i)
And there you have it: you can use this code as the baseline for Programming a Python Length of Dictionary Function with The isinstance Method to automatically get an accurate len ( ) return for your nested dictionaries!
Closing Words
The Python dictionary is a powerful data structure that features key-value pairs indexed by a non-mutable data type. The len ( ) function will always return an accurate count of your dictionary’s entries (assuming you’re not using nested dictionaries to organize your data).
If your code features nested dictionaries, you’ll have to adjust your len ( ) function to get an accurate entry count. Using a for loop with an isinstance function to check whether the value of a key is a dictionary is a pretty efficient way to detect and count those subsets of key-value pairs.
If any key or key:values parameter is a dictionary data type dict, the isisnstance method will detect it, and your loop will add it to the len ( ) counter every time. As with many Python-related things, there are many ways to solve a specific problem, so we encourage you to play a bit with mapping data types and the len ( ) function, as both can prove super helpful when handling extensive data collections in your code!
