Throughout my time working with datasets in Python, the dictionary has been my most used data structure. It’s versatile and easy to use.

Need to count occurrences of a character? Use a dictionary!

Want to create a list of soccer players and associated stats? Dictionary!

They’re not fool-proof, though. In many tasks, you’ll run into KeyErrors galore when grokking data, which can be frustrating to deal with.

Dealing with these errors results in several extra lines of code. This reduces readability and increases complexity. If you’re handling a lot of data, this problem can spiral out of control.

The collections module addresses this problem of complexity. The collections module is a part of the Python standard library which contains a few awesome ways to wrangle data. The primary goal of the module is to make your code more readable and to simplify data processing with some extra types.

The one that I use the most is defaultdict, and we’ll explore some simple use cases for that today. To fully appreciate this data container, you should have a working knowledge of Python. More specifically, the regular dictionary type.

How to Simplify Your Code with the DefaultDict

Before we get into today’s topic, let’s look at a situation. I want to create a dictionary that gives me the count of all the different letters in the word “Mississippi”. There are a lot of S’s and P’s, and I don’t have the time to count them all by hand.

Here’s how I would do that using a standard dictionary:

letters = {}

for letter in "Mississippi":
    if letter not in letters:
        letters[letter] = 1
    else:
        letters[letter] +=1

print(letters)
# {'M': 1, 'i': 4, 's': 4, 'p': 2}

Simple enough. This program:

• Iterated through the string.
• Each iteration, it checked if the letter currently had an entry into our letters dictionary.
• If the letter is present, it adds one to the current value.
• If the letter is not present in the letters dictionary, it creates the entry and sets the initial value to 1.

This example was pretty easy, but you can see the code complexity creeping in already. Let’s see how we can do better:

from collections import defaultdict

letters = defaultdict(int)

for letter in "Mississippi":
    letters[letter] += 1

print(letters)
# defaultdict(<class 'int'>, {'M': 1, 'i': 4, 's': 4, 'p': 2})

You should notice that all the conditional statements are now gone. The code should be a little easier to read, but we still got the same result at the end of the program.

This is the benefit of defaultdict. Let’s break this data container down.

Exploring the DefaultDict Data Container

The idea of a defaultdict is simple: if we attempt to access or change the value of a key that does not exist, it creates the entry in the dictionary with the given default value.

In the above example, we started with an empty defaultdict with no entries. For each unique letter we parsed, the dictionary created an entry. Since we used int as the default value, the value of the created entry was 0. After the dictionary created the entry, it added one to the entry.

At the end of the program, the letter count was output without conditionals or manual intervention. Very Pythonic.

How to Set the Default in DefaultDict

The defaultdict data container takes a single argument during its initialization, named default_factory.

This default_factory argument is a function. When the program attempts to access an entry that does not exist, the defaultdict calls the default_factory without any arguments. So, for example, I can call a defaultdict with the function int() like this:

d1 = defaultdict(int)

When I attempt to access an entry that does not exist, it’ll append that entry with the value of the int function, which is 0.

d1 = defaultdict(int)

d1[“Adding an entry!”]

Print(d1)
# defaultdict(<class 'int'>, {'Adding an Entry!': 0})

Exploring the Possibilities of DefaultDict

Now that you know the basic usage of defaultdict, we can explore the possibilities.

As I mentioned earlier, the default_factory is a function without arguments. This means we can use built-in data types as well as custom-defined functions – so, as long as they don’t take arguments.

Let’s go back to our Mississippi example. I want to know the actual index of where all the letter I’s are. I’m going to use a defaultdict with a list for the default_factory argument so we can track all the indices.

from collections import defaultdict

my_word = "Mississippi"

d1 = defaultdict(list)

for index, letter in enumerate(my_word):
    if letter == "i":
        d1[letter].append(index)

print(d1)
# defaultdict(<class 'list'>, {'i': [1, 4, 7, 10]})

Awesome! I hand-checked this example, and it looks like it’s correct. There is the letter I located at index 1, 4, 7, and 10.

This example looks a little different, but the idea is still the same. Here are the steps:

• I created a defaultdict with the default_factory argument of list.
• I iterated through the word “Mississippi”.
• If the iterated letter equals “i”, I access the dictionary with the key “i”.
• If that entry in the dictionary does not already exist, the defaultdict data container will create it for me and use an empty list as the value.
• I then use the list’s append method to add the index of the iterated letter.

Let’s explore some more. Since the default_factory takes a function as an argument, we can define our own – so as long as our custom function does not take an argument.

from collections import defaultdict

def return_hello():
    return "Hello!"

d1 = defaultdict(return_hello)

d1[1]
d1[2]
d1[3]

print(d1)
# defaultdict(<function return_hello at 0x0000014FC5D28DC0>, {1: 'Hello!', 2: 'Hello!', 3: 'Hello!'})

I defined a function here to simply return “Hello!” and assigned it to the default_factory argument. Now, when we try to access entries in our dictionary that do not exist, the defaultdict calls my custom function to determine the default value!

To Recap

In this guide, we went over the defaultdict, which is a data container in the built-in collections module from the Python Standard Library. It allows us to access entries in a dictionary that do not exist by creating them on the fly and assigning a default value.

We saw that the defaultdict takes a default_factory argument, which tells the dictionary the default value to give a key. These can be built-in functions, such as int or list, or can be custom-defined functions, such as our return_hello function above.

I hope you learned something today!

When you're coding in Python, you'll use different data structures. In Python, among the most used is the dictionary.

A dictionary is a collection of key-value pairs that allows you to store and retrieve data.

When working with dictionaries, it's a common practice to check if a key exists or not. This can be most helpful when you are working with a large dataset and need to access values based on their keys.

In this article, we are going to explore different ways that we can use to check if a key exists in a dictionary in Python. Let's get started.

Method 1: Using the in Operator

You can use the in operator to check if a key exists in a dictionary. It's one of the most straightforward ways of accomplishing the task. When used, it returns either a True if present and a False if otherwise.

You can see an example of how to use it below:

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

if 'key1' in my_dict:
    print("Key exists in the dictionary.")
else:
    print("Key does not exist in the dictionary.")

From the code sample above, we check if key1 exists in my_dict. If it does, then the confirmation message will be displayed. If not, the message indicating the key does not exist gets printed.

Method 2: Using the dict.get() Method

The dict.get() method will return the value associated with a given key if it exists and None if the requested key is not found.

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

if my_dict.get('key1') is not None:
    print("Key exists in the dictionary.")
else:
    print("Key does not exist in the dictionary.")

From the code sample above, we used the dict.get() method to get the values associated with key1. If the requested key is present, the my_dict.get('key1') is not None evaluates to True, meaning the requested key is present.

Method 3: Using Exception Handling

Exception handling allows you to first try and access the value of the key and handle the KeyError exception if it occurs.

my_dict = {'key1': 'value1', 'key2': 'value2', 'key3': 'value3'}

try:
    value = my_dict['key1']
    print("Key exists in the dictionary.")
except KeyError:
    print("Key does not exist in the dictionary.")

The code sample above allows us to access the value associated with key1. If it exists, the code inside try executes and the message gets printed. But if the KeyError exception occurs, then it means the key does not exist and the code inside the except block will be executed.

Additional Points

• Key exists versus value exists The methods we have discussed above only check if a key exists. If we were to check if a value is present, we will need to iterate through the values using methods like dictname.values().

• Performance considerations Different methods may have different performance implications depending on the size of your dictionary. Generally the in operator is best for small to medium-sized dictionaries while dict.get() and exemption handling are a good fit for large dictionaries.

• Combining methods A good thing about working with Python dictionary methods is that you can combine them. For example, you can use the in operator to check if a key exists and the dict.get() to retrieve its value if it exists.

• Using dict.setdefault() It allows you to check if a key exists and returns the value if present. In case the key is missing, then you can set a default value while adding it to the dictionary at the same time.

With an understanding of the above points and good practice using these methods, you should be comfortable working with dictionaries in Python.

Sorting is a fundamental operation in computer programming that involves arranging elements in a specific order.

Whether you're working with numbers, strings, or complex data structures, sorting plays a crucial role in organizing and manipulating data efficiently.

From small arrays to large datasets, sorting algorithms allow programmers to solve a wide range of problems, from searching for specific values to optimizing data access and analysis.

In this article, we will explore how to sort a dictionary with keys in Python. We will break down the steps for easy follow up and understanding. I recommend that you be familiar with the Python programming language to get the most out of this article.

What is a Python Dictionary?

In Python, dictionaries are a powerful data structure used to store key-value pairs. They provide a convenient way to organize and retrieve data based on unique keys. But there may be situations where you need to sort a dictionary by its keys in a specific order.

A key in Python refers to the unique identifier associated with a specific value. It serves as a way to access and retrieve values from the dictionary based on their corresponding keys. Keys in a dictionary can be of any immutable data type, such as strings, numbers (integers or floats), or tuples. The key must be unique within the dictionary, meaning that no two keys can have the same value.

Ways to Sort a Dict by Keys in Python

Method 1: Using the sorted() Function

The simplest way to sort a dictionary by its keys is by using the sorted() function along with the items() method of the dictionary.

The items() method returns a list of key-value pairs as tuples. By passing this list to the sorted() function, we can sort the tuples based on their first element (the keys).

Example:

my_dict = {'b': 2, 'a': 1, 'c': 3}
sorted_dict = dict(sorted(my_dict.items()))

print(sorted_dict)

Output:

{'a': 1, 'b': 2, 'c': 3}

