python multiple assignment from dict

Table of Contents
Course Home
Assignments
Peer Instruction (Instructor)
Peer Instruction (Student)
Change Course
Instructor's Page
Progress Page
Edit Profile
Change Password
Scratch ActiveCode
Scratch Activecode
Instructors Guide
About Runestone
Report A Problem
Mixed-Up Code Questions
Write Code Questions
Peer Instruction: Tuples Multiple Choice Questions
11.1 Tuples are Immutable
11.2 Comparing Tuples
11.3 Tuple Assignment
11.4 Dictionaries and Tuples
11.5 Multiple Assignment with Dictionaries
11.6 The Most Common Words
11.7 Using Tuples as Keys in Dictionaries
11.8 Sequences: Strings, Lists, and Tuples - Oh My!
11.9 Debugging
11.10 Glossary
11.11 Multiple Choice Questions
11.12 Tuples Mixed-Up Code Questions
11.13 Write Code Questions
11.4. Dictionaries and Tuples" data-toggle="tooltip">
11.6. The Most Common Words' data-toggle="tooltip" >

11.5. Multiple Assignment with Dictionaries ¶

By combining items , tuple assignment, and for , you can make a nice code pattern for traversing the keys and values of a dictionary in a single loop:

This loop has two iteration variables because items returns a list of tuples and key, val is a tuple assignment that successively iterates through each of the key-value pairs in the dictionary.

For each iteration through the loop, both key and value are advanced to the next key-value pair in the dictionary (still in hash order).

The output of this loop is:

Again, it is in hash key order (i.e., no particular order).

11-9-1: How will the contents of list “lst” be ordered after the following code is run?

[(4, 'd'), (10, 'a'), (15, 'b'), (17, 'c')]
Incorrect! Remember, key-value pairs aren't in any particular order. Try again.
[('a', 10), ('b', 15), ('c', 17), ('d', 4)]
There will be no particular order
Correct! When running this type of iteration, we are left with a hash key order, meaning there is no particular order.

If we combine these two techniques, we can print out the contents of a dictionary sorted by the value stored in each key-value pair.

To do this, we first make a list of tuples where each tuple is (value, key) . The items method would give us a list of (key, value) tuples, but this time we want to sort by value, not key. Once we have constructed the list with the value-key tuples, it is a simple matter to sort the list in reverse order and print out the new, sorted list.

By carefully constructing the list of tuples so that the value is the first element of each tuple and the key is the second element, we can sort our dictionary contents by value.

Construct a block of code to iterate through the items in dictionary d and print out its key-value pairs.

Write code to create a list called ‘lst’ and add the key-value pairs of dictionary d to list lst as tuples. Sort list lst by the values in descending order.

Python Course
Python Basics
Interview Questions
Python Quiz
Popular Packages
Python Projects
Practice Python
AI With Python
Learn Python3
Python Automation
Python Web Dev
DSA with Python
Python OOPs
Dictionaries

Dictionaries in Python

A Python dictionary is a data structure that stores the value in key: value pairs.

Example: Here, The data is stored in key: value pairs in dictionaries, which makes it easier to find values .

Python dictionaries are essential for efficient data mapping and manipulation in programming. To deepen your understanding of dictionaries and explore advanced techniques in data handling, consider enrolling in our Complete Machine Learning & Data Science Program. This course covers everything from basic dictionary operations to advanced data processing methods, empowering you to become proficient in Python programming and data analysis.

Python Dictionary Syntax

dict_var = {key1 : value1, key2 : value2, …..}

What is a Dictionary in Python?

Dictionaries in Python is a data structure, used to store values in key: value format. This makes it different from lists, tuples, and arrays as in a dictionary each key has an associated value.

Note: As of Python version 3.7, dictionaries are ordered and can not contain duplicate keys.

How to Create a Dictionary

In Python , a dictionary can be created by placing a sequence of elements within curly {} braces, separated by a ‘comma’. The dictionary holds pairs of values, one being the Key and the other corresponding pair element being its Key:value . Values in a dictionary can be of any data type and can be duplicated, whereas keys can’t be repeated and must be immutable .

Note – Dictionary keys are case sensitive, the same name but different cases of Key will be treated distinctly.

The code demonstrates creating dictionaries with different types of keys. The first dictionary uses integer keys, and the second dictionary uses a mix of string and integer keys with corresponding values. This showcases the flexibility of Python dictionaries in handling various data types as keys.

Dictionary Example

A dictionary can also be created by the built-in function dict(). An empty dictionary can be created by just placing curly braces{}.

Different Ways to Create a Python Dictionary

The code demonstrates different ways to create dictionaries in Python. It first creates an empty dictionary, and then shows how to create dictionaries using the dict() constructor with key-value pairs specified within curly braces and as a list of tuples.

Complexities for Creating a Dictionary:

Time complexity: O(len(dict))
Space complexity: O(n)

Nested Dictionaries

Example : The code defines a nested dictionary named ‘Dict’ with multiple levels of key-value pairs. It includes a top-level dictionary with keys 1, 2, and 3. The value associated with key 3 is another dictionary with keys ‘A,’ ‘B,’ and ‘C.’ This showcases how Python dictionaries can be nested to create hierarchical data structures.

Adding Elements to a Dictionary

The addition of elements can be done in multiple ways. One value at a time can be added to a Dictionary by defining value along with the key e.g. Dict[Key] = ‘Value’.

Updating an existing value in a Dictionary can be done by using the built-in update() method. Nested key values can also be added to an existing Dictionary.

Note- While adding a value, if the key-value already exists, the value gets updated otherwise a new Key with the value is added to the Dictionary.

Example: Add Items to a Python Dictionary with Different DataTypes

The code starts with an empty dictionary and then adds key-value pairs to it. It demonstrates adding elements with various data types, updating a key’s value, and even nesting dictionaries within the main dictionary. The code shows how to manipulate dictionaries in Python.

Complexities for Adding Elements in a Dictionary:

Time complexity: O(1)/O(n)
Space complexity: O(1)

Accessing Elements of a Dictionary

To access the items of a dictionary refer to its key name. Key can be used inside square brackets.

Access a Value in Python Dictionary

The code demonstrates how to access elements in a dictionary using keys. It accesses and prints the values associated with the keys ‘name’ and 1, showcasing that keys can be of different data types (string and integer).

There is also a method called get() that will also help in accessing the element from a dictionary. This method accepts key as argument and returns the value.

Complexities for Accessing elements in a Dictionary:

Time complexity: O(1)

Example: Access a Value in Dictionary using get() in Python

The code demonstrates accessing a dictionary element using the get() method. It retrieves and prints the value associated with the key 3 in the dictionary ‘Dict’ . This method provides a safe way to access dictionary values, avoiding KeyError if the key doesn’t exist.

Accessing an Element of a Nested Dictionary

To access the value of any key in the nested dictionary, use indexing [] syntax.

Example : The code works with nested dictionaries. It first accesses and prints the entire nested dictionary associated with the key ‘Dict1’ . Then, it accesses and prints a specific value by navigating through the nested dictionaries. Finally, it retrieves and prints the value associated with the key ‘Name’ within the nested dictionary under ‘Dict2’ .

Deleting Elements using ‘del’ Keyword

The items of the dictionary can be deleted by using the del keyword as given below.

Example : The code defines a dictionary, prints its original content, and then uses the ‘del’ statement to delete the element associated with key 1. After deletion, it prints the updated dictionary, showing that the specified element has been removed.

Dictionary Methods

Here is a list of in-built dictionary functions with their description. You can use these functions to operate on a dictionary.


	This function is used to create a new dictionary or convert other iterable objects into a dictionary.
	Remove all the elements from the dictionary
	Returns a copy of the dictionary
(key, default = “None”)	Returns the value of specified key
	Returns a list containing a tuple for each key value pair
	Returns a list containing dictionary’s keys
dict2)	Updates dictionary with specified key-value pairs
	Returns a list of all the values of dictionary
	Remove the element with specified key
	Removes the last inserted key-value pair
key,default= “None”)	set the key to the default value if the key is not specified in the dictionary
key)	returns true if the dictionary contains the specified key.

For Detailed Explanations: Python Dictionary Methods

Multiple Dictionary Operations in Python

The code begins with a dictionary ‘dict1’ and creates a copy ‘dict2’ . It then demonstrates several dictionary operations: clearing ‘dict1’ , accessing values, retrieving key-value pairs and keys, removing specific key-value pairs, updating a value, and retrieving values. These operations showcase how to work with dictionaries in Python.

We have covered all about dictionaries in Python, discussed its definition, and uses, and saw different dictionary methods with examples. The dictionary is an important data structure for storing data in Python. It is very different from tuples and lists.

Read More Data Structures in Python

How to create a Dictionary in Python
Difference between List and Dictionary in Python
Python | Merging two Dictionaries

Dictionaries in Python – FAQs

How to use dictionaries in python.

