Dictionary Literals

You can define a dictionary by enclosing a comma-separated series of key-value pairs in curly braces ({}). To separate the keys from their values, you need to use a colon (:). Here’s the syntax for a dictionary literal:

{<key_1>:<value_1>,<key_2>:<value_2>,...,<key_N>:<value_N>,}

The keys and values are completely optional, which means that you can use an empty pair of curly braces to create an empty dictionary. Then, you have the keys, a colon, and the value associated with the current key. To separate the pairs, you use a comma.

The keys must behashable objects like numbers, strings, or tuples. Being hashable means they can be passed to a hash function. Ahash function takes data of arbitrary size and maps it to a fixed-size value called ahash value—or justhash—which is used for table lookup and comparison. In Python, the built-in immutable data types are hashable, and the mutable types are unhashable.

The following code defines a dictionary that maps cities or states to the names of their corresponding Major League Baseball (MLB) teams:

>>>MLB_teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}

You can only use hashable Python objects as dictionary keys. The following example shows a dictionary with integer, float, and Boolean objects used as keys:

>>>{42:"aaa",2.78:"bbb",True:"ccc"}{42: 'aaa', 2.78: 'bbb', True: 'ccc'}

You can even use objects like data types and functions as keys:

>>>types={int:1,float:2,bool:3}>>>types{<class 'int'>: 1, <class 'float'>: 2, <class 'bool'>: 3}>>>types[float]2>>>types[bool]3

However, you can’t use unhashable objects as keys. If you try to, then you’ll get an error:

>>>{[1,2]:"A list as a key? Hmm..."}Traceback (most recent call last):...TypeError:unhashable type: 'list'

Python lists are unhashable because any changes to their content would change their hash value, violating the requirement that hash values must remain constant for hashable types. In practice, you can’t use anymutable data type as a key in a dictionary. This means that lists, sets, and dictionaries themselves aren’t allowed.

If you need to usesequences as dictionary keys, then you can use tuples because tuples are immutable:

>>>a_dict={(1,1):"a",(1,2):"b",(2,1):"c",(2,2):"d"}>>>a_dict[(1,1)]'a'>>>a_dict[(2,1)]'c'

It’s important to note that even though tuples are immutable, they can contain mutable objects. You can’t use a tuple that contains mutable objects as a dictionary key:

>>>{(1,[1,1]):"a"}Traceback (most recent call last):...TypeError:unhashable type: 'list'

In this example, the tuple that you try to use as a dictionary key contains a list. As a result, the tuple isn’t hashable anymore, so you get an error.

Duplicate keys aren’t allowed in Python’sdict data type. Because of this restriction, when you assign a value to an existing key, you won’t add a second instance of the key. Instead, you’ll replace the previously associated value with a new one.

For example, say that a given city has a second MLB team. You may try to add the second team by assigning it to the same key:

>>>MLB_teams["Chicago"]="Cubs">>>MLB_teams{    'Colorado': 'Rockies',    'Chicago': 'Cubs',    'Boston': 'Red Sox',    'Minnesota': 'Twins',    'Milwaukee': 'Brewers',    'Seattle': 'Mariners',}

In this example, you try to add a new key-value pair for the second MLB team in Chicago. However, what happens is that you replace the old team name ("White Sox") with the new one ("Cubs").

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

>>>MLB_teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Chicago":"Cubs",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}>>>MLB_teams{    'Colorado': 'Rockies',    'Chicago': 'Cubs',  # "White Sox" is not present    'Boston': 'Red Sox',    'Minnesota': 'Twins',    'Milwaukee': 'Brewers',    'Seattle': 'Mariners'}

In this example, your dictionary ends up containing the"Chicago": "Cubs" pair because you inserted it after"Chicago": "White Sox" with the same key.

Unlike dictionary keys, there are no restrictions for dictionary values. Literally none at all. A dictionary value can be any type of object, including mutable types like lists and dictionaries, as well as user-defined objects:

>>>classPoint:...def__init__(self,x,y):...self.x=x...self.y=y...>>>{..."colors":["red","green","blue"],..."plugins":{"py_code","dev_sugar","fasting_py"},..."timeout":3,..."position":Point(42,21),...}

In this example, you create a dictionary with a list, a set, an integer, and a custom object as values. All these objects work because values have no restrictions.

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

>>>{0:"a",1:"a",2:"a",3:"a"}{0: 'a', 1: 'a', 2: 'a', 3: 'a'}