In this example, the sorted() function takes the my_dict.items() list and returns a new sorted list of tuples. We use the dict() constructor to convert the sorted list back into a dictionary.

Method 2: Using a List of Tuples

If you prefer a more manual approach, you can convert the dictionary to a list of tuples, sort the list using any sorting technique available in Python, and then convert it back to a dictionary.

Example:

my_dict = {'b': 2, 'a': 1, 'c': 3}
sorted_list = sorted(my_dict.items())

sorted_dict = {}
for key, value in sorted_list:
    sorted_dict[key] = value

print(sorted_dict)

Output:

{'a': 1, 'b': 2, 'c': 3}

In this example, we used the sorted() function to sort the my_dict.items() list. Then, a new empty dictionary, sorted_dict, is created. The sorted list is iterated over, and each key-value pair is added to the sorted_dict using assignment.

Method 3: Using the collections.OrderedDict Class

Another approach to sorting a dictionary by key is to use the collections.OrderedDict class from the Python standard library.

This class is a dict subclass that remembers the order of its elements based on the insertion order. We can leverage this feature to achieve key-based sorting.

Example:

from collections import OrderedDict

my_dict = {'b': 2, 'a': 1, 'c': 3}
sorted_dict = OrderedDict(sorted(my_dict.items()))

print(sorted_dict)

Output:

OrderedDict([('a', 1), ('b', 2), ('c', 3)])

In this example, the sorted() function is used to sort the my_dict.items() list, and then the sorted list is passed to the OrderedDict() constructor to create a new dictionary with the sorted order.

Conclusion

In Python, you can sort a dictionary by its keys using various methods. In this article, we explored three approaches: using the sorted() function, utilizing the collections.OrderedDict class, and manually sorting a list of tuples. Each method provides a different level of control and flexibility.

By using the sorted() function, we can quickly sort a dictionary by key and obtain a new dictionary as the result. If preservation of the insertion order is crucial, the collections.OrderedDict class is a suitable choice.

For those who prefer a more manual approach, converting the dictionary to a list of tuples, sorting the list, and then creating a new dictionary can provide more customization options.

Let's connect on Twitter and on LinkedIn. You can also subscribe to my YouTube channel.

Happy Coding!

You can read about the different methods you can use to access, modify, add, and remove elements in a dictionary here.

In this article, you'll learn how to merge two dictionaries using the following:

• The update() method.
• The double asterisk/star operator (**).
• The chain() method.
• The ChainMap() method.
• The merge operator (|).
• The update operator (|=).

How to Merge Two Dictionaries in Python

In this section, we'll discuss the different methods you can use to merge dictionaries in Python, along with code examples.

All the examples you'll see in this article will involve the merging of two dictionaries, but you can merge as many as you want.

How to Merge Two Dictionaries in Python Using the update() Method

The update() method is a built-in method that you can use to add data to dictionaries.

Consider the dictionary below:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

devBio.update({"role": "Technical Writer"})

print(devBio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'role': 'Technical Writer'}

In the code above, we created a dictionary called devBio with three key and value pairs: {'name': 'Ihechikara', 'age': 50, 'language': 'Python'}.

Using the update() method, we added another key and value pair: devBio.update({"role": "Technical Writer"}).

In the same manner, we can merge two dictionaries by passing another dictionary as a parameter to the update() method. Here's an example:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

devBio.update(tools)

