new dictionary in python assignment expert

Dictionaries in Python

Table of Contents

Defining a Dictionary

Accessing dictionary values, dictionary keys vs. list indices, building a dictionary incrementally, restrictions on dictionary keys, restrictions on dictionary values, operators and built-in functions, d.get(<key>[, <default>]), d.pop(<key>[, <default>]), d.popitem(), d.update(<obj>).

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Dictionaries in Python

Python provides another composite data type called a dictionary , which is similar to a list in that it is a collection of objects.

Here’s what you’ll learn in this tutorial: You’ll cover the basic characteristics of Python dictionaries and learn how to access and manage dictionary data. Once you have finished this tutorial, you should have a good sense of when a dictionary is the appropriate data type to use, and how to do so.

Dictionaries and lists share the following characteristics:

• Both are mutable.
• Both are dynamic. They can grow and shrink as needed.
• Both can be nested. A list can contain another list. A dictionary can contain another dictionary. A dictionary can also contain a list, and vice versa.

Dictionaries differ from lists primarily in how elements are accessed:

• List elements are accessed by their position in the list, via indexing.
• Dictionary elements are accessed via keys.

Take the Quiz: Test your knowledge with our interactive “Python Dictionaries” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Test your understanding of Python dictionaries

Dictionaries are Python’s implementation of a data structure that is more generally known as an associative array. A dictionary consists of a collection of key-value pairs. Each key-value pair maps the key to its associated value.

You can define a dictionary by enclosing a comma-separated list of key-value pairs in curly braces ( {} ). A colon ( : ) separates each key from its associated value:

The following defines a dictionary that maps a location to the name of its corresponding Major League Baseball team:

You can also construct a dictionary with the built-in dict() function. The argument to dict() should be a sequence of key-value pairs. A list of tuples works well for this:

MLB_team can then also be defined this way:

If the key values are simple strings, they can be specified as keyword arguments. So here is yet another way to define MLB_team :

Once you’ve defined a dictionary, you can display its contents, the same as you can do for a list. All three of the definitions shown above appear as follows when displayed:

The entries in the dictionary display in the order they were defined. But that is irrelevant when it comes to retrieving them. Dictionary elements are not accessed by numerical index:

Perhaps you’d still like to sort your dictionary. If that’s the case, then check out Sorting a Python Dictionary: Values, Keys, and More .

Of course, dictionary elements must be accessible somehow. If you don’t get them by index, then how do you get them?

A value is retrieved from a dictionary by specifying its corresponding key in square brackets ( [] ):

If you refer to a key that is not in the dictionary, Python raises an exception:

Adding an entry to an existing dictionary is simply a matter of assigning a new key and value:

If you want to update an entry, you can just assign a new value to an existing key:

To delete an entry, use the del statement , specifying the key to delete:

Begone, Seahawks! Thou art an NFL team.

You may have noticed that the interpreter raises the same exception, KeyError , when a dictionary is accessed with either an undefined key or by a numeric index:

In fact, it’s the same error. In the latter case, [1] looks like a numerical index, but it isn’t.

You will see later in this tutorial that an object of any immutable type can be used as a dictionary key. Accordingly, there is no reason you can’t use integers:

In the expressions MLB_team[1] , d[0] , and d[2] , the numbers in square brackets appear as though they might be indices. But they have nothing to do with the order of the items in the dictionary. Python is interpreting them as dictionary keys. If you define this same dictionary in reverse order, you still get the same values using the same keys:

The syntax may look similar, but you can’t treat a dictionary like a list:

Note: Although access to items in a dictionary does not depend on order, Python does guarantee that the order of items in a dictionary is preserved. When displayed, items will appear in the order they were defined, and iteration through the keys will occur in that order as well. Items added to a dictionary are added at the end. If items are deleted, the order of the remaining items is retained.

You can only count on this preservation of order very recently. It was added as a part of the Python language specification in version 3.7 . However, it was true as of version 3.6 as well—by happenstance as a result of the implementation but not guaranteed by the language specification.

Defining a dictionary using curly braces and a list of key-value pairs, as shown above, is fine if you know all the keys and values in advance. But what if you want to build a dictionary on the fly?

You can start by creating an empty dictionary, which is specified by empty curly braces. Then you can add new keys and values one at a time:

Once the dictionary is created in this way, its values are accessed the same way as any other dictionary:

Retrieving the values in the sublist or subdictionary requires an additional index or key:

This example exhibits another feature of dictionaries: the values contained in the dictionary don’t need to be the same type. In person , some of the values are strings, one is an integer, one is a list, and one is another dictionary.

Just as the values in a dictionary don’t need to be of the same type, the keys don’t either:

Here, one of the keys is an integer, one is a float, and one is a Boolean . It’s not obvious how this would be useful, but you never know.

Notice how versatile Python dictionaries are. In MLB_team , the same piece of information (the baseball team name) is kept for each of several different geographical locations. person , on the other hand, stores varying types of data for a single person.

You can use dictionaries for a wide range of purposes because there are so few limitations on the keys and values that are allowed. But there are some. Read on!

Almost any type of value can be used as a dictionary key in Python. You just saw this example, where integer, float, and Boolean objects are used as keys:

You can even use built-in objects like types and functions:

However, there are a couple restrictions that dictionary keys must abide by.

First, a given key can appear in a dictionary only once. Duplicate keys are not allowed. A dictionary maps each key to a corresponding value, so it doesn’t make sense to map a particular key more than once.

You saw above that when you assign a value to an already existing dictionary key, it does not add the key a second time, but replaces the existing value:

Similarly, if you specify a key a second time during the initial creation of a dictionary, the second occurrence will override the first:

Begone, Timberwolves! Thou art an NBA team. Sort of.

Secondly, a dictionary key must be of a type that is immutable. You have already seen examples where several of the immutable types you are familiar with—integer, float, string, and Boolean—have served as dictionary keys.

A tuple can also be a dictionary key, because tuples are immutable:

(Recall from the discussion on tuples that one rationale for using a tuple instead of a list is that there are circumstances where an immutable type is required. This is one of them.)

However, neither a list nor another dictionary can serve as a dictionary key, because lists and dictionaries are mutable :

Technical Note: Why does the error message say “unhashable”?

Technically, it is not quite correct to say an object must be immutable to be used as a dictionary key. More precisely, an object must be hashable , which means it can be passed to a hash function. A hash function takes data of arbitrary size and maps it to a relatively simpler fixed-size value called a hash value (or simply hash), which is used for table lookup and comparison.

Python’s built-in hash() function returns the hash value for an object which is hashable, and raises an exception for an object which isn’t:

All of the built-in immutable types you have learned about so far are hashable, and the mutable container types (lists and dictionaries) are not. So for present purposes, you can think of hashable and immutable as more or less synonymous.

In future tutorials, you will encounter mutable objects which are also hashable.

By contrast, there are no restrictions on dictionary values. Literally none at all. A dictionary value can be any type of object Python supports, including mutable types like lists and dictionaries, and user-defined objects, which you will learn about in upcoming tutorials.

There is also no restriction against a particular value appearing in a dictionary multiple times:

You have already become familiar with many of the operators and built-in functions that can be used with strings , lists , and tuples . Some of these work with dictionaries as well.

For example, the in and not in operators return True or False according to whether the specified operand occurs as a key in the dictionary:

You can use the in operator together with short-circuit evaluation to avoid raising an error when trying to access a key that is not in the dictionary:

In the second case, due to short-circuit evaluation, the expression MLB_team['Toronto'] is not evaluated, so the KeyError exception does not occur.

The len() function returns the number of key-value pairs in a dictionary:

Built-in Dictionary Methods

As with strings and lists, there are several built-in methods that can be invoked on dictionaries. In fact, in some cases, the list and dictionary methods share the same name. (In the discussion on object-oriented programming, you will see that it is perfectly acceptable for different types to have methods with the same name.)

The following is an overview of methods that apply to dictionaries:

Clears a dictionary.

d.clear() empties dictionary d of all key-value pairs:

Returns the value for a key if it exists in the dictionary.

The Python dictionary .get() method provides a convenient way of getting the value of a key from a dictionary without checking ahead of time whether the key exists, and without raising an error.

d.get(<key>) searches dictionary d for <key> and returns the associated value if it is found. If <key> is not found, it returns None :

If <key> is not found and the optional <default> argument is specified, that value is returned instead of None :

Returns a list of key-value pairs in a dictionary.

d.items() returns a list of tuples containing the key-value pairs in d . The first item in each tuple is the key, and the second item is the key’s value:

Returns a list of keys in a dictionary.

d.keys() returns a list of all keys in d :

Returns a list of values in a dictionary.

d.values() returns a list of all values in d :

Any duplicate values in d will be returned as many times as they occur:

Technical Note: The .items() , .keys() , and .values() methods actually return something called a view object . A dictionary view object is more or less like a window on the keys and values. For practical purposes, you can think of these methods as returning lists of the dictionary’s keys and values.

Removes a key from a dictionary, if it is present, and returns its value.

If <key> is present in d , d.pop(<key>) removes <key> and returns its associated value:

d.pop(<key>) raises a KeyError exception if <key> is not in d :

If <key> is not in d , and the optional <default> argument is specified, then that value is returned, and no exception is raised:

