ZetCode

All Spring Boot Python C# Java JavaScript Subscribe

Python create dictionary

last modified July 6, 2020

Python create dictionary tutorial shows how to create dictionaries in Python. This is a
supplementary tutorial to the Python tutorial.

There are several ways how dictionaries can be formed in Python. We demonstrate them in the
following examples.

Soluciones Internet Fibra

Impulsa el rendimiento de tu empresa en Planes Trío con tu Web Ver más

digital con la velocidad de Fibra Movistar

Python dictionary
Python dictionary is an unordered collection of key-value pairs. It is mutable and can contain
mixed types. The keys in a dictionary must be immutable objects like strings or numbers. They
must also be unique within a dictionary.

Python create empty dictionary

One way to create a dictionary is to form an empty dictionary and later add new pairs.

empty.py
 #!/usr/bin/env python

capitals = {}

capitals["svk"] = "Bratislava"
capitals["deu"] = "Berlin"
capitals["dnk"] = "Copenhagen"

print(capitals)

The example creates a new empty dictionary and adds new keys and values.

$ ./empty.py
{'svk': 'Bratislava', 'dnk': 'Copenhagen', 'deu': 'Berlin'}

This is the output.

Alternatively, we can create a new empty dictionary with the dict function.

empty2.py
#!/usr/bin/env python3
 capitals = dict()

capitals.update([('svk', 'Bratislava'), ('deu', 'Berlin'), ('dnk', 'Copenhagen')])

print(capitals)

An empty dictionary is created with dict and new values are added with update

Python create dictionary with literal notation

A common way of creating dictionaries is the literal notation. The dictionary elements are specified
within the {} brackets, separated by comma. The key and values are separated by colon.

literals.py
#!/usr/bin/env python3

cities = { 'Bratislava': 432000, 'Budapest': 1759000, 'Prague': 1280000,

Warsaw': 1748000, 'Los Angeles': 3971000, 'Edinburgh': 464000,
'Berlin': 3671000 }

print(cities['Bratislava'])
print(cities)

The example creates a dictionary of cities with literal notation.

Python dictionary fromkeys

The fromkeys is a class method to create a new dictionary with keys from an iterable and values
set to a value.

fromkeys.py
 data = ['coins', 'pens', 'books', 'cups'];

items = dict.fromkeys(data, 0)

print(items)

items['coins'] = 13
items['pens'] = 4
items['books'] = 39
items['cups'] = 7

print(items)

The example creates a new dictionary from a list of values. Each element is initialized to zero.
Later, each item is assigned a new integer value.

$ ./from_keys.py
{'coins': 0, 'pens': 0, 'books': 0, 'cups': 0}
{'coins': 13, 'pens': 4, 'books': 39, 'cups': 7}

This is the output.

List of tuples to create a dictionary

A list of tuples can be passed to the dict function to create a new dictionary.

from_list_of_tuples.py
#!/usr/bin/env python3

data = [('Bratislava', 432000), ('Budapest', 1759000), ('Prague', 1280000),

('Warsaw', 1748000), ('Los Angeles', 3971000), ('Edinburgh', 464000),
('Berlin', 3671000)]

cities = dict(data)

print(cities['Bratislava'])
print(cities['Los Angeles'])
print(cities)

The example creates a list with nested tuples. The list is passed to the dict.

Passing params to dict

Another way to create a dictionary is to pass parameters to the dict function.

pass_params.py
#!/usr/bin/env python3

cities = dict(Bratislava = 432000, Budapest = 1759000, Prague = 1280000,

Warsaw = 1748000, Los_Angeles = 3971000, Edinburgh = 464000, Berlin = 3671000)

print(cities['Bratislava'])
print(cities)

This approach has a limitation; Los Angeles must be joined with an underscore.

Using zip with dict

The zip function takes iterables (zero or more), aggregates them and returns an iterator of tuples
based on the iterable objects.

from_two_lists.py
#!/usr/bin/env python3

keys = ['coins', 'pens', 'books', 'cups'];

vals = [13, 4, 39, 7];

items = dict(zip(keys, vals))

print(items)

The example joins two lists with zip and passes the iterable to the dict.

Python dictionary comprehension

New dictionaries can be derived from existing dictionaries using dictionary comprehension. A
dictionary comprehension is a syntactic construct which creates a dictionary based on existing
dictionary.

comprehension.py
#!/usr/bin/env python3

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,

"Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
"Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
"Yokyo": 13189000, "Madrid": 3233527 }

capitals2 = { key:val for key, val in capitals.items() if val < 1000000 }

print(capitals2)
In the example, we create a new dictionary from an existing dictionary.

capitals = { "Bratislava": 424207, "Vilnius": 556723, "Lisbon": 564657,

"Riga": 713016, "Jerusalem": 780200, "Warsaw": 1711324,
"Budapest": 1729040, "Prague": 1241664, "Helsinki": 596661,
"Yokyo": 13189000, "Madrid": 3233527 }

We have a dictionary of capitals. The capital in a key and the population is the value.

capitals = { key:val for key, val in capitals.items() if val < 1000000 }

A new dictionary is created using a dictionary comprehension. It contains capitals that have a
population smaller than one million.

$ ./comprehension.py
{'Bratislava': 424207, 'Vilnius': 556723, 'Jerusalem': 780200, 'Riga': 713016,
'Lisbon': 564657, 'Helsinki': 596661}

These capitals have a population smaller than one million.

In this tutorial, we have practiced creating dictionaries in Python.

List all Python tutorials.

Home Facebook Twitter Github Subscribe Privacy

© 2007 - 2021 Jan Bodnar admin(at)zetcode.com