print(devBio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we created two dictionaries — devBio and tools.

Using the update() method, we merged the key and value pairs of the tools dictionary to the devBio dictionary: devBio.update(tools).

The merged dictionaries looked like this:

{
    'name': 'Ihechikara', 
    'age': 500, 
    'language': 'Python', 
    'dev environment': 'JupyterLab', 
    'os': 'Windows', 
    'visualization': 'Matplotlib'
}

How to Merge Two Dictionaries in Python Using the Double Asterisk Operator (**)

You can use the double asterisk (also called double star) operator (**) to "unpack" and merge the key and value pairs of two or more dictionaries into a variable.

Here's a code example:

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = { **devBio, **tools}

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we unpacked the devBio and tools dictionaries using the double asterisk operator: { **devBio, **tools}.

We then stored them in a variable called merged_bio.

How to Merge Two Dictionaries in Python Using the chain() Method

The chain() method takes multiple iterable objects as its parameter. It merges and returns the objects as one iterable object.

You have to import the chain() method from the itertools module before using it:

from itertools import chain

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = dict(chain(devBio.items(), tools.items()))

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we passed the dictionaries to be merged as parameters to the chain() method: chain(devBio.items(), tools.items()).

We used the items() method to access the key and value pairs of each dictionary.

Lastly, we nested the chain() method and its parameters in the dict() method: dict(chain(devBio.items(), tools.items())).

The dict() method can be used to create a dictionary so we used it to convert the iterable objects returned (the key and value pairs) into a dictionary, and stored them in the merged_bio variable.

How to Merge Two Dictionaries in Python Using the ChainMap() Method

The ChainMap() method works the same way as the chain() method as regards to merging dictionaries. The main difference is that you don't need the items() method to access the key and value pairs of the dictionaries.

You can import the ChainMap() method from the collections module.

Here's how you can use the ChainMap() method to merger two dictionaries:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = dict(ChainMap(devBio, tools))

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

You can check the explanation in the last section to understand the logic in the code above.

How to Merge Two Dictionaries in Python Using the Merge Operator (|)

The merge operator (|) was first introduced in Python 3.9. It's a shorter and simpler syntax that you can use to merge dictionaries.

Here's an example:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

merged_bio = devBio | tools

print(merged_bio)
# {'name': 'Ihechikara', 'age': 500, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

So to merge the devBio and tools dictionary, we put the | operator between them: devBio | tools.

How to Merge Two Dictionaries in Python Using the Update Operator (|=)

The update operator (|=) operator is another operator that was introduced in Python 3.9.

It works just like the update() method. That is:

from collections import ChainMap

devBio = {
  "name": "Ihechikara",
  "age": 500,
  "language": "Python"
}

tools = {
  "dev environment": "JupyterLab",
  "os": "Windows",
  "visualization": "Matplotlib"
}

devBio |= tools

print(devBio)
# {'name': 'Ihechikara', 'age': 50, 'language': 'Python', 'dev environment': 'JupyterLab', 'os': 'Windows', 'visualization': 'Matplotlib'}

In the code above, we used the |= to mege the key and value pairs in the tools dictionary into the devBio dictionary.

Summary

In this article, we talked about dictionaries in Python. You can use them to store data in key-value pairs.

We saw how to merge two dictionaries in Python using:

• The update() method.
• The double asterisk/star operator (**).
• The chain() method.
• The ChainMap() method.
• The merge operator (|).
• The update operator (|=).

Each method had its own section with code examples that showed how to use them to merge dictionaries.

Happy coding! You can learn more about Python on my blog.

In this article, we will talk about dictionaries, and also learn how to loop through a dictionary in python.

Python Dictionaries

In Python, a dictionary is a built-in data structure used to store and organize data in key-value pairs.

A dictionary has two parts for each entry: a key and a value. The associated value can be accessed using the key, a special identifier. Any data type, including a number, string, list, or another dictionary, may be used as the value.

Dictionaries can be created by explicitly assigning values to keys or by using the dict() constructor function. They are indicated by curly braces { }. Here is an illustration of a basic dictionary:

DemoDict = {'name': 'John', 'age': 25, 'city': 'New Jersey'}

In this example, the keys are 'name', 'age', and 'city', and the corresponding values are 'John', 25, and 'New Jersey', respectively.

We will now check out the different methods for looping through a dictionary: the items() method, the keys() method, the values() method, and using list comprehension.

How to Iterate Through a Dict Using the items() Method

We can use the items() method to loop through a dictionary and get both the key and value pairs.

Let's consider an example:

DemoDict = {'apple': 1, 'banana': 2, 'orange': 3}

# Loop through the dictionary
for key, value in my_dict.items():
    print(key, value)

Output:

apple 1
banana 2
orange 3

How to Iterate Through a Dict Using the keys() Method

If we only want to loop through the keys of the dictionary, we can use the keys() method.

DemoDict = {'apple': 1, 'banana': 2, 'orange': 3}

# Loop through the keys of the dictionary
for key in my_dict.keys():
    print(key)

Output:

apple
banana
orange

How to Iterate Through a Dict Using the values() Method

Similarly, if we only want to loop through the values of the dictionary, we can use the values() method.

my_dict = {'apple': 1, 'banana': 2, 'orange': 3}

# Loop through the values of the dictionary
for value in my_dict.values():
    print(value)

Output:

1
2
3

How to Iterate Through a Dict Using List Comprehension

Finally, we can also use list comprehension to loop through a dictionary and get both the key and value pairs.

Let's demonstrate this with an example:

my_dict = {'apple': 2, 'banana': 3, 'orange': 4}

# Loop through the dictionary using list comprehension
[(key, value) for key, value in my_dict.items()]

Output:

[('apple', 1), ('banana', 2), ('orange', 3)]

Note: The output of list comprehension is a list of tuples where each tuple contains a key-value pair of the dictionary.

Key Differences Between Methods of Looping Through a Dictionary in Python

Compatibility with different Python versions:

• The items() method and values() method were introduced in Python 3, so they are not compatible with Python 2. If you need to write code that is compatible with both Python 2 and 3, you should use a basic for loop to iterate through the keys of the dictionary.
• The keys() method is compatible with both Python 2 and 3, so it is a good option if you need to write code that works on both versions of Python.

Performance:

• In general, using a basic for loop to iterate through the keys of a dictionary is the fastest method of looping through a dictionary in Python. This is because it avoids the overhead of creating a list of the dictionary's keys or items.
• The items() method is slower than a basic for loop because it creates a new list of tuples that contains the key-value pairs of the dictionary.
• The values() method is also slower than a basic for loop because it creates a new list of the values of the dictionary.

Access to keys, values, or both:

• When using a basic for loop to iterate through a dictionary, you only have access to the keys of the dictionary. To access the corresponding values, you need to use the keys as the index to the dictionary.
• The items() method provides a way to access both the keys and values of the dictionary in a single loop. This is convenient when you need to work with both the keys and values of a dictionary.
• The values() method, on the other hand, allows you to access only the values of the dictionary. This can be useful when you don't need the keys but just want to work with the values themselves.

Conclusion

Dictionaries are incredibly useful for storing and retrieving data in a flexible and efficient manner. They are commonly used in Python programming for tasks such as data analysis, web development, and machine learning.

Let's connect on Twitter and on LinkedIn. You can also subscribe to my YouTube channel.

Happy Coding!

Welcome to this Python article on how to create a dictionary.

A dictionary (also called a hashmap in other languages) is an unordered grouping of key-value pairs in Python. Since each value can be accessed by its corresponding key, it offers a practical means of storing and retrieving data.

We'll cover the fundamentals of creating a dictionary in Python in this tutorial, including how to initialize an empty dictionary, how to add and remove key-value pairs, and how to access and work with dictionary data.

I'll illustrate each concept with examples, and demonstrate each operation with code snippets.

By the time you finish reading this article, you ought to know everything you need to use dictionaries in Python, from creating them to modifying them. And and you should be able to use this information to solve issues and construct more sophisticated programs.

Let's begin!

How to Create a Dict in Python

A dictionary is a type of data structure that allows us to store key-value pairs. It is also known as a hashmap in other programming languages.

Dictionaries are useful when we want to store data in a way that is easily accessible and modifiable. To create dictionaries in Python, we use curly braces, the dict() constructor, and the fromkeys() method.

How to create a dict using curly braces

Curly braces { } are one method of creating a dictionary in Python. We can enclose a comma-separated list of key-value pairs in curly braces to make a dictionary. We use a colon and a comma to separate each pair of key-value pairs from the others.

Here's an example:

MyDict = {1: "apple", 2: "banana", 3: "orange"}

In this example, we've created a dictionary MyDict with three key-value pairs:
1: "apple", 2: "banana", and 3: "orange". The keys are integers and the values are strings.

How to create a dict using the dict() constructor

Another method for making a dictionary in Python is using the dict() constructor. The constructor dict() produces a dictionary from an iterable of key-value pairs as input. Both a list of tuples and arguments can be used to pass in the key-value pairs. As an illustration, consider the following.

Let's create a dictionary from a tuple.

# create a dictionary from a tuple using dict() constructor
MyDict = dict(one=1, two=2, three=3)
print(MyDict)

Output:

{'one': 1, 'two': 2, 'three': 3}

Let's create a dictionary from a list of tuples.

# create a dictionary from a list of tuples using dict() constructor
MyList = [('one', 1), ('two', 2), ('three', 3)]
MyDict = dict(MyDict)
print(MyDict)

Output:

{'one': 1, 'two': 2, 'three': 3}

In the first example, we created a dictionary with key-value pairs one:1, two:2, and three:3 by passing them as arguments to the dict() constructor.

In the second example, we created a dictionary using a list of tuples MyList, which contains the same key-value pairs as before. We passed MyList as an argument to the dict() constructor, which returns a dictionary with the same key-value pairs.

The dict() constructor can also be used to create an empty dictionary by not passing any arguments. For example, MyDict = dict() creates an empty dictionary MyDict.

How to create a dict using the fromkeys() method

You can also use the built-in fromkeys() method to create a dictionary by selecting keys from a sequence and setting values to default values.

The first argument to the fromkeys() method is a list of keys, and the second (optional) argument is the value that will be assigned to each key after it has been set. The values will automatically be set to None if the second argument is not provided.

Example

keys = ['a', 'b', 'c']
values = 0  # set default value to 0

MyDict = dict.fromkeys(keys, values)
print(MyDict)

Output:

{'a': 0, 'b': 0, 'c': 0}

In the example above, we passed a list of keys ['a', 'b', 'c'] and a default value 0 to the fromkeys() method. We get a new dictionary where all keys are set the value of 0.

Conclusion

In this tutorial, we learned how to create a dict in Python by focusing on three ways: using curly braces, the dict() constructor, and the fromkeys() method. With this knowledge, you can confidently create and manipulate dictionaries in your Python code.

Let's connect on Twitter and on LinkedIn. You can also subscribe to my YouTube channel.

Happy Coding!

A dictionary in Python is a group of unordered items, each of which has a unique set of keys and values.

Any immutable data type, such as a string, number, or tuple, can be used as the key. It serves as an exclusive identifier for the value in the dictionary. The value is repeatable and applicable to all types of data.

In Python, dictionaries are denoted by curly braces { }, and each key-value pair is delimited by a colon :. A comma separates the key and value. Here is an illustration of a basic dictionary:

my_dict = {"pineapple": 12, "apple": 30, "orange": 5, "avocado":7}

In this example, "pineapple", "apple", "orange", and "avocado" are the keys, and 12, 30, 5 and 7 are the corresponding values.

We will have a look at how we can add a single key-value pair to a dictionary using the update() method, and finally the dict() constructor.

How to add a single key-value pair to a dictionary

To add a single key-value pair to a dictionary in Python, we can use the following code:

myDict = {'a': 1, 'b': 2}
myDict['c'] = 3

The above code will create a dictionary myDict with two key-value pairs. Then we added a new key-value pair 'c' : 3 to the dictionary by just assigning the value 3 to the key 'c'. After the code is executed, the dictionary myDict will now contain the key-value pair 'c': 3.

Let's confirm this by printing the dictionary.

print(myDict)

Output:

{'a': 1, 'b': 2, 'c': 3}

If there is a key 'c' in the dictionary already, the value would be updated to 3.

How to add multiple key-value pairs with the update() method

Multiple key-value pairs can be simultaneously added to a dictionary using the update() method. This method inserts new entries into the original dictionary from another dictionary or an iterable of key-value pairs as input. The value of an existing key in the original dictionary will be updated with the new value.

Example using the update() method to add multiple entries to a dictionary:

myDict = {'a': 1, 'b': 2}
new_data = {'c': 3, 'd': 4}

myDict.update(new_data)

print(myDict)

Output:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Another fun thing about this method is that, we can use the update() method with an iterable of key-value pairs, such as a list of tuples. Let's see this in action.

myDict = {'a': 1, 'b': 2}
new_data = [('c', 3), ('d', 4)]

myDict.update(new_data)

print(myDict)

The output is the same as the previous example:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

How to update a dictionary using the dict() constructor

In Python, a dictionary can be updated or made from scratch using the dict() constructor. By passing a dictionary containing the new key-value pair as an argument to the dict() constructor, we can add a single key-value pair to an existing dictionary.

Example:

myDict = {'a': 1, 'b': 2, 'c': 3}
newDict = dict(myDict, d=4)

print(newDict)

Output:

{'a': 1, 'b': 2, 'c': 3, 'd': 4}

In this example, three key-value pairs were added to a brand-new dictionary called myDict. Then, we created a new dictionary called newDict using the dict() constructor, which also added the key-value pair 'd': 4'.

When the two dictionaries are combined by the dict() constructor, any keys that are present in both dictionaries have their values overwritten by the value from the second dictionary (in this case, 'd': 4').

Keep in mind that a new dictionary can also be created using the dict() constructor from a list of key-value pairs, where each pair is represented by a tuple.

MyList = [('a', 1), ('b', 2), ('c', 3)]
MyDict = dict(MyList)

print(MyDict)

Output:

{'a': 1, 'b': 2, 'c': 3}

Conclusion

In Python, dictionaries are frequently used to store data and provide quick access to it using a distinct key value. They come in handy when working with lists or tuples, where we need to access data using a specific identifier rather than its place in a sequence.

Let's connect on Twitter and on LinkedIn. You can also subscribe to my YouTube channel.

Happy Coding!

Dictionaries are a useful data type in Python for storing data in a key-value format. And there are times when you might need to remove a particular key-value pair from a dictionary.

You'll learn some dictionary basics, as well as how to delete keys, in this tutorial.

How to Write a Dict in Python

Dictionaries are denoted by curly braces {} and the key-value pairs are separated by colons :. For example, the following code initializes a dictionary with three key-value pairs:

my_dict = {'apple': 2, 'banana': 3, 'orange': 5}

You can also initialize dictionaries using the built-in dict() function. For example:

my_dict = dict(apple=2, banana=3, orange=5)

Now I'll teach you how to securely remove keys from a Python dictionary. When I say "securely," I mean that if the key doesn't actually exist in the dictionary, the code won't throw an error.

We'll discover how to accomplish this using the del keyword, the pop() method, and the popitem() method. Finally, you'll see how to use Python to remove multiple keys from a dictionary.

Let's get started!

How to Remove a Key from a Dict Using the del Keyword

The most popular method for removing a key:value pair from a dictionary is to use the del keyword. You can also use it to eliminate a whole dictionary or specific words.

Simply use the syntax shown below to access the value you need to delete:

del dictionary[key]

Let's have a look at an example:

Members = {"John": "Male", "Kat": "Female", "Doe": "Female" "Clinton": "Male"}

del Members["Doe"]
print(Members)

Output:

{"John": "Male", "Kat": "Female", "Clinton": "Male"}

How to Remove a Key from a Dict Using the pop() Method

Another technique to remove a key-value pair from a dictionary is to use the pop() method. The syntax is shown below:

dictionary.pop(key, default_value)

Example:

My_Dict = {1: "Mathew", 2: "Joe", 3: "Lizzy", 4: "Amos"}
data = My_Dict.pop(1)
print(data)
print(My_Dict)

Output:

Mathew
{2: "Joe", 3: "Lizzy", 4: "Amos"}

How to Remove a Key from a Dict Using the popitem() Function

The built-in popitem() function eliminates the the last key:value pair from a dictionary. The element that needs to be removed cannot be specified and the function doesn't accept any inputs.

The syntax looks like this:

dict.popitem()

Let's consider and example for a better understanding.

# initialize a dictionary
My_dict = {1: "Red", 2: "Blue", 3: "Green", 4: "Yello", 5: "Black"}

# using popitem()
Deleted_key = My_dict.popitem()
print(Deleted_key)

Output:

(5, 'Black')

As you can see, the function removed the last key:value pair – 5: "Black" – from the dictionary.

How to Remove Multiple Keys from a Dict

You can easily delete multiple keys from a dictionary using Python. The .pop() method, used in a loop over a list of keys, is the safest approach for doing this.

Let's examine how we can supply a list of unique keys to remove, including some that aren't present:

My_dict = {'Sam': 16, 'John': 19, 'Alex': 17, 'Doe': 15}

#define the keys to remove
keys = ['Sam', 'John', 'Doe']

for key in keys:
    My_dict.pop(key, None)

print(My_dict)

Output:

{'Alex': 17}

One thing to note is that in the pop() method inside the loop, we pass in None and the default value, just to make sure no KeyError is printed if a key doesn't exist.

How to Remove All Keys from a Dict Using the clear() Method

You can use the clear() method to remove all key-value pairs from a dictionary. The syntax is as follows:

dictionary.clear()

Example:

Colors = {1: "Red", 2: "Blue", 3: "Green"}
Colors.clear()
print(Colors)

Output:

{}

Conclusion

For removing a key-value pair or several key-value pairs from a dictionary, we discussed a variety of Python methods in this article.

You can do so using the del keyword, which is the most common method of removing a key-value pair from a dictionary. The pop() method is useful when we need to remove a key-value pair and also get the value of the key-value pair. Using the popitem() function, we can remove the final key-value pair in a dictionary.

Also, if you need to remove all key:value pairs in a dictionary, you can use the clear() method.

Let's connect on Twitter and on LinkedIn. You can also subscribe to my YouTube channel.

Happy Coding!

stack_dict = {
    "frontend": "JavaScript",
    "backend": "Node JS",
    "markup": "HTML and JSX",
}

To access the value in the dictionary, you can do it this way: dict[key]. For example, if I want to access what the frontend key holds, I can do it like this:

print(stack_dict["frontend"])
# JavaScript

But what if you want to add another entry to the dictionary without going back to the dictionary to put it there? That's what we are going to look at in this article. And I'm going to show you how to do it in 3 different ways.

What We'll Cover

• How to Add to a Dictionary in Python
• How to Add to a Dictionary by Mapping a key to the Dictionary
• How to Add to a Dictionary by Using the update() Method
• How to Add to a Dictionary by Using the if Statement
• Conclusion

How to Add to a Dictionary in Python

You can add to a dictionary in three different ways:

• map a key to the dictionary
• use the update() method
• use an if statement

How to Add to a Dictionary in Python by Mapping a key to the Dictionary

If you want to add to a dictionary with this method, you'll need to add the value with the assignment operator.

dict["key"] = "value"`

This would also override the value of an existing key.

In the stack dictionary I defined earlier, there's no styling there:

stack_dict = {
    "frontend": "JavaScript",
    "backend": "Node JS",
    "markup": "HTML and JSX",
}

So let's add a styling key and CSS value to the dictionary by mapping a new key to the dictionary:

stack_dict["styling"] = "CSS"

print(stack_dict)
# Output: {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML and JSX', 'styling': 'CSS'}

You can see that a new key of styling and a value of CSS has been added to the dictionary.

If the key already exists, the value gets overwritten:

stack_dict["markup"] = "HTML only"
print(stack_dict)

# {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML only'}

How to Add to a Dictionary in Python Using the update() Method

The stack is still missing a JavaScript library, so let's add it with the update() method. You can do that this way:

dict.update({"key": "value"})`.

So, to add the JavaScript framework/library, I did it like this:

stack_dict.update({"JS Framework": "React/Next"})

print(stack_dict)
# {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML and JSX', 'styling': 'CSS', 'JS Framework': 'React/Next'}

The update() also overwrites an existing value if it's different:

stack_dict.update({"backend": "Django"})

print(stack_dict)
# {'frontend': 'JavaScript', 'backend': 'Django', 'markup': 'HTML and JSX'}

How to Add to a Dictionary in Python Using the if Statement

If you don't want an entry to be overwritten even if it already exists, you can use an if statement. You can do it with this syntax:

if "value" not it dict.keys():
    dict["key"] = "value"

I want to add a "CSS Framework" key with a value of "Tailwind CSS" to the stack dictionary, so I'm going to do that with the help of this syntax:

if "Tailwind CSS" not in stack_dict.keys():
    stack_dict["CSS Framework"] = "Tailwind CSS"

print(stack_dict)
# {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML and JSX', 'styling': 'CSS', 'JS Framework': 'React/Next', 'CSS Framework': 'Tailwind CSS'}

If the entry is already in the dictionary, it won't be added in there:

if "HTML and JSX" not in stack_dict.keys():
    stack_dict["markup"] = "HTML and JSX"

print(stack_dict)
# {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML and JSX', 'styling': 'CSS', 'JS Framework': 'React/Next'}

If you don't feel like using an if statement to add to the dictionary, you can do the same thing with try…except…:

try:
  stack_dict["Deployment"] = "Anywhere possible"
except:
  print("An exception occurred")

print(stack_dict)
# {'frontend': 'JavaScript', 'backend': 'Node JS', 'markup': 'HTML and JSX', 'styling': 'CSS', 'JS Framework': 'React/Next', 'Deployment': 'Anywhere possible'}

Conclusion

This article took you through three different ways to add to a dictionary in Python:

• mapping a key to the dictionary
• using the update() method
• using an if statement

We even looked at how you can add to a dictionary with the try…except… expression.

Thank you for reading.

And you can use dictionary comprehension to create a new dictionary from an already existing one.

When creating a new dictionary using dictionary comprehension, you can perform various operations using expressions to determine the data (key and/or value) that will be stored in the new dictionary.

In this article, you'll learn how to create dictionaries in Python using dictionary comprehension. You'll also see various expressions that you can use to modify the data to be stored in the new dictionary.

Let's get started!

How to Use Dictionary Comprehension in Python

Before we take a look at some examples, here's what the syntax for dictionary comprehension looks like:

new_dictionary = {key: value for (key,value) in iterable}

In the syntax above, key and value represent the key and value in the initial dictionary. Whatever operation you carry out on them determines the keys/values in the new dictionary — you'll understand this better soon with some examples.

The key and value in parenthesis – (key, value) – are still the same as the ones we mentioned above. In this case, they are used in a for loop.

So whatever operation you perform on key and value will be used by the loop to apply that operation on every item the operation is associated with in the initial dictionary.

iterable, in the syntax, denotes an iterable object. In our case, it denotes the initial dictionary.

Let's look at some examples to help you understand the explanations above.

items_in_cm = {'pen': 40, 'book': 50, 'keyboard': 60}

In the code above, we created a dictionary with three items. The keys are the names of the items while the values are the length of these items in centimeters.

Using a dictionary comprehension, we'll create a new dictionary with the length of each item in meters.

Here's how it works:

items_in_cm = {'pen': 40, 'book': 50, 'keyboard': 60}

items_in_meters = {key: value/100 for (key, value) in items_in_cm.items()}

print(items_in_meters)
# {'pen': 0.4, 'book': 0.5, 'keyboard': 0.6}

What to look out for is in the second line above: items_in_meters = {key: value/100 for (key, value) in items_in_cm.items()}

Let's break it down.

The first part has this: key: value/100. This implies that every value in the dictionary is to be divided by 100.

But the dictionary comprehension is yet to understand where to apply the command above.

This leads us to the second part: for (key, value) in items_in_cm.items(). This part the code has a for loop that takes two parameters — key and value.

So this will run through every key and value in the items_in_cm dictionary and divide each value by 100.

We are able to access the items in that dictionary using the items() method which returns every key and value pair in a dictionary.

Printing the new dictionary (items_in_meters), we have this: {'pen': 0.4, 'book': 0.5, 'keyboard': 0.6}. Every value in the new dictionary has been divided by 100.

You'll notice that we only altered the data in the dictionary's values. You can also modify the keys. Here's an example:

items_in_cm = {'pen': 40, 'book': 50, 'keyboard': 60}

items_in_meters = {key + ' in meters': value/100 for (key, value) in items_in_cm.items()}

print(items_in_meters)
# {'pen in meters': 0.4, 'book in meters': 0.5, 'keyboard in meters': 0.6}

In the example above, we added a string to every key in the dictionary comprehension: key + ' in meters'.

How to Use Conditional Statements in Dictionary Comprehension in Python

In this section and the next, you'll learn about other expressions that you can use to modify the items stored in dictionaries created using dictionary comprehension.

We'll start with conditional statements.

developers = {'Jane': 'Python', 'Jade': 'JavaScript', 'John': 'Python', 'Doe': 'JavaScript'}

python_developers = {key: value for (key, value) in developers.items() if value == 'Python'}

print(python_developers)
# {'Jane': 'Python', 'John': 'Python'}

In the example above, we created a dictionary called developers which stores a list of developers with their favorite languages: {'Jane': 'Python', 'Jade': 'JavaScript', 'John': 'Python', 'Doe': 'JavaScript'}.

In the dictionary comprehension, we added an expression at the end: if value == 'Python'. This will scan through and return all the items whose value has a value of 'Python'.

When printed out, we have this in the console: {'Jane': 'Python', 'John': 'Python'}.

We can also use an if/else statement in dictionary comprehensions. Here's an example:

random_items = {'monitor': 100, 'pen': 40, 'keyboard': 60, 'pencil': 30}

items_length_check = {key: ('above 50' if value > 50 else 'below 50') for (key, value) in random_items.items()}

print(items_length_check)
# {'monitor': 'above 50', 'pen': 'below 50', 'keyboard': 'above 50', 'pencil': 'below 50'}

Using an if/else statement above, we modified the values in the new dictionary. The value for each item will be "above 50" if the value in the initial dictionary is above 50 and "below 50" if less than 50.

The code in the dictionary comprehension is starting to look bulky. We'll clean it up in the next section using a function.

How to Use a Function in Dictionary Comprehension in Python

When using dictionary comprehension, you can use functions to replace/extract logic that should go into the curly brackets of the dictionary comprehension. This help keep the code neat and readable.

random_items = {'monitor': 100, 'pen': 40, 'keyboard': 60, 'pencil': 30}

def check_length(value):
    if value >50:
        return 'above 50'
    else:
        return 'below 50'

items_length_check = {key: check_length(value) for (key, value) in random_items.items()}


print(items_length_check)
# {'monitor': 'above 50', 'pen': 'below 50', 'keyboard': 'above 50', 'pencil': 'below 50'}

The example above is similar to the one in the last section.

We made one major change — extracting the logic in the dictionary comprehension and putting it in a function. That is:

def check_length(value):
    if value >50:
        return 'above 50'
    else:
        return 'below 50'

We then put the function name in the dictionary comprehension: items_length_check = {key: check_length(value) for (key, value) in random_items.items()}.

When the code in the dictionary comprehension runs, the function is fired.

Summary

In this article, we talked about dictionary comprehension in Python. You can use it to create new dictionaries from existing ones.

We saw the syntax and how to use dictionary comprehension.

We also saw examples that showed how to use conditional statements and functions when working with dictionary comprehension.

Happy coding!

The problem is that sorting a dictionary by value is never a straightforward thing to do. That’s because Python doesn’t have an inbuilt method to do it.

However, I figured out a way to sort dictionaries by value, and that’s what I’m going to show you how to do in this article.

What We'll Cover

• How to Sort Data with the sorted() Method
• How the sorted() Method Works
  • Parameters of the sorted() Method
• How to Sort a Dictionary with the sorted() Method
  • How to Convert the Resulting List to a Dictionary
  • How to Sort the Dictionary by Value in Ascending or Descending Order
• Conclusion

How to Sort Data with the sorted() Method

The sorted() method sorts iterable data such as lists, tuples, and dictionaries. But it sorts by key only.

The sorted() method puts the sorted items in a list. That’s another problem we have to solve, because we want the sorted dictionary to remain a dictionary.

For instance, sorted() arranged the list below in alphabetical order:

persons = ['Chris', 'Amber', 'David', 'El-dorado', 'Brad', 'Folake']
sortedPersons = sorted(persons)

print(sortedPersons)
# Output: ['Amber', 'Brad', 'Chris', 'David', 'El-dorado', 'Folake']

And the sorted() method sorts the numbers in the tuple below in ascending order:

numbers = (14, 3, 1, 4, 2, 9, 8, 10, 13, 12)
sortedNumbers = sorted(numbers)

print(sortedNumbers)
# Output: [1, 2, 3, 4, 8, 9, 10, 12, 13, 14]

If you use the sorted() method with a dictionary, only the keys will be returned and as usual, it will be in a list:

my_dict = { 'num6': 6, 'num3': 3, 'num2': 2, 'num4': 4, 'num1': 1, 'num5': 5}
sortedDict = sorted(my_dict)

print(sortedDict)
# ['num1', 'num2', 'num3', 'num4', 'num5', 'num6']

This is not the behavior you want. You want the dictionary to be sorted by value and remain a dictionary. That’s what I’m going to show you next.

How the sorted() Method Works

To sort a dictionary, we are still going to use the sorted function, but in a more complicated way. Don’t worry, I will explain everything you need to know.

Since we are still going to use the sorted() method, then it’s time to explain the sorted() method in detail.

Parameters of the sorted() Method

The sorted() method can accept up to 3 parameters:

• iterable – the data to iterate over. It could be a tuple, list, or dictionary.

• key – an optional value, the function that helps you to perform a custom sort operation.

• reverse – another optional value. It helps you arrange the sorted data in ascending or descending order

If you guess it right, the key parameter is what we’ll pass into the sorted() method to get the dictionary sorted by value.

Now, it’s time to sort our dictionary by value and make sure it remains a dictionary.

How to Sort a Dictionary with the sorted() Method

To correctly sort a dictionary by value with the sorted() method, you will have to do the following:

• pass the dictionary to the sorted() method as the first value
• use the items() method on the dictionary to retrieve its keys and values
• write a lambda function to get the values retrieved with the item() method

Here’s an example:

footballers_goals = {'Eusebio': 120, 'Cruyff': 104, 'Pele': 150, 'Ronaldo': 132, 'Messi': 125}

sorted_footballers_by_goals = sorted(footballers_goals.items(), key=lambda x:x[1])
print(sorted_footballers_by_goals)

As I said earlier, we have to get those values of the dictionary so we can sort the dictionary by values. That’s why you can see 1 in the lambda function.

1 represents the indexes of the values. The keys are 0. Remember that a programmer starts counting from 0, not 1.

With that code above, I got the result below:

# [('Cruyff', 104), ('Eusebio', 120), ('Messi', 125), ('Ronaldo', 132), ('Pele', 150)]

Here’s the full code so you don’t get confused:

footballers_goals = {'Eusebio': 120, 'Cruyff': 104, 'Pele': 150, 'Ronaldo': 132, 'Messi': 125}

sorted_footballers_by_goals = sorted(footballers_goals.items(), key=lambda x:x[1])
print(sorted_footballers_by_goals)

# [('Cruyff', 104), ('Eusebio', 120), ('Messi', 125), ('Ronaldo', 132), ('Pele', 150)]

You can see the dictionary has been sorted by values in ascending order. You can also sort it in descending order. But we’ll look at that later because we still have a problem with the result we got.

The problem is that the dictionary is not a dictionary anymore. The individual keys and values were put in a tuple and further condensed into a list. Remember that whatever you get as the result of the sorted() method is put in a list.

We’ve been able to sort the items in the dictionary by value. What’s left is converting it back to a dictionary.

How to Convert the Resulting List to a Dictionary

To convert the resulting list to a dictionary, you don’t need to write another complicated function or a loop. You just need to pass the variable saving the resulting list into the dict() method.

converted_dict = dict(sorted_footballers_by_goals)
print(converted_dict)
# Output: {'Cruyff': 104, 'Eusebio': 120, 'Messi': 125, 'Ronaldo': 132, 'Pele': 150}

Remember we saved the sorted dictionary in the variable named sorted_footballers_by_goals, so it’s the variable we have to pass to dict().

The full code looks like this:

footballers_goals = {'Eusebio': 120, 'Cruyff': 104, 'Pele': 150, 'Ronaldo': 132, 'Messi': 125}

sorted_footballers_by_goals = sorted(footballers_goals.items(), key=lambda x:x[1])
converted_dict = dict(sorted_footballers_by_goals)

print(converted_dict)
# Output: {'Cruyff': 104, 'Eusebio': 120, 'Messi': 125, 'Ronaldo': 132, 'Pele': 150}

That’s it! We’ve been able to sort the items in the dictionary and convert them back to a dictionary. We’ve just had our cake and ate it as well!

How to Sort the Dictionary by Value in Ascending or Descending Order

Remember the sorted() method accepts a third value called reverse.

reverse with a value of True will arrange the sorted dictionary in descending order.

footballers_goals = {'Eusebio': 120, 'Cruyff': 104, 'Pele': 150, 'Ronaldo': 132, 'Messi': 125}

sorted_footballers_by_goals = sorted(footballers_goals.items(), key=lambda x:x[1], reverse=True)
converted_dict = dict(sorted_footballers_by_goals)

print(converted_dict)
# Output: {'Pele': 150, 'Ronaldo': 132, 'Messi': 125, 'Eusebio': 120, 'Cruyff': 104}

You can see the output is reversed because we passed reverse=True to the sorted() method.

If you don’t set reverse at all or you set its value to false, the dictionary will be arranged in ascending order. That’s the default.

Conclusion

Congratulations. You can now sort a dictionary by value despite not having a built-in method or function to use in Python.

However, there’s something that raised my curiosity when I was preparing to write this article. Remember we were able to use sorted() directly on a dictionary. This got us a list as the result, though we only got the keys and not the values.

What if we convert that list to a dictionary with the dict() method? Do you think we can get the desired result? Let's see:

my_dict = { 'num6': 6, 'num3': 3, 'num2': 2, 'num4': 4, 'num1': 1, 'num5': 5}
sortedDict = sorted(my_dict)

converted_dict = dict(sortedDict)
print(converted_dict)
"""
Output: 
dict_by_value.py
Traceback (most recent call last):
  File "sort_dict_by_value.py", line 17, in <module>
    converted_dict = dict(sortedDict)
ValueError: dictionary update sequence element #0 has length 4; 2 is required
"""

We got an error! That’s because if you want to create a dictionary from a list, you have to use dictionary comprehension. And if you use dictionary comprehension for this type of data, you’d have to specify one value for all the entries. That would defy the purpose of sorting a dictionary by value, so it's not what we want.

If you want to learn more about dictionary comprehension, you should read this article.

Thank you for reading!

If you’re familiar with JavaScript, Python dictionaries are like JavaScript objects.

Python provides more than 10 methods for working with dictionaries.

In this article, I will show you how to create a dictionary in Python and work with it using those methods.

What We'll Cover

• How to Create a Dictionary in Python
• Methods for Working with Python Dictionaries
  • How to Use the get() Dictionary Method
  • How to Use the items() Dictionary Method
  • How to Use the keys() Dictionary Method
  • How to Use the values() Dictionary Method
  • How to Use the pop() Dictionary Method
  • How to Use the popitem() Dictionary Method
  • How to Use the update() Dictionary Method
  • How to Use the copy() Dictionary Method
  • How to Use the clear() Dictionary Method
• Conclusion

How to Create a Dictionary in Python

To create a dictionary, you open up a curly brace and put the data in a key-value pair separated by commas.

The basic syntax of a dictionary looks like this:

demo_dict = {
"key1": "value1",
"key2": "value2", 
"key3": "value3"
}

Note that the values can be of any data type and can be duplicated, but the key must not be duplicated. If the keys are duplicated, you will get an invalid syntax error.

Methods for Working with Python Dictionaries

I will be working with the dictionary below to show you how the dictionary methods work:

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

How to Use the get() Dictionary Method

The get method returns the value of a specified key.

In the code below, I was able to get the founder of freeCodeCamp by passing the founder key inside the get() method:

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

founder = first_dict.get("founder")
print(founder)

# Output: Quincy Larson

How to Use the items() Dictionary Method

The items() method returns all the entries of the dictionary in a list. In the list is a tuple representing each of the items.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

items = first_dict.items()
print(items)

# Output: dict_items([('name', 'freeCodeCamp'), ('founder', 'Quincy Larson'), ('type', 'charity'), ('age', 8), ('price', 'free'), ('work-style', 'remote')])

How to Use the keys() Dictionary Method

The keys() returns all the keys in the dictionary. It returns the keys in a tuple – another Python data structure.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

dict_keys = first_dict.keys()
print(dict_keys)

# Output: dict_keys(['name', 'founder', 'type', 'age', 'price', 'work-style'])

How to Use the values() Dictionary Method

The values method accesses all the values in a dictionary. Like the keys() method, it returns the values in a tuple.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

dict_values = first_dict.values()
print(dict_values)

# Output: dict_values(['freeCodeCamp', 'Quincy Larson', 'charity', 8, 'free', 'remote'])

How to Use the pop() Dictionary Method

The pop() method removes a key-value pair from the dictionary. To make it work, you need to specify the key inside its parentheses.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

first_dict.pop("work-style")
print(first_dict)

# Output: {'name': 'freeCodeCamp', 'founder': 'Quincy Larson', 'type': 'charity', 'age': 8, 'price': 'free'}

You can see the work-style key and its value have been removed from the dictionary.

How to Use the popitem() Dictionary Method

The popitem() method works like the pop() method. The difference is that it removes the last item in the dictionary.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

first_dict.popitem()
print(first_dict)

# Output: {'name': 'freeCodeCamp', 'founder': 'Quincy Larson', 'type': 'charity', 'age': 8, 'price': 'free'}

You can see that the last key-value pair ("work-style": "remote") has been removed from the dictionary.

How to Use the update() Dictionary Method

The update() method adds an item to the dictionary. You have to specify both the key and value inside its braces and surround it with curly braces.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

first_dict.update({"Editor": "Abbey Rennemeyer"})
print(first_dict)

# Output: {'name': 'freeCodeCamp', 'founder': 'Quincy Larson', 'type': 'charity', 'age': 8, 'price': 'free', 'work-style': 'remote', 'Editor': 'Abbey Rennemeyer'}

The new entry has been added to the dictionary.

How to Use the copy() Dictionary Method

The copy() method does what its name implies – it copies the dictionary into the variable specified.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

second_dict = first_dict.copy()
print(second_dict)

# Output: {'name': 'freeCodeCamp', 'founder': 'Quincy Larson', 'type': 'charity', 'age': 8, 'price': 'free', 'work-style': 'remote'}

How to Use the clear() Dictionary Method

The clear method removes all the entries in the dictionary.

first_dict = {
    "name": "freeCodeCamp", 
    "founder": "Quincy Larson",
    "type": "charity", 
    "age": 8, 
    "price": "free", 
    "work-style": "remote",
}

first_dict.clear()
print(first_dict)

# Output: {}

Conclusion

In this article, you learned how to create a Python dictionary and how to work with it using the built-in methods provided by Python.

If you find the article helpful, don’t hesitate to share it with friends and family.

Keep coding :)

You can access the values using the key. You can also iterate through the complete dictionary to access every element.

Sometimes while iterating through the dictionary, you may need to remove a key from the dictionary.

This tutorial will teach you how to remove a key from a dictionary while iterating over it.

To remove a key directly without iterating, read the freeCodeCamp tutorial How to Remove a key from a Python Dictionary.

How to Create a Dictionary

Let's first create a dictionary with some key-value pairs using the assignment operator.

To add a key to the dictionary using different methods, read How to Add a Key to a Dictionary

After creating the dictionary, you can use the for loop to iterate through it and print the values to check if the dictionary has been created successfully.

Here's the code:

yourdict = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
}