Removes a key-value pair from a dictionary.

d.popitem() removes the last key-value pair added from d and returns it as a tuple:

If d is empty, d.popitem() raises a KeyError exception:

Note: In Python versions less than 3.6, popitem() would return an arbitrary (random) key-value pair since Python dictionaries were unordered before version 3.6.

Merges a dictionary with another dictionary or with an iterable of key-value pairs.

If <obj> is a dictionary, d.update(<obj>) merges the entries from <obj> into d . For each key in <obj> :

• If the key is not present in d , the key-value pair from <obj> is added to d .
• If the key is already present in d , the corresponding value in d for that key is updated to the value from <obj> .

Here is an example showing two dictionaries merged together:

In this example, key 'b' already exists in d1 , so its value is updated to 200 , the value for that key from d2 . However, there is no key 'd' in d1 , so that key-value pair is added from d2 .

<obj> may also be a sequence of key-value pairs, similar to when the dict() function is used to define a dictionary. For example, <obj> can be specified as a list of tuples:

Or the values to merge can be specified as a list of keyword arguments:

In this tutorial, you covered the basic properties of the Python dictionary and learned how to access and manipulate dictionary data.

Lists and dictionaries are two of the most frequently used Python types. As you have seen, they have several similarities, but differ in how their elements are accessed. Lists elements are accessed by numerical index based on order, and dictionary elements are accessed by key

Because of this difference, lists and dictionaries tend to be appropriate for different circumstances. You should now have a good feel for which, if either, would be best for a given situation.

Next you will learn about Python sets . The set is another composite data type, but it is quite different from either a list or dictionary.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About John Sturtz

John is an avid Pythonista and a member of the Real Python tutorial team.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Related Topics: basics python

Recommended Video Course: Dictionaries in Python

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Python Dictionary: How To Create And Use, With Examples

The Python dictionary is one of the language’s most powerful data types. In other programming languages and computer science in general, dictionaries are also known as associative arrays. They allow you to associate one or more keys to values. If you are familiar with JSON , you might feel right at home. The syntax of a dictionary strongly resembles the syntax of a JSON document.

Table of Contents

• 1 Creating a Python Dictionary
• 2 Access and delete a key-value pair
• 3 Overwrite dictionary entries
• 4 Using try… except
• 5 Valid dictionary values
• 6 Valid dictionary keys
• 7 More ways to create a Python dictionary
• 8 Check if a key exists in a Python dictionary
• 9 Getting the length of a Python dictionary
• 10 Dictionary view objects
• 11 Merging dictionaries
• 12 Comparing Python dictionaries
• 13 Built-in Python dictionary methods
• 14 Conclusion

Creating a Python Dictionary

Let’s look at how we can create and use a Python dictionary in the  Python REPL :

A dictionary is created by using curly braces. Inside these braces, we can add one or more key-value pairs. The pairs are separated by commas when adding more than one key-value pair. The first dictionary in our example associates keys (names like Jack and Pete) with values (their phone numbers). The second dictionary is an empty one.

Access and delete a key-value pair

Now that you’ve seen how to initialize a dictionary, let’s see how we can add and remove entries to an already existing one:

Default values and dict.get()

Another way to retrieve a single value from a dictionary is using the get-method. The advantage? It returns a default value, None , if the key was not found. You can specify your own default value too.

With the get-method, you don’t have to surround the operation with a try… except. It’s ideal when working with configuration data that is parsed from YAML or JSON files, where your software offers defaults for unset configuration items.

An example:

That last get call returns None , but the more recent versions of the REPL don’t print None.

Overwrite dictionary entries

To overwrite an entry, simply assign a new value to it. You don’t need to  del()  it first. E.g.:

Using try… except

If a requested key does not exist, an exception of type  KeyError  is thrown:

If you know data can be missing, e.g., when parsing input from the outside world, make sure to surround your code with a  try ... except KeyError. I’ve explained this in detail in the best practices section of my article on try… except . In that article, I also explain the concept of asking for forgiveness, not permission . E.g., don’t check if a key exists before trying to access it. Instead, just try it, and catch the exception if it doesn’t exist.

Valid dictionary values

You can put anything in a dictionary. You’re not limited to numbers or strings . In fact, you can put dictionaries and Python lists inside your dictionary and access the nested values in a very natural way:

Python’s JSON decoding and encoding library  uses this feature of Python when parsing more complex JSON documents. It creates nested trees of lists, dictionaries, and other valid data types.

Valid dictionary keys

You can go pretty wild on your dictionary keys, too. The only requirement is that the key is hashable. Mutable types like lists , dictionaries, and sets won’t work and result in an error like: TypeError: unhashable type: ‘dict’ .

Besides this limitation, you can use all data types as a dictionary key, including native types like a tuple ,  float  and  int or even a class name or object based on a class. Although completely useless for most, I’ll demonstrate anyway:

A more likely use case is the use of numbers as keys. For example, consider this registration of runners in a marathon:

More ways to create a Python dictionary

Depending on your data source, there are more advanced ways to initialize a dictionary that might come in handy.

Using the dict() constructor

The  dict()  function builds a dictionary from a sequence or list of key-value pairs ( tuples ):

Dictionary Comprehensions

Analogous to list comprehensions , you can also use dictionary comprehensions to create a new dictionary. While a list only contains values, a dictionary contains key/value pairs. Hence, dictionary comprehensions need to define both. Other than that, the syntax is similar:

Please read my article on list comprehensions for a more detailed explanation of comprehensions in general.

Using dict.fromkeys

The  dict.fromkeys(keys, value)  method creates a new dictionary, based on the list of  keys  supplied to it. The value of all elements will be set to the supplied  value , or  None  by default, if you don’t supply a value.

See the following code:

The list of keys can be anything that is iterable. E.g., this works just as well with a set or a tuple .

Parse a JSON object to a dictionary

As explained in the section on working with JSON, you can also  decode JSON data into a dictionary  like this:

Check if a key exists in a Python dictionary

You can check if a key exists inside a dictionary with the  in  and  not in  keywords:

Getting the length of a Python dictionary

The built-in Python  len()  function returns the number of key/value pairs in a dictionary:

Dictionary view objects

Some built-in dictionary methods return a view object, offering a window on your dictionary’s keys and values. Before we start using such view objects, there’s an important concept you need to understand: values in a view object change as the content of the dictionary changes.

dict.keys() and dict.values()

This is best illustrated with an example, in which we use two of these views: keys() and values(). Keys returns a view on all the keys of a dictionary, while values() returns a view on all its values:

If that didn’t work, here’s the non-interactive version:

The output of this code is  dict_keys(['Jack', 'Pete', 'Eric', 'Linda']) . As you can see, Linda is part of the list too, even though she got added after creating the  names  view object.

dict.items(): loop through a Python dictionary

The  items()  method of a dictionary returns an iterable view object, offering both the keys and values, as can be seen below. You can loop through this object with a simple Python for-loop :

Alternatively, you can use the keys() and values() methods to loop through just the keys or values. Both functions return an iterable view object.

More ways to get all the keys

We’ve seen the  dict.keys()  method, which returns a view object containing a list of all the dictionary keys. The advantage of this object is that it stays in sync with the dictionary. It’s perfect for looping over all the keys, but you still might opt for the  list  or  sorted  methods though, because those return a native list that you can manipulate as well.

There are two other easy ways to get all the keys from a dictionary:

list()  returns all the keys in insertion order, while  sorted()  returns all the keys sorted alphabetically.

Merging dictionaries

If you’re running Python 3.9 or later, you can use the newly introduced merging operator for dictionaries:

If you’re still on a Python version between 3.5 and 3.9, you can merge two dictionaries using the following method:

Comparing Python dictionaries

If you need to compare two dictionaries, you can use a comparison operator like this:

This looks and sounds trivial, but it’s not! A dictionary can contain objects of any type, after all! Consequently, Python has to walk through all the keys and values and individually compare them.

You might wonder if a dictionary with the same keys and values inserted in another order is the same. Let’s check this:

They are the same to Python, despite having a different order.

Good to know: the order of dictionaries is guaranteed to be insertion order since Python 3.7. In other words, it means that the order of the dictionary is determined by the order in which you insert items.

Built-in Python dictionary methods

Each dictionary inherits some handy built-in functions, as listed in the following table:

You’ve learned what a Python dictionary is, how to create dictionaries, and how to use them. We’ve examined many practical use cases involving Python dictionaries with example code. If there’s still something missing, or you simply want to learn even more about dictionaries, you can head over to the official manual page at Python.org .

Get certified with our courses

Learn Python properly through small, easy-to-digest lessons, progress tracking, quizzes to test your knowledge, and practice sessions. Each course will earn you a downloadable course certificate.

Related articles

• Python List Comprehension: Tutorial With Examples
• Python Read And Write File: With Examples
• JSON in Python: How To Read, Write, and Parse
• Python YAML: How to Load, Read, and Write YAML

Create a Dictionary in Python – Python Dict Methods

In this article, you will learn the basics of dictionaries in Python.

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:

• Define an empty dictionary
• Define a dictionary with items
• 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
• Access individual items
• Add new items
• Update items
• 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, {} .

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:

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:

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:

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.

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:

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

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

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:

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 .

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

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:

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:

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:

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:

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

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

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.

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.

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:

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.

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:

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

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

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.

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:

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:

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 :

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.

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:

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

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:

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:

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

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.

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:

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

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

