Python Tutorial- Dictionary Introduction

A Python dictionary is an unordered, mutable sequence whose elements are stored in the form of "key-value". In contrast, lists and tuples are ordered sequences, and their elements are stored next to each other at the bottom.

The dictionary type is the only mapping type in Python. "Mapping" is a term in mathematics. To understand it in simple form, it refers to the corresponding relationship between elements, that is, through one element, the other element can be found uniquely.

In the dictionary, it is customary to refer to the index corresponding to each element as a key, the element corresponding to each key as a value, and the key and its associated value as a "key-value pair."

In general, the main characteristics of dictionary types are shown in the following table.

Main Features Explanation
Reading elements by key instead of by index Dictionary types are sometimes called associative arrays or hashes. It is a series of values linked by key, so you can get the specified item from the dictionary by key, but not by index.
Dictionary is an unordered collection of any data type Unlike lists and tuples, the element corresponding to index 0 is usually called the first element, while the elements in the dictionary are out of order.
Dictionaries are mutable and can be arbitrarily nested The dictionary can be grown or shortened in place (no need to generate a copy), and it supports any depth of nesting, that is, the value stored in the dictionary can also be a list or other dictionary.
The keys in the dictionary must be unique The dictionary does not support multiple occurrences of the same key, otherwise only the last key-value pair will be retained.
The keys in the dictionary must be immutable The values in the dictionary are immutable. You can only use numbers, strings, or tuples. You cannot use lists.

Like lists and tuples, dictionary have their own types. In Python, the data type of a dictionary is dict, which can be viewed through the type function:

a = {'Jason': 18, 'Nicole': 27, 'Peter': 3} #a is a dictionary type

The output is:


Python - Create Dictionary

There are many ways to create a dictionary.

a) Create a dictionary using {}

Since each element in the dictionary contains two parts, namely the key and the value, when creating the dictionary, use a colon: to separate the keys and values, and use a comma to separate the adjacent elements. All Elements are enclosed in braces {}.

The syntax for creating a dictionary using {} is as follows:

dictname = {'key': 'value1', 'key2': 'value2', ..., 'keyn': valuen}


  • dictname represents the dictionary variable name, and
  • keyn: valuen represents the key-value pairs of each element.

Note that each key in the same dictionary must be unique and cannot be repeated.

The following code demonstrates creating a dictionary using curly brace syntax:

#Use string as key
age = {'Jason': 18, 'Nicole': 27, 'Peter': 3}
print (age)
#Using tuples and numbers as keys
dict_1 = {('Jason', 'Nicole'): 88, 55: [9,8,7]}
print (dict_1)
#Create empty tuple
dict_2 = ()
print (dict_2)

The output is:

{'Jason': 18, 'Nicole': 27, 'Peter': 3}
{('Jason', 'Nicole'): 88, 55: [9, 8, 7]}

You can see that the keys of the dictionary can be integers, strings, or tuples, as long as they meet the unique and immutable characteristics; the values of the dictionary can be any data type supported by Python.

b) Create a dictionary via the fromkeys () method

In Python, you can also use the fromkeys () method provided by the dictionary type to create a dictionary with default values in the following format:

dictname = dict.fromkeys (list, value = None)

Among them, the list parameter represents a list of all the keys in the dictionary (list); the value parameter represents the default value, or null if not written.

Consider the following example:

knowledge = {'Language', 'Mathematics', 'English'}
scores = dict.fromkeys (knowledge, 60)
print (scores)

The output is:

{'Language': 60, 'English': 60, 'Mathematics': 60}

As you can see, all the elements in the knowledge list are used as the keys of the scores dictionary, and the value of each key is 60. This method of creation is usually used to initialize the dictionary and set the default value of value.

c) create dictionary with dict () mapping function

There are many ways to create a dictionary through the dict function. The following table lists several commonly used methods. They all create the same dictionary a.

Create Format Precautions
a = dict(str1=value1, str2=value2, str3=value3) str represents a string type key, and value represents the value corresponding to the key. When creating a dictionary using this method, strings cannot be quoted.
#Method 1
demo = [('two', 2), ('one', 1), ('three', 3)]
#Method 2
demo = [['two', 2], ['one', 1], ['three', 3]]
#Method 3
demo = (('two', 2), ('one', 1), ('three', 3))
#Method 4
demo = (['two', 2], ['one', 1], ['three', 3])
a = dict (demo)
Pass a list or tuple to the dict function, and each of these elements is a list or tuple of 2 elements, with the first element as the key and the second element as the value.
keys = ['one', 'two', 'three'] #can also be a string or tuple
values = [1, 2, 3] # can also be a string or tuple
a = dict (zip (keys, values))
By applying the dict function and the zip function, the first two lists can be converted into corresponding dictionaries.