for key in yourdict.keys():
    print(key, yourdict[key])

You can print the values in the dictionary as follows.

Output:

    one 1
    two 2
    three 3
    four 4

To check if a key exists in a dictionary without iterating over it, read how to check if a key exists in dictionary in Python.

How to Check the Python Version

Python 2 and Python 3 work differently when you try to delete a key from a dictionary while iterating.

To check which version of Python you are using, use the below code snippet.

Here's the code:

import sys
print(sys.version)

Output:

3.8.2 (default, Sep  4 2020, 00:03:40) [MSC v.1916 32 bit (Intel)]

You'll see whatever version you have. And now you know which version of Python you are using.

You can follow the appropriate methods explained below.

How to Delete A Key from a Dict Based on Key Value – Python 3

This section teaches you how to delete a key from a dictionary using Python 3.

You need to convert the keys to a list using the list(dict.keys()) and iterate through a dictionary using the for loop.

While converting the keys to a list, Python 3 creates a new copy of the keys in the list. There will be no reference to the dictionary during the iteration.

If you do not convert it into a list, then the keys method just returns a new view of the keys with reference to the currently iterated dictionary.

Now, during each iteration of the list of keys, you can check if the key is equal to the item you need to delete. If it is True, you can delete the key using the del statement.

Here's the code:

The below code demonstrates how to remove a key from the dictionary while iterating over it using Python 3.

yourdict = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
}

for k in list(yourdict.keys()):
    if k == "four":
        del yourdict[k]

yourdict

As you can see in the code below, the key four gets deleted from the dictionary while iterating through it.

Output:

    {'one': 1, 'two': 2, 'three': 3}

If you use the dict.keys() method to iterate and issue a del statement, you’ll see the below error in Python 3.

RuntimeError: dictionary changed size during iteration

How to Delete a Key from a Dict Based on Values – Python 3

This section teaches you how to remove a key from a dictionary based on the value of the key while iterating over the dictionary.

First, you need to convert the dictionary keys to a list using the list(dict.keys()) method.

During each iteration, you can check if the value of a key is equal to the desired value. If it is True, you can issue the del statement to delete the key.

yourdict = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
}

for k in list(yourdict.keys()):
    if yourdict [k] == 4:
        del yourdict[k]

print(yourdict)

The key four gets deleted based on its value 4.

Output:

{‘three’: 3, 'two': 2, 'one': 1}

How to Delete a Key from a Dict Based on the Key – Python 2

This section teaches you how to remove a key from a dictionary while iterating over it using Python 2.

You can directly iterate through a dictionary using the dict.keys() method. In Python 2, the dict.keys() method creates a copy of the keys and iterates over the copy instead of iterating through the keys directly. So there will be no reference to the dictionary directly while iterating.