In this example, your dictionary contains multiple instances of the lettera as a value. This is completely okay because values don’t have the restriction of needing to be unique.

Thedict() Constructor

You can also build dictionaries with thedict() constructor. The arguments todict() can be a series of keyword arguments, another mapping, or an iterable of key-value pairs. Here are the constructor’s signatures:

dict()dict(**kwargs)dict(mapping,**kwargs)dict(iterable,**kwargs)

If you call thedict() constructor without arguments, then you get an empty dictionary:

>>>dict(){}

In most cases, you’ll use an empty pair of curly braces to create empty dictionaries. However, in some situations, using the constructor might be more explicit.

If the keys of your dictionary are strings representing valid Pythonidentifiers, then you can specify them as keyword arguments. Here’s how you’d create theMLB_teams dictionary with this approach:

>>>MLB_teams=dict(...Colorado="Rockies",...Chicago="White Sox",...Boston="Red Sox",...Minnesota="Twins",...Milwaukee="Brewers",...Seattle="Mariners",...)>>>MLB_teams{    'Colorado': 'Rockies',    'Chicago': 'White Sox',    'Boston': 'Red Sox',    'Minnesota': 'Twins',    'Milwaukee': 'Brewers',    'Seattle': 'Mariners'}

Again, to build a dictionary using keyword arguments, the keys must be strings holding valid Python names. Otherwise, they won’t work as argument names. This is a syntactical restriction of Python.

You can also create a dictionary from an iterable of key-value pairs. Here’s how you can build theMLB_teams dictionary this way:

>>>MLB_teams=dict(...[...("Colorado","Rockies"),...("Chicago","White Sox"),...("Boston","Red Sox"),...("Minnesota","Twins"),...("Milwaukee","Brewers"),...("Seattle","Mariners"),...]...)>>>MLB_teams{    'Colorado': 'Rockies',    'Chicago': 'White Sox',    'Boston': 'Red Sox',    'Minnesota': 'Twins',    'Milwaukee': 'Brewers',    'Seattle': 'Mariners'}

In this example, you build the dictionary using a list of two-item tuples. The first item acts as the key, and the second is the associated value.

A cool way to create dictionaries from sequences of values is to combine them with the built-inzip() function and then calldict() as shown below:

>>>places=[..."Colorado",..."Chicago",..."Boston",..."Minnesota",..."Milwaukee",..."Seattle",...]>>>teams=[..."Rockies",..."White Sox",..."Red Sox",..."Twins",..."Brewers",..."Mariners",...]>>>dict(zip(places,teams)){    'Colorado': 'Rockies',    'Chicago': 'White Sox',    'Boston': 'Red Sox',    'Minnesota': 'Twins',    'Milwaukee': 'Brewers',    'Seattle': 'Mariners'}

Thezip() function takes one or more iterables as arguments and yields tuples that combine items from each iterable. Note that your original data must be stored in ordered sequences for this technique to work correctly because the order is essential. Otherwise, you can end up with a dictionary that maps keys to values incorrectly.

Using the.fromkeys() Class Method

Thedict data type has a class method called.fromkeys() that lets you create new dictionaries from an iterable of keys and a default value. The method’s signature looks like the following:

.fromkeys(iterable,value=None,/)

Theiterable argument provides the keys that you want to include in your dictionary. Even though the input iterable can have duplicate items, the final dictionary will have unique keys as usual.

Thevalue argument allows you to define an appropriate default value for all the keys. This argument defaults toNone, which can serve as a good default value in several scenarios. Here’s an example of how to create a new dictionary with the.fromkeys() method:

>>>inventory=dict.fromkeys(["apple","orange","banana","mango"],0)>>>inventory{'apple': 0, 'orange': 0, 'banana': 0, 'mango': 0}

In this example, you create a dictionary to store an inventory of fruits. Initially, you have the list of fruits in stock but don’t have the corresponding amounts. So, you use0 as the default amount in the call to.fromkeys().

Assigning Keys Manually

Sometimes, you start by creating an empty dictionary with an empty pair of curly braces. Then, you start adding new key-value pairs one at a time. Consider the following example where you populate a dictionary with a person’s data:

>>>person={}>>>person["first_name"]="John">>>person["last_name"]="Doe">>>person["age"]=35>>>person["spouse"]="Jane">>>person["children"]=["Ralph","Betty","Bob"]>>>person["pets"]={"dog":"Frieda","cat":"Sox"}>>>person{    'first_name': 'John',    'last_name': 'Doe',    'age': 35,    'spouse': 'Jane',    'children': ['Ralph', 'Betty', 'Bob'],    'pets': {'dog': 'Frieda', 'cat': 'Sox'}}