Using this method will leave you with an empty dictionary.

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!

Read more posts .

If this article was helpful, share it .

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started

✌️ Dictionary

A Python dictionary is an unordered collection of key-value pairs that is mutable, meaning you can change its contents, unlike tuples and strings. It is also known as associative arrays, hash tables, or simply hashes. Each key-value pair in a dictionary is separated by a colon (:), and the pairs are separated from each other by commas. A dictionary is defined within curly braces ({}) and can be assigned to a variable just like any other data type in Python.

Dictionaries are extremely useful when it comes to dealing with large data sets or datasets where the position of data is not important. Instead, what is important is the association between two pieces of information.

In Python, dictionaries are implemented as hash tables, which means that the time complexity for accessing, inserting, or deleting a key-value pair is O(1), making them very efficient for many use cases.

Creating a Dictionary

In Python, we can create a dictionary by enclosing a comma-separated list of key-value pairs inside curly braces {} . Each key-value pair is separated by a colon : . Here is an example:

In the example above, we created a dictionary called person that contains three key-value pairs: 'name': 'John' , 'age': 30 , and 'city': 'New York' . We then printed the dictionary using the print() function.

Accessing Elements from a Dictionary

We can access the elements of a dictionary by referring to its key name, inside square brackets or by using the get() method.

Example using square brackets:

Example using the get() method:

If we try to access a key that does not exist in the dictionary using square brackets, we will get a KeyError . However, if we use the get() method and the key does not exist in the dictionary, it will return None (or a default value we can specify).

Updating and Adding Elements to a Dictionary

To update an element in a dictionary, we can simply access the key and reassign a new value to it. If the key does not exist, it will be added as a new key-value pair.

Here's an example:

In this example, we first created a dictionary my_dict with three key-value pairs. Then we updated the value of the key 'apple' to 3 . Finally, we added a new key-value pair 'pear': 5' to the dictionary.

Removing Elements from a Dictionary

We can remove elements from a dictionary in several ways, using the del keyword, pop() method, and clear() method.

Using the del keyword:

We can use the del keyword to remove a specific key-value pair from the dictionary. Here's an example:

Using the pop() method:

We can use the pop() method to remove a specific key-value pair from the dictionary and return the value of the removed key. Here's an example:

Using the clear() method:

We can use the clear() method to remove all the key-value pairs from the dictionary. Here's an example:

Change Value of Dictionary

To change the value of a dictionary, you can simply assign a new value to the corresponding key. Here's an example:

In the above example, we first created a dictionary my_dict with three key-value pairs. Then we changed the value of the 'age' key to 30 by assigning a new value to it. Finally, we printed the updated dictionary.

Dictionary Methods

Methods that are available with a dictionary are tabulated below. Some of them have already been used in the above examples.

Dictionary Membership Test

In Python, we can use the in keyword to check if a key is present in a dictionary. Here is an example:

We can also use the not in keyword to check if a key is not present in a dictionary. Here is an example:

Iterating Through a Dictionary

You can iterate through a dictionary using a for loop to access each key-value pair of the dictionary. Here is an example:

In this example, the items() method is used to access the key-value pairs of the dictionary, and then a for loop is used to iterate through the pairs. The key and value variables are used to store the key and value of each pair in each iteration of the loop.

Looping Techniques with Dictionaries

In Python, there are several looping techniques that can be used to iterate through a dictionary. Here are some of them:

Looping through keys:

We can use a for loop to iterate over the keys of a dictionary. Here's an example:

Looping through values:

We can also use a for loop to iterate over the values of a dictionary. Here's an example:

Looping through key-value pairs:

We can use a for loop to iterate over the key-value pairs of a dictionary using the items() method. Here's an example:

Using List Comprehensions:

We can also use list comprehensions to iterate over the keys, values, or items of a dictionary. Here are some examples:

Built-in Functions with Dictionaries

Last updated 1 year ago

software development and tech.

Dictionaries in Python: A Complete Guide (with Examples)

Python dictionaries are a data type that allows for the storage and retrieval of key-value pairs. They are useful because they provide an efficient way to access and modify data, allowing for quick and easy data manipulation. Additionally, dictionaries can be nested and combined with other data types, making them versatile and powerful tools for data analysis and manipulation.

For some beginners, Python dictionaries may be challenging to understand at first because they involve using keys and values instead of indices like lists do. However, with practice and guidance, most beginners can learn to use Python dictionaries effectively.

This is a comprehensive guide to Python dictionaries .

You will learn how to create and maintain dictionaries with operations and built-in methods. Besides, you will see countless examples to support your understanding of dictionaries and their use.

Let’s jump into it!

How to Define a Dictionary in Python

A Python dictionary is a collection of key-value pairs. It is defined using curly braces {} in which you place key-value pairs such that each key-value pair is separated by a comma.

The best way to understand this is by having a look at some examples.

Let’s create a dictionary called my_dict and place some data in it:

In this example, ‘name’, ‘age’, and ‘city’ are the keys, and ‘John’, 25, and ‘New York’ are their respective values.

Let’s create another Python dictionary for demonstration’s sake.

In this example, the keys are ‘fruit1’, ‘fruit2’, and ‘fruit3’ and their corresponding values are ‘apple’, ‘banana’, and ‘pear’.

You can also create an empty dictionary in Python and start placing values in it with the square-bracket operator.

In this example, an empty dictionary is first defined and then key-value pairs are added to it using the square bracket notation. The name placed inside the square brackets specifies a new key and the assignment operator adds a new value to it.

Now that you’ve seen a bunch of examples of creating dictionaries in Python, let’s talk about how you can easily read values from a dictionary—the very reason that makes dictionaries so handy.

How to Access Dictionary Values

To access dictionary values in Python, you can use the square bracket notation and specify the key associated with the value you want to access.

For example, let’s say you have a dictionary called fruits that has the following keys and values:

To access the value associated with the key “apple”, you can use the following code:

This retrieves the value 5 from the dictionary and assigns it to a variable called value .

You can also use a for loop to iterate over all the keys and values in the dictionary and access each value individually:

This will print out each key and its associated value, separated by a colon.

More about the dict.items() method later on.

Dictionaries Use Keys Instead of Indexes

The key difference between a list and a dictionary in Python is that a list uses an index to access elements. On the other hand, a dictionary uses keys to access values.

Here’s a code example that illustrates the usage of keys instead of indices in Python dictionaries:

As you can see, we access the values in a dictionary using keys, instead of using an index like in a list. We can also add, update, and delete key-value pairs using the keys, and check if a key exists in the dictionary using the in keyword. This makes the dictionary a much more extensible and multi-purpose data structure than a list.

Dictionary Key Restrictions

Even though a Python dictionary is a flexible data type, there are some restrictions on the keys. For example, no two keys can be called the same.

Let’s take a closer look at the key restrictions in Python dictionaries.

1. Unique Keys

Keys must be unique within a dictionary . This means that no two keys can have the same value.

For example:

This piece of code doesn’t throw an error. Instead, the second “apple” key-value pair is going to override the first key-value pair. You can see this by printing the dictionary:

2. Immutable Keys

Dictionary keys must be immutable .

This means that the keys cannot be changed or modified once they are added to the dictionary.

Dictionary Value Restrictions

Python dictionary values have no restrictions. As long as the value is valid in Python, it’s ok to have one in a dictionary!

For example, you can assign a class, method, integer, string, or anything as a dictionary value in Python.

Python Dictionary Operators and Functions

One thing that makes Python dictionaries such a useful and extensible data type in Python is that you can do all sorts of operations on them.

Let’s take a closer look at some of the handiest operations you can perform on a Python dictionary.

The “[]” Operator

In Python, the “[]” operator gives access to the value of a given key in a dictionary.

For example, let’s read the “name” in an example dictionary:

The “in” Operator

You can call the “in” operator on a Python dictionary. It checks if a given key exists in a dictionary

For example, let’s check if the “name” key exists in my_dict :

The “not in” Operator

The “not in” operator is the opposite of the “in” operator. You can use it to check if a key does not exist in a dictionary.

For example, let’s check if the “email” field is not present in my_dict :

The “del” Operator

The “del” operator deletes a key-value pair from a dictionary.

For example, let’s remove the key-value pair with the key “name”:

The “+” Operator

You can use the “+” operator to merge two dictionaries into a new dictionary.

For instance:

Now that you know about the most notable operations of dictionaries, let’s talk about the perhaps even more useful dictionary methods.

Dictionary Methods in Python

The dictionary data type comes with a whole bunch of useful built-in methods. With these methods, you can apply the most common operations on dictionaries without reinventing the logic yourself.

For example, you can safely access a dictionary value with the .get() method such that the program doesn’t crash if the key doesn’t exist.

This is just one example of the many useful methods there are.

Let’s take a closer look at some of the most useful dictionary methods in Python.

dict.clear()

The dictionary.clear() method in Python is a built-in method used to remove all items from a dictionary. This method does not take any arguments and returns nothing.

Here is an example of how to use the dictionary.clear() method:

In the above example, we have created a dictionary called my_dict with two key-value pairs. Then, we used the dictionary.clear() method to remove all items from the dictionary. Finally, we printed the dictionary to see that it is now empty.