Dictionaries in Python are used to store key-value pairs. They are unordered, mutable, and can contain any Python objects as values. # Creating a dictionary my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’} # Accessing values by keys print(my_dict[‘key1’]) # Output: value1 # Modifying values my_dict[‘key2’] = ‘new_value’ # Adding new key-value pairs my_dict[‘key3’] = ‘value3’ # Removing a key-value pair del my_dict[‘key1’]

How to print dictionaries in Python?

You can use print() to display the contents of a dictionary. You can print the entire dictionary or specific elements by accessing keys or values. my_dict = {‘name’: ‘Alice’, ‘age’: 30} # Printing the entire dictionary print(my_dict) # Printing specific elements print(my_dict[‘name’]) # Output: Alice

How to declare a dictionary in Python?

You can declare a dictionary by enclosing key-value pairs within curly braces {}. # Empty dictionary empty_dict = {} # Dictionary with initial values my_dict = {‘key1’: ‘value1’, ‘key2’: ‘value2’}

What are dictionary keys and values in Python?

In a dictionary, keys are unique identifiers that are used to access values. Values are the data associated with those keys. my_dict = {‘name’: ‘Alice’, ‘age’: 30} # Accessing keys and values print(my_dict.keys()) # Output: dict_keys([‘name’, ‘age’]) print(my_dict.values()) # Output: dict_values([‘Alice’, 30])

What is the use of all() , any() , cmp() , and sorted() in dictionary?

all() checks if all values in the dictionary evaluate to True . any() checks if any value in the dictionary evaluates to True . cmp() (no longer available in Python 3) used to compare two dictionaries. sorted() returns a new sorted list of keys in the dictionary. my_dict = {‘A’: 10, ‘B’: 20, ‘C’: 0} print(all(my_dict.values())) # False (0 evaluates to False) print(any(my_dict.values())) # True (at least one value is True) print(sorted(my_dict)) # [‘A’, ‘B’, ‘C’] (sorted keys)

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Multiple Assignment Syntax in Python

python-tricks

The multiple assignment syntax, often referred to as tuple unpacking or extended unpacking, is a powerful feature in Python. There are several ways to assign multiple values to variables at once.

Let's start with a first example that uses extended unpacking . This syntax is used to assign values from an iterable (in this case, a string) to multiple variables:

a : This variable will be assigned the first element of the iterable, which is 'D' in the case of the string 'Devlabs'.

*b : The asterisk (*) before b is used to collect the remaining elements of the iterable (the middle characters in the string 'Devlabs') into a list: ['e', 'v', 'l', 'a', 'b']

c : This variable will be assigned the last element of the iterable: 's'.

The multiple assignment syntax can also be used for numerous other tasks:

Swapping Values

This swaps the values of variables a and b without needing a temporary variable.

Splitting a List

first will be 1, and rest will be a list containing [2, 3, 4, 5] .

Assigning Multiple Values from a Function

This assigns the values returned by get_values() to x, y, and z.

Ignoring Values

Here, you're ignoring the first value with an underscore _ and assigning "Hello" to the important_value . In Python, the underscore is commonly used as a convention to indicate that a variable is being intentionally ignored or is a placeholder for a value that you don't intend to use.

Unpacking Nested Structures

This unpacks a nested structure (Tuple in this example) into separate variables. We can use similar syntax also for Dictionaries:

In this case, we first extract the 'person' dictionary from data, and then we use multiple assignment to further extract values from the nested dictionaries, making the code more concise.

Extended Unpacking with Slicing

first will be 1, middle will be a list containing [2, 3, 4], and last will be 5.

Split a String into a List

*split, is used for iterable unpacking. The asterisk (*) collects the remaining elements into a list variable named split . In this case, it collects all the characters from the string.

The comma , after *split is used to indicate that it's a single-element tuple assignment. It's a syntax requirement to ensure that split becomes a list containing the characters.

Dictionaries in Python

Table of Contents

Defining a Dictionary

Accessing dictionary values, dictionary keys vs. list indices, building a dictionary incrementally, restrictions on dictionary keys, restrictions on dictionary values, operators and built-in functions, d.get(<key>[, <default>]), d.pop(<key>[, <default>]), d.popitem(), d.update(<obj>).

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Dictionaries in Python

Python provides another composite data type called a dictionary , which is similar to a list in that it is a collection of objects.

Here’s what you’ll learn in this tutorial: You’ll cover the basic characteristics of Python dictionaries and learn how to access and manage dictionary data. Once you have finished this tutorial, you should have a good sense of when a dictionary is the appropriate data type to use, and how to do so.

Dictionaries and lists share the following characteristics:

Both are mutable.
Both are dynamic. They can grow and shrink as needed.
Both can be nested. A list can contain another list. A dictionary can contain another dictionary. A dictionary can also contain a list, and vice versa.

Dictionaries differ from lists primarily in how elements are accessed:

List elements are accessed by their position in the list, via indexing.
Dictionary elements are accessed via keys.

Take the Quiz: Test your knowledge with our interactive “Python Dictionaries” quiz. You’ll receive a score upon completion to help you track your learning progress:

Interactive Quiz

Test your understanding of Python dictionaries

Dictionaries are Python’s implementation of a data structure that is more generally known as an associative array. A dictionary consists of a collection of key-value pairs. Each key-value pair maps the key to its associated value.

You can define a dictionary by enclosing a comma-separated list of key-value pairs in curly braces ( {} ). A colon ( : ) separates each key from its associated value:

The following defines a dictionary that maps a location to the name of its corresponding Major League Baseball team:

You can also construct a dictionary with the built-in dict() function. The argument to dict() should be a sequence of key-value pairs. A list of tuples works well for this:

MLB_team can then also be defined this way:

If the key values are simple strings, they can be specified as keyword arguments. So here is yet another way to define MLB_team :

Once you’ve defined a dictionary, you can display its contents, the same as you can do for a list. All three of the definitions shown above appear as follows when displayed:

The entries in the dictionary display in the order they were defined. But that is irrelevant when it comes to retrieving them. Dictionary elements are not accessed by numerical index:

Perhaps you’d still like to sort your dictionary. If that’s the case, then check out Sorting a Python Dictionary: Values, Keys, and More .

Of course, dictionary elements must be accessible somehow. If you don’t get them by index, then how do you get them?

A value is retrieved from a dictionary by specifying its corresponding key in square brackets ( [] ):

If you refer to a key that is not in the dictionary, Python raises an exception:

Adding an entry to an existing dictionary is simply a matter of assigning a new key and value:

If you want to update an entry, you can just assign a new value to an existing key:

To delete an entry, use the del statement , specifying the key to delete:

Begone, Seahawks! Thou art an NFL team.

You may have noticed that the interpreter raises the same exception, KeyError , when a dictionary is accessed with either an undefined key or by a numeric index:

In fact, it’s the same error. In the latter case, [1] looks like a numerical index, but it isn’t.

You will see later in this tutorial that an object of any immutable type can be used as a dictionary key. Accordingly, there is no reason you can’t use integers:

In the expressions MLB_team[1] , d[0] , and d[2] , the numbers in square brackets appear as though they might be indices. But they have nothing to do with the order of the items in the dictionary. Python is interpreting them as dictionary keys. If you define this same dictionary in reverse order, you still get the same values using the same keys:

The syntax may look similar, but you can’t treat a dictionary like a list:

Note: Although access to items in a dictionary does not depend on order, Python does guarantee that the order of items in a dictionary is preserved. When displayed, items will appear in the order they were defined, and iteration through the keys will occur in that order as well. Items added to a dictionary are added at the end. If items are deleted, the order of the remaining items is retained.

You can only count on this preservation of order very recently. It was added as a part of the Python language specification in version 3.7 . However, it was true as of version 3.6 as well—by happenstance as a result of the implementation but not guaranteed by the language specification.

Defining a dictionary using curly braces and a list of key-value pairs, as shown above, is fine if you know all the keys and values in advance. But what if you want to build a dictionary on the fly?

You can start by creating an empty dictionary, which is specified by empty curly braces. Then you can add new keys and values one at a time:

Once the dictionary is created in this way, its values are accessed the same way as any other dictionary:

Retrieving the values in the sublist or subdictionary requires an additional index or key:

This example exhibits another feature of dictionaries: the values contained in the dictionary don’t need to be the same type. In person , some of the values are strings, one is an integer, one is a list, and one is another dictionary.

Just as the values in a dictionary don’t need to be of the same type, the keys don’t either:

Here, one of the keys is an integer, one is a float, and one is a Boolean . It’s not obvious how this would be useful, but you never know.

Notice how versatile Python dictionaries are. In MLB_team , the same piece of information (the baseball team name) is kept for each of several different geographical locations. person , on the other hand, stores varying types of data for a single person.

You can use dictionaries for a wide range of purposes because there are so few limitations on the keys and values that are allowed. But there are some. Read on!