You can populate your dictionaries manually with new key-value pairs by assigning values to new keys. Internally, Python will create the key-value pair for you. It’s important to remember that keys are unique. If you assign a new value to an existing key, then the old value will be lost.

Adding Keys in afor Loop

You’ll also find situations where afor loop is a good approach for populating an empty dictionary with new data. For example, say that you have arange of numbers and want to create a dictionary that maps each number to its corresponding square value. To create and populate the dictionary, you can use the following code:

>>>squares={}>>>forintegerinrange(1,10):...squares[integer]=integer**2...>>>squares{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

In this example, you first create an empty dictionary using a pair of curly braces. Then, you use a loop to iterate over a range of integer numbers. Inside the loop, you populate the dictionary using the numbers as keys and the square values as the corresponding values.

Building Dictionaries With Comprehensions

Python has dictionary comprehensions, which is another great tool for creating and populating dictionaries with concise syntax. Here’s how you can create yoursquare dictionary with a comprehension:

>>>squares={integer:integer**2forintegerinrange(1,10)}>>>squares{1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}

Dictionary comprehensions are expressions that build and return a new dictionary. In this example, you use a comprehension to create a dictionary that maps numbers to their square values.

Comprehensions provide a powerful way to create new dictionaries, transform and filter existing dictionaries, and more. They’re a great tool for you to have under your belt.

Retrieving Data From Dictionaries

To get started, you’ll learn about methods you can use to access the data stored in an existing dictionary. You’ll also learn about methods for getting a single key and retrieving all the values, keys, and pairs from a dictionary. These methods are useful in real-world Python programming.

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.get("apple")100>>>print(inventory.get("mango"))None

>>>inventory.get("mango",0)0

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.values()dict_values([100, 80, 100])

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.keys()dict_keys(['apple', 'orange', 'banana'])

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.items()dict_items([('apple', 100), ('orange', 80), ('banana', 100)])

Adding Key-Value Pairs and Updating Dictionaries

Python’s built-indict data type also has methods for adding and updating key-value pairs. For this purpose, you have the.setdefault() and.update() methods. You’ll learn about them in the following sections.

>>>inventory={"apple":100,"orange":80}>>>inventory.setdefault("apple")100>>>print(inventory.setdefault("mango"))None>>>inventory{'apple': 100, 'orange': 80, 'mango': None}>>>inventory.setdefault("banana",0)0>>>inventory{'apple': 100, 'orange': 80, 'mango': None, 'banana': 0}

>>>config={..."color":"green",..."width":42,..."height":100,..."font":"Courier",...}>>>user_config={..."path":"/home",..."color":"red",..."font":"Arial",..."position":(200,100),...}>>>config.update(user_config)>>>config{    'color': 'red',    'width': 42,    'height': 100,    'font': 'Arial',    'path': '/home',    'position': (200, 100)}

>>>config.update([("width",200),("api_key",1234)])>>>config{    'color': 'red',    'width': 200,    'height': 100,    'font': 'Arial',    'path': '/home',    'position': (200, 100),    'api_key': 1234}

>>>config.update(color="yellow",script="__main__.py")>>>config{    'color': 'yellow',    'width': 200,    'height': 100,    'font': 'Arial',    'path': '/home',    'position': (200, 100),    'api_key': 1234,    'script': '__main__.py'}

Removing Data From Dictionaries

Removing key-value pairs is another common operation that you may need to perform on your dictionaries. To do this, thedict class provides a few useful methods. In the following sections, you’ll learn about these methods and how they work.

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.pop("apple")100>>>inventory{'orange': 80, 'banana': 100}>>>inventory.pop("mango")Traceback (most recent call last):...KeyError:'mango'>>>inventory.pop("mango",0)0

>>>delinventory["banana"]>>>inventory{'orange': 80}

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory.popitem()('banana', 100)>>>inventory{'apple': 100, 'orange': 80}>>>inventory.popitem()('orange', 80)>>>inventory{'apple': 100}>>>inventory.popitem()('apple', 100)>>>inventory{}

>>>inventory.popitem()Traceback (most recent call last):...KeyError:'popitem(): dictionary is empty'

>>>inventory={"apple":100,"orange":80,"banana":100}>>>inventory{'apple': 100, 'orange': 80, 'banana': 100}>>>inventory.clear()>>>inventory{}

Membership:in andnot in

The membership operatorsin andnot in allow you to determine whether a given key, value, or item is in a dictionary, depending on the target iterable you use.

For example, to check whether:

• A key is in a dictionary, you can use the dictionary itself or the.keys() method to provide the target iterable
• A value is in a dictionary, you can use the.values() method to provide the target iterable
• An item is in a dictionary, you can use the.items() method to provide the target iterable

To illustrate, say that you want to check whether a given city is in yourMLB_teams dictionary. To do this, you can use thein andnot in operator with the dictionary itself or with the.keys() method:

>>>MLB_teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}>>>"Milwaukee"inMLB_teamsTrue>>>"Indianapolis"inMLB_teamsFalse>>>"Indianapolis"notinMLB_teamsTrue>>>"Milwaukee"inMLB_teams.keys()True>>>"Indianapolis"inMLB_teams.keys()False>>>"Indianapolis"notinMLB_teams.keys()True