In Python, the get() method allows you to retrieve the value for a given key from a dictionary.

This method takes two arguments:

• The key of the value you want to retrieve.
• Default value to return if the key is not found in the dictionary.

Here’s an example:

If the key you specify in the get() method exists in the dictionary, the method will return the corresponding value. If the key does not exist, the method will return the default value you specified.

This is useful for avoiding errors when trying to retrieve values from a dictionary.

dict.items()

The items() method in Python dictionaries returns a view object that contains a list of pairs (key, value) for each key-value pair in the dictionary. This method allows the user to access and iterate through the keys and values in the dictionary simultaneously.

For example, let’s loop through the keys and values of a sample dictionary:

dict.keys()

The dictionary’s keys() method returns a view object that contains the keys of the dictionary.

The keys can then be accessed and used in various ways, such as looping through the keys to access the corresponding values or using the keys to check if a specific key exists in the dictionary.

You can use the keys() method to loop through the keys and print the corresponding values.

dict.values()

The values() method in Python dictionaries returns a view object containing the values in the dictionary. This view object is dynamic and updates itself as the dictionary is modified. The values can be accessed by iterating over the view object or by converting it to a list using the list() function

The pop() method in Python dictionaries is used to remove a specific key-value pair from the dictionary and return the removed value. The syntax for using the pop method is as follows:

Where key is the key of the key-value pair to be removed, and default_value is the value to be returned if the key does not exist in the dictionary.

For example, consider the following dictionary:

To remove the key-value pair with the key “age” using the pop method, we can use the following code:

This will remove the key-value pair with the key “age” from the dictionary and return the value 20. The updated dictionary will be:

If you try to use the pop() method to remove a key that does not exist in the dictionary, it will raise a KeyError exception. To avoid this, we can specify a default value to be returned if the key does not exist in the dictionary, as shown below:

In this example, if the key “age” does not exist in the dictionary, the value None will be returned and no error will be raised.

dict.popitem()

The popitem() method in Python dictionaries works by removing and returning a randomly chosen key-value pair from the dictionary.

Here is an example of how the popitem() method can be used in a Python dictionary:

In the above example, the popitem() method removes a random key-value pair from the dictionary and stores it in the random_pair variable. The updated dictionary is then printed, which shows that the removed key-value pair is no longer present in the dictionary.

dict.update()

The update() method in Python dictionaries is used to add or update key-value pairs in a dictionary. It takes a dictionary or an iterable object (such as a list or a set) as an argument and adds the key-value pairs from that object to the original dictionary.

For example, let’s first create a dictionary called my_dict :

Then let’s see a couple of examples of using the update() method.

1. Add a new key-value pair to the dictionary

You can update the dictionary by passing in a new key-value pair:

Let’s print the dictionary to see how it changed:

Update the value of an existing key in the dictionary

You can also use the update() method to update the value of an existing key.

Note: If the same key exists in both the original dictionary and the object passed to the update method, the value in the object passed to the update method will replace the value in the original dictionary.

How to Loop Through Dictionaries in Python?

To loop through a dictionary in Python, use the for loop and the items() method, which returns the dictionary’s keys and values.

You actually saw an example of this earlier in this guide. But because looping through a dictionary is such a common operation, it’s worthwhile to go through it in a bit more detail here.

This prints each key-value pair on a separate line:

To loop through the keys only, use the for loop combined with the keys() method.

This will print each key on a separate line, like this:

To loop through the values only, use the values() method. It returns a list of the dictionary’s values.

This prints each value on a separate line, like this:

Today you learned what is a dictionary in Python.

The main use case for Python dictionaries is to store and retrieve data in a key-value format. In Python, dictionaries are used to represent data structures that are similar to associative arrays or hash tables in other programming languages.

Dictionaries are often used to store data in a more structured and efficient way than other data types, such as lists or tuples. This is because dictionaries allow you to access and retrieve the data using keys instead of indexes. This makes it easier to organize and manipulate the data in your code, especially when working with large datasets.

Additionally, dictionaries are often used to implement more complex data structures, such as graphs and trees, because they allow you to store and access data in a hierarchical or nested format.

Overall, the main advantage of using dictionaries in Python is that they provide an efficient and flexible way to store, retrieve, and manipulate data in your code.

Thanks for reading. Happy coding!

Why Python Is Still Popular?

Python Dictionary Comprehensions for Shorthand Looping

Learn Python practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn python interactively, python introduction.

• Get Started With Python
• Your First Python Program
• Python Comments

Python Fundamentals

• Python Variables and Literals
• Python Type Conversion
• Python Basic Input and Output
• Python Operators

Python Flow Control

• Python if...else Statement
• Python for Loop
• Python while Loop
• Python break and continue
• Python pass Statement

Python Data types

• Python Numbers and Mathematics
• Python List
• Python Tuple
• Python String

Python Dictionary

• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files
• Reading CSV files in Python
• Writing CSV files in Python
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes
• Python Inheritance
• Python Multiple Inheritance
• Polymorphism in Python
• Python Operator Overloading

Python Advanced Topics

• List comprehension
• Python Lambda/Anonymous Function
• Python Iterators
• Python Generators
• Python Namespace and Scope
• Python Closures
• Python Decorators
• Python @property decorator
• Python RegEx

Python Date and Time

• Python datetime
• Python strftime()
• Python strptime()
• How to get current date and time in Python?
• Python Get Current Time
• Python timestamp to datetime and vice-versa
• Python time Module
• Python sleep()

Additional Topic

• Precedence and Associativity of Operators in Python
• Python Keywords and Identifiers
• Python Asserts
• Python Json
• Python *args and **kwargs

Python Tutorials

Python reversed()

Python Dictionary clear()

• Python Dictionary items()
• Python Dictionary keys()

Python Dictionary fromkeys()

• Python Nested Dictionary

A Python dictionary is a collection of items, similar to lists and tuples. However, unlike lists and tuples, each item in a dictionary is a key-value pair (consisting of a key and a value).

• Create a Dictionary

We create a dictionary by placing key: value pairs inside curly brackets {} , separated by commas. For example,

• Dictionary keys must be immutable, such as tuples, strings, integers, etc. We cannot use mutable (changeable) objects such as lists as keys.
• We can also create a dictionary using a Python built-in function dict() . To learn more, visit Python dict() .

Valid and Invalid Dictionaries

Immutable objects can't be changed once created. Some immutable objects in Python are integer, tuple and string.

In this example, we have used integers, tuples, and strings as keys for the dictionaries. When we used a list as a key, an error message occurred due to the list's mutable nature.

Note: Dictionary values can be of any data type, including mutable types like lists.

The keys of a dictionary must be unique. If there are duplicate keys, the later value of the key overwrites the previous value.

Here, the key Harry Potter is first assigned to Gryffindor . However, there is a second entry where Harry Potter is assigned to Slytherin .

As duplicate keys are not allowed in a dictionary, the last entry Slytherin overwrites the previous value Gryffindor .

• Access Dictionary Items

We can access the value of a dictionary item by placing the key inside square brackets.

Note: We can also use the get() method to access dictionary items.

• Add Items to a Dictionary

We can add an item to a dictionary by assigning a value to a new key. For example,

• Remove Dictionary Items

We can use the del statement to remove an element from a dictionary. For example,

Note : We can also use the pop() method to remove an item from a dictionary.

If we need to remove all items from a dictionary at once, we can use the clear() method.

• Change Dictionary Items

Python dictionaries are mutable (changeable). We can change the value of a dictionary element by referring to its key. For example,

Note : We can also use the update() method to add or change dictionary items.

• Iterate Through a Dictionary

A dictionary is an ordered collection of items (starting from Python 3.7), therefore it maintains the order of its items.

We can iterate through dictionary keys one by one using a for loop .

• Find Dictionary Length

We can find the length of a dictionary by using the len() function.

• Python Dictionary Methods

Here are some of the commonly used dictionary methods .

• Dictionary Membership Test

We can check whether a key exists in a dictionary by using the in and not in operators.

Note: The in operator checks whether a key exists; it doesn't check whether a value exists or not.

Table of Contents

Before we wrap up, let’s put your knowledge of Python dictionary to the test! Can you solve the following challenge?

Write a function to merge two dictionaries.

• Merge dict1 and dict2 , then return the merged dictionary.

Video: Python Dictionaries to Store key/value Pairs

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

• Interactive Courses
• Certificates
• 2000+ Challenges

Related Tutorials

Python Library

Python Tutorial

Python Data Types

Python Add to Dictionary – Adding an Item to a Dict

Dictionaries are one of the most widely used data structures across Python programming, powering many real-world applications and frameworks through their speed and versatility.

Whether it‘s looking up configuration data, caching web app results, or parsing scientific datasets – dictionaries lend themselves well to fast key-value lookups and dynamic expansion.

According to Python developers surveyed, modifying dictionaries through methods like update() , comprehensions, and mergers accounted for over 25% of all dictionary operations in their code.

In this comprehensive guide, we‘ll go beyond the basics and look at some advanced tactics and best practices for modifying dictionaries from a seasoned Python coder‘s perspective.

Topics include:

• Common real-world use cases for dictionary modification
• Recommended methods for building and expanding dictionaries
• Performance considerations of different techniques
• Dictionary modification patterns to avoid pitfalls
• Tips from leading Python programmers & coders

Let‘s dive in!

Real-World Use Cases for Updating Dictionaries

Dictionaries are so versatile in Python that they can be found in all types of applications undergoing frequent modification during execution.

Some top areas include:

Web Applications

In server-side web apps built with frameworks like Django or Flask, dictionaries often store user session data that changes frequently with each page request:

Session dictionaries may be written and re-written thousands of times per user over the course of web browsing.

Data Analysis & Science

Libraries like Pandas and NumPy use dictionaries internally for performance enhancing techniques like memoization :

Dictionaries minimize expensive re-computing by caching prior results the first time a function is called.

Machine Learning

Dictionaries are commonly used in ML for tokenization when converting text into numerical vectors:

New vocabulary terms encountered require expanding the token dictionary on-the-fly without impacting existing assigned indexes.

These examples illustrate why efficient dictionary modification is so vital across common Python data applications. The usage spans far and wide!

Now let‘s explore some recommended techniques that balance performance and safety when altering dictionary contents.

Building and Updating Dictionaries in Python

There are a few approaches suitable for different dictionary modification use cases:

1. Key Assignment

Adding new key-value pairs through key assignment remains one of the most popular ways for modifying:

It provides a clean and readable syntax for defining new terms.

Be aware that any existing entry gets overridden without warning:

So watch out for unintentional overwriting of data.

2. update() Method

The update() dict method offers more control for safely merging two dictionaries:

No more worrying about accidentally removing entries when combining dictionaries. The original keys persist while new ones get added.

3. Comprehension Expressions

Dictionary comprehensions provide a shortcut for transforming and constructing new dictionaries:

Comprehensions keep logic expressive. Use them to derive updated data more declaratively from an existing dictionary.

So when should you use each technique? Here are some guidelines:

The next section looks at performance trade-offs.

Speed and Performance Considerations

While convenient syntax can make certain methods attractive, performance also needs to be factored when working on large production systems.

Here‘s how the common techniques compare in terms of computation speed:

Processing time measured for dictionary with 50,000 entries

Key assignment wins out by directly changing the dict in-place without copying data. Comprehensions have some overhead from creating new dictionary structures. update() is the slowest since it combines dict content.

The performance differences become very apparent at scale – key assignment took 1.5x less time than update() on large dictionaries with over 75,000 elements in testing.

Caching frequently accessed data in a mutable dictionary is a common optimization. Using key assignment ensures subsequent lookups remain fast after modifications by avoiding large data transfers or reconstructions.

However raw speed isn‘t everything. We also need to watch for subtle programming traps with dictionaries…

Avoiding Dictionary Pitfalls

Working with such a flexible structure, it doesn‘t take much for a dictionary to become riddled with bugs if you aren‘t careful:

Such unintended overwriting can quickly corrupt previously stored results without any errors raised due to the nature of dictionaries.

Here are two ways to mitigate this:

1. Keep Dictionaries Immutable

An immutable dictionary that cannot be modified will guarantee no monkeying with contents:

This enforcement using special immutable dict types prevents tampering when building auditable datasets.

2. Dict Subclass for Defaults

For cases requiring expansion, a default dict subclass makes it easy to initialize placeholders without clobbering:

With some guidance, hazards can be averted!

Finally, I consulted experienced Python developers for their tips on effectively managing dictionaries. Here‘s what I learned…

Expert Tips from Python Coders & Developers

I interviewed senior Python coders from top tech companies about best practices they follow for production dictionary usage.

Here were two of their top recommendations:

"Always tread lightly when handling nested dicts" – Mark, Software Engineer

"Use tools like DeepDiff to recursively track changes during complex operations" – Julia, Senior Developer

Additionally, they provided these guidelines tailored to different contexts:

Deep copy dicts before modifying to avoid side effects

Use nested defaultdicts for dynamically generated JSON

Data Science:

Specify dict types like OrderedDict for reproducible transformations

Avoid mutation – instead create new dicts with cleaned results

Machine Learning:

Subclass dict to log all changes during model training, like accesses

Adding memoization to reusable model dicts avoids recomputing

There is certainly an art beyond basics when it comes to mastering dictionary usage – hopefully the wisdom shared here by generously donating Python veterans helps you on that journey towards dict proficiency!

We‘ve explored quite a lot of ground when it comes to the myriad techniques and best practices for updating dictionaries with new items or merging existing dictionary content in Python.

Key highlights include:

• Common real-world use cases across Python frameworks rely heavily on mutable dicts
• Key assignment provides the best performance, while update() focuses on safety
• Dictionary comprehensions give declarative flexibility to transform contents
• Default dicts and immutable variants should be used to prevent overwriting and data loss
• Veteran Python coders have shared their tips for smooth dict wrangling

Python dictionaries are a versatile built-in type that lend themselves well to all kinds of modifications. I hope reviewing the guidance in this guide gives you a stable footing to leverage dicts in your projects safely and efficiently!

Let me know in the comments if you have any other favorite dictionary techniques I may have missed. Thanks for reading!

Dr. Alex Mitchell is a dedicated coding instructor with a deep passion for teaching and a wealth of experience in computer science education. As a university professor, Dr. Mitchell has played a pivotal role in shaping the coding skills of countless students, helping them navigate the intricate world of programming languages and software development.

Beyond the classroom, Dr. Mitchell is an active contributor to the freeCodeCamp community, where he regularly shares his expertise through tutorials, code examples, and practical insights. His teaching repertoire includes a wide range of languages and frameworks, such as Python, JavaScript, Next.js, and React, which he presents in an accessible and engaging manner.

Dr. Mitchell’s approach to teaching blends academic rigor with real-world applications, ensuring that his students not only understand the theory but also how to apply it effectively. His commitment to education and his ability to simplify complex topics have made him a respected figure in both the university and online learning communities.

Similar Posts

HTML Font Size – How to Change Text Size with CSS

In the early days of the web, the only way to control text size was by…

How to Build a Robust and Scalable JSON API with Python

Building efficient web APIs is critical for modern applications that need to fetch or modify remote…

How I Solved a Simple CrackMe Challenge with Ghidra

Reverse engineering software is crucial for security analysts and malware researchers. By disassembling binaries, we can…

Best Practices for Building Secure API Keys

API keys enable controlled access for outside applications to interface with various web services and APIs….

The Evolution of Tokenization – Byte Pair Encoding in NLP

Tokenization is a vital first step in natural language processing (NLP) pipelines… Why Tokenization Matters Before…

What is the OSI Model? An In-Depth Guide for Beginners

The OSI (Open Systems Interconnection) model is a conceptual framework to understand modern computer networking. By…

Add and update an item in a dictionary in Python

This article explains how to add an item (key-value pair) to a dictionary ( dict ) or update the value of an existing item in Python.

Add or update a single item in a dictionary

Specify keyword arguments, specify an iterable of key-value pairs, specify other dictionaries.

See the following articles to learn how to add a dictionary to a dictionary (i.e., merge dictionaries), remove an item from a dictionary, and change a key name.

• Merge dictionaries in Python
• Remove an item from a dictionary in Python (clear, pop, popitem, del)
• Change a key name in a dictionary in Python

You can add an item to a dictionary or update the value of an existing item as follows.

If a non-existent key is specified, a new item is added; if an existing key is specified, the value of that item is updated (overwritten).

To avoid updating the value for an existing key, use the setdefault() method. See the following article for details.

• Add an item if the key does not exist in dict with setdefault in Python

Add or update multiple items in a dictionary: update()

You can add or update multiple items at once using the update() method.

• Built-in Types - dict.update() — Python 3.11.3 documentation

If the keyword argument ( key=value ) is specified for update() , the item with that key and value is added. If the key already exists, it is overwritten with the value specified in the argument.

An error is raised if the same key is specified multiple times.

In this case, keys must be valid identifiers in Python. They cannot start with a number or contain symbols other than _ .

• Valid variable names and naming rules in Python

In other approaches, values that are invalid as identifiers can be used as keys.

You can pass a list of (key, value) pairs to update() . If a key in the list duplicates an existing key, it is overwritten with the value specified in the argument.

In the above example, a list of tuples was specified. However, any iterable containing key-value pairs (two-element iterables) is acceptable. This could include a tuple of lists, such as ([key1, value1], [key2, value2], ...) , or other iterable structures.

You can use zip() to add items by pairing elements from a list of keys and a list of values.

• zip() in Python: Get elements from multiple lists

When using an iterable of key-value pairs, duplicate keys are acceptable. The value corresponding to the later occurrence of a key will overwrite the earlier one.

You can specify another dictionary as an argument to update() to add all its items.

Passing multiple dictionaries directly to update() will result in an error. You can prefix dictionaries with ** and pass each element as a keyword argument.

• Expand and pass a list and dictionary as arguments in Python

When using ** , as shown in the above example, duplicate keys between the caller's dictionary and the dictionary specified in the argument are not a problem. However, if the same keys are found across multiple dictionaries specified in the argument, this will result in an error.

For more details on merging dictionaries, refer to the following article.

Related Categories

Related articles.