Now during each iteration, you can check if the item is equal to the key you want to delete. And if it is equal, you can issue the del statement. It’ll remove the key from the dictionary.

Here's the code:

The below code demonstrates how to remove a key from dictionary while iterating over it using Python 2.

yourdict = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
}

for k in yourdict.keys():
    if k == "four":
        del yourdict[k]

yourdict

The key four gets deleted, and only the other items are available in the dictionary.

Output:

    {'one': 1, 'two': 2, 'three': 3}

This is how you can remove a key based on the key.

How to Delete a Key in a Dict Based on Values – Python 2

This section teaches you how to remove a key from a dictionary based on the value of the key while iterating over the dictionary.

Iterate over the dictionary using the dict.items() method. It’ll return the key-value pair during each iteration.

Then you can check if the value of the current iteration equals your desired value to be removed. Then issue the del statement to remove the key from the dictionary.

yourdict = {
    "one": 1,
    "two": 2,
    "three": 3,
    "four": 4,
}

for key, val in yourdict.items():
    if val == 3:
        del yourdict[key]

print(yourdict)

The key three gets deleted based on its value 3. All other items are available in the dictionary.

Output:

{'four': 4, 'two': 2, 'one': 1}

Why Do Python 3 and Python 2 Work Differently?

When using the dict.keys() method, Python 3 returns a view of the keys. This means there is a reference to the dictionary while iterating over it.