Almost any type of value can be used as a dictionary key in Python. You just saw this example, where integer, float, and Boolean objects are used as keys:

You can even use built-in objects like types and functions:

However, there are a couple restrictions that dictionary keys must abide by.

First, a given key can appear in a dictionary only once. Duplicate keys are not allowed. A dictionary maps each key to a corresponding value, so it doesn’t make sense to map a particular key more than once.

You saw above that when you assign a value to an already existing dictionary key, it does not add the key a second time, but replaces the existing value:

Similarly, if you specify a key a second time during the initial creation of a dictionary, the second occurrence will override the first:

Begone, Timberwolves! Thou art an NBA team. Sort of.

Secondly, a dictionary key must be of a type that is immutable. You have already seen examples where several of the immutable types you are familiar with—integer, float, string, and Boolean—have served as dictionary keys.

A tuple can also be a dictionary key, because tuples are immutable:

(Recall from the discussion on tuples that one rationale for using a tuple instead of a list is that there are circumstances where an immutable type is required. This is one of them.)

However, neither a list nor another dictionary can serve as a dictionary key, because lists and dictionaries are mutable :

Technical Note: Why does the error message say “unhashable”?

Technically, it is not quite correct to say an object must be immutable to be used as a dictionary key. More precisely, an object must be hashable , which means it can be passed to a hash function. A hash function takes data of arbitrary size and maps it to a relatively simpler fixed-size value called a hash value (or simply hash), which is used for table lookup and comparison.

Python’s built-in hash() function returns the hash value for an object which is hashable, and raises an exception for an object which isn’t:

All of the built-in immutable types you have learned about so far are hashable, and the mutable container types (lists and dictionaries) are not. So for present purposes, you can think of hashable and immutable as more or less synonymous.

In future tutorials, you will encounter mutable objects which are also hashable.

By contrast, there are no restrictions on dictionary values. Literally none at all. A dictionary value can be any type of object Python supports, including mutable types like lists and dictionaries, and user-defined objects, which you will learn about in upcoming tutorials.

There is also no restriction against a particular value appearing in a dictionary multiple times:

You have already become familiar with many of the operators and built-in functions that can be used with strings , lists , and tuples . Some of these work with dictionaries as well.

For example, the in and not in operators return True or False according to whether the specified operand occurs as a key in the dictionary:

You can use the in operator together with short-circuit evaluation to avoid raising an error when trying to access a key that is not in the dictionary:

In the second case, due to short-circuit evaluation, the expression MLB_team['Toronto'] is not evaluated, so the KeyError exception does not occur.

The len() function returns the number of key-value pairs in a dictionary:

Built-in Dictionary Methods

As with strings and lists, there are several built-in methods that can be invoked on dictionaries. In fact, in some cases, the list and dictionary methods share the same name. (In the discussion on object-oriented programming, you will see that it is perfectly acceptable for different types to have methods with the same name.)

The following is an overview of methods that apply to dictionaries:

Clears a dictionary.

d.clear() empties dictionary d of all key-value pairs:

Returns the value for a key if it exists in the dictionary.

The Python dictionary .get() method provides a convenient way of getting the value of a key from a dictionary without checking ahead of time whether the key exists, and without raising an error.

d.get(<key>) searches dictionary d for <key> and returns the associated value if it is found. If <key> is not found, it returns None :

If <key> is not found and the optional <default> argument is specified, that value is returned instead of None :

Returns a list of key-value pairs in a dictionary.

d.items() returns a list of tuples containing the key-value pairs in d . The first item in each tuple is the key, and the second item is the key’s value:

Returns a list of keys in a dictionary.

d.keys() returns a list of all keys in d :

Returns a list of values in a dictionary.

d.values() returns a list of all values in d :

Any duplicate values in d will be returned as many times as they occur:

Technical Note: The .items() , .keys() , and .values() methods actually return something called a view object . A dictionary view object is more or less like a window on the keys and values. For practical purposes, you can think of these methods as returning lists of the dictionary’s keys and values.

Removes a key from a dictionary, if it is present, and returns its value.

If <key> is present in d , d.pop(<key>) removes <key> and returns its associated value:

d.pop(<key>) raises a KeyError exception if <key> is not in d :

If <key> is not in d , and the optional <default> argument is specified, then that value is returned, and no exception is raised:

Removes a key-value pair from a dictionary.

d.popitem() removes the last key-value pair added from d and returns it as a tuple:

If d is empty, d.popitem() raises a KeyError exception:

Note: In Python versions less than 3.6, popitem() would return an arbitrary (random) key-value pair since Python dictionaries were unordered before version 3.6.

Merges a dictionary with another dictionary or with an iterable of key-value pairs.

If <obj> is a dictionary, d.update(<obj>) merges the entries from <obj> into d . For each key in <obj> :

If the key is not present in d , the key-value pair from <obj> is added to d .
If the key is already present in d , the corresponding value in d for that key is updated to the value from <obj> .

Here is an example showing two dictionaries merged together:

In this example, key 'b' already exists in d1 , so its value is updated to 200 , the value for that key from d2 . However, there is no key 'd' in d1 , so that key-value pair is added from d2 .

<obj> may also be a sequence of key-value pairs, similar to when the dict() function is used to define a dictionary. For example, <obj> can be specified as a list of tuples:

Or the values to merge can be specified as a list of keyword arguments:

In this tutorial, you covered the basic properties of the Python dictionary and learned how to access and manipulate dictionary data.

Lists and dictionaries are two of the most frequently used Python types. As you have seen, they have several similarities, but differ in how their elements are accessed. Lists elements are accessed by numerical index based on order, and dictionary elements are accessed by key

Because of this difference, lists and dictionaries tend to be appropriate for different circumstances. You should now have a good feel for which, if either, would be best for a given situation.

Next you will learn about Python sets . The set is another composite data type, but it is quite different from either a list or dictionary.

🐍 Python Tricks 💌

Get a short & sweet Python Trick delivered to your inbox every couple of days. No spam ever. Unsubscribe any time. Curated by the Real Python team.

About John Sturtz

John is an avid Pythonista and a member of the Real Python tutorial team.

Each tutorial at Real Python is created by a team of developers so that it meets our high quality standards. The team members who worked on this tutorial are:

Master Real-World Python Skills With Unlimited Access to Real Python

Join us and get access to thousands of tutorials, hands-on video courses, and a community of expert Pythonistas:

What Do You Think?

What’s your #1 takeaway or favorite thing you learned? How are you going to put your newfound skills to use? Leave a comment below and let us know.

Commenting Tips: The most useful comments are those written with the goal of learning from or helping out other students. Get tips for asking good questions and get answers to common questions in our support portal . Looking for a real-time conversation? Visit the Real Python Community Chat or join the next “Office Hours” Live Q&A Session . Happy Pythoning!

Keep Learning

Keep reading Real Python by creating a free account or signing in:

Already have an account? Sign-In

Learn Python practically and Get Certified .

Python Fundamentals

Python Variables and Literals
Python Type Conversion
Python Basic Input and Output
Python Operators

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 and Mathematics
Python List
Python Tuple
Python String

Python Dictionary

Python Functions
Python Function Arguments
Python Variable Scope
Python Global Keyword
Python Recursion
Python Modules
Python Package
Python Main function

Python Files

Python Directory and Files Management
Python CSV: Read and Write CSV files
Reading CSV files in Python
Writing CSV files in Python
Python Exception Handling
Python Exceptions
Python Custom Exceptions

Python Object & Class

Python Objects and Classes
Python Inheritance
Python Multiple Inheritance
Polymorphism in Python
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

Precedence and Associativity of Operators in Python
Python Keywords and Identifiers
Python Asserts
Python Json
Python *args and **kwargs

Python Tutorials

Python reversed()

Python Dictionary clear()

Python Dictionary items()
Python Dictionary keys()

Python Dictionary fromkeys()

Python Nested Dictionary

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 .

Function	Description
	Removes the item with the specified key.
	Adds or changes dictionary items.
	Remove all the items from the dictionary.
	Returns all the dictionary's keys.
	Returns all the dictionary's values.
	Returns the value of the specified key.
	Returns the last inserted key and value as a tuple.
	Returns a copy of the dictionary.

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.

Before we wrap up, let’s put your knowledge of Python dictionary to the test! Can you solve the following challenge?

Write a function to merge two dictionaries.

Merge dict1 and dict2 , then return the merged dictionary.

Video: Python Dictionaries to Store key/value Pairs

Sorry about that.

Our premium learning platform, created with over a decade of experience and thousands of feedbacks .

Learn and improve your coding skills like never before.

Interactive Courses
Certificates
2000+ Challenges

Python Enhancement Proposals

Python »
PEP Index »

PEP 572 – Assignment Expressions