• Extract specific key values from a list of dictionaries in Python
• Pretty-print with pprint in Python
• Sort a list of dictionaries by the value of the specific key in Python
• Create a dictionary in Python ({}, dict(), dict comprehensions)
• Get keys from a dictionary by value in Python
• Set operations on multiple dictionary keys in Python
• Swap keys and values in a dictionary in Python
• Iterate through dictionary keys and values in Python
• Check if a key/value exists in a dictionary in Python
• Get maximum/minimum values and keys in Python dictionaries

Python Programming

Practice Python Exercises and Challenges with Solutions

Free Coding Exercises for Python Developers. Exercises cover Python Basics , Data structure , to Data analytics . As of now, this page contains 18 Exercises.

What included in these Python Exercises?

Each exercise contains specific Python topic questions you need to practice and solve. These free exercises are nothing but Python assignments for the practice where you need to solve different programs and challenges.

• All exercises are tested on Python 3.
• Each exercise has 10-20 Questions.
• The solution is provided for every question.
• Practice each Exercise in Online Code Editor

These Python programming exercises are suitable for all Python developers. If you are a beginner, you will have a better understanding of Python after solving these exercises. Below is the list of exercises.

Select the exercise you want to solve .

Basic Exercise for Beginners

Practice and Quickly learn Python’s necessary skills by solving simple questions and problems.

Topics : Variables, Operators, Loops, String, Numbers, List

Python Input and Output Exercise

Solve input and output operations in Python. Also, we practice file handling.

Topics : print() and input() , File I/O

Python Loop Exercise

This Python loop exercise aims to help developers to practice branching and Looping techniques in Python.

Topics : If-else statements, loop, and while loop.

Python Functions Exercise

Practice how to create a function, nested functions, and use the function arguments effectively in Python by solving different questions.

Topics : Functions arguments, built-in functions.

Python String Exercise

Solve Python String exercise to learn and practice String operations and manipulations.

Python Data Structure Exercise

Practice widely used Python types such as List, Set, Dictionary, and Tuple operations in Python

Python List Exercise

This Python list exercise aims to help Python developers to learn and practice list operations.

Python Dictionary Exercise

This Python dictionary exercise aims to help Python developers to learn and practice dictionary operations.

Python Set Exercise

This exercise aims to help Python developers to learn and practice set operations.

Python Tuple Exercise

This exercise aims to help Python developers to learn and practice tuple operations.

Python Date and Time Exercise

This exercise aims to help Python developers to learn and practice DateTime and timestamp questions and problems.

Topics : Date, time, DateTime, Calendar.

Python OOP Exercise

This Python Object-oriented programming (OOP) exercise aims to help Python developers to learn and practice OOP concepts.

Topics : Object, Classes, Inheritance

Python JSON Exercise

Practice and Learn JSON creation, manipulation, Encoding, Decoding, and parsing using Python

Python NumPy Exercise

Practice NumPy questions such as Array manipulations, numeric ranges, Slicing, indexing, Searching, Sorting, and splitting, and more.

Python Pandas Exercise

Practice Data Analysis using Python Pandas. Practice Data-frame, Data selection, group-by, Series, sorting, searching, and statistics.

Python Matplotlib Exercise

Practice Data visualization using Python Matplotlib. Line plot, Style properties, multi-line plot, scatter plot, bar chart, histogram, Pie chart, Subplot, stack plot.

Random Data Generation Exercise

Practice and Learn the various techniques to generate random data in Python.

Topics : random module, secrets module, UUID module

Python Database Exercise

Practice Python database programming skills by solving the questions step by step.

Use any of the MySQL, PostgreSQL, SQLite to solve the exercise

Exercises for Intermediate developers

The following practice questions are for intermediate Python developers.

If you have not solved the above exercises, please complete them to understand and practice each topic in detail. After that, you can solve the below questions quickly.

Exercise 1: Reverse each word of a string

Expected Output

• Use the split() method to split a string into a list of words.
• Reverse each word from a list
• finally, use the join() function to convert a list into a string

Steps to solve this question :

• Split the given string into a list of words using the split() method
• Use a list comprehension to create a new list by reversing each word from a list.
• Use the join() function to convert the new list into a string
• Display the resultant string

Exercise 2: Read text file into a variable and replace all newlines with space

Given : Assume you have a following text file (sample.txt).

Expected Output :

• First, read a text file.
• Next, use string replace() function to replace all newlines ( \n ) with space ( ' ' ).

Steps to solve this question : -

• First, open the file in a read mode
• Next, read all content from a file using the read() function and assign it to a variable.
• Display final string

Exercise 3: Remove items from a list while iterating

Description :

In this question, You need to remove items from a list while iterating but without creating a different copy of a list.

Remove numbers greater than 50

Expected Output : -

• Get the list's size
• Iterate list using while loop
• Check if the number is greater than 50
• If yes, delete the item using a del keyword
• Reduce the list size

Solution 1: Using while loop

Solution 2: Using for loop and range()

Exercise 4: Reverse Dictionary mapping

Exercise 5: display all duplicate items from a list.

• Use the counter() method of the collection module.
• Create a dictionary that will maintain the count of each item of a list. Next, Fetch all keys whose value is greater than 2

Solution 1 : - Using collections.Counter()

Solution 2 : -

Exercise 6: Filter dictionary to contain keys present in the given list

Exercise 7: print the following number pattern.

Refer to Print patterns in Python to solve this question.

• Use two for loops
• The outer loop is reverse for loop from 5 to 0
• Increment value of x by 1 in each iteration of an outer loop
• The inner loop will iterate from 0 to the value of i of the outer loop
• Print value of x in each iteration of an inner loop
• Print newline at the end of each outer loop

Exercise 8: Create an inner function

Question description : -

• Create an outer function that will accept two strings, x and y . ( x= 'Emma' and y = 'Kelly' .
• Create an inner function inside an outer function that will concatenate x and y.
• At last, an outer function will join the word 'developer' to it.

Exercise 9: Modify the element of a nested list inside the following list

Change the element 35 to 3500

Exercise 10: Access the nested key increment from the following dictionary

Under Exercises: -

Python Object-Oriented Programming (OOP) Exercise: Classes and Objects Exercises

Updated on:  December 8, 2021 | 52 Comments

Python Date and Time Exercise with Solutions

Updated on:  December 8, 2021 | 10 Comments

Python Dictionary Exercise with Solutions

Updated on:  May 6, 2023 | 56 Comments

Python Tuple Exercise with Solutions

Updated on:  December 8, 2021 | 96 Comments

Python Set Exercise with Solutions

Updated on:  October 20, 2022 | 27 Comments

Python if else, for loop, and range() Exercises with Solutions

Updated on:  September 3, 2024 | 298 Comments

Updated on:  August 2, 2022 | 155 Comments

Updated on:  September 6, 2021 | 109 Comments

Python List Exercise with Solutions

Updated on:  December 8, 2021 | 201 Comments

Updated on:  December 8, 2021 | 7 Comments

Python Data Structure Exercise for Beginners

Updated on:  December 8, 2021 | 116 Comments

Python String Exercise with Solutions

Updated on:  October 6, 2021 | 221 Comments

Updated on:  March 9, 2021 | 23 Comments

Updated on:  March 9, 2021 | 51 Comments

Updated on:  July 20, 2021 | 29 Comments

Python Basic Exercise for Beginners

Updated on:  August 29, 2024 | 498 Comments

Useful Python Tips and Tricks Every Programmer Should Know

Updated on:  May 17, 2021 | 23 Comments

Python random Data generation Exercise

Updated on:  December 8, 2021 | 13 Comments

Python Database Programming Exercise

Updated on:  March 9, 2021 | 17 Comments

• Online Python Code Editor

Updated on:  June 1, 2022 |

About PYnative

PYnative.com is for Python lovers. Here, You can get Tutorials, Exercises, and Quizzes to practice and improve your Python skills .

Explore Python

• Learn Python
• Python Basics
• Python Databases
• Python Exercises
• Python Quizzes
• Python Tricks

To get New Python Tutorials, Exercises, and Quizzes

Legal Stuff

We use cookies to improve your experience. While using PYnative, you agree to have read and accepted our Terms Of Use , Cookie Policy , and Privacy Policy .

Copyright © 2018–2024 pynative.com

• How it works
• Homework answers

Answer to Question #288912 in Python for sai krishna

New Dictionary

Peter is making a new dictionary. He wants to arrange the words in the ascending order of their length and later arrange the ones with the same length in lexicographic order. Each word is given a serial number according to its position. Find the word according to the serial number.

The serial number of words in Peter's dictionary is as follows

Serial Number

Need a fast expert's response?

and get a quick answer at the best price

for any assignment or question with DETAILED EXPLANATIONS !

Leave a comment

Ask your question, related questions.

• 1. a class of students p gave a science viva their final results are listed out in the order of their r
• 2. A credit card company calculates a customer's "minimum payment" according to the foll
• 3. smallest amoung three numbers input = 6,5, 4 and -1000, - 1000, -1000
• 4. Find the closest pairs (excluding self pairs) on the basis of both the distance measures
• 5. b) Define the find_max_gap function which will take as a parameter a list of values, sort it in asce
• 6. A program is asked to execute a text that is given as a multi-line string, and then returns statisti
• 7. Assume that you have to create such an application for maintaining a database of book titles and the
• Programming
• Engineering