In the first membership test, you check whether Milwaukee is included in theMLB_teams dictionary. Because this city is in the dictionary, you getTrue as a result. Then, you check whether Indianapolis is a member of the dictionary, which returnsFalse.

In this first series of examples, you use the dictionary as the target iterable for thein andnot in operators. In the second series of examples, you use.keys(). As you can see, both techniques work the same. However, using.keys() in membership is redundant and slightly less efficient than using the dictionary directly.

For an execution time comparison, click to open the collapsible section below and run the script on your computer:

importtimeitMLB_teams={"Colorado":"Rockies","Chicago":"White Sox","Boston":"Red Sox","Minnesota":"Twins","Milwaukee":"Brewers","Seattle":"Mariners",}# Run timeit to compare the membership testtime_in_dict=timeit.timeit('"Milwaukee" in MLB_teams',globals=globals(),number=1_000_000)time_in_keys=timeit.timeit('"Milwaukee" in MLB_teams.keys()',globals=globals(),number=1_000_000)time_not_in_dict=timeit.timeit('"Indianapolis" in MLB_teams',globals=globals(),number=1_000_000)time_not_in_keys=timeit.timeit('"Indianapolis" in MLB_teams.keys()',globals=globals(),number=1_000_000)print(f"{time_in_dict= } seconds",f"{time_in_keys= } seconds",f"{time_not_in_dict= } seconds",f"{time_not_in_keys= } seconds",sep="\n",)

$pythonmembership.pytime_in_dict     = 0.018622874980792403 secondstime_in_keys     = 0.047137481975369155 secondstime_not_in_dict = 0.018104779010172933 secondstime_not_in_keys = 0.046951496973633766 seconds

You can also use thein andnot in operators with the.values() method to determine whether a given value is in your dictionary:

>>>"Rockies"inMLB_teams.values()True>>>"Rockies"notinMLB_teams.values()False

In this example, you use the.values() method to provide the target iterable for the membership test. This is how to know if a given team is in your dictionary.

Finally, in some situations, you may want to know whether a key-value pair is in the target dictionary. To figure this out, you can use the membership operators with the.items() method:

>>>("Boston","Red Sox")inMLB_teams.items()True>>>("Boston","Red Sox")notinMLB_teams.items()False

Note that in this example, you use a tuple containing the key-value pair as the value to check. Then, you use the.items() method to provide the target iterable.

Equality and Inequality:== and!=

The equality (==) and inequality (!=) operators also work with dictionaries. These operators disregard element order when you use them with dictionaries, which is different from what happens with lists, for example:

>>>[1,2,3]==[3,2,1]False>>>{1:1,2:2,3:3}=={3:3,2:2,1:1}True>>>[1,2,3]!=[3,2,1]True>>>{1:1,2:2,3:3}!={3:3,2:2,1:1}False

When you compare a list using the equality operator, the result depends on both the content and the order. In contrast, when you compare two dictionaries that contain the same series of key-value pairs, the order of those pairs isn’t considered. The inequality operator when used with dictionaries doesn’t consider the order of pairs either.

Union and Augmented Union:| and|=

The union operator (|) creates a new dictionary by merging the keys and values of two initial dictionaries. The values of the dictionary to the right of the operator take precedence when both dictionaries share keys:

>>>default_config={..."color":"green",..."width":42,..."height":100,..."font":"Courier",...}>>>user_config={..."path":"/home",..."color":"red",..."font":"Arial",..."position":(200,100),...}>>>config=default_config|user_config>>>config{    'color': 'red',    'width': 42,    'height': 100,    'font': 'Arial',    'path': '/home',    'position': (200, 100)}

In this example, you merge thedefault_config anduser_config dictionaries to build the finalconfig dictionary using the union operator.

Note that the"color" and"font" keys are common to both initial dictionaries,default_config anduser_config. After the union, the values associated with these keys inuser_config prevail. The key-value pairs that didn’t exist indefault_config are added to the end of the new dictionary.

Similarly, the augmented union operator (|=) updates an existing dictionary with key-value pairs from another dictionary,mapping, oriterable of key-value pairs. Again, when the operands share keys, the values from the right-hand side operand take priority:

>>>config={..."color":"green",..."width":42,..."height":100,..."font":"Courier",...}>>>user_config={..."path":"/home",..."color":"red",..."font":"Arial",..."position":(200,100),...}>>>config|=user_config>>>config{    'color': 'red',    'width': 42,    'height': 100,    'font': 'Arial',    'path': '/home',    'position': (200, 100)}

In this new version of theconfig dictionary, you don’t create a new dictionary for the final configuration. Instead, you update the existing dictionary with the content ofuser_config using the augmented union operator. In a sense, the augmented union operator works like the.update() method, updating an existing dictionary with the content of another.

Checking for Truthy Data in Dictionaries:all() andany()

To start off, say that you have a dictionary that maps products to their amounts. You want to know whether all of the products are stocked. To figure this out, you can use theall() function with the dictionary values as a target:

>>>inventory={"apple":100,"orange":80,"banana":100,"mango":200}>>>all(inventory.values())True>>># Update the stock>>>inventory["mango"]=0>>>all(inventory.values())False

In the first call toall(), you getTrue because all product amounts differ from0. In the second example, you getFalse because you’re out of mangoes. You can use theany() function in a similar fashion.

You can use these functions with keys as well. To do this, you can use either the dictionary directly or the.keys() method. Finally, using these functions with items doesn’t make sense because the.items() method returns non-empty tuples.

Determining the Number of Dictionary Items:len()

Sometimes, you need to know the number of key-value pairs in an existing dictionary. The built-inlen() function returns exactly that number:

>>>MLB_teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}>>>len(MLB_teams)6

When you use a dictionary as an argument forlen(), the function returns the number of items in the dictionary. In this example, the input dictionary has six key-value pairs, so you get 6 as a result.

Finding Minimum and Maximum Values:min() andmax()

If you ever need to find the minimum and maximum value stored in a dictionary, then you can use the built-inmin() andmax() functions:

>>>computer_parts={..."CPU":299.99,..."Motherboard":149.99,..."RAM":89.99,..."GPU":499.99,..."SSD":129.99,..."Power Supply":79.99,..."Case":99.99,..."Cooling System":59.99,...}>>>min(computer_parts.values())59.99>>>max(computer_parts.values())499.99

In this example, you use themin() andmax() functions to find the lower and higher prices with the.values() method. You can also use the functions with dictionary keys and even with items. However, note that these functions are mostly used with numeric values.

Sorting Dictionaries by Keys, Values, and Items:sorted()

Sorting the items of a dictionary may be another common requirement. To do this, you can use the built-insorted() function. To illustrate, say that you have a dictionary matching student names with their average grades and you want to sort the data by grades.

Here’s how you can do this sorting:

>>>students={..."Alice":89.5,..."Bob":76.0,..."Charlie":92.3,..."Diana":84.7,..."Ethan":88.9,..."Fiona":95.6,..."George":73.4,..."Hannah":81.2,...}>>>dict(sorted(students.items(),key=lambdaitem:item[1])){    'George': 73.4,    'Bob': 76.0,    'Hannah': 81.2,    'Diana': 84.7,    'Ethan': 88.9,    'Alice': 89.5,    'Charlie': 92.3,    'Fiona': 95.6}>>>dict(sorted(students.items(),key=lambdaitem:item[1],reverse=True)){    'Fiona': 95.6,    'Charlie': 92.3,    'Alice': 89.5,    'Ethan': 88.9,    'Diana': 84.7,    'Hannah': 81.2,    'Bob': 76.0,    'George': 73.4}