The importance of real code, exceptional cases, scope of the target, relative precedence of :=, change to evaluation order, differences between assignment expressions and assignment statements, specification changes during implementation, _pydecimal.py, datetime.py, sysconfig.py, simplifying list comprehensions, capturing condition values, changing the scope rules for comprehensions, alternative spellings, special-casing conditional statements, special-casing comprehensions, lowering operator precedence, allowing commas to the right, always requiring parentheses, why not just turn existing assignment into an expression, with assignment expressions, why bother with assignment statements, why not use a sublocal scope and prevent namespace pollution, style guide recommendations, acknowledgements, a numeric example, appendix b: rough code translations for comprehensions, appendix c: no changes to scope semantics.

This is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr .

As part of this change, there is also an update to dictionary comprehension evaluation order to ensure key expressions are executed before value expressions (allowing the key to be bound to a name and then re-used as part of calculating the corresponding value).

During discussion of this PEP, the operator became informally known as “the walrus operator”. The construct’s formal name is “Assignment Expressions” (as per the PEP title), but they may also be referred to as “Named Expressions” (e.g. the CPython reference implementation uses that name internally).

Naming the result of an expression is an important part of programming, allowing a descriptive name to be used in place of a longer expression, and permitting reuse. Currently, this feature is available only in statement form, making it unavailable in list comprehensions and other expression contexts.

Additionally, naming sub-parts of a large expression can assist an interactive debugger, providing useful display hooks and partial results. Without a way to capture sub-expressions inline, this would require refactoring of the original code; with assignment expressions, this merely requires the insertion of a few name := markers. Removing the need to refactor reduces the likelihood that the code be inadvertently changed as part of debugging (a common cause of Heisenbugs), and is easier to dictate to another programmer.

During the development of this PEP many people (supporters and critics both) have had a tendency to focus on toy examples on the one hand, and on overly complex examples on the other.

The danger of toy examples is twofold: they are often too abstract to make anyone go “ooh, that’s compelling”, and they are easily refuted with “I would never write it that way anyway”.

The danger of overly complex examples is that they provide a convenient strawman for critics of the proposal to shoot down (“that’s obfuscated”).

Yet there is some use for both extremely simple and extremely complex examples: they are helpful to clarify the intended semantics. Therefore, there will be some of each below.

However, in order to be compelling , examples should be rooted in real code, i.e. code that was written without any thought of this PEP, as part of a useful application, however large or small. Tim Peters has been extremely helpful by going over his own personal code repository and picking examples of code he had written that (in his view) would have been clearer if rewritten with (sparing) use of assignment expressions. His conclusion: the current proposal would have allowed a modest but clear improvement in quite a few bits of code.

Another use of real code is to observe indirectly how much value programmers place on compactness. Guido van Rossum searched through a Dropbox code base and discovered some evidence that programmers value writing fewer lines over shorter lines.

Case in point: Guido found several examples where a programmer repeated a subexpression, slowing down the program, in order to save one line of code, e.g. instead of writing:

they would write:

Another example illustrates that programmers sometimes do more work to save an extra level of indentation:

This code tries to match pattern2 even if pattern1 has a match (in which case the match on pattern2 is never used). The more efficient rewrite would have been:

Syntax and semantics

In most contexts where arbitrary Python expressions can be used, a named expression can appear. This is of the form NAME := expr where expr is any valid Python expression other than an unparenthesized tuple, and NAME is an identifier.

The value of such a named expression is the same as the incorporated expression, with the additional side-effect that the target is assigned that value:

There are a few places where assignment expressions are not allowed, in order to avoid ambiguities or user confusion:

This rule is included to simplify the choice for the user between an assignment statement and an assignment expression – there is no syntactic position where both are valid.

Again, this rule is included to avoid two visually similar ways of saying the same thing.

This rule is included to disallow excessively confusing code, and because parsing keyword arguments is complex enough already.

This rule is included to discourage side effects in a position whose exact semantics are already confusing to many users (cf. the common style recommendation against mutable default values), and also to echo the similar prohibition in calls (the previous bullet).

The reasoning here is similar to the two previous cases; this ungrouped assortment of symbols and operators composed of : and = is hard to read correctly.

This allows lambda to always bind less tightly than := ; having a name binding at the top level inside a lambda function is unlikely to be of value, as there is no way to make use of it. In cases where the name will be used more than once, the expression is likely to need parenthesizing anyway, so this prohibition will rarely affect code.

This shows that what looks like an assignment operator in an f-string is not always an assignment operator. The f-string parser uses : to indicate formatting options. To preserve backwards compatibility, assignment operator usage inside of f-strings must be parenthesized. As noted above, this usage of the assignment operator is not recommended.

An assignment expression does not introduce a new scope. In most cases the scope in which the target will be bound is self-explanatory: it is the current scope. If this scope contains a nonlocal or global declaration for the target, the assignment expression honors that. A lambda (being an explicit, if anonymous, function definition) counts as a scope for this purpose.

There is one special case: an assignment expression occurring in a list, set or dict comprehension or in a generator expression (below collectively referred to as “comprehensions”) binds the target in the containing scope, honoring a nonlocal or global declaration for the target in that scope, if one exists. For the purpose of this rule the containing scope of a nested comprehension is the scope that contains the outermost comprehension. A lambda counts as a containing scope.

The motivation for this special case is twofold. First, it allows us to conveniently capture a “witness” for an any() expression, or a counterexample for all() , for example:

Second, it allows a compact way of updating mutable state from a comprehension, for example:

However, an assignment expression target name cannot be the same as a for -target name appearing in any comprehension containing the assignment expression. The latter names are local to the comprehension in which they appear, so it would be contradictory for a contained use of the same name to refer to the scope containing the outermost comprehension instead.

For example, [i := i+1 for i in range(5)] is invalid: the for i part establishes that i is local to the comprehension, but the i := part insists that i is not local to the comprehension. The same reason makes these examples invalid too:

While it’s technically possible to assign consistent semantics to these cases, it’s difficult to determine whether those semantics actually make sense in the absence of real use cases. Accordingly, the reference implementation [1] will ensure that such cases raise SyntaxError , rather than executing with implementation defined behaviour.

This restriction applies even if the assignment expression is never executed:

For the comprehension body (the part before the first “for” keyword) and the filter expression (the part after “if” and before any nested “for”), this restriction applies solely to target names that are also used as iteration variables in the comprehension. Lambda expressions appearing in these positions introduce a new explicit function scope, and hence may use assignment expressions with no additional restrictions.

Due to design constraints in the reference implementation (the symbol table analyser cannot easily detect when names are re-used between the leftmost comprehension iterable expression and the rest of the comprehension), named expressions are disallowed entirely as part of comprehension iterable expressions (the part after each “in”, and before any subsequent “if” or “for” keyword):

A further exception applies when an assignment expression occurs in a comprehension whose containing scope is a class scope. If the rules above were to result in the target being assigned in that class’s scope, the assignment expression is expressly invalid. This case also raises SyntaxError :

(The reason for the latter exception is the implicit function scope created for comprehensions – there is currently no runtime mechanism for a function to refer to a variable in the containing class scope, and we do not want to add such a mechanism. If this issue ever gets resolved this special case may be removed from the specification of assignment expressions. Note that the problem already exists for using a variable defined in the class scope from a comprehension.)

See Appendix B for some examples of how the rules for targets in comprehensions translate to equivalent code.

The := operator groups more tightly than a comma in all syntactic positions where it is legal, but less tightly than all other operators, including or , and , not , and conditional expressions ( A if C else B ). As follows from section “Exceptional cases” above, it is never allowed at the same level as = . In case a different grouping is desired, parentheses should be used.

The := operator may be used directly in a positional function call argument; however it is invalid directly in a keyword argument.

Some examples to clarify what’s technically valid or invalid:

Most of the “valid” examples above are not recommended, since human readers of Python source code who are quickly glancing at some code may miss the distinction. But simple cases are not objectionable:

This PEP recommends always putting spaces around := , similar to PEP 8 ’s recommendation for = when used for assignment, whereas the latter disallows spaces around = used for keyword arguments.)

In order to have precisely defined semantics, the proposal requires evaluation order to be well-defined. This is technically not a new requirement, as function calls may already have side effects. Python already has a rule that subexpressions are generally evaluated from left to right. However, assignment expressions make these side effects more visible, and we propose a single change to the current evaluation order:

In a dict comprehension {X: Y for ...} , Y is currently evaluated before X . We propose to change this so that X is evaluated before Y . (In a dict display like {X: Y} this is already the case, and also in dict((X, Y) for ...) which should clearly be equivalent to the dict comprehension.)

Most importantly, since := is an expression, it can be used in contexts where statements are illegal, including lambda functions and comprehensions.

Conversely, assignment expressions don’t support the advanced features found in assignment statements:

Multiple targets are not directly supported: x = y = z = 0 # Equivalent: (z := (y := (x := 0)))
Single assignment targets other than a single NAME are not supported: # No equivalent a [ i ] = x self . rest = []
Priority around commas is different: x = 1 , 2 # Sets x to (1, 2) ( x := 1 , 2 ) # Sets x to 1
Iterable packing and unpacking (both regular or extended forms) are not supported: # Equivalent needs extra parentheses loc = x , y # Use (loc := (x, y)) info = name , phone , * rest # Use (info := (name, phone, *rest)) # No equivalent px , py , pz = position name , phone , email , * other_info = contact
Inline type annotations are not supported: # Closest equivalent is "p: Optional[int]" as a separate declaration p : Optional [ int ] = None
Augmented assignment is not supported: total += tax # Equivalent: (total := total + tax)

The following changes have been made based on implementation experience and additional review after the PEP was first accepted and before Python 3.8 was released:

for consistency with other similar exceptions, and to avoid locking in an exception name that is not necessarily going to improve clarity for end users, the originally proposed TargetScopeError subclass of SyntaxError was dropped in favour of just raising SyntaxError directly. [3]
due to a limitation in CPython’s symbol table analysis process, the reference implementation raises SyntaxError for all uses of named expressions inside comprehension iterable expressions, rather than only raising them when the named expression target conflicts with one of the iteration variables in the comprehension. This could be revisited given sufficiently compelling examples, but the extra complexity needed to implement the more selective restriction doesn’t seem worthwhile for purely hypothetical use cases.

Examples from the Python standard library

env_base is only used on these lines, putting its assignment on the if moves it as the “header” of the block.

Current: env_base = os . environ . get ( "PYTHONUSERBASE" , None ) if env_base : return env_base
Improved: if env_base := os . environ . get ( "PYTHONUSERBASE" , None ): return env_base

Avoid nested if and remove one indentation level.

Current: if self . _is_special : ans = self . _check_nans ( context = context ) if ans : return ans
Improved: if self . _is_special and ( ans := self . _check_nans ( context = context )): return ans

Code looks more regular and avoid multiple nested if. (See Appendix A for the origin of this example.)

Current: reductor = dispatch_table . get ( cls ) if reductor : rv = reductor ( x ) else : reductor = getattr ( x , "__reduce_ex__" , None ) if reductor : rv = reductor ( 4 ) else : reductor = getattr ( x , "__reduce__" , None ) if reductor : rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )
Improved: if reductor := dispatch_table . get ( cls ): rv = reductor ( x ) elif reductor := getattr ( x , "__reduce_ex__" , None ): rv = reductor ( 4 ) elif reductor := getattr ( x , "__reduce__" , None ): rv = reductor () else : raise Error ( "un(deep)copyable object of type %s " % cls )

tz is only used for s += tz , moving its assignment inside the if helps to show its scope.

Current: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) tz = self . _tzstr () if tz : s += tz return s
Improved: s = _format_time ( self . _hour , self . _minute , self . _second , self . _microsecond , timespec ) if tz := self . _tzstr (): s += tz return s

Calling fp.readline() in the while condition and calling .match() on the if lines make the code more compact without making it harder to understand.

Current: while True : line = fp . readline () if not line : break m = define_rx . match ( line ) if m : n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v else : m = undef_rx . match ( line ) if m : vars [ m . group ( 1 )] = 0
Improved: while line := fp . readline (): if m := define_rx . match ( line ): n , v = m . group ( 1 , 2 ) try : v = int ( v ) except ValueError : pass vars [ n ] = v elif m := undef_rx . match ( line ): vars [ m . group ( 1 )] = 0

A list comprehension can map and filter efficiently by capturing the condition:

Similarly, a subexpression can be reused within the main expression, by giving it a name on first use:

Note that in both cases the variable y is bound in the containing scope (i.e. at the same level as results or stuff ).

Assignment expressions can be used to good effect in the header of an if or while statement:

Particularly with the while loop, this can remove the need to have an infinite loop, an assignment, and a condition. It also creates a smooth parallel between a loop which simply uses a function call as its condition, and one which uses that as its condition but also uses the actual value.

An example from the low-level UNIX world:

Rejected alternative proposals

Proposals broadly similar to this one have come up frequently on python-ideas. Below are a number of alternative syntaxes, some of them specific to comprehensions, which have been rejected in favour of the one given above.

A previous version of this PEP proposed subtle changes to the scope rules for comprehensions, to make them more usable in class scope and to unify the scope of the “outermost iterable” and the rest of the comprehension. However, this part of the proposal would have caused backwards incompatibilities, and has been withdrawn so the PEP can focus on assignment expressions.

Broadly the same semantics as the current proposal, but spelled differently.

Since EXPR as NAME already has meaning in import , except and with statements (with different semantics), this would create unnecessary confusion or require special-casing (e.g. to forbid assignment within the headers of these statements).

(Note that with EXPR as VAR does not simply assign the value of EXPR to VAR – it calls EXPR.__enter__() and assigns the result of that to VAR .)

Additional reasons to prefer := over this spelling include:

In if f(x) as y the assignment target doesn’t jump out at you – it just reads like if f x blah blah and it is too similar visually to if f(x) and y .
import foo as bar
except Exc as var
with ctxmgr() as var

To the contrary, the assignment expression does not belong to the if or while that starts the line, and we intentionally allow assignment expressions in other contexts as well.

NAME = EXPR
if NAME := EXPR

reinforces the visual recognition of assignment expressions.

This syntax is inspired by languages such as R and Haskell, and some programmable calculators. (Note that a left-facing arrow y <- f(x) is not possible in Python, as it would be interpreted as less-than and unary minus.) This syntax has a slight advantage over ‘as’ in that it does not conflict with with , except and import , but otherwise is equivalent. But it is entirely unrelated to Python’s other use of -> (function return type annotations), and compared to := (which dates back to Algol-58) it has a much weaker tradition.

This has the advantage that leaked usage can be readily detected, removing some forms of syntactic ambiguity. However, this would be the only place in Python where a variable’s scope is encoded into its name, making refactoring harder.

Execution order is inverted (the indented body is performed first, followed by the “header”). This requires a new keyword, unless an existing keyword is repurposed (most likely with: ). See PEP 3150 for prior discussion on this subject (with the proposed keyword being given: ).

This syntax has fewer conflicts than as does (conflicting only with the raise Exc from Exc notation), but is otherwise comparable to it. Instead of paralleling with expr as target: (which can be useful but can also be confusing), this has no parallels, but is evocative.

One of the most popular use-cases is if and while statements. Instead of a more general solution, this proposal enhances the syntax of these two statements to add a means of capturing the compared value:

This works beautifully if and ONLY if the desired condition is based on the truthiness of the captured value. It is thus effective for specific use-cases (regex matches, socket reads that return '' when done), and completely useless in more complicated cases (e.g. where the condition is f(x) < 0 and you want to capture the value of f(x) ). It also has no benefit to list comprehensions.

Advantages: No syntactic ambiguities. Disadvantages: Answers only a fraction of possible use-cases, even in if / while statements.

Another common use-case is comprehensions (list/set/dict, and genexps). As above, proposals have been made for comprehension-specific solutions.

This brings the subexpression to a location in between the ‘for’ loop and the expression. It introduces an additional language keyword, which creates conflicts. Of the three, where reads the most cleanly, but also has the greatest potential for conflict (e.g. SQLAlchemy and numpy have where methods, as does tkinter.dnd.Icon in the standard library).

As above, but reusing the with keyword. Doesn’t read too badly, and needs no additional language keyword. Is restricted to comprehensions, though, and cannot as easily be transformed into “longhand” for-loop syntax. Has the C problem that an equals sign in an expression can now create a name binding, rather than performing a comparison. Would raise the question of why “with NAME = EXPR:” cannot be used as a statement on its own.

As per option 2, but using as rather than an equals sign. Aligns syntactically with other uses of as for name binding, but a simple transformation to for-loop longhand would create drastically different semantics; the meaning of with inside a comprehension would be completely different from the meaning as a stand-alone statement, while retaining identical syntax.

Regardless of the spelling chosen, this introduces a stark difference between comprehensions and the equivalent unrolled long-hand form of the loop. It is no longer possible to unwrap the loop into statement form without reworking any name bindings. The only keyword that can be repurposed to this task is with , thus giving it sneakily different semantics in a comprehension than in a statement; alternatively, a new keyword is needed, with all the costs therein.

There are two logical precedences for the := operator. Either it should bind as loosely as possible, as does statement-assignment; or it should bind more tightly than comparison operators. Placing its precedence between the comparison and arithmetic operators (to be precise: just lower than bitwise OR) allows most uses inside while and if conditions to be spelled without parentheses, as it is most likely that you wish to capture the value of something, then perform a comparison on it:

Once find() returns -1, the loop terminates. If := binds as loosely as = does, this would capture the result of the comparison (generally either True or False ), which is less useful.

While this behaviour would be convenient in many situations, it is also harder to explain than “the := operator behaves just like the assignment statement”, and as such, the precedence for := has been made as close as possible to that of = (with the exception that it binds tighter than comma).

