python dictionary variable assignment

Assign a dictionary Key or Value to variable in Python

Last updated: Apr 9, 2024 Reading time · 4 min

# Table of Contents

• Assign a dictionary value to a Variable in Python
• Assign dictionary key-value pairs to variables in Python
• Assign dictionary key-value pairs to variables using exec()

# Assign a dictionary value to a Variable in Python

Use bracket notation to assign a dictionary value to a variable, e.g. first = my_dict['first_name'] .

The left-hand side of the assignment is the variable's name and the right-hand side is the value.

The first example uses square brackets to access a dictionary key and assigns the corresponding value to a variable.

If you need to access the dictionary value using an index , use the dict.values() method.

The dict.values() method returns a new view of the dictionary's values.

We had to use the list() class to convert the view object to a list because view objects are not subscriptable (cannot be accessed at an index).

You can use the same approach if you have the key stored in a variable.

If you try to access a dictionary key that doesn't exist using square brackets, you'd get a KeyError .

On the other hand, the dict.get() method returns None for non-existent keys by default.

The dict.get() method returns the value for the given key if the key is in the dictionary, otherwise a default value is returned.

The method takes the following 2 parameters:

If a value for the default parameter is not provided, it defaults to None , so the get() method never raises a KeyError .

If you need to assign the key-value pairs of a dictionary to variables, update the locals() dictionary.

# Assign dictionary key-value pairs to variables in Python

Update the locals() dictionary to assign the key-value pairs of a dictionary to variables.

The first example uses the locals() dictionary to assign the key-value pairs of a dictionary to local variables.

The locals() function returns a dictionary that contains the current scope's local variables.

The dict.update method updates the dictionary with the key-value pairs from the provided value.

You can access the variables directly after calling the dict.update() method.

The SimpleNamespace class can be initialized with keyword arguments.

The keys of the dictionary are accessible as attributes on the namespace object.

Alternatively, you can use the exec() function.

# Assign dictionary key-value pairs to variables using exec()

This is a three-step process:

• Iterate over the dictionary's items.
• Use the exec() function to assign each key-value pair to a variable.

The exec() function supports dynamic execution of Python code.

The dict.items() method returns a new view of the dictionary's items ((key, value) pairs).

On each iteration, we use the exec() function to assign the current key-value pair to a variable.

The function takes a string, parses it as a suite of Python statements and runs the code.

Which approach you pick is a matter of personal preference. I'd go with the SimpleNamespace class to avoid any linting errors for trying to access undefined variables.

# Additional Resources

You can learn more about the related topics by checking out the following tutorials:

• Check if all values in a Dictionary are equal in Python
• How to Replace values in a Dictionary in Python
• Get multiple values from a Dictionary in Python
• Get random Key and Value from a Dictionary in Python
• Join the Keys or Values of Dictionary into String in Python
• Multiply the Values in a Dictionary in Python
• Print specific key-value pairs of a dictionary in Python
• How to set all Dictionary values to 0 in Python
• Sum all values in a Dictionary or List of Dicts in Python
• Swap the keys and values in a Dictionary in Python

Borislav Hadzhiev

Web Developer

Copyright © 2024 Borislav Hadzhiev

Python: Using variables as dictionary keys (basic and advanced examples)

Introduction.

Dictionaries in Python are versatile data structures allowing for fast key-value pair storage and retrieval. Incorporating variables as keys adds a dynamic layer to managing and accessing data effectively. This article delves into how to use variables as dictionary keys, exploring basic to advanced techniques enriched with examples.

Basic Usage of Variables as Dictionary Keys

Starting with the basics, using variables as dictionary keys is straightforward. It involves defining a variable and then using it to assign a value within a dictionary.

This approach makes the code more readable and maintainable, as it clearly identifies the role of the key.

Advanced Key Manipulation

As we delve deeper, one can enhance the flexibility of using variables as keys through manipulation. This involves combining variables, computation, or incorporating conditionals to generate keys dynamically.

This method enables creating more descriptive keys dynamically, improving data structure organisation.

Using Variables for Conditional Keys

A more complex scenario involves using variables to generate keys based on conditions. This facilitates more control over data structure, especially in cases requiring dynamic structure updates.

Here, the key is generated dynamically based on the presence of a role, showcasing the power of variables in creating flexible and descriptive keys.

Key Uniqueness Concerns