Who Can Help Me with My Assignment

There are three certainties in this world: Death, Taxes and Homework Assignments. No matter where you study, and no matter…

How to Finish Assignments When You Can’t

Crunch time is coming, deadlines need to be met, essays need to be submitted, and tests should be studied for.…

How to Effectively Study for a Math Test

Numbers and figures are an essential part of our world, necessary for almost everything we do every day. As important…

• Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
• Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
• OverflowAI GenAI features for Teams
• OverflowAPI Train & fine-tune LLMs
• Labs The future of collective knowledge sharing
• About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

How can I add new keys to a dictionary?

How do I add a new key to an existing dictionary? It doesn't have an .add() method.

20 Answers 20

You create a new key/value pair on a dictionary by assigning a value to that key

If the key doesn't exist, it's added and points to that value. If it exists, the current value it points to is overwritten.

• 41 What is the difference between this and the .update() method? Which is better when? –  hegash Commented Jan 16, 2019 at 19:14
• 38 @hegash the d[key]=val syntax as it is shorter and can handle any object as key (as long it is hashable), and only sets one value, whereas the .update(key1=val1, key2=val2) is nicer if you want to set multiple values at the same time, as long as the keys are strings (since kwargs are converted to strings). dict.update can also take another dictionary, but I personally prefer not to explicitly create a new dictionary in order to update another one. –  bgusach Commented Feb 13, 2019 at 8:38
• how can i add an element in a nested dict. Like php $foo[ ] = [ . . . . ] –  Juan-Kabbali Commented Apr 28, 2020 at 12:55
• 1 Based on If it exists, the current value it points to is overwritten. how can i make it elegantly check if the key i m trying to add info on, already exists and then raise exception? –  Kots Commented Feb 25, 2021 at 9:19
• 1 @Selfcontrol7 append is not a dict's method, it's a method for lists, it adds a value at the end of the list. –  Łukasz Kwieciński Commented Aug 1, 2021 at 20:41

I feel like consolidating info about Python dictionaries:

Creating an empty dictionary

Creating a dictionary with initial values, inserting/updating a single value, inserting/updating multiple values, python 3.9+:.

The update operator |= now works for dictionaries:

Creating a merged dictionary without modifying originals

Python 3.5+:.

This uses a new feature called dictionary unpacking .

The merge operator | now works for dictionaries:

Deleting items in dictionary

Check if a key is already in dictionary, iterate through pairs in a dictionary, create a dictionary from two lists.

• 1 The "OR" operator | in 3.9 appears to solve my issue with python dicts not having any builder pattern. –  WestCoastProjects Commented Feb 24, 2021 at 15:56
• 1 Would be good to mention for the various options of "update one entry", that the ones using "update" have the overhead of creating a temporary dictionary. –  kdb Commented Jul 28, 2021 at 7:55

To add multiple keys simultaneously, use dict.update() :

For adding a single key, the accepted answer has less computational overhead.

"Is it possible to add a key to a Python dictionary after it has been created? It doesn't seem to have an .add() method."

Yes it is possible, and it does have a method that implements this, but you don't want to use it directly.

To demonstrate how and how not to use it, let's create an empty dict with the dict literal, {} :

Best Practice 1: Subscript notation

To update this dict with a single new key and value, you can use the subscript notation (see Mappings here) that provides for item assignment:

my_dict is now:

Best Practice 2: The update method - 2 ways

We can also update the dict with multiple values efficiently as well using the update method . We may be unnecessarily creating an extra dict here, so we hope our dict has already been created and came from or was used for another purpose:

Another efficient way of doing this with the update method is with keyword arguments, but since they have to be legitimate python words, you can't have spaces or special symbols or start the name with a number, but many consider this a more readable way to create keys for a dict, and here we certainly avoid creating an extra unnecessary dict :

and my_dict is now:

So now we have covered three Pythonic ways of updating a dict .

Magic method, __setitem__ , and why it should be avoided

There's another way of updating a dict that you shouldn't use, which uses the __setitem__ method. Here's an example of how one might use the __setitem__ method to add a key-value pair to a dict , and a demonstration of the poor performance of using it:

So we see that using the subscript notation is actually much faster than using __setitem__ . Doing the Pythonic thing, that is, using the language in the way it was intended to be used, usually is both more readable and computationally efficient.

• 1 The difference is rather less marked in 2020 (on my machine, 1.35 ms subscripting vs 2ms for d.__setitem__ ), though the conclusion (and especially the last sentence) remains sound. Hoisting the method name lookup out of the loop reduced time to about 1.65 ms; the remaining difference is likely largely due to unavoidable Python call mechanism overhead. –  holdenweb Commented Feb 5, 2020 at 13:41
• xrange is only used in python2 and no longer used in python3 –  Brunisboy Commented Apr 22 at 0:19

The conventional syntax is d[key] = value , but if your keyboard is missing the square bracket keys you could also do:

In fact, defining __getitem__ and __setitem__ methods is how you can make your own class support the square bracket syntax. See Dive Into Python, Classes That Act Like Dictionaries .

If you want to add a dictionary within a dictionary you can do it this way.

Example: Add a new entry to your dictionary & sub dictionary

NOTE: Python requires that you first add a sub

before adding entries.

You can create one:

Let's pretend you want to live in the immutable world and do not want to modify the original but want to create a new dict that is the result of adding a new key to the original.

In Python 3.5+ you can do:

The Python 2 equivalent is:

After either of these:

params is still equal to {'a': 1, 'b': 2}

new_params is equal to {'a': 1, 'b': 2, 'c': 3}

There will be times when you don't want to modify the original (you only want the result of adding to the original). I find this a refreshing alternative to the following:

Reference: What does `**` mean in the expression `dict(d1, **d2)`?

This popular question addresses functional methods of merging dictionaries a and b .

Here are some of the more straightforward methods (tested in Python 3)...

Note: The first method above only works if the keys in b are strings.

To add or modify a single element , the b dictionary would contain only that one element...

This is equivalent to...

There is also the strangely named, oddly behaved, and yet still handy dict.setdefault() .

basically just does this:

This question has already been answered ad nauseam, but since my (now deleted) comment gained a lot of traction, here it is as an answer:

Adding new keys without updating the existing dict

If you are here trying to figure out how to add a key and return a new dictionary (without modifying the existing one), you can do this using the techniques below

Python >= 3.5

Python < 3.5.

Note that with this approach, your key will need to follow the rules of valid identifier names in Python.

If you're not joining two dictionaries, but adding new key-value pairs to a dictionary, then using the subscript notation seems like the best way.

However, if you'd like to add, for example, thousands of new key-value pairs, you should consider using the update() method.

Here's another way that I didn't see here:

You can use the dictionary constructor and implicit expansion to reconstruct a dictionary. Moreover, interestingly, this method can be used to control the positional order during dictionary construction ( post Python 3.6 ). In fact, insertion order is guaranteed for Python 3.7 and above!

The above is using dictionary comprehension.

First to check whether the key already exists:

Then you can add the new key and value.

Add a dictionary (key,value) class.

I think it would also be useful to point out Python's collections module that consists of many useful dictionary subclasses and wrappers that simplify the addition and modification of data types in a dictionary , specifically defaultdict :

dict subclass that calls a factory function to supply missing values

This is particularly useful if you are working with dictionaries that always consist of the same data types or structures, for example a dictionary of lists.

If the key does not yet exist, defaultdict assigns the value given (in our case 10 ) as the initial value to the dictionary (often used inside loops). This operation therefore does two things: it adds a new key to a dictionary (as per question), and assigns the value if the key doesn't yet exist. With the standard dictionary, this would have raised an error as the += operation is trying to access a value that doesn't yet exist:

Without the use of defaultdict , the amount of code to add a new element would be much greater and perhaps looks something like:

defaultdict can also be used with complex data types such as list and set :

Adding an element automatically initialises the list.

Adding keys to dictionary without using add

update() and inplace merge operator ( |= )

A dictionary can be updated in-place via |= and update() by a list of tuples as well.

Not only is |= more concise than update , it is also faster. For example, if a dictionary is updated by a dict of length 5, |= is almost 30% faster than update() (which in turn is also faster than a loop) (tested on Python 3.9.12).

Add new keys to a nested dictionary

If a key has to be added to a dictionary that is nested inside a dictionary, dict.setdefault (or collections.defaultdict ) is really useful. For example, let's try to add a new key-value pair to mydict only nested inside another key: 'address' .

Then the desired output can be obtained in two lines (by first initializing an empty dictionary under 'address' ):

or it can be done in one step via dict.setdefault() :

The reason it works is that a default value of empty dict ( {} ) was passed to .setdefault , so when it is time to add the key-value pair to it, it is already initialized.

You can write a function for doing that, e.g.:

Not the answer you're looking for? Browse other questions tagged python dictionary lookup or ask your own question .

• The Overflow Blog
• At scale, anything that could fail definitely will
• Best practices for cost-efficient Kafka clusters
• Featured on Meta
• Announcing a change to the data-dump process
• Bringing clarity to status tag usage on meta sites
• What does a new user need in a homepage experience on Stack Overflow?
• Feedback requested: How do you use tag hover descriptions for curating and do...
• Staging Ground Reviewer Motivation

Hot Network Questions