Note that no matter which way to create a dictionary, the keys of each element in the dictionary can only be strings, tuples or numbers, not lists. Lists are mutable and cannot be used as keys.

If no parameters are passed to the dict function, it means creating an empty dictionary, for example:

# Create empty dictionary
d = dict ()
print (d)

The output is:


Python - Access Dictionary

Lists and tuples access elements by subscripts. Unlike dictionaries, they access the corresponding values by keys. Because the elements in the dictionary are out of order and the position of each element is not fixed, the dictionary cannot access multiple elements at once in a sliced manner like lists and tuples.

The specific format for accessing dictionary elements in Python is:

dictname [key]


  • dictname represents the name of the dictionary variable
  • key represents the key name.

Note that the key must exist, otherwise an exception will be thrown.

Consider the following example:

tup = (['three', 56], ['ten', 88], ['five', 100], ['nine',-59])
dic = dict (tup)
print (dic ['five']) #Key exists
print (dic ['one']) #Key does not exist

The output is:

KeyError Traceback (most recent call last)
[ipython-input-100-de9aa00746a3] in [module]
2 dic = dict (tup)
3 print (dic ['five']) #Key exists
----> 4 print (dic ['one']) #Key does not exist
KeyError: 'one'

In addition to the above method, Python recommends using the get method provided by the dict type to get the value corresponding to the specified key. When the specified key does not exist, the get method does not throw an exception.

The syntax of the get method is:

dictname.get (key [, default])


  • dictname represents the name of a dictionary variable;
  • key represents the specified key;
  • default is used to specify the default value returned when the key to be queried does not exist, or None if not manually specified.


a = dict (three = 0.75, two = 68, one = 99, nine = -58)
print (a.get ('one'))

The output is:


Note that when the key does not exist, get returns the null value None. If you want to explicitly prompt the user that the key does not exist, you can manually set the second parameter of get, for example:

a = dict (three = 0.75, two = 68, one = 99, nine = -58)
print (a.get ('five', 'The key does not exist'))

The output is:

The key does not exist

Python - Delete Dictionary

As with deleting lists and tuples, manually deleting the dictionary can also use the del keyword, for example:

a = dict (three = 0.75, two = 68, one = 99, nine = -58)
print (a)
del a
print (a)

The output is:

{'three': 0.75, 'two': 68, 'one': 99, 'nine': -58}
NameError      Traceback (most recent call last)
[ipython-input-103-1f9a48b3b040] in [module]
2 print (a)
3 del a
----> 4 print (a)
NameError: name 'a' is not defined

Python's built-in garbage collection function will automatically destroy unused dictionaries, so generally you don't need to manually delete through del.


More Tutorials:

Python Installation - Linux (Ubuntu)
Python Installation - Mac OS
Integrated Development Environment - IDE
Python - Basic Variables
Python - Sequence Introduction
Python - Output Formatting
Python - Escape Character
Python - Type Conversion
Python - Numbers
Python – Arithmetic Operators
Python – Assignment Operators
Python – Comparison Operators
Python – Logical Operators
Python – Precedence and Associativity Operators
Python – Bytes Type and Usage
Python – Long & Raw Strings
Python – Concatenate Function
Python – Slice Function
Python – Length and Split Function
Python – Join and Count Function
Python – Find Function
Python – Index Function
Python – Alignment Function
Python – Startswith and Endswith Function
Python – String Case Conversion
Python – Remove Specified Character
Python – Encode and Decode Function
Python – dir and help Function
Python – Input Output Introduction
Python – Basic Operation
Python – Open Function
Python – Read Function
Python – Readline Function
Python – Write Function
Python – Close Function
Python – Seek and Tell Function
Python – Pickle Module
Python - File Input Module and Linecache Module
Python - Pathlib Module
Python - Pathlib Module
Python - os.path Module
Python - fnmatch Module
Python - Tuple Introduction
Python - List Introduction
Python - List Add Element
Python - List Delete Element
Python - List Modification Element
Python - List Find Element
Python - Dictionary Introduction
Python - Dictionary Basic Operation
Python - Dictionary Method Guide
Python - Set Collection
Python - Set Basic Operation
Python - Set Basic Method
Python - Frozenset Method
Python - If Condition I
Python - If Condition II
Python - While loop
Python - For loop
Python - Pass Statement
Python - Break Statement
Python - Zip Reverse Function
Python - Function Introduction
Python - Positional Parameters
Python - Key Arguments
Python - None and Return
Python - Variable Scope
Python - Local Function
Python - Closure Method
Python - Lamdba Expression

More Python Exercises:

Python String Exercises
Python List Exercises
Python Library Exercises
Python Sets Exercises
Python Array Exercises
Python Condition Statement Exercises