How to destructure Dictionaries and Lists in Python

# Table of Contents

1. How to destructure Dictionaries in Python
2. How to destructure Lists in Python

Note: if you need to destructure lists in Python, click on the second subheading.

# How to destructure Dictionaries in Python

To destructure dictionaries in Python:

1. Call the dict.values() method to get a view of the dictionary's values.
2. Assign the results to variables.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

first, last, site = a_dict.values()
print(first)  # 👉️ bobby
print(last)  # 👉️ hadz
print(site)  # 👉️ com

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

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

# 👇️ dict_values(['bobby', 'hadz', 'bobbyhadz.com'])
print(a_dict.values())

first, last, site = a_dict.values()
print(first)  # 👉️ bobby
print(last)  # 👉️ hadz
print(site)  # 👉️ com

If you directly destructure without using dict.values(), you would assign the keys of the dictionary to variables.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

a, b, c = a_dict

print(a)  # 👉️ first
print(b)  # 👉️ last
print(c)  # 👉️ site

Make sure the variables on the left are exactly as many as the values in the dictionary, otherwise, an error is raised.

# Destructuring dictionaries with operator.itemgetter

You can also use the operator.itemgetter() class to destructure dictionaries.

Copied!
from operator import itemgetter

a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

first, last, site = itemgetter('first', 'last', 'site')(a_dict)
print(first)  # 👉️ bobby
print(last)  # 👉️ hadz
print(site)  # 👉️ com

The operator.itemgetter() class returns a callable object that fetches the items at the specified keys.

For example, x = itemgetter('key') and then calling x(my_dict), returns my_dict['key'].

When multiple keys are specified, the itemgetter() class returns a tuple containing the values of the keys.

You can also only do this for certain dictionary keys.

Copied!
from operator import itemgetter

a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

first, last = itemgetter('first', 'last')(a_dict)
print(first)  # 👉️ bobby
print(last)  # 👉️ hadz

Make sure the variables on the left-hand side of the assignment are exactly as many as the keys you've passed to the itemgetter() class.

# Destructuring dictionaries with a reusable function

If you have to destructure dictionaries often, you can also create a reusable function.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}


def pluck(dictionary, *keys):
    return (dictionary[key] for key in keys)


first, last = pluck(a_dict, 'first', 'last')

print(first)  # 👉️ bobby
print(last)  # 👉️ hadz

The pluck() function takes a dictionary and one or more keys and returns a tuple containing the corresponding values.

You can then destructure the keys from the tuple.

Here is an equivalent example without using a function.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

first, last = (a_dict[key] for key in ('first', 'last'))

print(first)  # 👉️ bobby
print(last)  # 👉️ hadz

The generator expression iterates over the tuple of keys and on each iteration, we return the corresponding value.

# Destructuring dictionaries directly in Python

You can also directly destructure dictionaries in Python.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}


first, last = a_dict['first'], a_dict['last']

print(first)  # 👉️ bobby
print(last)  # 👉️ hadz

The syntax is quite verbose, but the benefit of doing this is that you can also use the dict.get() method.

If a key doesn't exist and you use the square brackets syntax, you'd get a KeyError exception.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}


# ⛔️ KeyError: 'second'
first, second = a_dict['first'], a_dict['second']

However, if you use the dict.get() method, None is returned for non-existent keys by default.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}


first, second = a_dict.get('first'), a_dict.get('second')

print(first)  # 👉️ bobby
print(second)  # 👉️ None

You can also pass a second argument to the dict.get() method if you want to supply a different default value when the key doesn't exist.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}


first, second = a_dict.get('first', 'def val'), a_dict.get('second', 'def val')


print(first)  # 👉️ bobby
print(second)  # 👉️ def val

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:

# Destructuring dictionaries in for loops

You can also destructure dictionaries in for loops.

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

for key, value in a_dict.items():
    # first bobby
    # last hadz
    # site bobbyhadz.com
    print(key, value)

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

Copied!
a_dict = {
    'first': 'bobby',
    'last': 'hadz',
    'site': 'bobbyhadz.com'
}

# dict_items([('first', 'bobby'), ('last', 'hadz'), ('site', 'bobbyhadz.com')])
print(a_dict.items())

On each iteration, we assign the key to the key variable and the value to the value variable.

# How to destructure Lists in Python

One way to destructure a list is to declare exactly as many variables on the left as there are items in the list.

Copied!
a_list = ['bobby', 'hadz', 'com']

a, b, c = a_list

print(a)  # 👉️ bobby
print(b)  # 👉️ hadz
print(c)  # 👉️ com

If your list contains sublists, then you have to reflect that in the assignment on the left-hand side.

Copied!
a_list = ['bobby', ['hadz', '.', 'com']]

a, [b, c, d] = a_list

print(a)  # 👉️ bobby
print(b)  # 👉️ hadz
print(c)  # 👉️ .
print(d)  # 👉️ com

However, when using this approach, you have to declare exactly as many variables as the items in the list.

This is very often not what you want.

# Using underscores to discard items

You can use an underscore _ character to discard an item that is not needed.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

a, b, _, c = a_list


print(a)  # 👉️ bobby
print(b)  # 👉️ hadz
print(c)  # 👉️ com

The c variable stores the string com because we used an underscore _ to discard the period ..

You can use as many underscores as necessary in the assignment, as long as the variables that are declared on the left are exactly as many as the items in the list.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

a, _, _, b = a_list


print(a)  # 👉️ bobby
print(b)  # 👉️ com

# Using an asterisk * to gather items

You can also use an asterisk when you need to gather multiple items into a single variable.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

a, *b, c = a_list

print(a)  # 👉️ bobby
print(b)  # 👉️ ['hadz', '.']
print(c)  # 👉️ com

The b variable is a list that contains all of the list items in the middle (all list items except the first and the last).

The asterisk * character can also be used to gather the remaining list items after you've selected the ones you want to destructure.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

a, b, *c = a_list


print(a)  # 👉️ bobby
print(b)  # 👉️ hadz
print(c)  # 👉️ ['.', 'com']

In cases where you don't need the remaining items, use an underscore for the name of the variable.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

a, b, *_ = a_list


print(a)  # 👉️ bobby
print(b)  # 👉️ hadz

The a and b variables store the first two list items and the rest are stored in the _ variable.

The asterisk syntax is quite flexible and can be used to gather the first N, the middle N or the last N list items.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

*first_n, last = a_list

print(first_n)  # 👉️ ['bobby', 'hadz', '.']

print(last)  # 👉️ com

The first_n variable stores all list items but the last.

# Destructuring lists in for loops

You can also destructure lists in for loops.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

for item, index in enumerate(a_list):
    # 0 bobby
    # 1 hadz
    # 2 .
    # 3 com
    print(item, index)

The enumerate() function takes an iterable and returns an enumerate object containing tuples where the first element is the index and the second is the item.

Copied!
a_list = ['bobby', 'hadz', '.', 'com']

# [(0, 'bobby'), (1, 'hadz'), (2, '.'), (3, 'com')]
print(list(enumerate(a_list)))

On each iteration, we assign the current list item to the item variable and the index to the index variable.

# Additional Resources

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

• 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