• Largest number possible with +, -, ÷
• Geometry optimization of two or more different interacting molecules
• What is Zion's depth in the Matrix?
• Is it safe to install programs other than with a distro's package manager?
• "The earth was formless and void" Did the earth exist before God created the world?
• Maximizing the common value of both sides of an equation (part 2)
• How best to cut (slightly) varying size notches in long piece of trim
• Can a British judge convict and sentence someone for contempt in their own court on the spot?
• How to run only selected lines of a shell script?
• Whats the safest way to store a password in database?
• Are there ways to assist Gurobi in finding good solutions?
• Is loss of availability automatically a security incident?
• Could an empire rise by economic power?
• Nearly stalled on takeoff after just 3 hours training on a PPL. Is this normal?
• If a Palestinian converts to Judaism, can they get Israeli citizenship?
• Escape from the magic prison
• What is the translation of a code monkey in French?
• Risks of exposing professional email accounts?
• Can I arxive a paper that I had already published in a journal(EPL, in my case), so that eveyone can access it?
• Alternative to a single high spec'd diode
• How do I safely download and run an older version of software for testing without interfering with the currently installed version?
• Using rule-based symbology for overlapping layers in QGIS
• Why is there so much salt in cheese?
• Do all instances of a given string get replaced under a rewrite rule?

• Python Course
• Python Basics
• Interview Questions
• Python Quiz
• Popular Packages
• Python Projects
• Practice Python
• AI With Python
• Learn Python3
• Python Automation
• Python Web Dev
• DSA with Python
• Python OOPs
• Dictionaries

Dictionaries in Python

A Python dictionary is a data structure that stores the value in key: value pairs.

Example: Here, The data is stored in key: value pairs in dictionaries, which makes it easier to find values .

Python dictionaries are essential for efficient data mapping and manipulation in programming. To deepen your understanding of dictionaries and explore advanced techniques in data handling, consider enrolling in our Complete Machine Learning & Data Science Program. This course covers everything from basic dictionary operations to advanced data processing methods, empowering you to become proficient in Python programming and data analysis.

Python Dictionary Syntax

dict_var = {key1 : value1, key2 : value2, …..}

What is a Dictionary in Python?

Dictionaries in Python is a data structure, used to store values in key: value format. This makes it different from lists, tuples, and arrays as in a dictionary each key has an associated value.

Note: As of Python version 3.7, dictionaries are ordered and can not contain duplicate keys.

How to Create a Dictionary

In Python , a dictionary can be created by placing a sequence of elements within curly {} braces, separated by a ‘comma’. The dictionary holds pairs of values, one being the Key and the other corresponding pair element being its Key:value . Values in a dictionary can be of any data type and can be duplicated, whereas keys can’t be repeated and must be immutable .

Note – Dictionary keys are case sensitive, the same name but different cases of Key will be treated distinctly.

The code demonstrates creating dictionaries with different types of keys. The first dictionary uses integer keys, and the second dictionary uses a mix of string and integer keys with corresponding values. This showcases the flexibility of Python dictionaries in handling various data types as keys.

Dictionary Example

A dictionary can also be created by the built-in function dict(). An empty dictionary can be created by just placing curly braces{}.

Different Ways to Create a Python Dictionary

The code demonstrates different ways to create dictionaries in Python. It first creates an empty dictionary, and then shows how to create dictionaries using the dict() constructor with key-value pairs specified within curly braces and as a list of tuples.

Complexities for Creating a Dictionary:

• Time complexity: O(len(dict))
• Space complexity: O(n)

Nested Dictionaries

Example : The code defines a nested dictionary named ‘Dict’ with multiple levels of key-value pairs. It includes a top-level dictionary with keys 1, 2, and 3. The value associated with key 3 is another dictionary with keys ‘A,’ ‘B,’ and ‘C.’ This showcases how Python dictionaries can be nested to create hierarchical data structures.

More on Python Nested Dictionary

Adding Elements to a Dictionary

The addition of elements can be done in multiple ways. One value at a time can be added to a Dictionary by defining value along with the key e.g. Dict[Key] = ‘Value’.

Updating an existing value in a Dictionary can be done by using the built-in update() method. Nested key values can also be added to an existing Dictionary.

Note- While adding a value, if the key-value already exists, the value gets updated otherwise a new Key with the value is added to the Dictionary.

Example: Add Items to a Python Dictionary with Different DataTypes

The code starts with an empty dictionary and then adds key-value pairs to it. It demonstrates adding elements with various data types, updating a key’s value, and even nesting dictionaries within the main dictionary. The code shows how to manipulate dictionaries in Python.

Complexities for Adding Elements in a Dictionary:

• Time complexity: O(1)/O(n)
• Space complexity: O(1)

Accessing Elements of a Dictionary

To access the items of a dictionary refer to its key name. Key can be used inside square brackets.

Access a Value in Python Dictionary

The code demonstrates how to access elements in a dictionary using keys. It accesses and prints the values associated with the keys ‘name’ and 1, showcasing that keys can be of different data types (string and integer).

There is also a method called get() that will also help in accessing the element from a dictionary. This method accepts key as argument and returns the value.

Complexities for Accessing elements in a Dictionary:

• Time complexity: O(1)

Example: Access a Value in Dictionary using get() in Python

The code demonstrates accessing a dictionary element using the get() method. It retrieves and prints the value associated with the key 3 in the dictionary ‘Dict’ . This method provides a safe way to access dictionary values, avoiding KeyError if the key doesn’t exist.

Accessing an Element of a Nested Dictionary

To access the value of any key in the nested dictionary, use indexing [] syntax.

Example : The code works with nested dictionaries. It first accesses and prints the entire nested dictionary associated with the key ‘Dict1’ . Then, it accesses and prints a specific value by navigating through the nested dictionaries. Finally, it retrieves and prints the value associated with the key ‘Name’ within the nested dictionary under ‘Dict2’ .

Deleting Elements using ‘del’ Keyword

The items of the dictionary can be deleted by using the del keyword as given below.

Example : The code defines a dictionary, prints its original content, and then uses the ‘del’ statement to delete the element associated with key 1. After deletion, it prints the updated dictionary, showing that the specified element has been removed.

Dictionary Methods

Here is a list of in-built dictionary functions with their description. You can use these functions to operate on a dictionary.

For Detailed Explanations: Python Dictionary Methods

Multiple Dictionary Operations in Python

The code begins with a dictionary ‘dict1’ and creates a copy ‘dict2’ . It then demonstrates several dictionary operations: clearing ‘dict1’ , accessing values, retrieving key-value pairs and keys, removing specific key-value pairs, updating a value, and retrieving values. These operations showcase how to work with dictionaries in Python.

We have covered all about dictionaries in Python, discussed its definition, and uses, and saw different dictionary methods with examples. The dictionary is an important data structure for storing data in Python. It is very different from tuples and lists.

Read More Data Structures in Python

• How to create a Dictionary in Python
• Difference between List and Dictionary in Python
• Python | Merging two Dictionaries

Dictionaries in Python – FAQs

How to use dictionaries in python.

Dictionaries in Python are used to store key-value pairs. They are unordered, mutable, and can contain any Python objects as values. # Creating a dictionary my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’} # Accessing values by keys print(my_dict[‘key1’]) # Output: value1 # Modifying values my_dict[‘key2’] = ‘new_value’ # Adding new key-value pairs my_dict[‘key3’] = ‘value3’ # Removing a key-value pair del my_dict[‘key1’]

How to print dictionaries in Python?

You can use print() to display the contents of a dictionary. You can print the entire dictionary or specific elements by accessing keys or values. my_dict = {‘name’: ‘Alice’, ‘age’: 30} # Printing the entire dictionary print(my_dict) # Printing specific elements print(my_dict[‘name’]) # Output: Alice

How to declare a dictionary in Python?

You can declare a dictionary by enclosing key-value pairs within curly braces {}. # Empty dictionary empty_dict = {} # Dictionary with initial values my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’}

What are dictionary keys and values in Python?

In a dictionary, keys are unique identifiers that are used to access values. Values are the data associated with those keys. my_dict = {‘name’: ‘Alice’, ‘age’: 30} # Accessing keys and values print(my_dict.keys()) # Output: dict_keys([‘name’, ‘age’]) print(my_dict.values()) # Output: dict_values([‘Alice’, 30])

What is the use of all() , any() , cmp() , and sorted() in dictionary?

all() checks if all values in the dictionary evaluate to True . any() checks if any value in the dictionary evaluates to True . cmp() (no longer available in Python 3) used to compare two dictionaries. sorted() returns a new sorted list of keys in the dictionary. my_dict = {‘A’: 10, ‘B’: 20, ‘C’: 0} print(all(my_dict.values())) # False (0 evaluates to False) print(any(my_dict.values())) # True (at least one value is True) print(sorted(my_dict)) # [‘A’, ‘B’, ‘C’] (sorted keys)

Please Login to comment...

Similar reads.

• python-dict
• How to Delete Discord Servers: Step by Step Guide
• Google increases YouTube Premium price in India: Check our the latest plans
• California Lawmakers Pass Bill to Limit AI Replicas
• Best 10 IPTV Service Providers in Germany
• 15 Most Important Aptitude Topics For Placements [2024]

Improve your Coding Skills with Practice

What kind of Experience do you want to share?