Some critics have claimed that the assignment expressions should allow unparenthesized tuples on the right, so that these two would be equivalent:

(With the current version of the proposal, the latter would be equivalent to ((point := x), y) .)

However, adopting this stance would logically lead to the conclusion that when used in a function call, assignment expressions also bind less tight than comma, so we’d have the following confusing equivalence:

The less confusing option is to make := bind more tightly than comma.

It’s been proposed to just always require parentheses around an assignment expression. This would resolve many ambiguities, and indeed parentheses will frequently be needed to extract the desired subexpression. But in the following cases the extra parentheses feel redundant:

Frequently Raised Objections

C and its derivatives define the = operator as an expression, rather than a statement as is Python’s way. This allows assignments in more contexts, including contexts where comparisons are more common. The syntactic similarity between if (x == y) and if (x = y) belies their drastically different semantics. Thus this proposal uses := to clarify the distinction.

The two forms have different flexibilities. The := operator can be used inside a larger expression; the = statement can be augmented to += and its friends, can be chained, and can assign to attributes and subscripts.

Previous revisions of this proposal involved sublocal scope (restricted to a single statement), preventing name leakage and namespace pollution. While a definite advantage in a number of situations, this increases complexity in many others, and the costs are not justified by the benefits. In the interests of language simplicity, the name bindings created here are exactly equivalent to any other name bindings, including that usage at class or module scope will create externally-visible names. This is no different from for loops or other constructs, and can be solved the same way: del the name once it is no longer needed, or prefix it with an underscore.

(The author wishes to thank Guido van Rossum and Christoph Groth for their suggestions to move the proposal in this direction. [2] )

As expression assignments can sometimes be used equivalently to statement assignments, the question of which should be preferred will arise. For the benefit of style guides such as PEP 8 , two recommendations are suggested.

If either assignment statements or assignment expressions can be used, prefer statements; they are a clear declaration of intent.
If using assignment expressions would lead to ambiguity about execution order, restructure it to use statements instead.

The authors wish to thank Alyssa Coghlan and Steven D’Aprano for their considerable contributions to this proposal, and members of the core-mentorship mailing list for assistance with implementation.

Appendix A: Tim Peters’s findings

Here’s a brief essay Tim Peters wrote on the topic.

I dislike “busy” lines of code, and also dislike putting conceptually unrelated logic on a single line. So, for example, instead of:

instead. So I suspected I’d find few places I’d want to use assignment expressions. I didn’t even consider them for lines already stretching halfway across the screen. In other cases, “unrelated” ruled:

is a vast improvement over the briefer:

The original two statements are doing entirely different conceptual things, and slamming them together is conceptually insane.

In other cases, combining related logic made it harder to understand, such as rewriting:

as the briefer:

The while test there is too subtle, crucially relying on strict left-to-right evaluation in a non-short-circuiting or method-chaining context. My brain isn’t wired that way.

But cases like that were rare. Name binding is very frequent, and “sparse is better than dense” does not mean “almost empty is better than sparse”. For example, I have many functions that return None or 0 to communicate “I have nothing useful to return in this case, but since that’s expected often I’m not going to annoy you with an exception”. This is essentially the same as regular expression search functions returning None when there is no match. So there was lots of code of the form:

I find that clearer, and certainly a bit less typing and pattern-matching reading, as:

It’s also nice to trade away a small amount of horizontal whitespace to get another _line_ of surrounding code on screen. I didn’t give much weight to this at first, but it was so very frequent it added up, and I soon enough became annoyed that I couldn’t actually run the briefer code. That surprised me!

There are other cases where assignment expressions really shine. Rather than pick another from my code, Kirill Balunov gave a lovely example from the standard library’s copy() function in copy.py :

The ever-increasing indentation is semantically misleading: the logic is conceptually flat, “the first test that succeeds wins”:

Using easy assignment expressions allows the visual structure of the code to emphasize the conceptual flatness of the logic; ever-increasing indentation obscured it.

A smaller example from my code delighted me, both allowing to put inherently related logic in a single line, and allowing to remove an annoying “artificial” indentation level:

That if is about as long as I want my lines to get, but remains easy to follow.

So, in all, in most lines binding a name, I wouldn’t use assignment expressions, but because that construct is so very frequent, that leaves many places I would. In most of the latter, I found a small win that adds up due to how often it occurs, and in the rest I found a moderate to major win. I’d certainly use it more often than ternary if , but significantly less often than augmented assignment.

I have another example that quite impressed me at the time.

Where all variables are positive integers, and a is at least as large as the n’th root of x, this algorithm returns the floor of the n’th root of x (and roughly doubling the number of accurate bits per iteration):

It’s not obvious why that works, but is no more obvious in the “loop and a half” form. It’s hard to prove correctness without building on the right insight (the “arithmetic mean - geometric mean inequality”), and knowing some non-trivial things about how nested floor functions behave. That is, the challenges are in the math, not really in the coding.

If you do know all that, then the assignment-expression form is easily read as “while the current guess is too large, get a smaller guess”, where the “too large?” test and the new guess share an expensive sub-expression.

To my eyes, the original form is harder to understand:

This appendix attempts to clarify (though not specify) the rules when a target occurs in a comprehension or in a generator expression. For a number of illustrative examples we show the original code, containing a comprehension, and the translation, where the comprehension has been replaced by an equivalent generator function plus some scaffolding.

Since [x for ...] is equivalent to list(x for ...) these examples all use list comprehensions without loss of generality. And since these examples are meant to clarify edge cases of the rules, they aren’t trying to look like real code.

Note: comprehensions are already implemented via synthesizing nested generator functions like those in this appendix. The new part is adding appropriate declarations to establish the intended scope of assignment expression targets (the same scope they resolve to as if the assignment were performed in the block containing the outermost comprehension). For type inference purposes, these illustrative expansions do not imply that assignment expression targets are always Optional (but they do indicate the target binding scope).

Let’s start with a reminder of what code is generated for a generator expression without assignment expression.

Original code (EXPR usually references VAR): def f (): a = [ EXPR for VAR in ITERABLE ]
Translation (let’s not worry about name conflicts): def f (): def genexpr ( iterator ): for VAR in iterator : yield EXPR a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a simple assignment expression.

Original code: def f (): a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def f (): if False : TARGET = None # Dead code to ensure TARGET is a local variable def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Let’s add a global TARGET declaration in f() .

Original code: def f (): global TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def f (): global TARGET def genexpr ( iterator ): global TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Or instead let’s add a nonlocal TARGET declaration in f() .

Original code: def g (): TARGET = ... def f (): nonlocal TARGET a = [ TARGET := EXPR for VAR in ITERABLE ]
Translation: def g (): TARGET = ... def f (): nonlocal TARGET def genexpr ( iterator ): nonlocal TARGET for VAR in iterator : TARGET = EXPR yield TARGET a = list ( genexpr ( iter ( ITERABLE )))

Finally, let’s nest two comprehensions.

Original code: def f (): a = [[ TARGET := i for i in range ( 3 )] for j in range ( 2 )] # I.e., a = [[0, 1, 2], [0, 1, 2]] print ( TARGET ) # prints 2
Translation: def f (): if False : TARGET = None def outer_genexpr ( outer_iterator ): nonlocal TARGET def inner_generator ( inner_iterator ): nonlocal TARGET for i in inner_iterator : TARGET = i yield i for j in outer_iterator : yield list ( inner_generator ( range ( 3 ))) a = list ( outer_genexpr ( range ( 2 ))) print ( TARGET )

Because it has been a point of confusion, note that nothing about Python’s scoping semantics is changed. Function-local scopes continue to be resolved at compile time, and to have indefinite temporal extent at run time (“full closures”). Example:

This document has been placed in the public domain.

Source: https://github.com/python/peps/blob/main/peps/pep-0572.rst

Last modified: 2023-10-11 12:05:51 GMT

Add and update an item in a dictionary in Python

This article explains how to add an item (key-value pair) to a dictionary ( dict ) or update the value of an existing item in Python.

Add or update a single item in a dictionary

Specify keyword arguments, specify an iterable of key-value pairs, specify other dictionaries.

See the following articles to learn how to add a dictionary to a dictionary (i.e., merge dictionaries), remove an item from a dictionary, and change a key name.

Merge dictionaries in Python
Remove an item from a dictionary in Python (clear, pop, popitem, del)
Change a key name in a dictionary in Python

You can add an item to a dictionary or update the value of an existing item as follows.

If a non-existent key is specified, a new item is added; if an existing key is specified, the value of that item is updated (overwritten).

To avoid updating the value for an existing key, use the setdefault() method. See the following article for details.

Add an item if the key does not exist in dict with setdefault in Python

Add or update multiple items in a dictionary: update()

You can add or update multiple items at once using the update() method.

Built-in Types - dict.update() — Python 3.11.3 documentation