On the other hand, Python 2 returns a copy of the keys, meaning there is NO dictionary reference while iterating it. This means that deletion will be successful without problems.

Conclusion

In this article, you’ve learned how to remove a key from a dictionary while iterating over it in different versions of Python – Python 2 and Python 3.

You’ve also learned how to delete a key based on a key or the value of a key.

If you liked this article, feel free to share it.

You can check out my other Python tutorials here.

Each of these structures have their own syntax and methods for interacting with the data stored.

In this article, we'll talk about Dictionaries, their features, and how to add items to them.

How to Create a Dictionary in Python

Dictionaries are made up of key and value pairs nested in curly brackets. Here's an example of a Dictionary:

devBio = {
  "name": "Ihechikara",
  "age": 120,
  "language": "JavaScript"
}
print(devBio)
# {'name': 'Ihechikara', 'age': 120, 'language': 'JavaScript'}

In the code above, we created a dictionary called devBio with information about a developer – the developer's age is quite overwhelming.

Each key in the dictionary – name, age and language – has a corresponding value. A comma separates each key and value pair from another. Omitting the comma throws an error your way.

Before we dive into how we can add items to our dictionaries, let's have a look at some of the features of a dictionary. This will help you easily distinguish them from other data structures in Python.

Features of a Dictionary

Here are some of the features of a dictionary in Python:

Duplicate Keys Are Not Allowed

If we create a dictionary that has two or multiple identical keys in it, the last key out of them will override the rest. Here's an example:

devBio = {
  "name": "Ihechikara",
  "name": "Vincent",
  "name": "Chikara",
  "age": 120,
  "language": "JavaScript"
}
print(devBio)
# {'name': 'Chikara', 'age': 120, 'language': 'JavaScript'}

We created three keys with an identical key name of name. When we printed our dictionary to the console, the last key having a value of "Chikara" overwrote the rest.

Let's see the next feature.

Items in a Dictionary Are Changeable

After assigning an item to a dictionary, you can change its value to something different.

devBio = {
  "name": "Ihechikara",
  "age": 120,
  "language": "JavaScript"
}

devBio["age"] = 1

print(devBio)

# {'name': 'Chikara', 'age': 120, 'language': 'JavaScript'}

In the example above, we reassigned a new value to age. This will override the initial value we assigned when the dictionary was created.

We can also use the update() method to change the value of items in our dictionary. We can achieve the same result in the last example by using the update() method – that is: devBio.update({"age": 1}).

Items in a Dictionary Are Ordered

By being ordered, this means that the items in a dictionary maintain the order in which they were created or added. That order cannot change.

Prior to Python 3.7, dictionaries in Python were unordered.

In the next section, we will see how we can add items to a dictionary.

How to Add an Item to a Dictionary

The syntax for adding items to a dictionary is the same as the syntax we used when updating an item. The only difference here is that the index key will include the name of the new key to be created and its corresponding value.

Here's what the syntax looks like: devBio[**newKey**] = **newValue**.

We can also use the update() method to add new items to a dictionary. Here's what that would look like: devBio.**update**({"**newKey**": **newValue**}).

Let's see some examples.

devBio = {
  "name": "Ihechikara",
  "age": 120,
  "language": "JavaScript"
}

devBio["role"] = "Developer"

print(devBio)

# {'name': 'Ihechikara', 'age': 120, 'language': 'JavaScript', 'role': 'Developer'}

Above, using the index key devBio["role"], we created a new key with the value of Developer.

In the next example, we will use the update() method.

devBio = {
  "name": "Ihechikara",
  "age": 120,
  "language": "JavaScript"
}

devBio.update({"role": "Developer"})

print(devBio)

# {'name': 'Ihechikara', 'age': 120, 'language': 'JavaScript', 'role': 'Developer'}

Above, we achieved the same result as in the last example by passing in the new key and its value into the update() method – that is: devBio.update({"role": "Developer"}).

Conclusion

In this article, we learned what dictionaries are in Python, how to create them, and some of their features. We then saw two ways through which we can add items to our dictionaries.

Happy coding!

You will learn how to create dictionaries, access the elements inside them, and how to modify them depending on your needs.

You will also learn some of the most common built-in methods used on dictionaries.

Here is what we will cover:

1. Define a dictionary
   1. Define an empty dictionary
   2. Define a dictionary with items
2. An overview of keys and values 1.Find the number of key-value pairs contained in a dictionary 2.View all key-value pairs 3.View all keys 4.View all values
3. Access individual items
4. Modify a dictionary
   1. Add new items
   2. Update items
   3. Delete items

How to Create a Dictionary in Python

A dictionary in Python is made up of key-value pairs.

In the two sections that follow you will see two ways of creating a dictionary.

The first way is by using a set of curly braces, {}, and the second way is by using the built-in dict() function.

How to Create An Empty Dictionary in Python

To create an empty dictionary, first create a variable name which will be the name of the dictionary.

Then, assign the variable to an empty set of curly braces, {}.

#create an empty dictionary
my_dictionary = {}

print(my_dictionary)

#to check the data type use the type() function
print(type(my_dictionary))

#output

#{}
#<class 'dict'>

Another way of creating an empty dictionary is to use the dict() function without passing any arguments.

It acts as a constructor and creates an empty dictionary:

#create an empty dictionary
my_dictionary = dict()

print(my_dictionary)

#to check the data type use the type() function
print(type(my_dictionary))

#output

#{}
#<class 'dict'>

How to Create A Dictionary With Items in Python

To create a dictionary with items, you need to include key-value pairs inside the curly braces.

The general syntax for this is the following:

dictionary_name = {key: value}

Let's break it down:

• dictionary_name is the variable name. This is the name the dictionary will have.
• = is the assignment operator that assigns the key:value pair to the dictionary_name.
• You declare a dictionary with a set of curly braces, {}.
• Inside the curly braces you have a key-value pair. Keys are separated from their associated values with colon, :.

Let's see an example of creating a dictionary with items:

#create a dictionary
my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

print(my_information)

#check data type
print(type(my_information))

#output

#{'name': 'Dionysia', 'age': 28, 'location': 'Athens'}
#<class 'dict'>

In the example above, there is a sequence of elements within the curly braces.

Specifically, there are three key-value pairs: 'name': 'Dionysia', 'age': 28, and 'location': 'Athens'.

The keys are name, age, and location. Their associated values are Dionysia, 28, and Athens, respectively.

When there are multiple key-value pairs in a dictionary, each key-value pair is separated from the next with a comma, ,.

Let's see another example.

Say that you want to create a dictionary with items using the dict() function this time instead.

You would achieve this by using dict() and passing the curly braces with the sequence of key-value pairs enclosed in them as an argument to the function.

#create a dictionary with dict()
my_information = dict({'name': 'Dionysia' ,'age': 28,'location': 'Athens'})

print(my_information)

#check data type
print(type(my_information))

#output

#{'name': 'Dionysia', 'age': 28, 'location': 'Athens'}
#<class 'dict'>

It's worth mentioning the fromkeys() method, which is another way of creating a dictionary.

It takes a predefined sequence of items as an argument and returns a new dictionary with the items in the sequence set as the dictionary's specified keys.

You can optionally set a value for all the keys, but by default the value for the keys will be None.

The general syntax for the method is the following:

dictionary_name = dict.fromkeys(sequence,value)

Let's see an example of creating a dictionary using fromkeys() without setting a value for all the keys:

#create sequence of strings
cities = ('Paris','Athens', 'Madrid')

#create the dictionary, `my_dictionary`, using the fromkeys() method
my_dictionary = dict.fromkeys(cities)

print(my_dictionary)

#{'Paris': None, 'Athens': None, 'Madrid': None}

Now let's see another example that sets a value that will be the same for all the keys in the dictionary:

#create a sequence of strings
cities = ('Paris','Athens', 'Madrid')

#create a single value
continent = 'Europe'

my_dictionary = dict.fromkeys(cities,continent)

print(my_dictionary)

#output

#{'Paris': 'Europe', 'Athens': 'Europe', 'Madrid': 'Europe'}

An Overview of Keys and Values in Dictionaries in Python

Keys inside a Python dictionary can only be of a type that is immutable.

Immutable data types in Python are integers, strings, tuples, floating point numbers, and Booleans.

Dictionary keys cannot be of a type that is mutable, such as sets, lists, or dictionaries.

So, say you have the following dictionary:

my_dictionary = {True: "True",  1: 1,  1.1: 1.1, "one": 1, "languages": ["Python"]}

print(my_dictionary)

#output

#{True: 1, 1.1: 1.1, 'one': 1, 'languages': ['Python']}

The keys in the dictionary are Boolean, integer, floating point number, and string data types, which are all acceptable.

If you try to create a key which is of a mutable type you'll get an error - specifically the error will be a TypeError.

my_dictionary = {["Python"]: "languages"}

print(my_dictionary)

#output

#line 1, in <module>
#    my_dictionary = {["Python"]: "languages"}
#TypeError: unhashable type: 'list'

In the example above, I tried to create a key which was of list type (a mutable data type). This resulted in a TypeError: unhashable type: 'list' error.

When it comes to values inside a Python dictionary there are no restrictions. Values can be of any data type - that is they can be both of mutable and immutable types.

