How to Assign Dictionary Keys and Values to Variables in Python

This guide explains various ways to assign dictionary keys and values to individual variables in Python. We'll cover direct access, using locals().update(), SimpleNamespace, and the less-recommended exec() method, discussing the use cases and trade-offs of each.

Direct Assignment (for Known Keys)

If you know the specific keys you want to access, the simplest and most Pythonic way is direct assignment using bracket notation:

my_dict = {
    'first_name': 'Tom',
    'last_name': 'Nolan',
    'site': 'tutorialreference.com',
}

first = my_dict['first_name']
last = my_dict['last_name']
site = my_dict['site']

print(first) # Output: Tom
print(last)  # Output: Nolan
print(site)  # Output: tutorialreference.com

• This is the clearest, most readable, and most efficient way to access known dictionary keys. It's the preferred method in most cases.
• If the key is not defined, this will raise a KeyError exception.
• You can also use my_dict.get('key') to get None if the key is not found, or provide a default value: my_dict.get('key', 'default')

Iterating and Assigning (for Known Keys)

If you have a fixed set of keys that you want to assign to variables, and you want to handle potential missing keys, you can iterate:

my_dict = {
    'first_name': 'Tom',
    'last_name': 'Nolan',
    'site': 'tutorialreference.com',
}

# Use a dictionary to hold the variable names and default values
key_map = {
    'first_name': None,
    'last_name': None,
    'site': None,
    'occupation': 'Developer',  # Example of a key that might not exist
}
for key, default_value in key_map.items():
  globals()[key] = my_dict.get(key, default_value)

print(first_name) # Output: Tom
print(last_name)  # Output: Nolan
print(occupation) # Output: Developer

• We use a for loop to iterate over the dictionary.
• On each iteration, we check if the current key is present in the dictionary.
• If it's not, a default value of None is used.
• This loop uses globals() which creates a new global variable for each of the keys, and assigns to each key the associated value in my_dict, or the specified default value if not found.

locals().update() (Caution Advised)

You can dynamically create local variables from a dictionary's keys and values using locals().update(). However, this is generally discouraged for several reasons:

• Readability: It makes your code much harder to understand, as it's not immediately clear where variables are coming from.
• Maintainability: It's easy to accidentally overwrite existing local variables.
• Debugging: It makes debugging more difficult.
• Security: If my_dict contains data that is not fully controlled, it could be possible to inject any type of variable into the namespace.
• IDE warnings and errors: Most IDEs will show warning or errors when trying to access variables that were defined this way.

my_dict = {
    'first_name': 'Tom',
    'last_name': 'Nolan',
    'site': 'tutorialreference.com',
}

locals().update(my_dict) # Adds keys as local variables

# Now you can access the keys as variables:
# print(first_name)  # Output: Tom
# print(site)        # Output: tutorialreference.com

warning

Strong Recommendation: Avoid using locals().update() unless you have a very specific and well-justified reason. It's almost always better to work with the dictionary directly or use a more explicit approach. It's especially dangerous if the dictionary's contents come from user input or an external source.

SimpleNamespace (for Attribute-Style Access)

If you want to access dictionary values using dot notation (like attributes of an object), the types.SimpleNamespace class is a good, safe option:

from types import SimpleNamespace

my_dict = {
    'first_name': 'Tom',
    'last_name': 'Nolan',
    'site': 'tutorialreference.com',
}

namespace = SimpleNamespace(**my_dict) # Unpack dict into keyword arguments

print(namespace.first_name)  # Output: Tom
print(namespace.site)        # Output: tutorialreference.com

• SimpleNamespace(**my_dict): This creates a SimpleNamespace object. The **my_dict unpacks the dictionary into keyword arguments, effectively creating attributes on the object.
• You can then access the values using dot notation (e.g., namespace.first_name).
• Unlike locals().update() you are not modifying the local variable scope of your function.

exec() (Strongly Discouraged)

Using exec() to dynamically create variables from dictionary keys and values is even more dangerous than locals().update() and is almost never the right approach. It should only be used with trusted input data.

my_dict = {
'first_name': 'Tom',
'last_name': 'Nolan',
'site': 'tutorialreference.com',
}
for key, value in my_dict.items():
    exec(key + '=value')

print(first_name) # Output: Tom
print(site)       # Output: tutorialreference.com

• The for loop iterates through the key-value pairs in the dictionary, and then exec() is used to execute a string as a python expression.

warning

Extreme Danger: exec() executes arbitrary Python code from a string. If the dictionary contains user-provided data, a malicious user could inject code to compromise your system. Never, ever use exec() with untrusted input.