If the keyword argument ( key=value ) is specified for update() , the item with that key and value is added. If the key already exists, it is overwritten with the value specified in the argument.

An error is raised if the same key is specified multiple times.

In this case, keys must be valid identifiers in Python. They cannot start with a number or contain symbols other than _ .

Valid variable names and naming rules in Python

In other approaches, values that are invalid as identifiers can be used as keys.

You can pass a list of (key, value) pairs to update() . If a key in the list duplicates an existing key, it is overwritten with the value specified in the argument.

In the above example, a list of tuples was specified. However, any iterable containing key-value pairs (two-element iterables) is acceptable. This could include a tuple of lists, such as ([key1, value1], [key2, value2], ...) , or other iterable structures.

You can use zip() to add items by pairing elements from a list of keys and a list of values.

zip() in Python: Get elements from multiple lists

When using an iterable of key-value pairs, duplicate keys are acceptable. The value corresponding to the later occurrence of a key will overwrite the earlier one.

You can specify another dictionary as an argument to update() to add all its items.

Passing multiple dictionaries directly to update() will result in an error. You can prefix dictionaries with ** and pass each element as a keyword argument.

Expand and pass a list and dictionary as arguments in Python

When using ** , as shown in the above example, duplicate keys between the caller's dictionary and the dictionary specified in the argument are not a problem. However, if the same keys are found across multiple dictionaries specified in the argument, this will result in an error.

For more details on merging dictionaries, refer to the following article.

Related Categories

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 variables - assign multiple values, many values to multiple variables.

Python allows you to assign values to multiple variables in one line:

Note: Make sure the number of variables matches the number of values, or else you will get an error.

One Value to Multiple Variables

And you can assign the same value to multiple variables in one line:

Unpack a Collection

If you have a collection of values in a list, tuple etc. Python allows you to extract the values into variables. This is called unpacking .

Unpack a list:

Learn more about unpacking in our Unpack Tuples Chapter.

Video: Python Variable Names

COLOR PICKER

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail: [email protected]

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

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:

Name	Description
key	The key for which to return the value
default	The default value to be returned if the provided key is not present in the dictionary (optional)

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.

assign dictionary key value pairs to variables using exec

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

Stack Overflow for Teams Where developers & technologists share private knowledge with coworkers
Advertising & Talent Reach devs & technologists worldwide about your product, service or employer brand
OverflowAI GenAI features for Teams
OverflowAPI Train & fine-tune LLMs
Labs The future of collective knowledge sharing
About the company Visit the blog

Collectives™ on Stack Overflow

Find centralized, trusted content and collaborate around the technologies you use most.

Q&A for work

Connect and share knowledge within a single location that is structured and easy to search.

Get early access and see previews of new features.

What is the proper way to format a multi-line dict in Python?

In Python, I want to write a multi-line dict in my code. There are a couple of ways one could format it. Here are a few that I could think of:

mydict = { "key1": 1, "key2": 2, "key3": 3, }

I know that any of the above is syntactically correct, but I assume that there is one preferred indentation and line-break style for Python dicts. What is it?

Note: This is not an issue of syntax. All of the above are (as far as I know) valid Python statements and are equivalent to each other.

indentation
code-formatting

15 For 1 and 2: No spaces directly inside of the braces, see PEP 8. – Sven Marnach Commented Jun 17, 2011 at 15:41
3 I want to say that in pythons pprint module, it uses your first example, without spaces directly inside of the braces. – charmoniumQ Commented Jan 6, 2013 at 15:49

9 Answers 9

I use #3. Same for long lists, tuples, etc. It doesn't require adding any extra spaces beyond the indentations. As always, be consistent.

Similarly, here's my preferred way of including large strings without introducing any whitespace (like you'd get if you used triple-quoted multi-line strings):

2 Could you include some reference, I'm having trouble finding an authoritative source on this. (I do agree with you). – Trufa Commented Jun 17, 2011 at 16:34
3 lol, more seriously, I couldn't find an "authoritative" reference either. I'll let you know if I do! Perhaps someone should contact Guido. – FogleBird Commented Jun 17, 2011 at 19:00
4 This matches PEP 8: python.org/dev/peps/pep-0008/#indentation . There are some list examples at the bottom of the section on indentation. – Aaron Swan Commented Jun 15, 2018 at 20:52
Your "nested" example is invalid syntax. – data Commented Feb 5, 2020 at 14:30
1 Another advantage of this format is that you can easily comment out the first key-value pair (element), because it is on its own line. – mouwsy Commented Mar 3, 2022 at 18:25

First of all, like Steven Rumbalski said, "PEP8 doesn't address this question", so it is a matter of personal preference.

I would use a similar but not identical format as your format 3. Here is mine, and why.

1 i like the in line comment. my first programming professor (i'd already been programming for years before) insisted on inline comments, but never effectively explained why. you've now explained a practice i've used for about 20 years. – Joshua K Commented Apr 20, 2013 at 1:50
Aha, thanks. We have similar age, experience and "mileage" in terms of programming. So if you already began that inline comment practice 20 years ago (which is impressive!), why did you still need your professor's explanation at it in presumably 10 years ago when you were in your university? Just curious. :-) – RayLuo Commented Apr 20, 2013 at 3:32
very good question :) ATARI BASIC and GWbasic practically forced it, being top-down flow line-based compilers. it's something i adopted as i read peter norton's BASIC (and later ASM code) in paper magazines. i learned Turbo Pascal in between, but i had already learned from the examples in the paper magazines and conformed to BASIC's limitations. – Joshua K Commented Apr 26, 2013 at 13:15
PEP8 somewhat addresses it since it recommends against adding a space immediately after an opening brace, so options 1 and 2 in OP are out. – Daniel Serodio Commented Apr 1, 2014 at 17:41

Since your keys are strings and since we are talking about readability, I prefer :

8 Prefer not using spaces when defining kwargs. c = function(a=1, b=2) is more "pythonic". – Steve K Commented Jul 22, 2014 at 14:42