Thesorted() function returns a list of sorted values, so you wrap its call withdict() to build a new sorted dictionary. In the first call, you sort the items by value in ascending order. To do this, you use alambda function that takes a two-value tuple as an argument and returns the second item, which has an index of1.

In the second call tosorted(), you set thereverse argument toTrue so that the function returns a list of items stored in reverse order.

You can also sort the dictionary by its keys:

>>>dict(sorted(students.items(),key=lambdaitem:item[0])){    'Alice': 89.5,    'Bob': 76.0,    'Charlie': 92.3,    'Diana': 84.7,    'Ethan': 88.9,    'Fiona': 95.6,    'George': 73.4,    'Hannah': 81.2}

In this example, you sort the dictionary by keys using alambda function that returns the first value in the input tuple.

Finally, you can also usesorted() to sort the keys and values:

>>>sorted(students)['Alice', 'Bob', 'Charlie', 'Diana', 'Ethan', 'Fiona', 'George', 'Hannah']>>>sorted(students.values())[73.4, 76.0, 81.2, 84.7, 88.9, 89.5, 92.3, 95.6]

In the first call tosorted(), you use the dictionary as an argument. This results in a list of sorted keys. Next, you use the.values() method to get a list of sorted values.

Summing Dictionary Values:sum()

You can also use the built-insum() function with dictionaries. For example, you can use the function to sum up numeric dictionary values or keys.

To illustrate, say that you have a dictionary containing daily sales data and want to know the average daily sales. In this scenario, you can do something like the following:

>>>daily_sales={..."Monday":1500,..."Tuesday":1750,..."Wednesday":1600,..."Thursday":1800,..."Friday":2000,..."Saturday":2200,..."Sunday":2100,...}>>>sum(daily_sales.values())/len(daily_sales)1850.0

In this example, you use thesum() function to calculate the total sales. To do this, you use the.values() method. Then, you compute the average with the help oflen().

Traversing Dictionaries by Keys

There are two different ways you can iterate over the keys of a dictionary. You can either use the dictionary directly, or use the.keys() method. The following examples show how to use these two approaches:

>>>students={..."Alice":89.5,..."Bob":76.0,..."Charlie":92.3,..."Diana":84.7,..."Ethan":88.9,..."Fiona":95.6,..."George":73.4,..."Hannah":81.2,...}>>>forstudentinstudents:...print(student)...AliceBobCharlieDianaEthanFionaGeorgeHannah>>>forstudentinstudents.keys():...print(student)...AliceBobCharlieDianaEthanFionaGeorgeHannah

In these examples, you first iterate over the keys of a dictionary using the dictionary directly in the loop header. In the second loop, you use the.keys() method to iterate over the keys. Both loops are equivalent. The second loop is more explicit and readable, but it can be less efficient than the first loop because of the additional method call.

Note that in both loops, you can access the dictionary values as well:

>>>forstudentinstudents:...print(student,"->",students[student])...Alice -> 89.5Bob -> 76.0Charlie -> 92.3Diana -> 84.7Ethan -> 88.9Fiona -> 95.6George -> 73.4Hannah -> 81.2

To access the values in this type of iteration, you can use the original dictionary and a key lookup operation, as shown in the highlighted line.

Iterating Over Dictionary Values

When it comes to iterating through dictionary values, you can use the.values() method to feed the loop. To illustrate, say that you’re working with theMLB_teams dictionary and need to iterate over the team names only:

>>>MLB_teams={..."Colorado":"Rockies",..."Chicago":"White Sox",..."Boston":"Red Sox",..."Minnesota":"Twins",..."Milwaukee":"Brewers",..."Seattle":"Mariners",...}>>>forteaminMLB_teams.values():...print(team)...RockiesWhite SoxRed SoxTwinsBrewersMariners

To iterate over the values of a dictionary, you can use the.values() method. In this example, you iterate over the registered MLB teams one by one. Note that when you use the.values() method, you can’t access the dictionary keys.

Looping Through Dictionary Items

Finally, in many cases, you’ll need to iterate over both keys and values in a Python dictionary. In this case, the recommended and most Pythonic approach is to use the.items() method:

>>>forplace,teaminMLB_teams.items():...print(place,"->",team)...Colorado -> RockiesChicago -> White SoxBoston -> Red SoxMinnesota -> TwinsMilwaukee -> BrewersSeattle -> Mariners

When iterating over keys and values this way, you typically use a tuple of loop variables. The first variable will get the key, while the second will get the associated value. In this example, you have theplace andteam variables, which make the code clear and readable.