Another thing to note about the differences between keys and values in Python dictionaries, is the fact that keys are unique. This means that a key can only appear once in the dictionary, whereas there can be duplicate values.

How to Find the Number of key-value Pairs Contained in a Dictionary in Python

The len() function returns the total length of the object that is passed as an argument.

When a dictionary is passed as an argument to the function, it returns the total number of key-value pairs enclosed in the dictionary.

This is how you calcualte the number of key-value pairs using len():

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

print(len(my_information))

#output

#3

How to View All key-value Pairs Contained in a Dictionary in Python

To view every key-value pair that is inside a dictionary, use the built-in items() method:

year_of_creation = {'Python': 1993, 'JavaScript': 1995, 'HTML': 1993}

print(year_of_creation.items())

#output

#dict_items([('Python', 1993), ('JavaScript', 1995), ('HTML', 1993)])

The items() method returns a list of tuples that contains the key-value pairs that are inside the dictionary.

How to View All keys Contained in a Dictionary in Python

To see all of the keys that are inside a dictionary, use the built-in keys() method:

year_of_creation = {'Python': 1993, 'JavaScript': 1995, 'HTML': 1993}

print(year_of_creation.keys())

#output

#dict_keys(['Python', 'JavaScript', 'HTML'])

The keys() method returns a list that contains only the keys that are inside the dictionary.

How to View All values Contained in a Dictionary in Python

To see all of the values that are inside a dictionary, use the built-in values() method:

year_of_creation = {'Python': 1993, 'JavaScript': 1995, 'HTML': 1993}

print(year_of_creation.values())

#output

#dict_values([1993, 1995, 1993])

The values() method returns a list that contains only the values that are inside the dictionary.

How to Access Individual Items in A Dictionary in Python

When working with lists, you access list items by mentioning the list name and using square bracket notation. In the square brackets you specify the item's index number (or position).

You can't do exactly the same with dictionaries.

When working with dictionaries, you can't access an element by referencing its index number, since dictionaries contain key-value pairs.

Instead, you access the item by using the dictionary name and square bracket notation, but this time in the square brackets you specify a key.

Each key corresponds with a specific value, so you mention the key that is associated with the value you want to access.

The general syntax to do so is the following:

dictionary_name[key]

Let's look at the following example on how to access an item in a Python dictionary:

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

#access the value associated with the 'age' key
print(my_information['age'])

#output

#28

What happens though when you try to access a key that doesn't exist in the dictionary?

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

#try to access the value associated with the 'job' key
print(my_information['job'])

#output

#line 4, in <module>
#    print(my_information['job'])
#KeyError: 'job'

It results in a KeyError since there is no such key in the dictionary.

One way to avoid this from happening is to first search to see if the key is in the dictionary in the first place.

You do this by using the in keyword which returns a Boolean value. It returns True if the key is in the dictionary and False if it isn't.

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

#search for the 'job' key
print('job' in my_information)

#output

#False

Another way around this is to access items in the dictionary by using the get() method.

You pass the key you're looking for as an argument and get() returns the value that corresponds with that key.

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

#try to access the 'job' key using the get() method
print(my_information.get('job'))

#output

#None

As you notice, when you are searching for a key that does not exist, by default get() returns None instead of a KeyError.

If instead of showing that default None value you want to show a different message when a key does not exist, you can customise get() by providing a different value.

You do so by passing the new value as the second optional argument to the get() method:

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

#try to access the 'job' key using the get() method
print(my_information.get('job', 'This value does not exist'))

#output

#This value does not exist

Now when you are searching for a key and it is not contained in the dictionary, you will see the message This value does not exist appear on the console.

How to Modify A Dictionary in Python

Dictionaries are mutable, which means they are changeable.

They can grow and shrink throughout the life of the program.

New items can be added, already existing items can be updated with new values, and items can be deleted.

How to Add New Items to A Dictionary in Python

To add a key-value pair to a dictionary, use square bracket notation.

The general syntax to do so is the following:

dictionary_name[key] = value

First, specify the name of the dictionary. Then, in square brackets, create a key and assign it a value.

Say you are starting out with an empty dictionary:

my_dictionary = {}

print(my_dictionary)

#output

#{}

Here is how you would add a key-value pair to my_dictionary:

my_dictionary = {}

#add a key-value pair to the empty dictionary
my_dictionary['name'] = "John Doe"

#print dictionary
print(my_list)

#output

#{'name': 'John Doe'}

Here is how you would add another new key-value pair:

my_dictionary = {}

#add a key-value pair to the empty dictionary
my_dictionary['name'] = "John Doe"

# add another  key-value pair
my_dictionary['age'] = 34

#print dictionary
print(my_dictionary)

#output

#{'name': 'John Doe', 'age': 34}

Keep in mind that if the key you are trying to add already exists in that dictionary and you are assigning it a different value, the key will end up being updated.

Remember that keys need to be unique.

my_dictionary = {'name': "John Doe", 'age':34}

print(my_dictionary)

#try to create a an 'age' key and assign it a value
#the 'age' key already exists

my_dictionary['age'] = 46

#the value of 'age' will now be updated

print(my_dictionary)

#output

#{'name': 'John Doe', 'age': 34}
#{'name': 'John Doe', 'age': 46}

If you want to prevent changing the value of an already existing key by accident, you might want to check if the key you are trying to add is already in the dictionary.

You do this by using the in keyword as we discussed above:

my_dictionary = {'name': "John Doe", 'age':34}

#I want to add an `age` key. Before I do so, I check to see if it already exists
print('age' in my_dictionary)

#output

#True

How to Update Items in A Dictionary in Python

Updating items in a dictionary works in a similar way to adding items to a dictionary.

When you know you want to update one existing key's value, use the following general syntax you saw in the previous section:

dictionary_name[existing_key] = new_value

my_dictionary = {'name': "John Doe", 'age':34}

my_dictionary['age'] = 46

print(my_dictionary)

#output

#{'name': 'John Doe', 'age': 46}

To update a dictionary, you can also use the built-in update() method.

This method is particularly helpful when you want to update more than one value inside a dictionary at the same time.

Say you want to update the name and age key in my_dictionary, and add a new key, occupation:

my_dictionary = {'name': "John Doe", 'age':34}

my_dictionary.update(name= 'Mike Green', age = 46, occupation = "software developer")

print(my_dictionary)

#output

#{'name': 'Mike Green', 'age': 46, 'occupation': 'software developer'}

The update() method takes a tuple of key-value pairs.

The keys that already existed were updated with the new values that were assigned, and a new key-value pair was added.

The update() method is also useful when you want to add the contents of one dictionary into another.

Say you have one dictionary, numbers, and a second dictionary, more_numbers.

If you want to merge the contents of more_numbers with the contents of numbers, use the update() method.

All the key-value pairs contained in more_numbers will be added to the end of the numbers dictionary.

numbers = {'one': 1, 'two': 2, 'three': 3}
more_numbers = {'four': 4, 'five': 5, 'six': 6}

#update 'numbers' dictionary
#you update it by adding the contents of another dictionary, 'more_numbers',
#to the end of it
numbers.update(more_numbers)

print(numbers)

#output

#{'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6}

How to Delete Items from A Dictionary in Python

One of the ways to delete a specific key and its associated value from a dictionary is by using the del keyword.

The syntax to do so is the following:

del dictionary_name[key]

For example, this is how you would delete the location key from the my_information dictionary:

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

del my_information['location']

print(my_information)

#output

#{'name': 'Dionysia', 'age': 28}

If you want to remove a key, but would also like to save that removed value, use the built-in pop() method.

The pop() method removes but also returns the key you specify. This way, you can store the removed value in a variable for later use or retrieval.

You pass the key you want to remove as an argument to the method.

Here is the general syntax to do that:

dictionary_name.pop(key)

To remove the location key from the example above, but this time using the pop() method and saving the value associated with the key to a variable, do the following:

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

city = my_information.pop('location')

print(my_information)
print(city)

#output

#{'name': 'Dionysia', 'age': 28}
#Athens

If you specify a key that does not exist in the dictionary you will get a KeyError error message:

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

my_information.pop('occupation')

print(my_information)

#output

#line 3, in <module>
#   my_information.pop('occupation')
#KeyError: 'occupation'

A way around this is to pass a second argument to the pop() method.

By including the second argument there would be no error. Instead, there would be a silent fail if the key didn't exist, and the dictionary would remain unchanged.

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

my_information.pop('occupation','Not found')

print(my_information)

#output

#{'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

The pop() method removes a specific key and its associated value – but what if you only want to delete the last key-value pair from a dictionary?

For that, use the built-in popitem() method instead.

This is general syntax for the popitem() method:

dictionary_name.popitem()

The popitem() method takes no arguments, but removes and returns the last key-value pair from a dictionary.

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

popped_item = my_information.popitem()

print(my_information)
print(popped_item)

#output

#{'name': 'Dionysia', 'age': 28}
#('location', 'Athens')

Lastly, if you want to delete all key-value pairs from a dictionary, use the built-in clear() method.

my_information = {'name': 'Dionysia', 'age': 28, 'location': 'Athens'}

my_information.clear()

print(my_information)

#output

#{}

Using this method will leave you with an empty dictionary.

Conclusion

And there you have it! You now know the basics of dictionaries in Python.

I hope you found this article useful.

To learn more about the Python programming language, check out freeCodeCamp's Scientific Computing with Python Certification.

You'll start from the basics and learn in an interacitve and beginner-friendly way. You'll also build five projects at the end to put into practice and help reinforce what you've learned.

Thanks for reading and happy coding!