When using variables as dictionary keys, ensuring uniqueness is crucial. Dynamically generated keys, especially in loops or data-driven applications, require careful management to prevent key collisions and data overwrites.

This pattern ensures each key is unique, safeguarding against unintended data loss.

Employing variables as dictionary keys in Python enriches data management capabilities, facilitating dynamic, readable, and maintainable code structures. Through from basic to advanced examples, this article showcased how leveraging variables for key generation can enhance data organization and access, providing a potent tool for efficient programming. Take the techniques that best fit your needs, and harness the power of dynamic dictionaries in Python.

Next Article: 4 ways to create a dictionary in Python

Previous Article: Python: Using type hints with NamedTuple – Examples

Series: Working with Dict, Set, and Tuple in Python

Related Articles

• Python Warning: Secure coding is not enabled for restorable state
• Python TypeError: write() argument must be str, not bytes
• 4 ways to install Python modules on Windows without admin rights
• Python TypeError: object of type ‘NoneType’ has no len()
• Python: How to access command-line arguments (3 approaches)
• Understanding ‘Never’ type in Python 3.11+ (5 examples)
• Python: 3 Ways to Retrieve City/Country from IP Address
• Using Type Aliases in Python: A Practical Guide (with Examples)
• Python: Defining distinct types using NewType class
• Using Optional Type in Python (explained with examples)
• Python: How to Override Methods in Classes
• Python: Define Generic Types for Lists of Nested Dictionaries

Search tutorials, examples, and resources

• PHP programming
• Symfony & Doctrine
• Laravel & Eloquent
• Tailwind CSS
• Sequelize.js
• Mongoose.js

Adventures in Machine Learning

6 clever ways to assign dictionary values to variables in python.

Python is a popular programming language for its flexibility and ease of use. In Python, dictionaries are one of the most commonly used data structures to store and manipulate data efficiently.

A dictionary is a collection of key-value pairs that can be used to store and retrieve data in a fast and efficient manner. In this article, we will explore different ways of assigning values to variables from a dictionary in Python.

1) Assigning values to variables using bracket notation

One way to assign a value to a variable in Python is to use bracket notation to access the value of a key in a dictionary. The syntax for assigning a value to a variable from a dictionary using bracket notation is:

“`python

dictionary = {‘key1’: ‘value1’, ‘key2’: ‘value2’}

variable = dictionary[‘key1’]

This assigns the value of ‘value1’ to the variable ‘variable’.

You can also use variables as keys in a dictionary, like so:

key = ‘key1’

dictionary = {key: ‘value1’, ‘key2’: ‘value2’}

variable = dictionary[key]

This assigns the value of ‘value1’ to the variable ‘variable’, just like before. The advantage of using bracket notation is that it allows you to retrieve values from a dictionary quickly and easily.

2) Assigning values to variables using the dict.values() method

Another way to assign a value to a variable in Python is to use the dict.values() method to retrieve the values of all keys in a dictionary. The syntax for assigning a value to a variable using the dict.values() method is:

variable = list(dictionary.values())[0]

This retrieves the values of all keys in the dictionary and assigns the value of ‘value1’ to the variable ‘variable’.

The advantage of using the dict.values() method is that it allows you to retrieve all the values in a dictionary at once. 3) Assigning values to variables using the dict.get() method

The dict.get() method can be used to assign a value to a variable for non-existent keys.

The syntax for assigning a value to a variable using the dict.get() method is:

variable = dictionary.get(‘key3’, ‘default_value’)

This assigns the default value ‘default_value’ to the variable ‘variable’ since ‘key3’ does not exist in the dictionary. The advantage of using the dict.get() method is that it provides a default value in case the key is not present in the dictionary.

4) Assigning values to variables using the locals() dictionary

The locals() dictionary is a predefined dictionary in Python that stores all the local variables in a function or module. You can use the dict.update() method to update the locals() dictionary and assign key-value pairs of a dictionary to variables.

The syntax for assigning values to variables using the locals() dictionary is:

locals().update(dictionary)

variable1 = key1

variable2 = key2

This assigns the values of ‘value1’ and ‘value2’ to the variables ‘variable1’ and ‘variable2’, respectively. The advantage of using the locals() dictionary is that it allows you to update local variables dynamically.

5) Assigning values to variables using the SimpleNamespace class

The SimpleNamespace class is a predefined class in Python that can be used to create a namespace object. You can assign dictionary key-value pairs as attributes on the namespace object using keyword arguments.

The syntax for assigning values to variables using the SimpleNamespace class is:

From types import simplenamespace.

namespace = SimpleNamespace(**dictionary)

variable1 = namespace.key1

variable2 = namespace.key2

This assigns the values of ‘value1’ and ‘value2’ to the variables ‘variable1’ and ‘variable2’, respectively. The advantage of using the SimpleNamespace class is that it allows you to access dictionary key-value pairs as attributes on a namespace object.

6) Assigning values to variables using the exec() function

The exec() function is a built-in function in Python that can be used to execute dynamic code in a Python program. You can use the exec() function to assign dictionary key-value pairs to variables dynamically.

The syntax for assigning values to variables using the exec() function is:

for key in dictionary:

exec(f”{key} = ‘{dictionary[key]}'”)

This dynamically assigns the values of ‘value1’ and ‘value2’ to the variables ‘key1’ and ‘key2’, respectively. The advantage of using the exec() function is that it allows you to execute dynamic code at runtime.

Additional Resources

To learn more about dictionaries in Python, you can refer to the official Python documentation. You can also find several tutorials and resources online that cover different aspects of dictionaries and their usage in Python.

Here are some of the resources that you might find useful:

– Python Dictionaries – GeeksforGeeks (https://www.geeksforgeeks.org/python-dictionary/)

– Python Dictionary Methods – W3Schools (https://www.w3schools.com/python/python_ref_dictionary.asp)

– Python Dictionary – Real Python (https://realpython.com/python-dicts/)

– How to Iterate Through a Dictionary in Python – DataCamp (https://www.datacamp.com/community/tutorials/18-most-common-python-list-questions-learn-python)

In conclusion, assigning values to variables from a dictionary is an essential aspect of using Python effectively. There are various ways to do so, including bracket notation, dict.values() method, dict.get() method, the locals() dictionary, SimpleNamespace class, and exec() function.

Depending on the specific use case and requirements, each approach has its distinct advantages and disadvantages. It is essential for a Python programmer to understand these various methods and choose the most appropriate one for the task at hand.

Learning these techniques will improve your Python programming skills and help you work more efficiently with Python dictionaries.

Popular Posts

Best practices for creating and managing foreign keys in databases, mastering python together: real python’s community learning opportunities, creating smooth curves in matplotlib: a beginner’s guide.

• Terms & Conditions
• Privacy Policy

Learn Python practically and Get Certified .

Popular Tutorials

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

• How to Get Started With Python?
• Python Comments
• Python Variables, Constants and Literals
• Python Type Conversion
• Python Basic Input and Output
• Python Operators
• Precedence and Associativity of Operators in Python (programiz.com)

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, Type Conversion and Mathematics
• Python List
• Python Tuple
• Python Sets

Python Dictionary

• Python Functions
• Python Function Arguments
• Python Variable Scope
• Python Global Keyword
• Python Recursion
• Python Modules
• Python Package
• Python Main function (programiz.com)

Python Files

• Python Directory and Files Management
• Python CSV: Read and Write CSV files (programiz.com)
• Reading CSV files in Python (programiz.com)
• Writing CSV files in Python (programiz.com)
• Python Exception Handling
• Python Exceptions
• Python Custom Exceptions

Python Object & Class

• Python Objects and Classes
• Python Inheritance
• Python Multiple Inheritance
• Polymorphism in Python(with Examples) (programiz.com)
• 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

• Python Keywords and Identifiers
• Python Asserts
• Python Json
• Python *args and **kwargs (With Examples) (programiz.com)

Python Tutorials

Python Dictionary clear()

Python Dictionary items()

• Python Dictionary keys()

Python Dictionary fromkeys()

• Python Nested Dictionary
• Python Dictionary update()

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

Video: python dictionaries to store key/value pairs.

Sorry about that.

Related Tutorials

Python Library

Python Tutorial

Python Data Types

Guide to Dictionaries in Python

• Introduction

Python comes with a variety of built-in data structures, capable of storing different types of data. A Python dictionary is one such data structure that can store data in the form of key-value pairs - conceptually similar to a map. The values in a Python dictionary can be accessed using the keys.

In this guide, we will be discussing Python dictionaries in detail. Firstly, we'll cover the basic dictionary operations (creating a dictionary, updating it, removing and adding elements, etc.) and take a look at a couple more interesting methods afterward.

• How To Create a Dictionary in Python

To create a Python dictionary, we pass a sequence of items (entries) inside curly braces {} and separate them using a comma ( , ). Each entry consists of a key and a value, also known as a key-value pair.

Note: The values can belong to any data type and they can repeat , but the keys must remain unique . Additionally, you can't assign multiple values to the same key, though, you can assign a list of values (as a single value).

Now that we understand what dictionaries are, let's see how to use them in Python. First of all, we need to understand how to create an empty dictionary :

Great! We now have an empty directory. But what if we want to both create and fill a dictionary with some initial data? That's also a pretty easy task in Python - say we have integer keys and string values:

As we said before, it's not necessary that all keys are of the same type:

Alternatively, we can create a dictionary by explicitly calling the Python's dict() constructor :

A dictionary can also be created by passing a list of tuples to the dict() constructor:

Dictionaries can also be nested , which means that we can create a dictionary inside another dictionary:

To print the dictionary contents, we can use Python's print() method and pass the dictionary name as the argument to the method:

This results in:

Note: For concise and readable dictionary creation, consider dictionary comprehensions , especially when deriving from another data source:

• How To Access Elements of a Python Dictionary

To access dictionary items - we pass the key , using the square bracket notation:

This nets us the value associated with the "model" key:

You can store "configuration" items or common constants in a dictionary for ease of centralized access:

This would yield us with:

The dictionary object also provides the get() method , which can be used to access dictionary elements as well. We append the method with the dictionary name using the dot operator and then pass the name of the key as the argument to the method:

Now we know how to access dictionary elements! In the next section, we'll discuss how to add new elements to an already-existing dictionary.

Note: Rather than directly accessing a key, which could result in a KeyError , use the get() method to provide a default value.

• How To Add Elements to a Python Dictionary

There are numerous ways to add new elements to a dictionary. A common way is to add a new key and assign a value to it :

When a key doesn't exist, and we assign a value to it - it gets added to the dictionary:

The new element has Capacity as the key and 1800CC as its corresponding value. It has been added as the first element of the dictionary. Here is another example. First, let's first create an empty dictionary:

Let's verify that it's empty:

The dictionary returns nothing as it has nothing stored yet. Let us add some elements to it, one at a time:

Note: Starting from Python 3.7, dictionaries maintain the order of items based on their insertion. This behavior is guaranteed in Python 3.8+.

To add the elements, we specified keys as well as the corresponding values:

In the above example, 0 is the key while Apples is the value. It is even possible for us to add a set of values to one key as long as that set is referenceable as a single value, such as a collection:

And we have a key with a set as its value:

Other than adding new elements to a dictionary, dictionary elements can also be updated/changed, which we'll go over in the next section.

Advice: Read more about adding new keys to a dictionary in Python in our article "Python: How to Add Keys to a Dictionary" .

• How To Update Dictionary Elements

After adding a value to a dictionary we can then modify the existing dictionary element . You use the key of the element to change the corresponding value:

In this example, we've updated the value for the key year from the old value of 2012 to a new value of 2014 :

• How To Remove Dictionary Elements

The removal of an element from a dictionary can be done in several ways, which we'll discuss one by one in this section.

The del keyword can be used to remove the element with the specified key. We need to call the del keyword followed by the dictionary name. Inside the square brackets that follow the dictionary name, we passed the key of the element we need to delete from the dictionary, let it be the year :

This will remove the entry for the year :

Another way to delete a key-value pair is to use the pop() method and pass the key of the entry to be deleted as the argument to the method:

We invoked the pop() method by appending it with the dictionary name. Running this code will delete the entry for a year in the dictionary:

If you don't specify the key, the popitem() method removes the last item inserted into the dictionary:

The last entry into the dictionary was the year . It has been removed after calling the popitem() method:

But what if you want to delete the entire dictionary ? It would be difficult and cumbersome to use one of these methods on every single key. Instead, you can use the del keyword to delete the entire dictionary:

But, this code will return an error. The reason is that we are trying to access a dictionary that doesn't exist since it has been deleted beforehand:

Depending on the use case, you might need to remove all dictionary elements but not the dictionary itself. This can be achieved by calling the clear() method on the dictionary:

This will give you an empty dictionary (since all the dictionary elements have been removed):

• Other Common Dictionary Methods in Python

Besides methods we've covered so far, Python provides us with a lot of other interesting methods that help us perform operations other than the basic ones described before. In the following subsections, we'll take a look at some other methods you can use alongside dictionaries in Python.

Note: Remember that methods like keys() , values() , and items() return view objects , which are dynamic in nature. This means if the dictionary changes, these views will reflect the change.

• len() Method

With this method, you can count the number of elements in a dictionary:

There are three entries in the dictionary, hence the method will return 3 :

Advice: Read more about calculating the size of dictionaries in Python in our article "Python: Get Size of Dictionary" .

• copy() Method

This method returns a copy of the existing dictionary:

Check out our hands-on, practical guide to learning Git, with best-practices, industry-accepted standards, and included cheat sheet. Stop Googling Git commands and actually learn it!

Let's make sure the copy is properly made and assigned to the variable x :

After printing x in the console, you see that it contains the same elements as those stored in the example_dict dictionary.

Note: This is useful because modifications made to the copied dictionary won't affect the original one.

• items() Method

When called, this method returns an iterable object. The iterable object has key-value pairs for the dictionary, as tuples in a list. This method is primarily used when you want to iterate through a dictionary.

The method is simply called on the dictionary object name:

This will result in:

The object returned by items() can also be used to show the changes that have been implemented in the dictionary:

This code illustrates that when you change a value in the dictionary, the items object is also updated to reflect this change:

• keys() Method

This method also returns an iterable object. The object returned is a list of all keys in the dictionary. And just like with the items() method, the returned object can be used to reflect the changes made to the dictionary.

To use this method, we only call it on the name of the dictionary:

For example:

This will give us:

Often times this method is used to iterate through each key in your dictionary:

This will print each key of the example_dict in a separate line:

• fromkeys() Method

This method returns a dictionary having specified keys and values:

The value for the required keys parameter is iterable and it specifies the keys for the new dictionary. The value for the value parameter is optional and it specifies the default value for all the keys. The default value for this is None .

Suppose we need to create a dictionary of three keys all with the same value, say 25 :

Let's verify that the fromkeys() method created the dictionary we've described:

As expected, the fromkeys() method was able to pick the keys and combine them with the value 25 to create the dictionary we wanted.

The value for the keys parameter is mandatory. The following example demonstrates what happens when the value for the values parameter is not specified:

In this case, None was used as the default value:

• setdefault() Method

This method is applicable when we need to get the value of the element with the specified key. If the key is not found, it will be inserted into the dictionary alongside the specified default value.

The method takes the following syntax:

In this method, the keyname parameter is required. It represents the key name of the item you need to return a value from. The value parameter is optional. If the dictionary already has the key, this parameter won't have any effect. If the key doesn't exist, then the value given in this method will become the value of the key. It has a default value of None :

The dictionary doesn't have the key for color . The setdefault() method has inserted this key and the specified value, that is, Gray , has been used as its value:

The following example demonstrates how the method behaves if the value for the key does exist :

The value Allion has no effect on the dictionary since we already have a value for the key model :

• Dictionary Comprehensions

Dictionary comprehensions, akin to list and set comprehensions, offer a concise way to create dictionaries. Common applications include constructing dictionaries from iterables, transforming existing dictionaries, or filtering dictionary content. This section will guide you through the mechanics and potential uses of dictionary comprehension.

Advice: You can take a deeper dive into the topic of dictionary comprehensions in Python by reading our "Python Dictionary Comprehension: A Fast and Flexible Way to Build Dictionaries" article.

The basic syntax of a dictionary comprehension is pretty similar to the one used for the list comprehension:

The key_expr and value_expr are expressions defining the key-value pairs based on the current item in the iterable .

To illustrate this, let's construct a dictionary that maps numbers to their squares :

Sometimes, you'd like to filter out certain values when creating a dictionary. For that purpose, you can introduce conditions in the dictionary comprehension syntax:

Dictionary comprehension in Python is a powerful mechanism enabling us to do much more than just create simple dictionaries. For example, you can also use it to create and access nested dictionaries :

Combining the zip() function with dictionary comprehension can help you create a dictionary from two lists - one containing keys and one containing values of the newly created dictionary:

The last usage of dictionary comprehension we'll cover in this article is _modifying an existing dictionary. Let's say you want to create a new dictionary from an existing one, where each value is incremented by 1:

• Iterating Through Dictionaries

Iteration is a fundamental operation in programming, and when it comes to dictionaries, Python provides several intuitive methods to traverse through keys, values, or both. Let’s explore the different techniques and scenarios for iterating over dictionaries.

Advice: Read more about iterating through dictionaries in Python in our article "How to Iterate Over a Dictionary in Python" .

• Iterating Over Keys (Default Behavior)

When you loop through a dictionary directly using a for loop, it iterates over its keys by default:

We can achieve the same behavior (but more explicitly) by using the keys() method:

Avoid modifying the size of a dictionary while iterating over it. If you need to remove items, consider iterating over a copy of the dictionary's keys:

• Iterating Over Values Using values()

We'll use the values() method to help us loop through all the values in a dictionary:

• Iterating Over Key-Value Pairs Using items()

This method returns both the key and its corresponding value, which can be unpacked directly within the loop:

This will give us::

• Nested Dictionaries Iteration

If you have dictionaries within dictionaries, you'll need nested loops to traverse them:

We'll get a nicely formatted output:

• Conditional Iteration

You can also integrate conditions within loops for specific requirements:

Since the value of the age key is an integer, it won't be printed out:

• Dictionary and Memory

Dictionaries, while highly versatile and efficient, can also be memory-intensive due to their underlying data structures and mechanisms. This section aims to explore the memory implications of using dictionaries in Python, providing insights and best practices to ensure optimized memory usage.

Advice: In cases where you don't require the functionality of a full dictionary, consider using a list of tuples or a namedtuple .

There are several causes because dictionaries can be memory-intensive. First of all, dictionaries are essentially implemented using hash tables as their under-the-hood. This ensures O(1) average complexity for lookups but requires extra memory to store hashes, table indices, and handle collisions. Other than that, Python dictionaries are designed to resize when they reach a certain load factor. This means that memory might be allocated in advance, even if not immediately used.

If you're interested in checking the memory usage of a dictionary, you can do so by using Python’s sys module:

But what can you do about the size of your dictionaries? Let's take a look at a couple of tips that can help you do a better job of managing your dictionary's size. First of all, if a dictionary grows large and then shrinks (after deletions), it might still retain a large allocated size. In that case, use dict.copy() to create a smaller copy . Additionally, for dictionaries with the same set of keys (like objects of a class), key sharing can save memory. This technique involves using a single memory block to store the keys for multiple dictionaries.

Being conscious of memory implications doesn’t mean you should shy away from dictionaries. Instead, with an informed approach, you can make the most of what dictionaries offer without compromising on system performance.

This marks the end of this guide on Python dictionaries. These dictionaries store data in key-value pairs. The key acts as the identifier for the item while the value is the value of the item. The Python dictionary comes with a variety of methods that can be applied for the retrieval or manipulation of data. In this article, we saw how a Python dictionary can be created, modified, and deleted along with some of the most commonly used dictionary methods.

You might also like...

• Hidden Features of Python
• Python Docstrings
• Handling Unix Signals in Python
• The Best Machine Learning Libraries in Python
• Guide to Sending HTTP Requests in Python with urllib3

Improve your dev skills!

Get tutorials, guides, and dev jobs in your inbox.

No spam ever. Unsubscribe at any time. Read our Privacy Policy.

I am a programmer by profession. I am highly interested in Python, Java, Data Science and Machine learning. If you need help in any of these, don't hesitate to contact me.

In this article

Building Your First Convolutional Neural Network With Keras

Most resources start with pristine datasets, start at importing and finish at validation. There's much more to know. Why was a class predicted? Where was...

Data Visualization in Python with Matplotlib and Pandas

Data Visualization in Python with Matplotlib and Pandas is a course designed to take absolute beginners to Pandas and Matplotlib, with basic Python knowledge, and...

© 2013- 2024 Stack Abuse. All rights reserved.

Python Tutorial

File handling, python modules, python numpy, python pandas, python matplotlib, python scipy, machine learning, python mysql, python mongodb, python reference, module reference, python how to, python examples, python dictionaries.

Dictionaries are used to store data values in key:value pairs.

A dictionary is a collection which is ordered*, changeable and do not allow duplicates.

As of Python version 3.7, dictionaries are ordered . In Python 3.6 and earlier, dictionaries are unordered .

Dictionaries are written with curly brackets, and have keys and values:

Create and print a dictionary:

Dictionary Items

Dictionary items are ordered, changeable, and do not allow duplicates.

Dictionary items are presented in key:value pairs, and can be referred to by using the key name.

Print the "brand" value of the dictionary:

Ordered or Unordered?

When we say that dictionaries are ordered, it means that the items have a defined order, and that order will not change.

Unordered means that the items do not have a defined order, you cannot refer to an item by using an index.

Dictionaries are changeable, meaning that we can change, add or remove items after the dictionary has been created.

Duplicates Not Allowed

Dictionaries cannot have two items with the same key:

Duplicate values will overwrite existing values:

Advertisement

Dictionary Length

To determine how many items a dictionary has, use the len() function:

Print the number of items in the dictionary:

Dictionary Items - Data Types

The values in dictionary items can be of any data type:

String, int, boolean, and list data types:

From Python's perspective, dictionaries are defined as objects with the data type 'dict':

Print the data type of a dictionary:

The dict() Constructor

It is also possible to use the dict() constructor to make a dictionary.

Using the dict() method to make a dictionary:

Python Collections (Arrays)

There are four collection data types in the Python programming language:

• List is a collection which is ordered and changeable. Allows duplicate members.
• Tuple is a collection which is ordered and unchangeable. Allows duplicate members.
• Set is a collection which is unordered, unchangeable*, and unindexed. No duplicate members.
• Dictionary is a collection which is ordered** and changeable. No duplicate members.

*Set items are unchangeable, but you can remove and/or add items whenever you like.

**As of Python version 3.7, dictionaries are ordered . In Python 3.6 and earlier, dictionaries are unordered .

When choosing a collection type, it is useful to understand the properties of that type. Choosing the right type for a particular data set could mean retention of meaning, and, it could mean an increase in efficiency or security.

COLOR PICKER

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

[email protected]

Top Tutorials

Top references, top examples, get certified.

5 Best Ways to Convert Python Dictionaries to Variables

💡 Problem Formulation: How do we transform a dictionary in Python into separate variables for each key-value pair? Let’s say we have a dictionary {'name': 'Alice', 'age': 30, 'city': 'New York'} and we want to create individual variables such as name with value ‘Alice’, age with value 30, and city with value ‘New York’. This article explores 5 different methods to achieve such conversions efficiently.

Method 1: Explicit Unpacking

This method involves explicitly assigning each value in the dictionary to a variable. It is straightforward and simple, making it easy to understand and debug. However, it requires prior knowledge of the dictionary’s keys and is not dynamic.

Here’s an example:

As seen in the snippet, each dictionary key is individually assigned to a variable with the corresponding dictionary value. This method is clear but is only practical when you know the structure of the dictionary and are dealing with a limited number of items.

Method 2: The Unpack Operator (**)

Using the unpack operator ** , the dictionary can be unpacked with keys becoming variable names and values as respective variable values. It’s beneficial for dictionaries with unknown structures or when programmatically assigning a large number of variables.

This code snippet uses the locals().update() function to unpack the dictionary, assigning its key-value pairs directly as variables within the local scope. This method is more dynamic but should be used with caution as it may overwrite existing variables with the same names.

Method 3: Using a For Loop

A for loop can be used to iterate over the items of the dictionary, assigning each key-value pair to a variable. It is flexible and allows additional logic during the assignment process, such as type conversion or condition checks.

Each exec() is dynamically creating and executing a string of Python code that corresponds to a key-value assignment. The example above also includes a condition that adds quotes around string values. This is highly flexible but poses security risks and performance drawbacks if not used carefully.

Method 4: Using exec() and a Dictionary Comprehension

The exec() function can be combined with a dictionary comprehension to create a string of assignments and then execute them. This method is concise and can accommodate additional filtering or processing.

This example constructs a string from the dictionary that combines all the assignments separated by semicolons and executes the string using exec() . Using repr() ensures that the values are correctly formatted as Python literal expressions. Again, the usual cautions about using exec() apply here.

Bonus One-Liner Method 5: Using globals()

For a quick, one-liner solution, use the globals() function to add dictionary key-value pairs to the global scope. It is best used in simple cases when absence of local scope is not an issue.

With this method, variables are created at the global scope based on the dictionary’s contents. While incredibly succinct and useful for scripting or interactive sessions, it can lead to unexpected behavior in larger applications due to namespace pollution.

Summary/Discussion

• Method 1: Explicit Unpacking. Straightforward, ideal for dictionaries with known structure. Not suitable for dynamic variable creation.
• Method 2: Unpack Operator (**). Dynamic and efficient. Risky for overwriting existing variables and not recommended for namespace-sensitive contexts.
• Method 3: Using a For Loop. Offers flexibility with additional logic. May incur security risks and performance costs when using exec() .
• Method 4: Using exec() with Dictionary Comprehension. Concise with good filtering capacity. Security and performance concerns due to exec() .
• Method 5: Using globals(). Quick and easy for scripting. Risks global namespace contamination and is not recommended for production code.

Emily Rosemary Collins is a tech enthusiast with a strong background in computer science, always staying up-to-date with the latest trends and innovations. Apart from her love for technology, Emily enjoys exploring the great outdoors, participating in local community events, and dedicating her free time to painting and photography. Her interests and passion for personal growth make her an engaging conversationalist and a reliable source of knowledge in the ever-evolving world of technology.

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

• Free Python 3 Tutorial
• Control Flow
• Exception Handling
• Python Programs
• Python Projects
• Python Interview Questions
• Python Database
• Data Science With Python
• Machine Learning with Python
• How to Fix: ValueError: Unknown Label Type: 'Continuous' in Python
• How To Check If Variable Is Empty In Python?
• How To Fix - Python RuntimeWarning: overflow encountered in scalar
• How To Resolve Issue " Threading Ignores Keyboardinterrupt Exception" In Python?
• AttributeError: can’t set attribute in Python
• How to Fix ImportError: Cannot Import name X in Python
• AttributeError: __enter__ Exception in Python
• Modulenotfounderror: No Module Named 'httpx' in Python
• How to Fix - SyntaxError: (Unicode Error) 'Unicodeescape' Codec Can't Decode Bytes
• SyntaxError: ‘return’ outside function in Python
• How to fix "SyntaxError: invalid character" in Python
• No Module Named 'Sqlalchemy-Jsonfield' in Python
• Python Code Error: No Module Named 'Aiohttp'
• Fix Python Attributeerror: __Enter__
• Python Runtimeerror: Super() No Arguments
• Filenotfounderror: Errno 2 No Such File Or Directory in Python
• ModuleNotFoundError: No module named 'dotenv' in Python
• Nameerror: Name Plot_Cases_Simple Is Not Defined in Python
• How To Avoid Notimplementederror In Python?

How to Fix – UnboundLocalError: Local variable Referenced Before Assignment in Python

Developers often encounter the  UnboundLocalError Local Variable Referenced Before Assignment error in Python. In this article, we will see what is local variable referenced before assignment error in Python and how to fix it by using different approaches.

What is UnboundLocalError: Local variable Referenced Before Assignment?

This error occurs when a local variable is referenced before it has been assigned a value within a function or method. This error typically surfaces when utilizing try-except blocks to handle exceptions, creating a puzzle for developers trying to comprehend its origins and find a solution.

Below, are the reasons by which UnboundLocalError: Local variable Referenced Before Assignment error occurs in  Python :

Nested Function Variable Access

Global variable modification.

In this code, the outer_function defines a variable ‘x’ and a nested inner_function attempts to access it, but encounters an UnboundLocalError due to a local ‘x’ being defined later in the inner_function.

In this code, the function example_function tries to increment the global variable ‘x’, but encounters an UnboundLocalError since it’s treated as a local variable due to the assignment operation within the function.

Solution for Local variable Referenced Before Assignment in Python

Below, are the approaches to solve “Local variable Referenced Before Assignment”.

In this code, example_function successfully modifies the global variable ‘x’ by declaring it as global within the function, incrementing its value by 1, and then printing the updated value.

In this code, the outer_function defines a local variable ‘x’, and the inner_function accesses and modifies it as a nonlocal variable, allowing changes to the outer function’s scope from within the inner function.

Please Login to comment...

Similar reads.

• Python Errors
• Python How-to-fix
• Google Introduces New AI-powered Vids App
• Dolly Chaiwala: The Microsoft Windows 12 Brand Ambassador
• 10 Best Free Remote Desktop apps for Android in 2024
• 10 Best Free Internet Speed Test apps for Android in 2024
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?