flake8 – a utility for enforcing style consistency in python code, which checks your code syntax and provide instructions to improve it – recommends this format (see https://www.flake8rules.com/rules/E133.html ):

I looks like this check isn't on by default, though. It seem PEP 8 (linked from flake8) specifies either this or my style 3 from the question as acceptable alternatives. Do you have any insight as to why this one should be preferred over the other? – Ryan C. Thompson Commented Feb 6, 2022 at 17:24
It says "Best practice", for reasons read the answer of RayLuo, code line 5 and 6. – mouwsy Commented Feb 6, 2022 at 20:03

Usually, if you have big python objects it's quite hard to format them. I personally prefer using some tools for that.

Here is python-beautifier - www.cleancss.com/python-beautify that instantly turns your data into customizable style.

If you have configured the Black formatter, it will one-line short dictionaries:

When I want to manually override the line-length configuration and format the dictionary as multi-line, just add a comment in your dictionary:

and Black will keep the dictionary multi-line.

From my experience with tutorials, and other things number 2 always seems preferred, but it's a personal preference choice more than anything else.

This doesn't answer the question – bagerard Commented Feb 10, 2020 at 22:13

Generally, you would not include the comma after the final entry, but Python will correct that for you.

41 No! Always include the final comma, so if you add a new last element, you don't have to change the line before it. This is one of the great things about Python: practicality over purity. – Ned Batchelder Commented Jun 17, 2011 at 19:33
3 Additionally, this answer does not address the question asked. – RKD314 Commented Aug 19, 2016 at 3:48
Not everyone prefer trailing commas, maybe handful of us with OCD just prefer reading a cleaner code. – Yong Commented Feb 5, 2021 at 16:03

Your Answer

Reminder: Answers generated by artificial intelligence tools are not allowed on Stack Overflow. Learn more

Sign up or log in

Post as a guest.

Required, but never shown

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy .

Not the answer you're looking for? Browse other questions tagged python indentation code-formatting multiline or ask your own question .

The Overflow Blog
Looking under the hood at the tech stack that powers multimodal AI
Detecting errors in AI-generated code
Featured on Meta
User activation: Learnings and opportunities
Preventing unauthorized automated access to the network
Announcing the new Staging Ground Reviewer Stats Widget

Hot Network Questions

BSS138 level shifter - blocking current flow when high-side supply is not connected?
Can I obtain the source TeX file for the published version of my paper in Physical Review
My student's wrong method gives the right answer? A question about random points on a circle.
Why does lottery write "in trust" on winner's cheque?
How close can aircraft get to each other mid flight
Crime and poverty: Correlation or causation?
How to implement a "scanner" effect on Linux to fix documents with varying darkness of background?
"Partition" in GParted
Would a material that could absorb 99.5% of light be able to protect someone from Night Vision?
Would all disagreements vanish if everyone had access to the same information and followed the same reasoning process?
How does NASA calculate trajectory at planetary atmosphere entry
Where does the argument included below to "Prove the fundamental group of a Topological Group is abelian" fail for non-group topological spaces?
Has the UN ever made peace between two warring parties?
Terminated employee will not help the company locate its truck
Uppercase, lowercase – "in any case"?
What effect will a planet’s narcotic atmosphere have on sound of music at rave parties?
Why is it surprising that the CMB is so homogeneous?
Numerical integration of ODEs: Why does higher accuracy and precision not lead to convergence?
What is the book/author about preserved heads/brains?
Generic C++ Class to Associate enum Values with Strings for Translation
(5e 2024) Does Divine Intervention circumvent longer casting times?
How safe is the runastool.exe, any known issues?
How can I connect heavy-gauge wire to a 20A breaker?
The 12th Amendment: what if the presidential and vice-presidential candidates are from the same state?

IMAGES

Assigning multiple variables in one line in Python
4. Multiple Assignment Function in Python
PYTHON : Multiple assignments into a python dictionary
02 Multiple assignments in python
PPT
Get multiple values from a Dictionary in Python

VIDEO

Assignment
Variables and Multiple Assignment
How to Merge Dictionaries Having the Same Key
Assignment
Python Basics: Assignment Operators (Continuation)
Assignment and multiple Assignment operators in Python

COMMENTS

Multiple assignments into a python dictionary
Running the same test (on M1), I get different results: 934 µs ± 9.61 µs per loop; 1.3 ms ± 23.8 µs per loop; 744 µs ± 1.3 µs per loop; 1.02 ms ± 2.17 µs per loop; 816 µs ± 955 ns per loop; 693 µs ± 1.51 µs per loop; You can improve update's performance by instantiating a dict in advance; d1.update(dict(zip(keys, values))) has ...
Multiple assignments from a python dictionary
Multiple assignments from a python dictionary. Ask Question Asked 12 years, 5 months ago. Modified 12 years, 4 months ago. Viewed 2k times 2 Is it possible to make this line of code valid? description, content, state, city, datetime = makeTupleRightOrder(dictionary) this makeTupleRightOrder would get the 'parameters' from the left side of the ...
Python Nested Dictionary (With Examples)
Learn how to create, access, add, delete and iterate through nested dictionaries in Python. A nested dictionary is a dictionary inside a dictionary that contains key:value pairs.
10.5: Multiple assignment with dictionaries
Code 10.5.1 (Python) print(val, key) This loop has two iteration variables because items returns a list of tuples and key, val is a tuple assignment that successively iterates through each of the key-value pairs in the dictionary. For each iteration through the loop, both key and value are advanced to the next key-value pair in the dictionary ...
11.5. Multiple Assignment with Dictionaries
Learn how to use items, tuple assignment, and for to traverse and sort the keys and values of a dictionary in a single loop. See examples, exercises, and code patterns for this technique.
Dictionaries in Python
Learn how to create, manipulate, and use dictionaries in Python, a data structure that stores values in key: value pairs. See different ways to create dictionaries, add elements, access values, and handle nested dictionaries.
Multiple Assignment Syntax in Python
Learn how to use multiple assignment syntax, also known as tuple unpacking or extended unpacking, to assign multiple values to variables at once in Python. See examples of swapping, splitting, ignoring, and unpacking values from iterables and nested structures.
Dictionaries in Python
Learn how to define, access, and manipulate dictionaries, a composite data type that maps keys to values. See examples, methods, and restrictions of dictionaries in Python.
Multiple assignment in Python: Assign multiple values or the same value
Learn how to assign multiple values or the same value to multiple variables in Python using the = operator. Be careful when assigning mutable objects such as list and dict, as they may share the same reference.
Python Dictionary (With Examples)
Learn how to create, access, modify, and iterate through dictionaries in Python. See the syntax and examples of the pop(), clear(), update(), and len() methods for dictionaries.
PEP 572
This web page is a proposal for creating a way to assign to variables within an expression using the notation NAME := expr in Python. It explains the rationale, syntax, semantics and examples of assignment expressions, and the exceptions and limitations of their use.
Multiple assignment to python dictionary
Make a dictionary (dict) from separate lists of keys and values (21 answers) Closed 7 years ago . Suppose you have two lists of strings, the first one being the keys for the dictionary, and the second being the values for the keys of corresponding position.
Add and update an item in a dictionary in Python
Learn how to add or update an item in a dictionary in Python using different methods and examples. See how to use dict[key] = value, dict.update(), zip(), and other dictionaries.
Python Variables
Learn how to assign multiple values to multiple variables or the same value to multiple variables in one line in Python. Also, learn how to unpack a collection of values into variables.
Multiple Assignments in Python dictionary comprehension
6. You can use zip to turn each entry into a list of key-value pairs: You don't want a 'Name' label, you want to use the name as a label which duplicates location. So, now you need to fix up the dicts: d[d['Name']] = d['Location'] del d['Name'] # or not, if you can tolerate the extra key. Alternatively, you can do this in one step:
Assign a dictionary Key or Value to variable in Python
Learn different ways to assign a dictionary key or value to a variable in Python, using bracket notation, dict.values(), dict.get(), locals() or exec(). See examples ...
python nested dict multikey method suggestion
apparently, there is no built-in dict method (let's call it .multikey) for dynamic key addressing in multi-nested dict structures. this can be demanding when dealing with complex dict structures,. e.g., dic_1.multikey(list_of_keys_A) = value instead of manually doing dic_1["key_1"]["subkey_2"]["subsubkey_3"].. = value. this is not to be confused with level-1 assignment: dic_1["key_1"] = value ...
Is it possible to assign the same value to multiple keys in a dict
In Python, I need a dictionary object which looks like: {'a': 10, 'b': 20, 'c': 10, 'd': 10, 'e': 20} I've been able to get this successfully by combining the dict.update() and dict.fromkeys() functions like so: ... Multiple assignments into a python dictionary. 2.
Assigning multiple objects to a dict () in Python
Return the dict instead. For each key in dict you can only have one value, however that value can be a container that has several elements. E.g. tuple, list, another nested dict. You can't access any of the things you added to dict by [""] because that key does not exist. You might want to use for key, value in dict.items(): -
python
Unsubstantiated rhetoric like "Deep copy is considered harmful" is unhelpful. All else being equal, shallow copying a complex data structure is significantly more likely to yield unexpected edge case issues than deep copying the same structure. A copy in which modifications modify the original object isn't a copy; it's a bug.
What is the proper way to format a multi-line dict in Python?
# Oh did I just show you how to write # multiple-line inline comment here? # Basically, same indentation forms a natural paragraph. ) # Indentation here. Same idea as the long dict case. the_next_line_of_code() # By the way, now you see how I prefer inline comment to document the very line. # I think this inline style is more compact.

11.5. Multiple Assignment with Dictionaries ¶

Dictionaries in Python

Python Dictionary Syntax

What is a Dictionary in Python?

How to Create a Dictionary

Dictionary Example

Different Ways to Create a Python Dictionary

Complexities for Creating a Dictionary:

Nested Dictionaries

Adding Elements to a Dictionary

Accessing Elements of a Dictionary

Access a Value in Python Dictionary

Complexities for Accessing elements in a Dictionary:

Accessing an Element of a Nested Dictionary

Multiple Dictionary Operations in Python

Dictionaries in Python – FAQs

How to print dictionaries in Python?

How to declare a dictionary in Python?

What are dictionary keys and values in Python?

What is the use of all() , any() , cmp() , and sorted() in dictionary?

Please Login to comment...

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

Multiple Assignment Syntax in Python

Swapping Values

Splitting a List

Assigning Multiple Values from a Function

Ignoring Values

Unpacking Nested Structures

Extended Unpacking with Slicing

Split a String into a List

Dictionaries in Python

Defining a Dictionary

Built-in Dictionary Methods

Keep reading Real Python by creating a free account or signing in:

Popular Tutorials

Python Fundamentals

Python Flow Control

Python Data types

Python Dictionary

Python Files

Python Object & Class

Python Advanced Topics

Python Date and Time

Additional Topic

Python Tutorials

Valid and Invalid Dictionaries

Table of Contents

Video: Python Dictionaries to Store key/value Pairs

Related Tutorials

Python Enhancement Proposals

PEP 572 – Assignment Expressions

Syntax and semantics

Examples from the Python standard library

Rejected alternative proposals

Frequently Raised Objections

Appendix A: Tim Peters’s findings

Add and update an item in a dictionary in Python

Add or update a single item in a dictionary

Add or update multiple items in a dictionary: update()

Related Categories

Python Tutorial

One Value to Multiple Variables

Unpack a Collection

Video: Python Variable Names

COLOR PICKER

Contact Sales

Report Error

Top Tutorials

Assign a dictionary Key or Value to variable in Python

# 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()

# Additional Resources

Borislav Hadzhiev

Collectives™ on Stack Overflow

What is the proper way to format a multi-line dict in Python?

9 Answers 9

Your Answer