python字典dict入门 python 字典用法
了解如何在 Python 中遍历字典
作为 Python 开发人员，您经常会遇到这样的情况：在对现有字典的键值对执行某些操作时，您需要遍历现有字典。 。
当谈到在 Python 中迭代字典时， 使用 for 循环迭代字典及其键、值和项的基础知识。
直接遍历字典
Python 的字典有一些特殊的方法，Python 在内部使用这些方法来执行一些操作。这些方法使用在方法名称的开头和结尾添加双下划线的命名约定。
您可以使用内置的 dir（） 函数来获取任何 Python 对象提供的方法和属性的列表。如果使用空字典作为参数运行，则将获得 dict 类的所有方法和属性：dir()
>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]
对于 Python 字典，默认情况下，.__iter__（） 允许对键进行直接迭
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> for key in likes:
... print(key)
...
color
fruit
pet根据key来遍历dict
>>> for key in likes:
... print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog使用items遍历dict
>>> for item in likes.items():
... print(item)
... print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>>>> for item in likes.items():
... print(item)
... print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>获取idct的所有keys
>>> for item in likes.items():
... print(item)
... print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>获取所有的velues
likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
likes.values()>>> for value in likes.values():
... print(value)
...
blue
apple
dog遍历dict时修改值
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit, price in fruits.items():
... fruits[fruit] = round(price * 0.9, 2)
...
>>> fruits
{'apple': 0.36, 'orange': 0.32, 'banana': 0.23}安全地删除dict中的item
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits.copy():
... if fruits[fruit] >= 0.30:
... del fruits[fruit]
...
>>> fruits
{'banana': 0.25} 如果使用下面的方式删除dict中的item会出错
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits:
... if fruits[fruit] >= 0.30:
... del fruits[fruit]
...
Traceback (most recent call last):
File "<input>", line 1, in <module>
for fruit in fruits:
RuntimeError: dictionary changed size during iteration使用for循环来遍历dict
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits:
... if fruits[fruit] >= 0.30:
... del fruits[fruit]
...
Traceback (most recent call last):
File "<input>", line 1, in <module>
for fruit in fruits:
RuntimeError: dictionary changed size during iteration获取部分key
How to Iterate Through a Dictionary in Python
How to Iterate Through a Dictionary in Python
by Leodanis Pozo Ramos Nov 23, 2024 intermediate python
Table of Contents
Getting Started With Python Dictionaries
Understanding How to Iterate Through a Dictionary in Python
Traversing a Dictionary Directly
Looping Over Dictionary Items: The .items() Method
Iterating Through Dictionary Keys: The .keys() Method
Walking Through Dictionary Values: The .values() Method
Changing Dictionary Values During Iteration
Safely Removing Items From a Dictionary During Iteration
Iterating Through Dictionaries: for Loop Examples
Filtering Items by Their Value
Running Calculations With Keys and Values
Swapping Keys and Values Through Iteration
Iterating Through Dictionaries: Comprehension Examples
Filtering Items by Their Value: Revisited
Swapping Keys and Values Through Iteration: Revisited
Traversing a Dictionary in Sorted and Reverse Order
Iterating Over Sorted Keys
Looping Through Sorted Values
Sorting a Dictionary With a Comprehension
Iterating Through a Dictionary in Reverse-Sorted Order
Traversing a Dictionary in Reverse Order
Iterating Over a Dictionary Destructively With .popitem()
Using Built-in Functions to Implicitly Iterate Through Dictionaries
Applying a Transformation to a Dictionary’s Items: map()
Filtering Items in a Dictionary: filter()
Traversing Multiple Dictionaries as One
Iterating Through Multiple Dictionaries With ChainMap
Iterating Through a Chain of Dictionaries With chain()
Looping Over Merged Dictionaries: The Unpacking Operator (**)
Frequently Asked Questions
Remove ads
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: Python Dictionary Iteration: Advanced Tips & Tricks
Python offers several ways to iterate through a dictionary, such as using .items() to access key-value pairs directly and .values() to retrieve values only.
By understanding these techniques, you’ll be able to efficiently access and manipulate dictionary data. Whether you’re updating the contents of a dictionary or filtering data, this guide will equip you with the tools you need.
By the end of this tutorial, you’ll understand that:
You can directly iterate over the keys of a Python dictionary using a for loop and access values with dict_object[key].
You can iterate through a Python dictionary in different ways using the dictionary methods .keys(), .values(), and .items().
You should use .items() to access key-value pairs when iterating through a Python dictionary.
The fastest way to access both keys and values when you iterate over a dictionary in Python is to use .items() with tuple unpacking.
To get the most out of this tutorial, you should have a basic understanding of Python dictionaries, know how to use Python for loops, and be familiar with comprehensions. Knowing other tools like the built-in map() and filter() functions, as well as the itertools and collections modules, is also a plus.
Get Your Code: Click here to download the sample code that shows you how to iterate through a dictionary with Python.
Take the Quiz: Test your knowledge with our interactive “Python Dictionary Iteration” quiz. You’ll receive a score upon completion to help you track your learning progress:
How to Iterate Through a Dictionary in Python
Interactive Quiz
Python Dictionary Iteration
Dictionaries are one of the most important and useful data structures in Python. Learning how to iterate through a Dictionary can help you solve a wide variety of programming problems in an efficient way. Test your understanding on how you can use them better!
Getting Started With Python Dictionaries
Dictionaries are a cornerstone of Python. Many aspects of the language are built around dictionaries. Modules, classes, objects, globals(), and locals() are all examples of how dictionaries are deeply wired into Python’s implementation.
Here’s how the Python official documentation defines a dictionary:
An associative array, where arbitrary keys are mapped to values. The keys can be any object with __hash__() and __eq__() methods. (Source)
There are a couple of points to notice in this definition:
Dictionaries map keys to values and store them in an array or collection. The key-value pairs are commonly known as items.
Dictionary keys must be of a hashable type, which means that they must have a hash value that never changes during the key’s lifetime.
Unlike sequences, which are iterables that support element access using integer indices, dictionaries are indexed by keys. This means that you can access the values stored in a dictionary using the associated key rather than an integer index.
The keys in a dictionary are much like a set, which is a collection of hashable and unique objects. Because the keys need to be hashable, you can’t use mutable objects as dictionary keys.
On the other hand, dictionary values can be of any Python type, whether they’re hashable or not. There are literally no restrictions for values. You can use anything as a value in a Python dictionary.
Note: The concepts and topics that you’ll learn about in this section and throughout this tutorial refer to the CPython implementation of Python. Other implementations, such as PyPy, IronPython, and Jython, could exhibit different dictionary behaviors and features that are beyond the scope of this tutorial.
Before Python 3.6, dictionaries were unordered data structures. This means that the order of items typically wouldn’t match the insertion order:
>>> # Python 3.5
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes
{'color': 'blue', 'pet': 'dog', 'fruit': 'apple'}
Note how the order of items in the resulting dictionary doesn’t match the order in which you originally inserted the items.
In Python 3.6 and greater, the keys and values of a dictionary retain the same order in which you insert them into the underlying dictionary. From 3.6 onward, dictionaries are compact ordered data structures:
>>> # Python 3.6
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}
Keeping the items in order is a pretty useful feature. However, if you work with code that supports older Python versions, then you must not rely on this feature, because it can generate buggy behaviors. With newer versions, it’s completely safe to rely on the feature.
Another important feature of dictionaries is that they’re mutable data types. This means that you can add, delete, and update their items in place as needed. It’s worth noting that this mutability also means that you can’t use a dictionary as a key in another dictionary.
Remove ads
Understanding How to Iterate Through a Dictionary in Python
As a Python developer, you’ll often be in situations where you need to iterate through an existing dictionary while you perform some actions on its key-value pairs. So, it’s important for you to learn about the different options for dictionary iteration in Python.
When it comes to iterating through a dictionary in Python, the language provides some great tools and techniques to help you out. You’ll learn about several of these tools and techniques in this tutorial. To start off, you’ll learn the basics of iterating over dictionaries and their keys, values, and items using for loops.
Traversing a Dictionary Directly
Python’s dictionaries have some special methods that Python uses internally to perform some operations. These methods use the naming convention of adding a double underscore at the beginning of and at the end of the method’s name.
You can use the built-in dir() function to get a list of methods and attributes that any Python object provides. If you run dir() with an empty dictionary as an argument, then you’ll get all the methods and attributes of the dict class:
>>> dir({})
['__class__', '__contains__', '__delattr__', ... , '__iter__', ...]
A closer look at the previous output reveals the '__iter__' entry, which is a method that Python automatically calls when you require an iterator for a container data type. This method should return a new iterator object, which allows you to iterate through all the items in the underlying container type.
For Python dictionaries, .__iter__() allows direct iteration over the keys by default. This means that if you use a dictionary directly in a for loop, Python will automatically call .__iter__() on that dictionary, and you’ll get an iterator that goes over its keys:
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> for key in likes:
... print(key)
...
color
fruit
pet
Python is smart enough to know that likes is a dictionary and that it implements .__iter__(). In this example, Python calls .__iter__() automatically, and this allows you to iterate over the keys of likes without further effort on your side.
This is the primary way to iterate through a dictionary in Python. You just need to put the dictionary directly into a for loop, and you’re done!
If you use this approach along with the [key] operator, then you can access the values of your dictionary while you loop through the keys:
>>> for key in likes:
... print(key, "->", likes[key])
...
color -> blue
fruit -> apple
pet -> dog
In this example, you use key and likes[key] at the same time to access your target dictionary’s keys and the values, respectively. This technique enables you to perform different operations on both the keys and the values of likes.
Even though iterating through a dictionary directly is pretty straightforward in Python, you’ll often find that dictionaries provide more convenient and explicit tools to achieve the same result. That’s the case with the .items() method, which defines a quick way to iterate over the items or key-value pairs of a dictionary.
Looping Over Dictionary Items: The .items() Method
When you’re working with dictionaries, iterating over both the keys and values at the same time may be a common requirement. The .items() method allows you to do exactly that. The method returns a view object containing the dictionary’s items as key-value tuples:
>>> likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
>>> likes.items()
dict_items([('color', 'blue'), ('fruit', 'apple'), ('pet', 'dog')])
Dictionary view objects provide a dynamic view of the dictionary’s items. Here, dynamic means that when the dictionary changes, the views reflect those changes.
Views are iterable, so you can iterate through the items of a dictionary using the view object that results from calling .items(), as you can see in the example below:
>>> for item in likes.items():
... print(item)
...
('color', 'blue')
('fruit', 'apple')
('pet', 'dog')
In this example, .items() returns a view object that yields key-value pairs one at a time and allows you to iterate through them.
If you take a closer look at the individual items that .items() yields, then you’ll note that they’re tuple objects:
>>> for item in likes.items():
... print(item)
... print(type(item))
...
('color', 'blue')
<class 'tuple'>
('fruit', 'apple')
<class 'tuple'>
('pet', 'dog')
<class 'tuple'>
In this updated loop, you use the built-in type() function to check the data type of every item that .items() yields. As you can confirm in the loop’s output, all the items are tuples. Once you know this, you can use tuple unpacking to iterate through the keys and values in parallel.
To achieve parallel iteration through keys and values, you just need to unpack the elements of every item into two different variables, one for the key and another for the value:
>>> for key, value in likes.items():
... print(key, "->", value)
...
color -> blue
fruit -> apple
pet -> dog
The key and value variables in the header of your for loop do the unpacking. Every time the loop runs, key gets a reference to the current key, and value gets a reference to the value. This way, you have more control over the dictionary content. Therefore, you’ll be able to process the keys and values separately in a readable and Pythonic manner.
Remove ads
Iterating Through Dictionary Keys: The .keys() Method
Python dictionaries offer a second way for you to iterate through their keys. Apart from using the target dictionary directly in a loop, you can also use the .keys() method. This method returns a view object containing only the dictionary keys:
likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
likes.keys()
The .keys() method returns an object that provides a dynamic view of the keys in likes. You can use this view object to iterate through the dictionary keys. To do this, call .keys() in the header of a for loop:
>>> for key in likes.keys():
... print(key)
...
color
fruit
pet
When you call .keys() on likes, you get a view of keys. Python knows that view objects are iterable, so it starts looping.
You might wonder why you’d use .keys() instead of just iterating over the dictionary directly. The quick answer is that using .keys() explicitly allows you to better communicate the intention of iterating over the keys only.
Walking Through Dictionary Values: The .values() Method
Another common need that you’ll face when iterating through dictionaries is to loop over the values only. The way to do that is to use the .values() method, which returns a view with the values in the underlying dictionary:
likes = {"color": "blue", "fruit": "apple", "pet": "dog"}
likes.values()
In this code, .values() returns a view object that yields values from likes. As with other view objects, the result of .values() is also iterable, so you can use it in a loop:
>>> for value in likes.values():
... print(value)
...
blue
apple
dog
Using .values(), you only have access to the values of your target dictionary, likes. Note that this iteration tool doesn’t give you access to the key associated with each value. So, you should use this technique if you only need to access the values in the target dictionary.
Changing Dictionary Values During Iteration
Sometimes you’ll need to change the values in a dictionary while you iterate through them in Python. In the following example, you update the price of a bunch of products in a dictionary:
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit, price in fruits.items():
... fruits[fruit] = round(price * 0.9, 2)
...
>>> fruits
{'apple': 0.36, 'orange': 0.32, 'banana': 0.23}
In this example, you use the expression fruits[fruit] = round(price * 0.9, 2) to modify the values of fruits and apply a 10 percent discount.
A subtle detail to note in the above example is that to update the values, you use the original dictionary instead of just updating the current price directly with something like price = round(price * 0.9, 2). Why do you need fruits[fruit] if you have direct access to price? Is it possible to update price directly?
The real problem is that reassigning fruit or price doesn’t reflect in the original dictionary. What really happens is that you’ll lose the reference to the dictionary component without changing anything in the dictionary.
Safely Removing Items From a Dictionary During Iteration
Because Python dictionaries are mutable, you can remove existing key-value pairs from them as needed. In the following example, you remove an item selectively, according to its specific value. Note that to safely shrink a dictionary while iterating through it, you need to use a copy:
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits.copy():
... if fruits[fruit] >= 0.30:
... del fruits[fruit]
...
>>> fruits
{'banana': 0.25}
In this example, you use .copy() to create a shallow copy of your target dictionary, fruits. Then you loop over the copy while removing items from the original dictionary. In the example, you use the del statement to remove dictionary items. However, you can also use .pop() with the target key as an argument.
If you don’t use a copy of your target dictionary while trying to remove items in a loop, then you get an error:
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> for fruit in fruits:
... if fruits[fruit] >= 0.30:
... del fruits[fruit]
...
Traceback (most recent call last):
File "<input>", line 1, in <module>
for fruit in fruits:
RuntimeError: dictionary changed size during iteration
When you try to remove an item from a dictionary during iteration, Python raises a RuntimeError. Because the original dictionary has changed its size, it’s ambigous how to continue the iteration. So, to avoid this issue, always use a copy of your dictionary in the iteration.
Remove ads
Iterating Through Dictionaries: for Loop Examples
So far, you’ve learned the basic ways to iterate through a dictionary in Python. You now know how to iterate over dictionary keys, values, and items using different tools and techniques. It’s time to move on and write some examples of what you can do with the content of a dictionary while you iterate through it in a for loop.
Note: In the section on comprehension examples, you’ll learn that you can also use comprehensions to solve the same problems in a more concise way.
To kick things off, you’ll start with an example of how to filter dictionary items by value using a for loop.
Filtering Items by Their Value
Sometimes, you’ll be in situations where you have a dictionary and want to create a new one that only contains the data that satisfies a given condition. You can do this with a conditional statement while you traverse the dictionary. Consider the following toy example:
numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
small_numbers = {}
for key, value in numbers.items():
if value <= 2:
small_numbers[key] = value
small_numbers
In this example, you filter the items with a value less than 2 and add them to your small_numbers dictionary. This new dictionary only contains the items that satisfy the condition value <= 2, which is your filtering condition.
There’s another technique that you can use to filter items from a dictionary. Key view objects are like Python sets. So, they support set operations, such as union, intersection, and difference. You can take advantage of this set-like behavior to filter certain keys from a dictionary.
For example, in the code below, you use a set difference to filter out the citrus from your fruits dictionary:
>>> fruits = {"apple": 0.40, "orange": 0.35, "banana": 0.25}
>>> fruits.keys() - {"orange"}
{'apple', 'banana'}遍历部分dict的item
>>> non_citrus = {}
>>> for key in fruits.keys() - {"orange"}:
... non_citrus[key] = fruits[key]
...
>>> non_citrus
{'apple': 0.4, 'banana': 0.25}使用zip构造dict
>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
>>> likes = {key: value for key, value in zip(categories, objects)}
>>> likes
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}简化的方式
>>> categories = ["color", "fruit", "pet"]
>>> objects = ["blue", "apple", "dog"]
>>> dict(zip(categories, objects))
{'color': 'blue', 'fruit': 'apple', 'pet': 'dog'}字典数据过滤filter
>>> numbers = {"one": 1, "two": 2, "three": 3, "four": 4}
>>> {key: value for key, value in numbers.items() if value <= 2}
{'one': 1, 'two': 2}字典排序输出
>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> for fruit in sorted(incomes):
... print(fruit, "->", incomes[fruit])
...
apple -> 5600.0
banana -> 5000.0
orange -> 3500.0自定义排序
>>> incomes = {"apple": 5600.00, "orange": 3500.00, "banana": 5000.00}
>>> for fruit in sorted(incomes):
... print(fruit, "->", incomes[fruit])
...
apple -> 5600.0
banana -> 5000.0
orange -> 3500.0