Python for dict

How to Iterate Through a Dictionary in Python

Table of Contents

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

Dictionaries are one of the most important and useful data structures in Python. They can help you solve a wide variety of programming problems. This tutorial will take you on a deep dive into how to iterate through a dictionary in Python.

By the end of this tutorial, you’ll know:

For more information on dictionaries, you can check out the following resources:

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

Take the Quiz: Test your knowledge with our interactive “Python Dictionary Iteration” quiz. Upon completion you will receive a score so you can track your learning progress over time:

A Few Words on Dictionaries

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 points to keep in mind:

Dictionaries are frequently used for solving all kinds of programming problems, so they are a fundamental piece of your tool kit as a Python developer.

Unlike sequences, which are iterables that support element access using integer indices, dictionaries are indexed by keys.

On the other hand, values can be of any Python type, whether they are hashable or not. There are literally no restrictions for values.

In Python 3.6 and beyond, the keys and values of a dictionary are iterated over in the same order in which they were created. However, this behavior may vary across different Python versions, and it depends on the dictionary’s history of insertions and deletions.

In Python 2.7, dictionaries are unordered structures. The order of the dictionaries’ items is scrambled. This means that the order of the items is deterministic and repeatable. Let’s see an example:

If you leave the interpreter and open a new interactive session later, you’ll get the same item order:

A closer look at these two outputs shows you that the resulting order is exactly the same in both cases. That’s why you can say that the ordering is deterministic.

In Python 3.5, dictionaries are still unordered, but this time, randomized data structures. This means that every time you re-run the dictionary, you’ll get a different items order. Let’s take a look:

If you enter a new interactive session, then you’ll get the following:

This time, you can see that the order of the items is different in both outputs. That’s why you can say they are randomized data structures.

In Python 3.6 and beyond, dictionaries are ordered data structures, which means that they keep their elements in the same order in which they were introduced, as you can see here:

This is a relatively new feature of Python’s dictionaries, and it’s a very useful one. But if you’re writing code that is supposed to be run in different Python versions, then you must not rely on this feature, because it can generate buggy behaviors.

Another important feature of dictionaries is that they are mutable data structures, which means that you can add, delete, and update their items. It’s worth noting that this also means that they can’t be used as keys to other dictionaries, as they are not hashable objects.

Note: Everything you’ve learned in this section is related to the core Python implementation, CPython.

Other Python implementations, like PyPy, IronPython or Jython, could exhibit different dictionary behaviors and features that are beyond the scope of this article.

How to Iterate Through a Dictionary in Python: The Basics

Dictionaries are an useful and widely used data structure in Python. As a Python coder, you’ll often be in situations where you’ll need to iterate through a dictionary in Python, while you perform some actions on its key-value pairs.

When it comes to iterating through a dictionary in Python, the language provides you with some great tools that we’ll cover in this article.

Iterating Through Keys Directly

Python’s dictionaries are mapping objects. This means that they inherit some special methods, which Python uses internally to perform some operations. These methods are named using the naming convention of adding a double underscore at the beginning of and at the end of the method’s name.

This is the simplest way to iterate through a dictionary in Python. Just put it directly into a for loop, and you’re done!

If you use this approach along with a small trick, then you can process the keys and values of any dictionary. The trick consists of using the indexing operator [] with the dictionary and its keys to get access to the values:

The preceding code allowed you to get access to the keys ( key ) and the values ( a_dictPython for dict ) of a_dict at the same time. This way, you can do any operation with both the keys and the values.

Dictionary views like d_items provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the views reflect these changes.

Once you know this, you can use tuple unpacking to iterate through the keys and values of the dictionary you are working with. To achieve this, you just need to unpack the elements of every item into two different variables representing the key and the value:

Here, the variables key and value in the header of your for loop do the unpacking. Every time the loop runs, key will store the key, and value will store the value of the item that is been processed. This way, you’ll have more control over the items of the dictionary, and you’ll be able to process the keys and values separately and in a way that is more readable and Pythonic.

On the other hand, using the same trick you’ve seen before (indexing operator [] ), you can get access to the values of the dictionary:

This way you’ve gotten access to the keys ( key ) and values ( a_dictPython for dict ) of a_dict at the same time, and you’ll be able to perform any action on them.

It’s worth noting that they also support membership tests ( in ), which is an important feature if you’re trying to know if a specific element is in a dictionary or not:

The membership test using in returns True if the key (or value or item) is present in the dictionary you’re testing, and returns False otherwise. The membership test allows you to not iterate through a dictionary in Python if you just want to know if certain key (or value or item) is present in a dictionary or not.

Modifying Values and Keys

It can be pretty common to need to modify the values and keys when you’re iterating through a dictionary in Python. There are some points you’ll need to take into account to accomplish this task.

The values, for example, can be modified whenever you need, but you’ll need to use the original dictionary and the key that maps the value you want to modify:

So why do you have to use the original dictionary if you have access to its key ( k ) and its values ( v )? Should you be able to modify them directly?

The real problem is that k and v changes aren’t reflected in the original dictionary. That is, if you modify any of them ( k or v ) directly inside the loop, then what really happens is that you’ll lose the reference to the relevant dictionary component without changing anything in the dictionary.

This approach may have some performance implications, mainly related to memory consumption. For example, instead of a view object that yields elements on demand, you’ll have an entire new list in your system’s memory. However, this could be a safe way to modify the keys while you iterate through a dictionary in Python.

Real-World Examples

So far, you’ve seen the more basic ways of iterating through a dictionary in Python. Now it’s time to see how you can perform some actions with the items of a dictionary during iteration. Let’s look at some real-world examples.

Note: Later on in this article, you’ll see another way of solving these very same problems by using other Python tools.

Turning Keys Into Values and Vice Versa

Suppose you have a dictionary and for some reason need to turn keys into values and vice versa. In this situation, you can use a for loop to iterate through the dictionary and build the new dictionary by using the keys as values and vice versa:

The expression new_dict[value] = key did all the work for you by turning the keys into values and using the values as keys. For this code to work, the data stored in the original values must be of a hashable data type.

Filtering Items

Sometimes you’ll be in situations where you have a dictionary and you want to create a new one to store only the data that satisfies a given condition. You can do this with an if statement inside a for loop as follows:

Doing Some Calculations

It’s also common to need to do some calculations while you iterate through a dictionary in Python. Suppose you’ve stored the data for your company’s sales in a dictionary, and now you want to know the total income of the year.

To solve this problem you could define a variable with an initial value of zero. Then, you can accumulate every value of your dictionary in that variable:

Using Comprehensions

A dictionary comprehension is a compact way to process all or part of the elements in a collection and return a dictionary as a results. In contrast to list comprehensions, they need two expressions separated with a colon followed by for and if (optional) clauses. When a dictionary comprehension is run, the resulting key-value pairs are inserted into a new dictionary in the same order in which they were produced.

Suppose, for example, that you have two lists of data, and you need to create a new dictionary from them. In this case, you can use Python’s zip(*iterables) to loop over the elements of both lists in pairs:

Dictionary comprehensions open up a wide spectrum of new possibilities and provide you with a great tool to iterate through a dictionary in Python.

Turning Keys Into Values and Vice Versa: Revisited

If you take another look at the problem of turning keys into values and vice versa, you’ll see that you could write a more Pythonic and efficient solution by using a dictionary comprehension:

With this dictionary comprehension, you’ve created a totally new dictionary where the keys have taken the place of the values and vice versa. This new approach gave you the ability to write more readable, succinct, efficient, and Pythonic code.

Filtering Items: Revisited

Now new_dict contains only the items that satisfy your condition. Compared to the previous solutions, this one is more Pythonic and efficient.

Doing Some Calculations: Revisited

Remember the example with the company’s sales? If you use a list comprehension to iterate through the dictionary’s values, then you’ll get code that is more compact, fast, and Pythonic:

If you’re working with a really large dictionary, and memory usage is a problem for you, then you can use a generator expression instead of a list comprehension. A generator expression is an expression that returns an iterator. It looks like a list comprehension, but instead of brackets you need to use parentheses to define it:

If you change the square brackets for a pair of parentheses (the parentheses of sum() here), you’ll be turning the list comprehension into a generator expression, and your code will be memory efficient, because generator expressions yield elements on demand. Instead of creating and storing the whole list in memory, you’ll only have to store one element at a time.

Note: If you are totally new to generator expressions, you can take a look at Introduction to Python Generators and Python Generators 101 to get a better understanding of the topic.

Finally, there is a simpler way to solve this problem by just using incomes.values() directly as an argument to sum() :

Removing Specific Items

Now, suppose you have a dictionary and need to create a new one with selected keys removed. Remember how key-view objects are like sets? Well, these similarities go beyond just being collections of hashable and unique objects. Key-view objects also support common set operations. Let’s see how you can take advantage of this to remove specific items in a dictionary:

Sorting a Dictionary

It’s often necessary to sort the elements of a collection. Since Python 3.6, dictionaries are ordered data structures, so if you use Python 3.6 (and beyond), you’ll be able to sort the items of any dictionary by using sorted() and with the help of a dictionary comprehension:

For more information on how to fine-tune your sorting, check out Sorting a Python Dictionary: Values, Keys, and More.

Iterating in Sorted Order

Let’s see how you can use sorted() to iterate through a dictionary in Python when you need to do it in sorted order.

Sorted by Keys

In this example, you sorted the dictionary (alphabetically) by keys using sorted(incomes) in the header of the for loop. Notice that you can also use sorted(incomes.keys()) to get the same result. In both cases, you’ll get a list containing the keys of your dictionary in sorted order.

Note: The sorting order will depend on the data type you are using for keys or values and the internal rules that Python uses to sort those data types.

Sorted by Values

The key keyword argument specifies a function of one argument that is used to extract a comparison key from each element you’re processing.

To sort the items of a dictionary by values, you can write a function that returns the value of each item and use this function as the key argument to sorted() :

Reversed

Here, you iterated over the keys of incomes in reverse order by using sorted(incomes, reverse=True) in the header of the for loop.

Finally, it’s important to note that sorted() doesn’t really modify the order of the underlying dictionary. What really happen is that sorted() creates an independent list with its element in sorted order, so incomes remains the same:

Here, you used a while loop instead of a for loop. The reason for this is that it’s never safe to iterate through a dictionary in Python if you pretend to modify it this way, that is, if you’re deleting or adding items to it.

Note: In the previous code example, you used Python’s f-strings for string formatting. If you want to dive deeper into f-strings, then you can take a look at Python 3’s f-Strings: An Improved String Formatting Syntax (Guide).

If you run this script from your command-line, then you’ll get the following results:

Using Some of Python’s Built-In Functions

Python provides some built-in functions that could be useful when you’re working with collections, like dictionaries. These functions are a sort of iteration tool that provides you with another way of iterating through a dictionary in Python. Let’s see some of them.

filter()

Using collections.ChainMap

Now, suppose you have two (or more) dictionaries, and you need to iterate through them together as one. To achieve this, you can create a ChainMap object and initialize it with your dictionaries:

Using itertools

Python’s itertools is a module that provides some useful tools to perform iteration tasks. Let’s see how you can use some of them to iterate through a dictionary in Python.

Cyclic Iteration With cycle()

In the following example, you’ll be iterating through the items of a dictionary three consecutive times:

The preceding code allowed you to iterate through prices a given number of times ( 3 in this case). This cycle could be as long as you need, but you are responsible for stopping it. The if condition breaks the cycle when total_items counts down to zero.

Chained Iteration With chain()

This allows you to iterate through multiple dictionaries in a chain, like to what you did with collections.ChainMap :

Using the Dictionary Unpacking Operator ( ** )

It’s important to note that if the dictionaries you’re trying to merge have repeated or common keys, then the values of the right-most dictionary will prevail:

The pepper key is present in both dictionaries. After you merge them, the fruit_prices value for pepper ( 0.25 ) prevailed, because fruit_prices is the right-most dictionary.

Conclusion

You now know the basics of how to iterate through a dictionary in Python, as well as some more advanced techniques and strategies!

You’ve learned:

You have the tools and knowledge you’ll need to get the most out of dictionaries in Python. This will help you be more efficient and effective in your use of dictionary iteration in the future.

Take the Quiz: Test your knowledge with our interactive “Python Dictionary Iteration” quiz. Upon completion you will receive a score so you can track your learning progress over time:

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

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 Leodanis Pozo Ramos

Leodanis is an industrial engineer who loves Python and software development. He’s a self-taught Python developer with 6+ years of experience. He’s an avid technical writer with a growing number of articles published on Real Python and other sites.

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:

3 Ways To Iterate Over Python Dictionaries Using For Loops

…and other answers to the most popular Stack Overflow questions on Python dictionaries.

Hope you’ll find them useful too! Now enjoy the article 😀

Introduction

A Python dictionary is defined as a collection of data values, in which items are held as key-value pairs. For this reason, dictionaries are also known as associative arrays.

If you are relatively new to Python, or you are preparing for your next coding round, you might have stumbled upon a number of algorithms that require to interact with dictionaries.

However, it seems that dictionaries keep generating interest not only among newbies, but also among more experienced developers. In effect, looking at the top Stack Overflow Python questions of all times, it seems that three of the most voted topics are:

In this article, I will attempt to provide you with a succinct and clear answer to each one of this questions. This will spare you from going through dozens of comments on the web.

Let’s start from the top! 👆👆🏽👆🏻

How to iterate over dictionaries using a ‘for’ loop?

To answer this question, I have created a dictionary including data of a mock online banking transaction:

Method 1: Iteration Using For Loop + Indexing

The easiest way to iterate through a dictionary in Python, is to put it directly in a for loop. Python will automatically treat transaction_data as a dictionary and allow you to iterate over its keys.

Then, to also get access to the values, you can pass each key to the dictionary using the indexing operator [] :

As you can see, the keys are not ordered alphabetically. To achieve that, you should simply pass transaction_data to the sorted() method:

This is particularly handy when you just need to iterate over the keys of a dictionary, but it can also be used in combination with the indexing operator to retrieve values:

In order to iterate over the keys and the values of the transaction_data dictionary, you just need to ‘unpack’ the two items embedded in the tuple as shown below:

Note that k and v are just standard aliases for ‘key’ and ‘value’, but you can opt for an alternative naming convention too. For example using a and b leads to the same output:

In order to unpack the key-value pairs belonging to each nested dictionary, you can use the following loop:

How to check if a given key already exists in a dictionary?

You can check membership in Python dictionaries using the in operator.

Likewise, to check if the value GBP was already assigned to a key in the dictionary, you could run:

However, the check above won’t immediately tell you if GBP is the value assigned to the send_currency key or the target_currency key. In order to confirm that, you can pass a tuple to the values() method:

If the transaction_data dictionary included hundreds of values, this would be the perfect way to check that GBP is indeed the send_currency for that specific transaction.

How to add a new keys to a dictionary?

Lastly, let’s pretend that, at some point, the Analytics Team asked you to add both the user_address and the user_email fields to the the data available in the dictionary. How would you achieve that?

There are two main method:

Conclusion

In this article, I shared 3 methods to iterate through Python dictionaries with ‘for’ loops and extract key-value pairs efficiently. However, be aware that even more ‘pythonic’ solutions exist ( i.e. dictionary comprehensions).

Despite being a relatively basic topic, “ how to iterate over Python dictionaries?”, is one of the most voted questions ever asked on Stack Overflow.

For this reason, I also answered to other two extremely popular Stack Overflow questions about checking membership and adding new key-value pairs to Python dictionaries.

My hope is that you will use this article to clarify all your doubts about dictionaries in the same place. Learning code is fun and will change your life for good, so keep learning!

A Note For My Readers

This post includes affiliate links for which I may make a small commission at no extra cost to you, should you make a purchase.

Как перебрать словарь в Python

Словари являются одной из наиболее важных и полезных структур данных в Python. Они могут помочь вам решить широкий спектр задач программирования. Из этой статьи вы узнаете, как итерировать словарь в Python.

К концу этой статьи вы узнаете:

Для получения дополнительной информации о словарях, вы можете обратиться к следующим ресурсам:

Несколько слов о словарях

Словари являются краеугольным камнем Python. Сам язык построен вокруг словарей. Модули, классы, объекты, globals(), locals(): все это словари. Словари были центральным элементом для Python с самого начала.

Официальная документация Python определяет словарь следующим образом:

Ассоциативный массив, где произвольные ключи отображаются на значения. Ключами могут быть любые объекты с методами __hash__() и __eq__(). (Источник)

Есть несколько моментов, о которых следует помнить:

Словари часто используются для решения всевозможных задач программирования, поэтому они являются фундаментальной частью инструментария разработчика Python.

В отличие от последовательностей (sequences), которые так же являются итерационными поддерживающими доступ к элементам с использованием целочисленных индексов, словари индексируются по ключам.

С другой стороны, значения могут быть любого типа Python, независимо от того, являются они хэшируемыми или нет. Там нет буквально никаких ограничений.

В Python 3.6 и более поздних версиях ключи и значения словаря перебираются в том же порядке, в котором они были созданы. Однако это поведение может отличаться в разных версиях Python и зависит от истории вставок и удалений словаря.

В Python 2.7 словари являются неупорядоченными структурами. Порядок элементом словарей неизменяемый. Это означает, что порядок элементов является детерминированным и повторяемым. Давайте посмотрим на пример:

Если вы покинете интерпритатор и позже откроете новый интерактивный сеанс, вы получите тот же порядок элементов:

Более внимательное рассмотрение этих двух выходных данных показывает, что результирующий порядок в обоих случаях одинаков. Вот почему вы можете сказать, что порядок является детерминированным.

В Python 3.5 словари все еще неупорядочены, но на этот раз рандомизированные структуры данных. Это означает, что каждый раз, когда вы снова запускаете словарь, вы получаете другой порядок элементов. Давайте посмотрим:

Если вы войдете в новый интерактивный сеанс, вы получите следующее:

На этот раз вы можете видеть, что порядок элементов отличается на обоих выходах. Вот почему вы можете сказать, что это рандомизированные структуры данных.

В Python 3.6 и более поздних версиях словари являются упорядоченными структурами данных, что означает, что они хранят свои элементы в том же порядке, в котором они были созданы, как вы можете видеть здесь:

Это относительно новая функция словарей Python, и она очень полезна. Но если вы пишете код, который может быть запущен в разных версиях Python, вы не должны полагаться на этот функционал, поскольку он может генерировать некорректное поведение.

Другой важной особенностью словарей является то, что они являются изменчивыми структурами данных, что означает, что вы можете добавлять, удалять и обновлять их элементы. Стоит отметить, что это также означает, что их нельзя использовать в качестве ключей для других словарей, так как они не являются объектами, которые можно хэшировать.

Примечание. Все, что описано в этом разделе, относится к базовой реализации Python, CPython.

Другие реализации Python, такие как PyPy, IronPython или Jython, могут демонстрировать другое поведение словаря, которые выходят за рамки данной статьи.

Как перебирать словарь в Python: основы

Словари являются полезной и широко используемой структурой данных в Python. Как программист Python, вы часто будете в ситуациях, когда вам придется перебирать словарь, в то время как вы выполняете некоторые действия над его парами ключ-значение.

Когда дело доходит до перебора словаря в Python, язык предоставляет вам несколько отличных инструментов, которые мы рассмотрим в этой статье.

Прямая итерация по ключам

Словари Python являются отображающими объектами. Это означает, что они наследуют некоторые специальные методы, которые Python внутренне использует для выполнения некоторых операций. Эти методы называются с использованием соглашения об именах, заключающегося в добавлении двойного подчеркивания в начале и в конце имени метода.

Чтобы визуализировать методы и атрибуты любого объекта Python, вы можете использовать dir(), которая является встроенной функцией. Если вы запустите dir() с пустым словарем в качестве аргумента, вы сможете увидеть все методы и атрибуты, которые реализуют словари:

Если вы внимательно посмотрите на предыдущий вывод, вы увидите __iter__. Это метод, который вызывается, когда для контейнера требуется итератор, и он должен возвращать новый объект итератора, который может выполнять итерацию по всем объектам в контейнере.

Примечание: вывод предыдущего кода был сокращен (…) для экономии места.

Python достаточно умен, чтобы знать, что a_dict — это словарь и что он реализует .__iter__(). В этом примере Python автоматически вызывает .__iter__(), и это позволяет вам перебирать ключи a_dict.

Это самый простой способ перебора словаря в Python. Просто поместите его прямо в цикл for, и все готово!

Если вы используете этот подход вместе с небольшой уловкой, то вы можете обрабатывать ключи и значения любого словаря. Хитрость заключается в использовании оператора индексации [] со словарем и его ключами для получения доступа к значениям:

Предыдущий код позволил вам получить доступ к ключам (key) и значениям (a_dictPython for dict) a_dict одновременно. Таким образом, вы можете выполнить любую операцию как с ключами, так и со значениями.

Когда вы работаете со словарями, вероятно, вы захотите работать как с ключами, так и со значениями. Одним из наиболее полезных способов перебора словаря в Python является использование метода .items(), который возвращает новый вид элементов словаря:

Представления словаря, такое как d_items, обеспечивают динамическое представление записей словаря, что означает, что при изменении словаря представления отражают эти изменения.

Представления могут быть перебраны для получения соответствующих данных, поэтому вы можете итерировать словарь в Python, используя объект представления, возвращаемый .items():

Объект представления, возвращаемый функцией .items(), выдает пары ключ-значение по одной и позволяет перебирать словарь, и таким образом, вы получаете доступ к ключам и значениям одновременно.

Если вы присмотритесь к отдельным элементам, полученным с помощью .items(), вы заметите, что они действительно являются кортежами объектов. Давайте посмотрим:

Вы можете использовать распаковку кортежей для перебора ключей и значений словаря. Для этого вам просто нужно распаковать элементы каждого элемента в две разные переменные, представляющие ключ и значение:

Здесь, переменные key и value в заголовке вашего цикла for распаковываются. Каждый раз, когда цикл запускается, key будет хранить ключ, а value будет хранить значение элемента, который был обработан. Таким образом, у вас будет больше контроля над элементами словаря, и вы сможете обрабатывать ключи и значения отдельно.

Примечание: обратите внимание, что .values() и .keys() возвращают объекты представления так же, как .items(), как вы увидите в следующих двух разделах.

Если вам просто нужно работать с ключами словаря, то вы можете использовать метод .keys(), который возвращает новый объект представления, содержащий ключи словаря:

Чтобы перебрать словарь в Python с помощью .keys(), вам просто нужно вызвать .keys() в заголовке цикла for:

Используя тот же трюк, который вы видели ранее (оператор индексации []), вы можете получить доступ к значениям словаря:

Таким образом, вы получите доступ к ключам (key) и значениям (a_dictPython for dict) a_dict одновременно, и вы сможете выполнять с ними любые действия.

Также можно использовать значения для перебора словаря. Один из способов сделать это — использовать .values(), который возвращает представление со значениями словаря:

В предыдущем коде values содержит ссылку на объект представления, содержащий значения a_dict.

Как и любой объект представления, объект, возвращаемый функцией .values(), также может быть итерирован. В этом случае .values() возвращает значения a_dict:

Стоит отметить, что методы keys() и values() также поддерживают тесты членства (in) (membership tests ( in )), что является важной функцией, если вы пытаетесь узнать, есть ли определенный элемент в словаре или нет:

Проверка членства с помощью in возвращает True, если ключ (или значение или элемент) присутствует в тестируемом словаре, и возвращает False в противном случае. Тест на членство позволяет вам не выполнять итерацию по словарю в Python, если вы просто хотите узнать, присутствует ли определенный словарь (или значение, или элемент) в словаре или нет.

Изменение значений и ключей

Часто бывает необходимо изменить значения и ключа, когда вы перебираете словарь в Python. Есть некоторые моменты, которые вы должны принять во внимание, чтобы выполнить эту задачу.

Например, значения можно изменять всякий раз, когда вам нужно, но вам нужно будет использовать исходный словарь и ключ, который отображает значение, которое вы хотите изменить:

В этом примере кода, чтобы изменить значения prices и применить скидку 10%, мы использовали выражение prices[k] = round(v * 0.9, 2).

Так зачем вам использовать оригинальный словарь, если у вас есть доступ к его ключу (k) и его значениям (v)? Если мы можем изменить их напрямую?

Реальная проблема заключается в том, что изменения k и v не отражаются в исходном словаре. То есть, если вы измените какой-либо из них (k или v) непосредственно внутри цикла, то, что действительно происходит, так это то, что вы потеряете ссылку на соответствующий компонент словаря, не изменяя ничего в словаре.

С другой стороны, ключи могут быть добавлены или удалены из словаря путем преобразования представления, возвращаемого функцией .keys(), в объект list:

Этот подход может иметь некоторые последствия для производительности, в основном связанные с потреблением памяти. Например, вместо объекта просмотра, который выдает элементы по требованию, у вас будет полный новый list в памяти вашей системы. Тем не менее, это может быть безопасным способом изменения ключей при переборе словаря в Python.

Наконец, если вы попытаетесь удалить ключ из prices, используя напрямую .keys(), тогда Python вызовет RuntimeError, сообщающую, что размер словаря изменился во время итерации:

Это потому, что .keys() возвращает объект словаря-представления, который выдает ключи по запросу по одному, и если вы удаляете элемент (del values Python for dict), то Python вызывает RuntimeError, потому что вы изменили словарь во время итерации.

Примечание. В Python 2 объекты .items(), .keys() и .values() возвращают список объектов. Но .iteritems(), iterkeys() и .itervalues() возвращают итераторы. Итак, если вы используете Python 2, то вы можете изменить ключи словаря, используя .keys() напрямую.

С другой стороны, если вы используете iterkeys() в своем коде Python 2 и пытаетесь изменить ключи словаря, вы получите RuntimeError.

Примеры из реального мира

До сих пор вы видели более простые способы перебора словаря в Python. Теперь пришло время посмотреть, как вы можете выполнять некоторые действия с элементами словаря во время итерации. Давайте посмотрим на некоторые примеры из реальной жизни.

Примечание. Позже в этой статье вы увидите другой способ решения тех же самых проблем с помощью других инструментов Python.

Превращение ключей в значение и наоборот

Предположим, у вас есть словарь и по какой-то причине необходимо превратить ключи в значения и наоборот. В этой ситуации вы можете использовать цикл for для перебора словаря и создания нового словаря, используя ключи в качестве значений и наоборот:

Выражение new_dict[value] = key сделает всю работу за вас, превратив ключи в значения и используя значения в качестве ключей. Чтобы этот код работал, данные, хранящиеся в исходных значениях, должны иметь тип данных, который можно хэшировать.

Фильтрация

Иногда вы будете в ситуациях, когда у вас есть словарь, и вы захотите создать новый, чтобы хранить только данные, которые удовлетворяют заданному условию. Вы можете сделать это с помощью if внутри цикла for следующим образом:

В этом примере вы отфильтровали элементы со значением больше 2. Теперь new_dict содержит только элементы, которые удовлетворяют условному значению collections — полезный модуль из стандартной библиотеки Python, предоставляющий специализированные типы данных контейнеров. Одним из таких типов данных является ChainMap, который является словарным классом для создания единого представления нескольких сопоставлений (например, словарей). С ChainMap вы можете сгруппировать несколько словарей вместе, чтобы создать одно обновляемое представление.

Теперь предположим, что у вас есть два (или более) словаря, и вам нужно перебирать их вместе как один. Для этого вы можете создать объект ChainMap и инициализировать его своими словарями:

После импорта ChainMap из collections вам необходимо создать объект ChainMap со словарями, которые вы хотите объединить в цепочку, а затем вы можете свободно перебирать полученный объект, как если бы вы делали это с обычным словарем.

Объекты ChainMap также реализуют .keys(), values() и .items(), как это делает стандартный словарь, поэтому вы можете использовать эти методы для итерации по словарному объекту, сгенерированному ChainMap, точно так же, как вы это делаете с обычным словарь:

В этом случае мы вызвали .items() для объекта ChainMap. Объект ChainMap вел себя так, как будто это был обычный словарь, а .items() возвращает объект представления словаря, который можно перебирать как обычно.

Использование itertools

Iterotools — модуль, который предоставляет некоторые полезные инструменты для выполнения итерационных задач. Давайте посмотрим, как можно использовать некоторые из них для перебора словаря в Python.

Циклическая итерация с помощью cycle()

Предположим, вы хотите перебрать словарь в Python, но вам нужно перебирать его несколько раз в одном цикле. Чтобы выполнить эту задачу, вы можете использовать itertools.cycle(iterable), который заставляет итератор возвращать элементы из iterable и сохранять копию каждого из них. Когда итерация исчерпана, cycle() возвращает элементы из сохраненной копии. Это выполняется циклически, поэтому вы можете остановить цикл.

В следующем примере вы будете перебирать элементы словаря три раза подряд:

Этот код перебирает prices определенное количество раз (в данном случае 3). Этот цикл может длиться столько, сколько нужно, но вы должны позаботиться о его остановке. Условие if прерывает цикл, когда total_items ведет обратный отсчет до нуля.

Итерация с chain()

itertools также предоставляет функцию chain(*iterables), которая получает некоторые итерируемые аргументы в качестве аргументов и создает итератор, который возвращает элементы из итерируемого объекта до тех пор, пока он не будет исчерпан, а затем итерирует по следующему итерируемуго объекту и т. д., пока все они не будут исчерпаны.

Это позволяет вам перебирать несколько словарей в цепочке, как в случае с collections.ChainMap:

В приведенном выше коде chain() вернула итерацию, которая объединила элементы из fruit_prices и vegetable_prices.

Также возможно использовать .keys() или .values(), в зависимости от ваших потребностей, с условием быть однородным: если вы используете .keys() в качестве аргумента для chain(), то вам нужно использовать .keys( ) для остальных из них.

Использование оператора распаковки словаря (**)

Python 3.5 приносит новую и интересную функцию. PEP 448 — Additional Unpacking Generalizations могут упростить вашу жизнь, когда дело доходит до перебора нескольких словарей в Python. Давайте посмотрим, как это работает, на коротком примере.

Предположим, у вас есть два (или более) словаря, и вам нужно выполнять их итерацию вместе, без использования collection.ChainMap или itertools.chain(). В этом случае можно использовать оператор распаковки словаря (**), чтобы объединить два словаря в новый и затем выполнить итерацию по нему:

Оператор распаковки словаря (**) действительно замечательная функция в Python. Она позволяет объединить несколько словарей в один новый, как мы это делали в примере с vegetable_prices и fruit_prices. После объединения словарей с оператором распаковки вы можете перебирать новый словарь как обычно.

Важно отметить, что если словари, которые вы пытаетесь объединить, имеют повторяющиеся или общие ключи, то значения самого послденего словаря будут преобладать:

Ключ pepper присутствует в обоих словарях. После объединения их значение fruit_prices для pepper (0.25) превалирует, потому что fruit_prices — самый последний словарь.

Заключение

В этой статье мы основы того, как перебирать словарь в Python, а также некоторые более продвинутые методы и стратегии!

Вы узнали:

Эффективный обход словарей в цикле в Python

Словарь (dictionary, dict) — это ассоциативный массив, который позволяет сохранять значения по ключам.

Кроме того, словарь отлично подходит для решения множества прикладных задач, обладает хорошей вычислительной сложностью операций, так что и в вашем коде, наверняка, словари будут встречаться достаточно часто.

В Python большое внимание уделяется циклам. Правильно написанный заголовок цикла содержит много ценной информации: по чему итерируемся и какие данные будут использоваться в теле цикла. Это помогает читателю понять (или хотя бы предположить), что именно будет производиться в теле цикла, даже не смотря в него. Неправильно написанный цикл, который не выражает напрямую задумку автора, наоборот, сбивает читателя с толку и заставляет читать код целиком, возможно, даже не один раз.

Есть несколько способов обойти словарь в цикле. Очень важно научиться выбирать наиболее подходящий.

Что будет если просто попытаться обойти словарь в цикле?

Объявим словарь с отношением различных валют к российскому рублю, который нам по какой-то причине нужно обойти:

Самый очевидный вариант обхода словаря — это попытаться напрямую запустить цикл for по объекту словаря, так же как мы делаем это со списками, кортежами, строками и любыми другими итерируемыми объектами.

Словарь и правда поддерживает протокол итераций, но словарь не так прост, как другие объекты, которые мы упомянули выше. Словарь состоит из нескольких частей, ведь словарь — это отношение между ключами и значениями. Получается, что теоретически цикл по словарю может получать либо ключи, либо значения, либо пары (ключ, значение). Попробуете угадать, что же именно выведет код выше?

А выведет он следующее:

То есть обход словаря в цикле будет возвращать только ключи этого словаря.

Пожалуй, задать такое поведение по умолчанию — это очень логичное решение со стороны разработчиков Python. Было бы намного внезапнее, если бы цикл по словарю получал значения. Вариант с кортежами (ключ, значение) в качестве поведения по умолчанию мне кажется не таким уж плохим, но имеем то, что имеем.

Есть куча задач, в которых нужно обойти лишь ключи словаря, и это отличное решение для таких задач. У этого способа есть один крупный недостаток: нужно знать как работают словари. По коду совершенно неясно, что будет обходиться в цикле — ключи, значения или пары, а читатель может либо этого не знать, либо забыть, и в итоге неправильно интерпретировать код. Поэтому во избежание неоднозначности даже для обхода ключей словаря я рекомендую использовать следующий способ.

Как обойти в цикле ключи словаря?

Давайте представим, что нам нужно нарисовать какую-нибудь таблицу с валютами, и для создания шапки этой таблицы нужно получить список всех валют. Значения словаря нас не интересуют, только ключи.

Что такое представление словаря? Это некий объект, который предоставляет доступ к данным в словаре, либо к части этих данных, и работает по следующим принципам:

Создадим такое представление словаря по ключам:

Давайте добавим новый ключ в словарь:

Как видите, созданное ранее представление словаря обновилось автоматически, когда обновился его словарь.

Обратите внимание, что представление словаря — это не список, а совершенно другой объект. Представление словаря не поддерживает извлечение значений по индексам:

Зато представление словаря является итерируемым объектом и его без проблем можно обходить при помощи цикла:

Результат тот же самый, что и в предыдущем способе обхода словаря, но в этот раз явно видно, что в цикле будут обрабатываться только ключи словаря.

Обратите внимание, что если в цикле вам нужны не только ключи словаря, но и значения, то обходить словарь таким образом — не самое эффективное решение. Смотрите дальше, как можно обойти словарь, чтобы получать и ключи, и значения.

Как обойти в цикле значения словаря?

Вот как можно обойти в цикле только значения словаря, без ключей:

По значениям словаря уже невозможно получить ключи (ну, вообще можно попытаться, но для этого потребуется полный перебор словаря, и не факт, что ключи будут восстановлены правильно). Этот способ подойдёт только если в цикле используются исключительно значения словаря, а ключи не нужны.

Как обойти в цикле и ключи, и значения словаря?

Пожалуй, это самый распространённый случай. Во многих задачах, где выполняется обход словаря, в цикле используются и ключи, и соответствующие им значения.

В Python есть возможность распаковывать итерируемые объекты, такие как кортежи, в различные переменные. Давайте на примере посмотрим как это работает:

Таким образом можно распаковывать последовательности любого размера. Это намного проще, чем извлекать значения по индексам и присваивать в отдельные переменные. Этот приём можно использовать практически в любом месте программы, в том числе и в заголовке цикла.

Вот так можно обойти ключи и значения словаря, сохраняя ключ и значение в разные переменные прямо в заголовке цикла при помощи распаковки кортежа:

Заключение

При обходе словаря стоит руководствоваться следующей логикой:

Идеоматичный код проще читается и, как правило, работает быстрее.

Посмотрите запись классического выступления Реймонда Хеттингера, где он рассказывает про написание идеоматичного код. Много внимания уделяется циклам и словарям.

Обратите внимание, что это запись выступления от 2013 года, когда ещё вовсю был в ходу Python 2. В выступлении часто сравнивается Python 2 и Python 3. Не запутайтесь.

Если понравилась статья, то подпишитесь на уведомления о новых постах в блоге, чтобы ничего не пропустить!

How to Iterate Through Dictionary in Python? – Definitive Guide

Python dictionary is a data structure that allows you to store values as a key-value pair.

You can iterate through the dictionary in Python using the dict.items() method.

In this tutorial, you’ll learn how to iterate through the dictionary in Python.

If You’re in Hurry…

You can use the below code snippet to iterate over the dictionary items.

You’ll get both the key and value of each item during each iteration.

Snippet

You’ll see all the items in the dictionary are printed as below.

Output

If you’re iterating through the dictionary just to check if a specific key exists in the dictionary, check the guide How to Check If Key Exists in Dictionary.

If You Want to Understand Details, Read on…

In this tutorial, you’ll learn the different methods available to loop through the dictionary keys, values, or the items themselves.

Sample Dictionary

The above dictionary will be used for the demonstration purpose of the complete tutorial. However, tweaks will be made as required to match the demonstration of different use cases.

In most cases, you’ll iterate through the dictionary using for loop and the iterable methods provided by the dictionary to iterate through it.

Table of Contents

Using Keys() Method

You can use the keys() method provided by the dictionary to iterate through the keys of the dictionary.

Snippet

Output

Snippet 2

If you want to access the value of the key, you can use the get() method to get the value of the specific key during each iteration, as shown below.

Output

This is how you can iterate through the dictionary keys using for loop and the keys() method provided by the python dictionaries.

Using Values() Method

You can use the values() method provided by the dictionary to iterate through the values of the dictionary items.

Snippet

You’ll see the value of each item in the dictionary printed as below.

Output

Using this method will not give access to the dictionary keys() which is not necessary in most cases.

This makes this method the fastest method to iterate through the dictionary.

Using Items() method

You can iterate through the dictionary items using the items() method provided by the python dictionary.

Snippet

Output

You’ll see the below output. Keys and values will be printed for each iteration and no additional access to the dictionary is necessary to fetch the value of the key.

This is how you can access the items of the dictionary using for loop and the items() method provided by the dictionaries.

Iterating Through Keys Directly Using For Loop

You can access the items in the dictionary using the for loop directly.

It iterates through the keys of the dictionary, and this is an alternative to using the keys() method.

Snippet

When using the dictionary directly, it returns only the keys during the iteration.

You can access the value of each key by using the get() method.

Output

This is how you can loop through a dictionary using the for loop directly without using the methods provided by python dictionaries.

Iterate Over dictionary With Index

You can also iterate through the dictionary using the index of the items.

Snippet

You’ll see all the items printed as shown below.

Output

Iterate Over Dictionary In Alphabetical Order

Dictionaries typically don’t maintain any order. This means the order of the items during the iteration is not guaranteed.

To iterate a dictionary using the specific order, you can use the sorted() function in python. It’ll sort the object first and you can use for loop to iterate it.

Sort Using Dictionary Keys

In the below example,

Snippet

You’ll see the below output as the keys will be sorted alphabetically.

Output

Sort Using Dictionary Item Values

To sort the dictionary based on its values,

In the below example,

Now, this resultant dictionary will have the sorted values.

Snippet

Output

This is how you can sort dictionaries based on the values.

Iterate Over Dictionary And Update Values

Dictionary is an object which contains a list of values.

Apart from accessing the items in the dictionary, you may also need to update the values of the item in the dictionary.

In this section, you’ll learn how to iterate over dictionary and update values based on some condition.

Snippet

Once the script is executed, you’ll see the value » value updated for the key five as shown below.

Output

This is how you can loop through the dictionary and update values.

Conclusion

To summarize, you’ve learned the different methods to loop through the dictionary in python and you’ve also learned how to apply this method in different use-cases.

How to iterate through a python dictionary

A python Dictionary is one of the important data structure which is extensively used in data science and elsewhere when you want to store the data as a key-value pair. In this post we will take a deep dive into dictionaries and ways to iterate over dictionary and find out how to sort a dictionary values and other operations using dictionary data structure

Basically a dictionary in python is a mapping object where it maps a key to a value. The keys are hashable values which are mapped to values. The keys are arbitrary values and any values that are not hashable that is values containing list or other mutable types may not be used as Keys. Even it is not a good practice to use numeric values as keys also.

How to create a Dictionary?

We can create a Dictionary using key:value pairs separated by commas or using the dict constructor

Using comma separated key value pair

Using dict constructor

Convert two list into a dictionary

Convert list of tuples(Key,Value) into a dictionary

What’s Changed for Dictionary in Python 3.6

Dictionaries got ordered in Python 3.6 that means it remembers the order of insertion of key and value pairs. It means that keyword arguments can now be iterated by their creation order, which is basically the cpython implementation of python

The memory usage of this new dictionary implementation will also reduce the memory usage by 20-25%

Here is an example from the python dev mailing list for the implementation of new dict in python 3.6

Create a function to get the dictionary keys

Calling the above function in Python 3.5 and before returns an un-ordered dict_keys. Check the output the keys are randomly ordered

Output in Python 3.5 and before:

Calling the same function in python3.6 and above returns a dict_keys in the same order as it has been passed in the function

Output in Python 3.6 and above:

Iterating thru a dictionary

As a python developer or data scientists you will be working on dictionaries a lot and there are calculations or actions that needs to be performed while working through the dictionary keys and values

In this section we will see what are the ways you can retrieve the data from the dictionary

Python supports a concept of iteration over containers and An iterator needs to define two methods: iter() and next(). Usually, the object itself defines the next() method, so it just returns itself as the iterator.

the iter defines the next method which will be called by statements like for and in to yield the next item, and next() should raise the StopIteration exception when there are no more items

Hope this clears how the iterator works on the dictionary

These methods are used by for and in statements, so what it means is if you put a dictionary under a for loop then it will automatically call the iter() method and iterate over the dictionaries keys

Iterate dictionary using keys

Output:

Dictionary view objects

This provide a window of the dictionary entries and when any of the item changes in the dict then it will reflect those changes in the views

As per the python official documentation:

The objects returned by dict.keys(), dict.values() and dict.items() are view objects. They provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes

Length of Dictionary

This returns number of key,value pairs in the dictionary

list of dictionary keys

the keys() function returns dict_keys() which is wrapped with the list to get a list object.

Output:

list of dictionary values

the values() function returns dict_values() which is wrapped with the list to get a list object

Output:

Iterate thru dict values

The dict_values is an iterable so you can directly iterate through the values of dictionaries using for loop

Output:

Iterate thru dict keys

The dict_keys is an iterable so you can directly iterate through the keys of dictionaries using for loop

Output:

Iterate key, value pair using dict.items

This returns a (key,value) pair which is a tuple object.

Output:

Dictionary Comprehension

It is a syntactical extension to list comprehension. It produce a dictionary object and you can’t add keys to an existing dictionary using this

You group the expression using curly braces and the left part before the for keyword expresses both a key and a value, separated by a colon

Output:

Dictionary Get Key

Let’s understand this with a small example

Here is a dictionary of city and respective states:

We have to output the state name when user enters a city

When city is in Dictionary Key:

Output:

You live in state of North Carolina

When city is not in Dictionary Key:

Output:

You live in state of None

Unpack a Dictionary using itemgetter

You can unpack a dictionary using operator.itemgetter() function which is helpful if you want to get the values from the dictionary given a series of keys

Look at this example below we are extracting the values of keys a, b and c using itemgetter

Sorting

There are certain situations where you need to sort the dictionary either by key or values. You can achieve this using sorted() function. In the below section we will see how to sort the dictionary by keys and values

if you are using python 3.6 and above then do not worry the dictionary are ordered data structured and can be easily sorted using sorted() function inside a dictionary comprehension

Sorting Dictionary by Keys

You can pass the entire dictionary dict_items as an argument to sorted function and it will return a list of tuples after sorting which can be converted back to dictionary using the dict constructor

Output:

You can see the output the dictionary keys are sorted alphabetically

Sorting Dictionary by Values

You can also sort the dictionary with their values using the sorted() function and another argument key and value of the key parameter should be a function that takes a single argument and returns a key to use for sorting purposes

By default it gives the result in ascending order. You can see the list of keys that is returned here based on the values of each of the corresponding keys arranged in ascending order

Ascending Order

Output:

if you want the list of keys to be in descending order above then add another argument called reverse as True and this will give the keys based on their values arranged in descending order

Descending order

Output:

Enumerate Dictionary

You can also enumerate through the dictionary and can get the index of each of the key

Just remember d.keys(), d.values() returns a dict_keys object which behaves a lot more like a set than a list

Therefore, dict.values() needs to be wrapped in a list. You can see in the below code we have used list(d.values())[index]

Output:

Filter Dictionary

You can filter a dictionary using the dictionary comprehension which will create a new dictionary based on the filter criteria.

Output:

dict.pop()

If you aren’t sure about the key exists in dictionary then use dict.pop().

This will return d[‘f’] if key exists in the dictionary, and None otherwise.

If the second parameter is not specified (i.e. d.pop(‘f’)) and key does not exist, a KeyError is raised.

Merge two or more Dictionaries

You can use the dictionary unpacking operator ** to merge two or more dictionary into one single dictionary and then you can iterate this new merged dictionary

Here is an example:

Output:

Conclusion:

We have reached to the end of this comprehensive and detailed post on iterating through dictionaries. So here is what we have learned so far through our journey thru this blog

I have tried to cover all the possible ways to iterate through a dictionary and explain different ways to work with dictionary efficiently.

Still if there are anything you feel should be included in this post or can be done in more optimized way then please leave a comment below.

Updated: December 4, 2019

Share on

You may also enjoy

Pandas extract numbers and floats from string

We want to extract the numbers, float and multiple numbers from a string column in a dataframe.

Pandas Add month, days, hours, minutes, Bday (business days) and year to date and also find out first day of Month and last day of month

We want to add Month, Days, Hours, Minutes or Year offset to a date column in a dataframe and also like to see how to find out the MonthBegin and MonthEnd da.

Tensorflow available GPU and it’s details

In this post we will see how to find all the available CPU and GPU devices on the host machine and get the device details and other info like it’s Memory usa.

Pandas compare columns in two data frames

Python: Iterate / Loop over Dictionary (All key-value pairs)

In this article we will discuss different ways to iterate over all key-value pairs of a dictionary.

Table of Contents:

Suppose we have a dictionary with string as key and integers as value i.e.

Now let’s see how to iterate over this dictionary using 4 different techniques i.e.

Iterate over a dictionary using for loop over keys

A dictionary object can also be used as an iterable obejct, to iterate over all keys of dictionary. So, we can easily apply for loop on a dictionary. By using for in dictionary, it loops through all the keys in dictionary. For each key we will select the value associated with it and print them.

Output:

Its not an efficient solution because we are iterating over all the keys in dictionary and for each key we are again searching for its associated value.

Let’s see an efficient method i.e.

Iterate over key-value pairs of dictionary using dict.items()

In Python, dictionary class provides a function items(), which returns an sequence of all key-value pairs of dictionary. This sequence is an iterable View object of all key,value elements in the dictionary. Its backed by original dictionary. Let’s use this to iterate over all key-value pairs of dictionary,

Output:

As, view object is backed by original dictionary, therefore any changes made in dictionary will be reflected in it.
For example,

Take a view object of dictionary i.e.

Output

Now modify the dictionary

Now same view object will also be modified because its backed by original dictionary

Read More,

Iterate over a dictionary using list comprehension

As dictionary’s items() function returns an iterable sequence of key-value pairs, so we can also use this list comprehension to iterate over all pairs of diction. For example,

Output:

Iterate over specific key-value pairs of dictionary

We can also iterate over specific key-value pairs of dictionary, it means the pairs which satisfy a certain condition. For example, loop our pairs of dictionary, where value is greater than 20,

Output:

Summary:

We learned about four different ways to iterate over all key-value pairs of dictionary.

Are you looking to make a career in Data Science with Python?

Data Science is the future, and the future is here now. Data Scientists are now the most sought-after professionals today. To become a good Data Scientist or to make a career switch in Data Science one must possess the right skill set. We have curated a list of Best Professional Certificate in Data Science with Python. These courses will teach you the programming tools for Data Science like Pandas, NumPy, Matplotlib, Seaborn and how to use these libraries to implement Machine learning models.

Checkout the Detailed Review of Best Professional Certificate in Data Science with Python.

Remember, Data Science requires a lot of patience, persistence, and practice. So, start learning today.

Join a LinkedIn Community of Python Developers

Related Posts

Get statistics for each group using Pandas GroupBy

Get DataFrame Rows whose column has a certain value

Check if any value is NaN in a Pandas DataFrame

Add a new column to an existing DataFrame in Pandas

Select multiple columns from a DataFrame in Pandas

Select Rows from Pandas DataFrame based on column values

How to get a string after a specific substring?

How to Get a Function Name as a String in Python?

Format a floating number to fixed width in Python

Find all occurrences of a substring in a string in Python

Find a string between two substrings in Python

Convert an int to a hex String in Python

How to Convert a String to a double in Python?

Convert space delimited string to a list in Python

Convert a List to a String in Python

Convert a List of Characters into a String in Python

Convert a JSON String to a Dictionary in Python

How to Concatenate String and Integer in Python?

Check if a String is Empty in Python

How to Fill out a String with spaces in Python?

Leave a Comment Cancel Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Advertisements

Advertisements

Recent Posts

Python Tutorials

Looking for Something

C++ / C++11 Tutorials

Terms of Use

Terms and Policies

Python Tutorials

Favorite Sites

Disclaimer

Terms & Policy

Copyright © 2022 thisPointer

To provide the best experiences, we and our partners use technologies like cookies to store and/or access device information. Consenting to these technologies will allow us and our partners to process personal data such as browsing behavior or unique IDs on this site. Not consenting or withdrawing consent, may adversely affect certain features and functions.

Click below to consent to the above or make granular choices. Your choices will be applied to this site only. You can change your settings at any time, including withdrawing your consent, by using the toggles on the Cookie Policy, or by clicking on the manage consent button at the bottom of the screen.

Iterate through dictionary Python

In this Python tutorial, we will study how to iterate through a dictionary in Python using some examples in python. Moreover, we will also cover these topics.

Python iterate through dictionary Python

Syntax:

Let’s have a look at the syntax and understand the working of dict.items() function

Example:

Let’s take an example and check how to iterate a dictionary in Python.

Source Code:

In the above code, we have created a simple dictionary named ‘my_dictionary’ which contains elements in the form of key-value pairs. After that, we have used the for loop method to iterate through the key-value pair and it will operate both keys and values and return in the form of tuples.

Here is the Screenshot of the following given code.

Iterate through dictionary Python with index

Example:

Here is the execution of the following given code

Iterate through dictionary Python for loop

Example:

In the following given code, we have created a dictionary ‘Fruit’ that contains elements in the form of key-value pairs. After that, we have used the for loop and iterate each value in the dictionary.

Here is the implementation of the following given code.

Iterate through dictionary Python reverse

Syntax:

Here is the Syntax of the Python dictionary.items() function

Example:

Let’s take an example and check how to reverse the elements by iterating through the dictionary in Python

Source Code:

In the following given code, we have created a dictionary named ‘my_dictionary’ and then use the list comprehension method in which we have to assign the key and value variable to iterate with a given dictionary.

Here is the Output of the following given code.

Iterate through dictionary Python sorted

Syntax:

Here is the Syntax of the Python dictionary.keys() method

Example:

Here is the Screenshot of the following given code.

As you can see in the Screenshot the output displays the sorted keys and values.

Iterate through dictionary Python in order

Example:

Here is the implementation of the following given code.

Iterate through dictionary Python lambda

Example:

In the above code, we have created a dictionary named ‘my_dictionary’ that contains elements in the form of key-value pairs. After that, we have used the lambda function along with the dictionary.keys() method and it will iterate the keys of the given dictionary and store them into the list.

Here is the Screenshot of the following given code.

Iterate through dictionary Python with multiple values

Example:

Let’s take an example and check how to iterate a dictionary in Python with multiple values

In the following given code, we have created a dictionary named ‘new_dictionary’ that contains a single key with multiple values. After that, we have created an empty list in which all the values can be stored by using for loop and dict.items() method.

Once you will execute this code the output displays the list of pairs where the key remains the same and values are different.

Here is the Screenshot of the following given code.

Iterate through dictionary Python with list

Example:

Here is the implementation of the following given code.

Python iterate through dictionary within dictionary

Example:

Let’s take an example and check how to iterate a nested dictionary in Python.

Source Code:

In the above code, we have created a nested dictionary named ‘Country_name’, and the internal dictionary ‘A’ and ‘B’ are assigned to ‘Country_name’.

After that, we have a key name as countries name along with their random values. By using for loop and dict.items() method, we can easily extract the values from a list.

Here is the execution of the following given code.

Python iterate through dictionary of dataframes

Example:

Let’s take an example and check how to iterate a dictionary and convert them into Pandas DataFrame.

Source Code:

Here is the Screenshot of the following given code

Python iterate through dictionary and remove items

Let’s have a look at the syntax and understand the working of the del keyword

Example:

Let’s take an example and check how to iterate a dictionary and remove items from the dictionary.

Source Code:

In the following given code, we have created a dictionary that contains key-value pairs. After that, we have used the for loop method along with dict.items() function and it will iterate all the elements in the dictionary.

After iterating all the elements we have set the condition if new_val %3==0 and it will check the condition if the values are divided by 3 then it will remove from a dictionary and those who are not divided by 3 then it will return into tuple form.

Here is the implementation of the following given code

Python iterate through dictionary and change values

Example:

In the above code, we have created a dictionary that contains elements in the form of key-value pairs. After that, we have used the for-loop method for iterating the elements and set the condition if new_values==300, and it will check the condition if 300 value is available then it will update with 600 value.

You can refer to the below Screenshot.

Python iterate through dictionary sorted by key

Example:

Let’s take an example and check how to iterate a dictionary and sort by key in Python.

Source Code:

Here is the Screenshot of the following given code.

Python iterate through dictionary sorted by value

Syntax:

Here is the Syntax of dict.values() method

Example:

Here is the execution of the following given code.

You may also like to read the following Python tutorials.

In this Python tutorial, we have learned how to iterate through a dictionary in Python using some examples in python. Moreover, we have also covered these topics.

Python is one of the most popular languages in the United States of America. I have been working with Python for a long time and I have expertise in working with various libraries on Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… I have experience in working with various clients in countries like United States, Canada, United Kingdom, Australia, New Zealand, etc. Check out my profile.

Loop Through a Dictionary

You can loop through a dictionary by using a for loop.

When looping through a dictionary, the return value are the keys of the dictionary, but there are methods to return the values as well.

Example

Print all key names in the dictionary, one by one:

Example

Print all values in the dictionary, one by one:

Example

You can also use the values() method to return values of a dictionary:

Example

You can use the keys() method to return the keys of a dictionary:

Example

Loop through both keys and values, by using the items() method:

We just launched
W3Schools videos

COLOR PICKER

Get certified
by completing
a course today!

CODE GAME

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

Thank You For Helping Us!

Your message has been sent to W3Schools.

Top Tutorials

Top References

Top Examples

Web Courses

W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

Python «for» Loops (Definite Iteration)

Table of Contents

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: For Loops in Python (Definite Iteration)

This tutorial will show you how to perform definite iteration with a Python for loop.

In the previous tutorial in this introductory series, you learned the following:

Here’s what you’ll cover in this tutorial:

You’ll start with a comparison of some different paradigms used by programming languages to implement definite iteration.

Then you will learn about iterables and iterators, two concepts that form the basis of definite iteration in Python.

Finally, you’ll tie it all together and learn about Python’s for loops.

Free Download: Get a sample chapter from Python Tricks: The Book that shows you Python’s best practices with simple examples you can apply instantly to write more beautiful + Pythonic code.

A Survey of Definite Iteration in Programming

Definite iteration loops are frequently referred to as for loops because for is the keyword that is used to introduce them in nearly all programming languages, including Python.

Historically, programming languages have offered a few assorted flavors of for loop. These are briefly described in the following sections.

Numeric Range Loop

The most basic for loop is a simple numeric range statement with start and end values. The exact format varies depending on the language but typically looks something like this:

Here, the body of the loop is executed ten times. The variable i assumes the value 1 on the first iteration, 2 on the second, and so on. This sort of for loop is used in the languages BASIC, Algol, and Pascal.

Three-Expression Loop

Another form of for loop popularized by the C programming language contains three parts:

This type of loop has the following form:

This loop is interpreted as follows:

Three-expression for loops are popular because the expressions specified for the three parts can be nearly anything, so this has quite a bit more flexibility than the simpler numeric range form shown above. These for loops are also featured in the C++, Java, PHP, and Perl languages.

Collection-Based or Iterator-Based Loop

This type of loop iterates over a collection of objects, rather than specifying numeric values or conditions:

Further Reading: See the For loop Wikipedia page for an in-depth look at the implementation of definite iteration across programming languages.

The Python for Loop

Of the loop types listed above, Python only implements the last: collection-based iteration. At first blush, that may seem like a raw deal, but rest assured that Python’s implementation of definite iteration is so versatile that you won’t end up feeling cheated!

Shortly, you’ll dig into the guts of Python’s for loop in detail. But for now, let’s start with a quick prototype and example, just to get acquainted.

Python’s for loop looks like this:

Here is a representative example:

But what exactly is an iterable? Before examining for loops further, it will be beneficial to delve more deeply into what iterables are in Python.

Iterables

In Python, iterable means an object can be used in iteration. The term is used as:

Each of the objects in the following example is an iterable and returns some type of iterator when passed to iter() :

These object types, on the other hand, aren’t iterable:

All the data types you have encountered so far that are collection or container types are iterable. These include the string, list, tuple, dict, set, and frozenset types.

But these are by no means the only types that you can iterate over. Many objects that are built into Python or defined in modules are designed to be iterable. For example, open files in Python are iterable. As you will see soon in the tutorial on file I/O, iterating over an open file object reads data from the file.

In fact, almost any object in Python can be made iterable. Even user-defined objects can be designed in such a way that they can be iterated over. (You will find out how that is done in the upcoming article on object-oriented programming.)

Iterators

Okay, now you know what it means for an object to be iterable, and you know how to use iter() to obtain an iterator from it. Once you’ve got an iterator, what can you do with it?

An iterator is essentially a value producer that yields successive values from its associated iterable object. The built-in function next() is used to obtain the next value from in iterator.

Here is an example using the same list as above:

What happens when the iterator runs out of values? Let’s make one more next() call on the iterator above:

If all the values from an iterator have been returned already, a subsequent next() call raises a StopIteration exception. Any further attempts to obtain values from the iterator will fail.

You can only obtain values from an iterator in one direction. You can’t go backward. There is no prev() function. But you can define two independent iterators on the same iterable object:

Even when iterator itr1 is already at the end of the list, itr2 is still at the beginning. Each iterator maintains its own internal state, independent of the other.

If you want to grab all the values from an iterator at once, you can use the built-in list() function. Among other possible uses, list() takes an iterator as its argument, and returns a list consisting of all the values that the iterator yielded:

Similarly, the built-in tuple() and set() functions return a tuple and a set, respectively, from all the values an iterator yields:

The Guts of the Python for Loop

You now have been introduced to all the concepts you need to fully understand how Python’s for loop works. Before proceeding, let’s review the relevant terms:

Term	Meaning
Iteration	The process of looping through the objects or items in a collection
Iterable	An object (or the adjective used to describe an object) that can be iterated over
Iterator	The object that produces successive items or values from its associated iterable
iter()	The built-in function used to obtain an iterator from an iterable

Now, consider again the simple for loop presented at the start of this tutorial:

This loop can be described entirely in terms of the concepts you have just learned about. To carry out the iteration this for loop describes, Python does the following:

The loop body is executed once for each item next() returns, with loop variable i set to the given item for each iteration.

This sequence of events is summarized in the following diagram:

Schematic Diagram of a Python for Loop

Perhaps this seems like a lot of unnecessary monkey business, but the benefit is substantial. Python treats looping over all iterables in exactly this way, and in Python, iterables and iterators abound:

Many built-in and library objects are iterable.

There is a Standard Library module called itertools containing many functions that return iterables.

User-defined objects created with Python’s object-oriented capability can be made to be iterable.

Python features a construct called a generator that allows you to create your own iterator in a simple, straightforward way.

You will discover more about all the above throughout this series. They can all be the target of a for loop, and the syntax is the same across the board. It’s elegant in its simplicity and eminently versatile.

Iterating Through a Dictionary

As you can see, when a for loop iterates through a dictionary, the loop variable is assigned to the dictionary’s keys.

To access the dictionary values within the loop, you can make a dictionary reference using the key as usual:

In fact, you can iterate through both the keys and values of a dictionary simultaneously. That is because the loop variable of a for loop isn’t limited to just a single variable. It can also be a tuple, in which case the assignments are made from the items in the iterable using packing and unpacking, just as with an assignment statement:

Thus, the Pythonic way to iterate through a dictionary accessing both the keys and values looks like this:

The range() Function

In the first section of this tutorial, you saw a type of for loop called a numeric range loop, in which starting and ending numeric values are specified. Although this form of for loop isn’t directly built into Python, it is easily arrived at.

This solution isn’t too bad when there are just a few numbers. But if the number range were much larger, it would become tedious pretty quickly.

Happily, Python provides a better option—the built-in range() function, which returns an iterable that yields a sequence of integers.

However, when range() is used in code that is part of a larger application, it is typically considered poor practice to use list() or tuple() in this way. Like iterators, range objects are lazy—the values in the specified range are not generated until they are requested. Using list() or tuple() on a range object forces all the values to be returned at once. This is rarely necessary, and if the list is long, it can waste time and memory.

If is omitted, it defaults to 1 :

Technical Note: Strictly speaking, range() isn’t exactly a built-in function. It is implemented as a callable class that creates an immutable sequence type. But for practical purposes, it behaves like a built-in function.

Altering for Loop Behavior

You saw in the previous tutorial in this introductory series how execution of a while loop can be interrupted with break and continue statements and modified with an else clause. These capabilities are available with the for loop as well.

The break and continue Statements

break and continue work the same way with for loops as with while loops. break terminates the loop completely and proceeds to the first statement following the loop:

continue terminates the current iteration and proceeds to the next iteration:

The else Clause

A for loop can have an else clause as well. The interpretation is analogous to that of a while loop. The else clause will be executed if the loop terminates through exhaustion of the iterable:

The else clause won’t be executed if the list is broken out of with a break statement:

Conclusion

This tutorial presented the for loop, the workhorse of definite iteration in Python.

You also learned about the inner workings of iterables and iterators, two important object types that underlie definite iteration, but also figure prominently in a wide variety of other Python code.

In the next two tutorials in this introductory series, you will shift gears a little and explore how Python programs can interact with the user via input from the keyboard and output to the console.

Dictionaries in Python

Table of Contents

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:

Dictionaries differ from lists primarily in how elements are accessed:

Take the Quiz: Test your knowledge with our interactive “Python Dictionaries” quiz. Upon completion you will receive a score so you can track your learning progress over time:

Defining a Dictionary

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.

Accessing Dictionary Values

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.

Dictionary Keys vs. List Indices

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:

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.

Building a Dictionary Incrementally

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:

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.

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!

Restrictions on Dictionary Keys

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.

Restrictions on Dictionary Values

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:

Operators and Built-in Functions

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:

d.clear()

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

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

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

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

d.items()

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

d.keys()

Returns a list of keys in a dictionary.

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

d.values()

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:

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

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

d.popitem()

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.

d.update( )

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

Here is an example showing two dictionaries merged together:

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

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

Conclusion

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.

Take the Quiz: Test your knowledge with our interactive “Python Dictionaries” quiz. Upon completion you will receive a score so you can track your learning progress over time:

5. Data Structures¶

This chapter describes some things you’ve learned about already in more detail, and adds some new things as well.

5.1. More on Lists¶

The list data type has some more methods. Here are all of the methods of list objects:

list. extend ( iterable )

Remove the first item from the list whose value is equal to x. It raises a ValueError if there is no such item.

Remove the item at the given position in the list, and return it. If no index is specified, a.pop() removes and returns the last item in the list. (The square brackets around the i in the method signature denote that the parameter is optional, not that you should type square brackets at that position. You will see this notation frequently in the Python Library Reference.)

Return zero-based index in the list of the first item whose value is equal to x. Raises a ValueError if there is no such item.

The optional arguments start and end are interpreted as in the slice notation and are used to limit the search to a particular subsequence of the list. The returned index is computed relative to the beginning of the full sequence rather than the start argument.

Return the number of times x appears in the list.

Sort the items of the list in place (the arguments can be used for sort customization, see sorted() for their explanation).

Reverse the elements of the list in place.

An example that uses most of the list methods:

Another thing you might notice is that not all data can be sorted or compared. For instance, [None, ‘hello’, 10] doesn’t sort because integers can’t be compared to strings and None can’t be compared to other types. Also, there are some types that don’t have a defined ordering relation. For example, 3+4j 5+7j isn’t a valid comparison.

5.1.1. Using Lists as Stacks¶

5.1.2. Using Lists as Queues¶

It is also possible to use a list as a queue, where the first element added is the first element retrieved (“first-in, first-out”); however, lists are not efficient for this purpose. While appends and pops from the end of list are fast, doing inserts or pops from the beginning of a list is slow (because all of the other elements have to be shifted by one).

To implement a queue, use collections.deque which was designed to have fast appends and pops from both ends. For example:

5.1.3. List Comprehensions¶

List comprehensions provide a concise way to create lists. Common applications are to make new lists where each element is the result of some operations applied to each member of another sequence or iterable, or to create a subsequence of those elements that satisfy a certain condition.

For example, assume we want to create a list of squares, like:

Note that this creates (or overwrites) a variable named x that still exists after the loop completes. We can calculate the list of squares without any side effects using:

which is more concise and readable.

A list comprehension consists of brackets containing an expression followed by a for clause, then zero or more for or if clauses. The result will be a new list resulting from evaluating the expression in the context of the for and if clauses which follow it. For example, this listcomp combines the elements of two lists if they are not equal:

and it’s equivalent to:

Note how the order of the for and if statements is the same in both these snippets.

If the expression is a tuple (e.g. the (x, y) in the previous example), it must be parenthesized.

List comprehensions can contain complex expressions and nested functions:

5.1.4. Nested List Comprehensions¶

The initial expression in a list comprehension can be any arbitrary expression, including another list comprehension.

Consider the following example of a 3×4 matrix implemented as a list of 3 lists of length 4:

The following list comprehension will transpose rows and columns:

As we saw in the previous section, the nested listcomp is evaluated in the context of the for that follows it, so this example is equivalent to:

which, in turn, is the same as:

In the real world, you should prefer built-in functions to complex flow statements. The zip() function would do a great job for this use case:

See Unpacking Argument Lists for details on the asterisk in this line.

5.2. The del statement¶

There is a way to remove an item from a list given its index instead of its value: the del statement. This differs from the pop() method which returns a value. The del statement can also be used to remove slices from a list or clear the entire list (which we did earlier by assignment of an empty list to the slice). For example:

del can also be used to delete entire variables:

Referencing the name a hereafter is an error (at least until another value is assigned to it). We’ll find other uses for del later.

5.3. Tuples and Sequences¶

We saw that lists and strings have many common properties, such as indexing and slicing operations. They are two examples of sequence data types (see Sequence Types — list, tuple, range ). Since Python is an evolving language, other sequence data types may be added. There is also another standard sequence data type: the tuple.

A tuple consists of a number of values separated by commas, for instance:

As you see, on output tuples are always enclosed in parentheses, so that nested tuples are interpreted correctly; they may be input with or without surrounding parentheses, although often parentheses are necessary anyway (if the tuple is part of a larger expression). It is not possible to assign to the individual items of a tuple, however it is possible to create tuples which contain mutable objects, such as lists.

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:

This is called, appropriately enough, sequence unpacking and works for any sequence on the right-hand side. Sequence unpacking requires that there are as many variables on the left side of the equals sign as there are elements in the sequence. Note that multiple assignment is really just a combination of tuple packing and sequence unpacking.

5.4. Sets¶

Python also includes a data type for sets. A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.

Here is a brief demonstration:

5.5. Dictionaries¶

Performing list(d) on a dictionary returns a list of all the keys used in the dictionary, in insertion order (if you want it sorted, just use sorted(d) instead). To check whether a single key is in the dictionary, use the in keyword.

Here is a small example using a dictionary:

The dict() constructor builds dictionaries directly from sequences of key-value pairs:

In addition, dict comprehensions can be used to create dictionaries from arbitrary key and value expressions:

When the keys are simple strings, it is sometimes easier to specify pairs using keyword arguments:

5.6. Looping Techniques¶

When looping through dictionaries, the key and corresponding value can be retrieved at the same time using the items() method.

When looping through a sequence, the position index and corresponding value can be retrieved at the same time using the enumerate() function.

To loop over two or more sequences at the same time, the entries can be paired with the zip() function.

To loop over a sequence in reverse, first specify the sequence in a forward direction and then call the reversed() function.

To loop over a sequence in sorted order, use the sorted() function which returns a new sorted list while leaving the source unaltered.

Using set() on a sequence eliminates duplicate elements. The use of sorted() in combination with set() over a sequence is an idiomatic way to loop over unique elements of the sequence in sorted order.

It is sometimes tempting to change a list while you are looping over it; however, it is often simpler and safer to create a new list instead.

5.7. More on Conditions¶

The conditions used in while and if statements can contain any operators, not just comparisons.

The comparison operators in and not in are membership tests that determine whether a value is in (or not in) a container. The operators is and is not compare whether two objects are really the same object. All comparison operators have the same priority, which is lower than that of all numerical operators.

It is possible to assign the result of a comparison or other Boolean expression to a variable. For example,

5.8. Comparing Sequences and Other Types¶

Sequence objects typically may be compared to other objects with the same sequence type. The comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted. If two items to be compared are themselves sequences of the same type, the lexicographical comparison is carried out recursively. If all items of two sequences compare equal, the sequences are considered equal. If one sequence is an initial sub-sequence of the other, the shorter sequence is the smaller (lesser) one. Lexicographical ordering for strings uses the Unicode code point number to order individual characters. Some examples of comparisons between sequences of the same type:

Note that comparing objects of different types with or > is legal provided that the objects have appropriate comparison methods. For example, mixed numeric types are compared according to their numeric value, so 0 equals 0.0, etc. Otherwise, rather than providing an arbitrary ordering, the interpreter will raise a TypeError exception.

Python Dictionaries: A Comprehensive Tutorial (with 52 Code Examples)

What Is a Dictionary in Python?

A Python dictionary is a data structure that allows us to easily write very efficient code. In many other languages, this data structure is called a hash table because its keys are hashable. We’ll understand in a bit what this means.

A Python dictionary is a collection of key:value pairs. You can think about them as words and their meaning in an ordinary dictionary. Values are said to be mapped to keys. For example, in a physical dictionary, the definition science that searches for patterns in complex data using computer methods is mapped to the key Data Science.

In this Python tutorial, you’ll learn how to create a Python dictionary, how to use its methods, and dictionary comprehension, as well as which is better: a dictionary or a list. To get the most out of this tutorial, you should be already familiar with Python lists, for loops, conditional statements, and reading datasets with the reader() method. If you aren’t, you can learn more at Dataquest.

What Are Python Dictionaries Used for?

Python dictionaries allow us to associate a value to a unique key, and then to quickly access this value. It’s a good idea to use them whenever we want to find (lookup for) a certain Python object. We can also use lists for this scope, but they are much slower than dictionaries.

This speed is due to the fact that dictionary keys are hashable. Every immutable object in Python is hashable, so we can pass it to the hash() function, which will return the hash value of this object. These values are then used to lookup for a value associated with its unique key. See the example of the use of the hash() function below:

How to Create a Dictionary?

But let’s stop with the theory and go straight to the dictionary creation. We have two main methods to define a dictionary: with curly braces <> or using the dict() method. We’ll create two empty dictionaries:

The value of key1 is returned. We can also create a prepopulated dictionary using the syntax below:

We used the string data type for the key and the value, but what are the other admissible data types? In Python dictionaries, keys should be hashable objects (even if it’s not technically correct, we can also say that the objects should be immutable). Thus, mutable data types like lists, aren’t allowed. Let’s try to hash() different data types and see what happens:

Integers, floats, strings, and tuples are hashable data types (and they are also immutable) while lists are an unhashable data type (and they are mutable). Python uses hash values to quickly access a dictionary’s values.

On the other hand, values can be of whatever type. Let’s add more elements to the dictionary using different data types:

Additionally, we can modify the value of a key with bracket notation that we used to populate a dictionary:

Finally, dictionary keys should be unique. Let’s try to create a dictionary with duplicate keys:

Only the value of the last key is returned, so we can technically use duplicate keys, but it’s not recommended because one of the strengths of dictionaries is to quickly retrieve a value associated with some key. If there are duplicates, we may return a value we didn’t want. Imagine that we look up for the meaning of the word «data» and find 10 different entries for this word in a dictionary; it may be confusing.

Python Dictionary Methods

Now let’s see what methods we can use to work with dictionaries.

update()

The update() method is useful whenever we want to merge dictionaries or add new key:value pairs using an iterable (iterables are, for instance, lists or tuples). Let’s make an example using characters from the Harry Potter universe and the houses they belong to (spoiler: we’ll use Harry Potter datasets later on!):

Let’s now add other characters and their houses using different options we have available for the update() method:

We can see that the dictionary now contains Albus Dumbledore and Luna Lovegood. We can also use an iterable to add new elements to the dictionary:

We used a list of lists where the first element of each list is the character name and the second element is their house. The update() method then will automatically associate the first element (key) with the second element (value). For the sake of the experiment, try to update the dictionary with a list of lists but with three elements in each nested list.

We can also use a list of tuples:

What if we want to delete a key:value pair from a dictionary? We can use the del statement. It’s essential to say that del isn’t an exclusive dictionary method but rather a Python keyword that we can use in multiple situations to delete whatever Python object (like variable, function, class, list’s element, etc.).

If we’re trying to delete a pair that isn’t present in the dictionary, we’ll get a KeyError :

popitem() and pop()

Sometimes, we need to delete the last item that was inserted in a dictionary. The popitem() method is the way! Note that before Python 3.7, this method removes a random element from a dictionary:

We can also remove a specific key:value pair and return the value using the pop() method:

setdefault()

What if we want to return all the key:value pairs? Or just the keys? What about the values?

The answer to the first question is the items() method. When used on a dictionary, it will return a dict_items object, which is essentially a list of tuples, each containing a key and a value. This method may be useful when we loop through a dictionary as we’ll see later.

If we want to get just the keys, we should use the keys() method. It will return a dict_keys object:

Finally, we have the values() method that will return the values as a dict_values object:

When Do I Use All These Methods?

After this overview, you may feel overwhelmed by the amount of information. It’s also not easy to determine when you should use the Python dictionary methods. No worries — that’s absolutely okay. You shouldn’t try to remember every single method and its use cases. When you have a real-world problem in front of you (Dataquest guided projects can be a good start), and you have to use dictionaries, just head back to this Python tutorial and see if you can solve your problems with one of these methods. This is the only way you can gain valuable experience and become much faster at using dictionary methods in your future projects!

Looping Through a Dictionary

As we’re able to loop through lists, we’re also able to loop through dictionaries. They hold two different types of elements, keys and values, so we can either loop through both types of elements simultaneously or just one of them.

First of all, we’ll use the items() method, which yields both keys and values:

We can see that this method allows us to access both keys and values. What if we’re only interested in keys? Or only in values?

Frequency Tables

Python dictionaries are immensely handy when we have to create so-called frequency tables. Simply put, keys are the objects for which we want to count the frequency, and the values are the frequencies. As an example, we’ll be using the Harry Potter Movies Dataset from Kaggle (the Character.csv dataset). Let’s say that we want to count the frequency of each house present in the dataset. To do so, we first have to create an empty dictionary that will contain the frequency table. Then, we have to loop through the list of houses, and if the key for a house is already present in the frequency table, we add 1 to its value. Otherwise, we create a key for the current house and map it to value 1 (it’s one because we encounter this element for the first time). We also have to account for missing data in our dataset.

Most of the characters from the dataset are from Gryffindor. To practice, try to create frequency tables of the other columns.

Nested Dictionaries

Similar to lists, there are also nested dictionaries. In other words, a dictionary can contain another dictionary! Let’s use the Movies.csv dataset from the same set of Harry Potter datasets. It may happen that in your career, you work with multiple datasets at the same time. One way to organize them is by using dictionaries:

Now we can easily access each dataset or a specific entry. To illustrate this, let’s access the columns of the characters dataset:

We can also access the columns of both datasets with a for loop:

An alternative to this approach (especially when we don’t have dozens of datasets) is to reorganize each dataset in a dictionary. It will simplify our work when we have to access different entries:

Dictionary Comprehension

Dictionary comprehension in Python is an elegant and efficient method to create new dictionaries. You have probably already learned something about list comprehension. Just a quick reminder: comprehension in Python means applying the same operation on each element of an iterable (like a list). Let’s illustrate how this technique works. For example, we want a dictionary that holds the runtimes of each of the Harry Potter movies. Let’s create it from the dataset’s dictionary movies_dict :

Now we want to convert each runtime from minutes to hours. First of all, we can do it with a regular for loop:

However, we can simplify the above code by creating the runtime dictionary in just one line:

This code performs exactly the same operations as before, but it does it in 1 line instead of 3 lines.

Moreover, we can also add conditional statements. Let’s say that we want to exclude the movies that are shorter than 2.5 hours:

We just add an if-statement, and that’s it.

Dictionary comprehension also works with the keys in a similar manner. Try it yourself!

Note that if we have multiple conditional statements or complicated operations, it’s better to use a regular for loop because dictionary comprehension may become an incomprehensible coding jungle, which undermines the benefits of Python readability.

Python Dictionary vs List: Which Is Better?

Now that we know more about Python dictionaries, it’s time to compare dictionaries and lists. Which is better? Neither better than the other, but they are helpful in different coding tasks.

The rules to choose one of these data structures are actually pretty simple:

There is a bit more than that. Dictionaries are much faster if we want to access a specific element because they have a constant runtime, which means that the runtime doesn’t depend on the size of the input object. In contrast, when we want to see if an element exists in a list, the runtime will depend on the size of this list (Python loops through the entire list). Look at the examples:

It may seem that the difference is negligible, but as we increase the input size the difference will skyrocket.

Let’s make a more concrete example. Often, we’ll want to access a certain element in either a list or a dictionary. To find this element in a list, we first have to loop through the entire list, while in a dictionary, we can quickly access the same element by using its unique key. Let’s find 9000000 in the list and the dictionary defined above.

It took the dictionary almost no time to locate the number, while the list took around 1 second to perform the same operation. The dictionary is almost one million times faster!

Bonus: Using defaultdict() to Handle Missing Keys

Recall that we used the setdefault() method to insert a default key and its value in a dictionary. We also used the get() method to return a default value of a non-existing key. A more Pythonic way to perform similar operations is by using defaultdict() from the collections module(). We can initialize a dictionary with a default value data type by calling it and passing the data type we want to the method. Now if we try to access a missing key, the dictionary will create this key and map a default value to it:

Here the method created a key missing_key and assigned an empty list to it because that’s the default value of our dictionary. We can now append some values to this list:

The arguments we pass to defaultdict() must be callable. If we pass a non-callable object to defaultdict() we’ll get a TypeError :

In contrast, we can pass whatever object to the setdefault() method:

Let’s also look at the get() method. We use it when we want to return a value of a key we suspect doesn’t exist. This method will return only the value but won’t change the dictionary in any way:

Now we should be able to understand the difference between these three methods.

Conclusion

Here’s what we’ve covered in this tutorial:

Feel free to connect with me on LinkedIn or GitHub. Happy coding!

About the author

Artur Sannikov

I am a Molecular Biology student at the University of Padua, Italy interested in bioinformatics and data analysis.

Python Dictionary – The Ultimate Guide

Python comes with several built-in data types. These are the foundational building blocks of the whole language. They have been optimised and perfected over many years. In this comprehensive tutorial, we will explore one of the most important: the dictionary (or dict for short).

For your convenience, I’ve created a comprehensive 8000-word eBook which you can download directly as a high-resolution PDF (opens in a new window).

Unless stated otherwise I will be using Python 3.8 throughout. Dictionary functionality has changed over the last few Python versions. If you are using a version other than 3.8, you will probably get different results.

To check what version of Python you are running, enter the following in a terminal window (mine returns 3.8).

Here’s a minimal example that shows how to use a dictionary in an interactive Python shell. Feel free to play around!

Exercise: Add 2 apples and 3 oranges to your basket of fruits! How many fruits are in your basket?

Table of Contents

Python Dictionary Video Tutorial

Don’t want to read the article? No problem, watch me going over the article:

Here’s the link to the Python freelancer course in case you want to start being your own boss with Python.

Python Dictionary – Why Is It So Useful?

When I first found out about dictionaries, I wasn’t sure if they were going to be very useful. They seemed a bit clunky and I felt like lists would be much more useful. But boy was I wrong!

In real life, a dictionary is a book full of words in alphabetical order. Beside each word is a definition. If it has many meanings, there are many definitions. Each word appears exactly once.

If we abstract this idea, we can view a dictionary as a mapping from a word to its definition. Making this more abstract, a dictionary is a mapping from something we know (a word) to something we don’t (its definition).

We apply this mapping all the time in real life: In our phone, we map our friends’ names to their phone numbers.

In our minds, we map a person’s name to their face.

We map words to their meaning.

This ‘mapping’ is really easy for humans to understand and makes life much more efficient. We do it all the time without even realising. Thus it makes sense for Python to include this as a foundational data type.

Python Dictionary Structure

A traditional dictionary maps words to definitions. Python dictionaries can contain any data type, so we say they map keys to values. Each is called a key-value pair.

The key ‘unlocks’ the value. A key should be easy to remember and not change over time. The value can be more complicated and may change over time.

We will now express the same list as above using Python dictionary terminology.

Note: we can order dictionaries if we want but it is not necessary to do so. We’ll explain all these concepts in more detail throughout the article. But before we do anything, we need to know how to create a dictionary!

Python Create Dictionary

There are two ways to create a dictionary in Python:

Curly Braces

We write the key, immediately followed by a colon. Then a single space, the value and finally a comma. After the last pair, replace the comma with a closing curly brace.

You can write all pairs on the same line. I put each on a separate line to aid readability.

Let’s say you have 5 friends and want to record which country they are from. You would write it like so (names and countries start with the same letter to make them easy to remember!).

The dict() Constructor

Option 1 – fastest to type

So names_and_countries becomes

Each pair is like a keyword argument in a function. Keys are automatically converted to strings but values must be typed as strings.

Option 2 – slowest to type, best used with zip()

Like with curly braces, we must explicitly type strings as strings. If you forget the quotes, Python interprets it as a function.

Option 2 with zip() – Python list to dict

If you have two lists and want to make a dictionary from them, do this

If you have more than two lists, do this

This is the first time we’ve seen a dictionary containing more than just strings! We’ll soon find out what can and cannot be a key or value. But first, let’s see how to access our data.

Accessing Key-Value Pairs

There are 2 ways to access the data in our dictionaries:

Bracket Notation [ ]

This looks like list indexing but it is completely different! For instance, you cannot access values by their relative position or by slicing.

Note: As of Python 3.7, the order elements are added is preserved. Yet you cannot use this order to access elements. It is more for iteration and visual purposes as we will see later.

Let’s look at the second method for accessing the data stored in our dictionary.

Python Dictionary get() Method

The get() method takes two arguments:

This is hugely beneficial if you are iterating over a dictionary. If you use bracket notation and encounter an error, the whole iteration will stop. If you use get(), no error will be raised and the iteration will complete.

We will see how to iterate over dictionaries soon. But there is no point in doing that if we don’t even know what our dictionary can contain! Let’s learn about what can and can’t be a key-value pair.

Python Dict Keys

In real dictionaries, the spelling of words doesn’t change. It would make it quite difficult to use one if they did. The same applies to Python dictionaries. Keys cannot change. But they can be more than just strings. In fact, keys can be any immutable data type: string, int, float, bool or tuple.

What is Hashing in Python?

In the background, a Python dictionary is a data structure known as a hash table. It contains keys and hash values (numbers of fixed length). You apply hash() to a key to return its hash value. If we call hash() on the same key many times, the result will not change.

When we create a key-value pair, Python creates a hash-value pair in the background

Python uses this hash value when we look up a key-value pair. By design, the hash function can only be applied to immutable data types. If keys could change, Python would have to create a new hash table from scratch every time you change them. This would cause huge inefficiencies and many bugs.

Instead, once a table is created, the hash value cannot change. Python knows which values are in the table and doesn’t need to calculate them again. This makes dictionary lookup and membership operations instantaneous and of O(1).

In Python, the concept of hashing only comes up when discussing dictionaries. Whereas, mutable vs immutable data types come up everywhere. Thus we say that you can only use immutable data types as keys, rather than saying ‘hashable’ data types.

Finally, what happens if you use the hash value of an object as another key in the same dictionary? Does Python get confused?

It works! The reasons why are beyond the scope of this article. The full implementation of the algorithm and the reasons why it works are described here. All you really need to know is that Python always picks the correct value… even if you try to confuse it!

Python Dictionary Values

There are restrictions on dictionary keys but values have none. Literally anything can be a value. As long as your key is an immutable data type, your key-value pairs can be any combination of types you want. You have complete control!

Note: you must use braces notation to type a dictionary out like this. If you try to use the dict() constructor, you will get SyntaxErrors (unless you use the verbose method and type out a list of tuples… but why would you do that?).

If you need to refresh your basic knowledge of Python sets, I recommend reading the ultimate guide to Python sets on the Finxter blog.

Python Nested Dictionaries

When web scraping, it is very common to work with dictionaries inside dictionaries (nested dictionaries). To access values on deeper levels, you simply chain methods together. Any order of bracket notation and get() is possible.

We now know how to create a dictionary and what data types are allowed where. But what if you’ve already created a dictionary and want to add more values to it?

Python Add To Dictionary

Our dictionary reflects the order we added the pairs by first showing Zoe and then Fred.

To add a new key-value pair, we simply assume that key already exists and try to access it via bracket notation

Then (before pressing return) use the assignment operator ‘=’ and provide a value.

You cannot assign new key-value pairs via the get() method because it’s a function call.

To delete a key-value pair use the del statement. To change the value of an existing key, use the same bracket notation as above.

As with other mutable data types, be careful when using the del statement in a loop. It modifies the dictionary in place and can lead to unintended consequences. Best practice is to create a copy of the dictionary and to change the copy. Or you can use, my personal favorite, dictionary comprehensions (which we will cover later)—a powerful feature similar to the popular list comprehension feature in Python.

Python Dict Copy Method

To create a shallow copy of a dictionary use the copy() method. To create a deep copy use the deepcopy() method from the built-in copy module. We won’t discuss the distinction between the copy methods in this article for brevity.

Checking Dictionary Membership

Let’s say we have a dictionary with 100k key-value pairs. We cannot print it to the screen and visually check which key-value pairs it contains.

Thankfully, the following syntax is the same for dictionaries as it is for other objects such as lists and sets. We use the in keyword.

We expect INCORRECT_NAME not to be in our dict and Adam to be in it. But why does ‘Argentina’ return False? We’ve just seen that it’s the value of Adam?!

Remember at the start of the article that I said dictionaries are maps? They map from something we know (the key) to something we don’t (the value). So when we ask if something is in our dictionary, we are asking if it is a key. We’re not asking if it’s a value.

Which is more natural when thinking of a real-life dictionary:

Clearly the first one is the winner and this is the default behavior for Python.

We are checking if ‘something’ is a key in my_dict.

But fear not, if you want to check whether a specific value is in a dictionary, that is possible! We simply have to use some methods.

Python Dictionary Methods – Keys, Values and Items

There are 3 methods to look at. All can be used to check membership or for iterating over specific parts of a dictionary. Each returns an iterable.

Note: we’ve changed Ethan’s country back to Estonia for readability.

We can now check membership in keys and values:

You cannot check in the keys and values at the same time. This is because items() returns an iterable of tuples. As ‘Denmark’ is not a tuple, it will return False.

Python Loop Through Dictionary – An Overview

To iterate over any part of the dictionary we can use a for loop

It’s best practice to use descriptive names for the objects you iterate over. Code is meant to be read and understood by humans! Thus we chose ‘name’ and ‘country’ rather than ‘key’ and ‘value’.

If your key-value pairs don’t follow a specific pattern, it’s ok to use ‘key’ and ‘value’ as your iterable variables, or even ‘k’ and ‘v’.

A Note On Reusability

Do not specify keys() if your code needs to work with other objects like lists and sets. Use the keys() method if your code is only meant for dictionaries. This prevents future users inputting incorrect objects.

Python dict has_key

The method has_key() is exclusive to Python 2. It returns True if the key is in the dictionary and False if not.

Python 3 removed this functionality in favour of the following syntax:

This keeps dictionary syntax in line with that of other data types such as sets and lists. This aids readability and reusability.

Pretty Printing Dictionaries Using pprint()

The built-in module pprint contains the function pprint. This will ‘pretty print’ your dictionary. It sorts the keys alphabetically and prints each key-value pair on a newline.

It does not change the dictionary at all. It’s just much more readable now.

Python Dictionaries and JSON Files

We need to encode and decode all this data.

A common filetype you will interact with is a JSON file. It stands for Javascript Object Notation. They are used to structure and send data in web applications.

They work almost exactly the same way as dictionaries and you can easily turn one into the other very easily.

Python Dict to JSON

The above code takes my_dict and writes it to the file my_json.json in the current directory.

You can get more complex than this by setting character encodings and spaces. For more detail, we direct the reader to the docs.

Python JSON to Dict

We have the file my_json.json in our current working directory.

Note: the key-value pairs in JSON are always converted to strings when encoded in Python. It is easy to change any object into a string and it leads to fewer errors when encoding and decoding files. But it means that sometimes the file you load and the file you started with are not identical.

Python Dictionary Methods

Here’s a quick overview:

We’ll use letters A and B for our dictionaries as they are easier to read than descriptive names. Plus we have kept the examples simple to aid understanding.

dict.clear() – remove all key-value pairs from a dict

Calling this on a dict removes all key-value pairs in place. The dict is now empty.

dict.update() – merge two dictionaries together

We have just updated A. Thus all the key-value pairs from B have been added to A. B has not changed.

If A and B some keys, B’s value will replace A’s. This is because A is updated by B and so takes all of B’s values (not the other way around).

You can also pass a sequence of tuples or keyword arguments to update(), like you would with the dict() constructor.

dict.pop() – remove a key and return its value

If you try call dict.pop() with a key that is not in the dictionary, Python raises a KeyError.

Like the get() method, you can specify an optional second argument. This is returned if the key is not in the dictionary and so avoids KeyErrors.

dict.popitem() – remove a random key-value pair and return it as a tuple

If the dictionary is empty, Python raises a KeyError.

Python Loop Through Dictionary – In Detail

There are several common situations you will encounter when iterating over dictionaries. Python has developed several methods to help you work more efficiently.

But before we head any further, please remember the following:

NEVER EVER use bracket notation when iterating over a dictionary. If there are any errors, the whole iteration will break and you will not be happy.

The standard Python notation for incrementing numbers or appending to lists is

This follows the standard pattern:

When iterating over a dictionary, our values can be numbers or list-like. Thus we can add or we can append to values. It would be great if our code followed the above pattern. But…

Unfortunately, both raise a KeyError. Python tells us the key do not exist and so we cannot increment its value. Thus we must first create a key-value pair before we do anything with it.

We’ll now show 4 ways to solve this problem:

We’ll explain this through some examples, so let’s go to the setup.

Three friends – Adam, Bella and Cara, have gone out for a meal on Adam’s birthday. They have stored their starter, main and drinks orders in one list. The price of each item is in another list. We will use this data to construct different dictionaries.

Our three friends are very strict with their money. They want to pay exactly the amount they ordered. So we will create a dictionary containing the total cost for each person. This is a numerical incrementation problem.

Manually Initialize a Key

We write an if statement which checks if the key is already in the dictionary. If it isn’t, we set the value to 0. If it is, Python does not execute the if statement. We then increment using the expected syntax.

This works well but requires quite a few lines of code. Surely we can do better?

Python Dict get() Method When Iterating

We’ve got it down to one line!

We pass get() a second value which is returned if the key is not in the dictionary. In this case, we choose 0 like the above example. The first time we call get() it returns 0. We have just initialised a key-value pair! In the same line, we add on ‘price’. The next time we call get(), it returns the current value and we can add on ‘price’ again.

This method does not work for appending. You need some extra lines of code. We will look at the setdefault() method instead.

Python Dict setdefault() Method

The syntax of this method makes it an excellent choice for modifying a key’s value via the append() method.

First we will show why it’s not a great choice to use if you are incrementing with numbers.

It works but requires more lines of code than get() and prints lots of numbers to the screen. Why is this?

The setdefault() method takes two arguments:

So setdefault(person, 0) sets the default value of person to be 0.

It always returns one of two things:

This is why the numbers are printed to the screen. They are the values of ‘person’ at each iteration.

Clearly this is not the most convenient method for our current problem. If we do 100k iterations, we don’t want 100k numbers printed to the screen.

So we recommend using the get() method for numerical calculations.

Let’s see it in action with lists and sets. In this dictionary, each person’s name is a key. Each value is a list containing the price of each item they ordered (starter, main, dessert).

Now we see the true power of setdefault()! Like the get method in our numerical example, we initialise a default value and modify it in one line!

Note: setdefault() calculates the default value every time it is called. This may be an issue if your default value is expensive to compute. Get() only calculates the default value if the key does not exist. Thus get() is a better choice if your default value is expensive. Since most default values are ‘zeros’ such as 0, [ ] and < >, this is not an issue for most cases.

We’ve seen three solutions to the problem now. We’ve got the code down to 1 line. But the syntax for each has been different to what we want. Now let’s see something that solves the problem exactly as we’d expect: introducing defaultdict!

Python defaultdict()

Let’s solve our numerical incrementation problem:

Success!! But what about our list problem?

The defaultdict is part of the built-in collections module. So before we use it, we must first import it.

Defaultdict is the same as a normal Python dictionary except:

Thus you will never get a KeyError! Plus and initialising default values is taken care of automatically!

We have now solved the problem using the same syntax for lists and numbers!

Now let’s go over some special cases for defaultdict.

Python defaultdict() Special Cases

Above we said it’s not possible to get a KeyError when using defaultdict. This is only true if you correctly initialise your dict.

Let’s say you initialise defaultdict without any arguments. Then Python raises a KeyError if you call a key not in the dictionary. This is the same as initialising with None and defeats the whole purpose of defaultdict.

The issue is that None is not callable. Yet you can get defaultdict to return None by using a lambda function:

Note that you cannot increment or append to None. Make sure you choose your default value to match the problem you are solving!

Whilst we’re here, let’s take a look at some more dictionaries in the collections module.

OrderedDict

Earlier we said that dictionaries preserve their order from Python 3.7 onwards. So why do we need something called OrderedDict?

As the name suggests, OrderedDict preserves the order elements are added. But two OrderedDicts are the same if and only if their elements are in the same order. This is not the case with normal dicts.

Other than that, OrderedDict has all the same properties as a regular dictionary. If your elements must be in a particular order, then use OrderedDict!

Counter()

Let’s say we want to count how many times each word appears in a piece of text (a common thing to do in NLP). We’ll use The Zen of Python for our example. If you don’t know what it is, run

I’ve stored it in the list zen_words where each element is a single word.

We can manually count each word using defaultdict. But printing it out with the most frequent words occurring first is a bit tricky.

As counting is quite a common process, the Counter() dict subclass was created. It is complex enough that we could write a whole article about it.

For brevity, we will include the most basic use cases and let the reader peruse the docs themselves.

You can pass any iterable or dictionary to Counter(). It returns a dictionary in descending order of counts

Reversed()

Since it’s an iterator, remember to use the keys(), values() and items() methods to select the elements you want. If you don’t specify anything, you’ll iterate over the keys.

Dictionary Comprehensions

A wonderful feature of dictionaries, and Python in general, is the comprehension. This lets you create dictionaries in a clean, easy to understand and Pythonic manner. You must use curly braces <> to do so (not dict()).

We’ve already seen that if you have two lists, you can create a dictionary from them using dict(zip()).

We can also do this using a for loop

We initialize our dict and iterator variables with descriptive names. To iterate over both lists at the same time we zip them together. Finally, we add key-value pairs as desired. This takes 3 lines.

Using a comprehension turns this into one line.

They are a bit like for loops in reverse. First, we state what we want our key-value pairs to be. Then we use the same for loop as we did above. Finally, we wrap everything in curly braces.

Note that every comprehension can be written as a for loop. If you ever get results you don’t expect, try it as a for loop to see what is happening.

Here’s a common mistake

What’s going on? Let’s write it as a for loop to see. First, we’ll write it out to make sure we are getting the same, undesired, result.

Now we’ll use the bug-finder’s best friend: the print statement!

Here we remove the dictionary to check what is actually happening in the loop. Now we see the problem! The issue is we have nested for loops. The loop says: for each name pair it with every country. Since dictionary keys can only appear, the value gets overwritten on each iteration. So each key’s value is the final one that appears in the loop – ‘Estonia’.

The solution is to remove the nested for loops and use zip() instead.

Python Nested Dictionaries with Dictionary Comprehensions

This is where comprehensions become powerful. We define a dictionary within a dictionary to create lots of information in a few lines of code. The syntax is exactly the same as above but our value is more complex than the first example.

Remember that our key value pairs must be unique and so we cannot create a dictionary like the following

We can only define one pattern for key-value pairs in a comprehension. But if you could define more, it wouldn’t be very helpful. We would overwrite our key-value pairs on each iteration as keys must be unique.

If-Elif-Else Statements

We can apply if conditions after the for statement. This affects all the values you are iterating over.

You can also apply them to your key and value definitions. We’ll now create different key-value pairs based on whether a number is odd or even.

We can get really complex and use if/else statements in both the key-value definitions and after the for loop!

It is relatively simple to do this using comprehensions. Trying to do so with a for loop or dict() constructor would be much harder.

Merging Two Dictionaries

Let’s say we have two dictionaries A and B. We want to create a dictionary, C, that contains all the key-value pairs of A and B. How do we do this?

Using merge doesn’t work. It modifies A in place and so doesn’t return anything.

Before Python 3.5, you had to write a function to do this. In Python 3.5 they introduced this wonderful bit of syntax.

We use ** before each dictionary to ‘unpack’ all the key-value pairs.

The syntax is very simple: a comma-separated list of dictionaries wrapped in curly braces. You can do this for an arbitrary number of dictionaries.

Finally, what happens if the dicts share key-value pairs?

As is always the case with Python dictionaries, a key’s value is dictated by its last assignment. The dict B_second first takes A’s values then take’s B’s. Thus any shared keys between A and B will be overwritten with B’s values. The opposite is true for A_second.

Note: if a key’s value is overridden, the position of that key in the dict does not change.

Conclusion

You now know almost everything you’ll ever need to know to use Python Dictionaries. Well done! Please bookmark this page and refer to it as often as you need!

If you have any questions post them in the comments and we’ll get back to you as quickly as possible.

If you love Python and want to become a freelancer, there is no better course out there than this one:

I bought it myself and it is why you are reading these words today.

About the Author

This article is contributed by Finxter user Adam Murphy (data scientist, grandmaster of Python code):

I am a self-taught programmer with a First Class degree in Mathematics from Durham University and have been coding since June 2019.

I am well versed in the fundamentals of web scraping and data science and can get you a wide variety of information from the web very quickly.

I recently scraped information about all watches that Breitling and Rolex sell in just 48 hours and am confident I can deliver datasets of similar quality to you whatever your needs.

Being a native English speaker, my communication skills are excellent and I am available to answer any questions you have and will provide regular updates on the progress of my work.

If you want to hire Adam, check out his Upwork profile!

References

Where to Go From Here?

Congratulations! You’ve successfully mastered dictionaries in Python! Now, let’s dive into Python sets.

Python Dictionary

Dictionary in Python is a collection of keys values, used to store data values like a map, which, unlike other data types which hold only a single value as an element.

Example of Dictionary in Python

Dictionary holds key:value pair. Key-Value is provided in the dictionary to make it more optimized.

Python3

Output:

Creating a Dictionary

In Python, a dictionary can be created by placing a sequence of elements within curly <> braces, separated by ‘comma’. 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.

Performance in Python 3 dictionary iteration: dictPython for dict vs. dict.items()

Which of these is faster, and why? Or are they the same? Does the answer vary by any conditions (size of dictionary, type of data, etc.)?

I haven’t seen an exact duplicate, but if there is one I’d be happy to be pointed to it.

2 Answers 2

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

It turns out there are actually orders of magnitude of difference.

I don’t know much about performance testing, but what I tried to do was create 3 dicts of varying sizes, with each smaller dict being a subset of the larger dict. I then ran all three dicts through the two functions (Traditional vs. Hipster). Then I did that 100 times.

The dictionary sizes (number of key-value pairs) for dict1, dict2, and dict3 are 1000, 50000, 500000 respectively.

python: iterating over a large dictionary

First of all, am i right to assume that for:

assigns ‘key’ to be the keys of the dict and ‘value’ to be the values of the dict? also, why is that comma after the (key,value), needed?

and to my real question:
how do i do this over a larger dictionary with 5+ values per key? when i try to do it on my dict, it says the following:

is there a way to do this without the itertools module?

3 Answers 3

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

You are a bit vague, but there are two things I think you are asking for:

how to save all keys in a variable and all values in a variable:

or, and more likely so, you want to be able to use this to easily iterate through a dictionary:

No, the first assumption is incorrect. Given dict1 :

So the result of items is a list. As you may know, Python has (to an extent) destructuring assignment:

It uses the syntax of tuples, and as you may know, to make a 1-tuple, you use a trailing comma:

Now what happens if you try to unpack something with the wrong number of values?

Oops! We get an error. So your problem was not having too many values per key; it was having more than one key.

If you want the keys and values separately, use the appropriate dict methods:

To iterate over a ‘large dictionary’ you need a loop construct:

The construct you have here:

Is not doing what you think.

Python supports tuple assignment. The number on the Left Hand side needs to match the number on the Right Hand side:

(except for Python 3 which has the lovely * for LH assignments):

The trailing comma in (key,value), is ambiguous in this context in Py2 or Py3.

You use a trailing comma to construct a tuple with a single element:

With more than one element, it is ignored.

With the addition of parens on the LH then a trailing comma, you are creating a nested tuple:

The only way you can assign to such a beast is to match the nesting on the RH:

Without using parenthesis to create a tuple explicitly in Python, you need to be careful with the order of operations:

You can do this:

And you can construct a dict from those two lists of keys/values using zip:

Refer to dictionary element in ‘for’ loop

If I have a list of dictionaries, is there a way to refer to a specific element within the for loop declaration?

Something like this:

Or something similar?

4 Answers 4

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

No, there’s no as clause in for statements.

But it’s pretty easy to do this explicitly:

Or, if you want to get fancy:

Or, just for fun:

Which you can wrap up as a reusable function:

You can use a generator expression like so:

This is one of the fastest and Pythonic methods to do it, lean on Python 3:

There is also a similar method items which does almost the same. items will create a list of tuples with key and value if you call it in the for loop statement. There is also a similar method keys which only returns you a list of keys.

iteritems will not generate a list of tuples when you call it in the for loop. Each element will be evaluated in each loop cycle. So there is no initial overhead and extensive memory usage. If you break the loop it’s better as well.

Python Dictionary (Dict) Tutorial

Python Dictionary Items

The key-value pairs are also called items or elements of the dictionary. We can use dict.items() method to get the iterable to loop through the dictionary items. There is no restriction on the values of the dictionary items.

Python Dictionary Keys

The keys are unique in a dictionary. It is used to retrieve the records from the dictionary. A dictionary is created using a pair of braces. The key-value pairs are separated using a comma.

Dictionary keys must be immutable. So we can use strings, numbers, and tuples as dict keys. If the tuple contains any mutable objects, we can’t use it as a dictionary key.

Can we use List as Dictionary Keys?

We can’t use a List as a dictionary key because it can be modified. If we try to use a list as a key, it will throw “TypeError: unhashable type: list”.

Creating a Dictionary

The dictionary items are separated using commas and the key-value pair is separated using a colon. The curly braces are used to define the dictionary with all the items. Let’s look at a simple example to create a dictionary and print it.

Notice that the type of dictionary class is dict and the keys-values are of different types too.

Creating a Dictionary

Accessing Dictionary Values

We can access a dictionary value using the key name in the square brackets.

If the key doesn’t exist, this way to access the dictionary element will raise KeyError. It’s better to use the get() method that returns None if the key is not present.

Adding/Updating Dictionary Value

We can add or update dictionary elements using the assignment operator. If the key doesn’t exist in the dictionary, the key-value pair gets added to the dictionary. Otherwise, the value is updated with the new value.

Deleting Dictionary Items

We can use the del keyword to delete a dictionary key-value pair. If we use the del keyword with the dictionary, the complete dictionary will be deleted, which is different from deleting all the elements of the dictionary.

Iterating over Dictionary using for loop

We can iterate over a dictionary using the for loop. There are many ways to use for loop with a dictionary.

1. Dictionary items() function

The items() function returns an object of dict_items, which is iterable. We can use it with the for loop and unpack its elements to key and value and then use them inside the for loop.

Output:

2. Loop through Dictionary Keys

If we use the dictionary object in the for loop, it will return keys one by one. Since the dictionary is unordered, the returned keys can be in any order.

Output:

3. Python Dictionary values()

We can use the values() function to get the dictionary values and then iterate over them. The values() function returns an object of dict_values, which is the list of values in the dict.

Output:

Check if the key exists in the Dictionary

We can use the “in” keyword to check if the key exists in the dictionary or not. Similarly, we can use the “not in” keyword to check if the key is missing or not.

Length of Dictionary

We can use len() function to find out the length or size of the dictionary.

Python dict() Constructor

We can use the built-in dict() constructor to create a dictionary object.

Python Dictionary Methods

Python dict class has many methods. Let’s look into some of the important methods of dict class.

1. values()

This method returns an object that contains the values from the dictionary. The type of returned object is ‘dict_values’ and we can iterate over it to perform some operations on the dictionary values.

2. items()

This method provides a set-like view of Dictionary items. It’s mostly used to unpack dictionary key-value pairs to different values and then iterate over them.

Output:

3. pop(key[,default])

This method removes the specified key from the dictionary and returns the corresponding value. If the key is not found, the optional default value is returned. If the key is not found and the default value is not given, KeyError is raised.

We are using a try-except block to catch KeyError and print the error message.

4. copy()

This function returns a shallow copy of the dictionary. If the underlying object is mutable and changed, then the change will reflect in the dict returned using the copy() method too.

Output:

5. clear()

This method removes all the items from the dictionary. It’s similar to assigning the variable to an empty dictionary.

6. fromKeys(iterable, value)

This static method creates a new dictionary with the keys from the iterable and the values set to the value provided. If the value is not given, the values are set to None.

Output:

7. get(key[,default])

This method returns the value for the key. If the key is not found, the optional default value is returned. If the key is not found and the default value is not provided, None is returned.

8. keys()

This function returns a list of keys in the dict_keys object. We can iterate over this list to process dictionary values.

Output:

9. popitem()

This method removes and returns some dictionary items as a key-value tuple. If the dictionary is empty, KeyError is raised. We can use this function with a while loop to process dictionary items in random order.

Output:

10. setdefault(key[,default])

This method is used to add a key to the dictionary if and only if it’s not present in the dictionary. This method sets the key value to the default value provided, otherwise None.

The method returns the value for the key if it’s present in the dictionary, otherwise returns the default value.

Output:

11. update(dict)

This method is used to update the dictionary items from the given dictionary. If the given dictionary key is not found, it gets added to the dictionary. If the key is found, the value gets updated.

Output:

Summary

Dictionary is a map-like collection to store key-value pairs. The items in the dictionary are accessed via a key-based index. We can update, add, and delete dictionary items. There are various ways to use for loop to iterate over the dictionary keys, values, or items.

OrderedDict vs dict in Python: The Right Tool for the Job

Table of Contents

This changed in Python 3.6. The built-in dict class now keeps its items ordered as well. Because of that, many in the Python community now wonder if OrderedDict is still useful. A closer look at OrderedDict will uncover that this class still provides valuable features.

In this tutorial, you’ll learn how to:

With this knowledge, you’ll able to choose the dictionary class that best fits your needs when you want to preserve the order of items.

Free Bonus: Click here to get a Python Cheat Sheet and learn the basics of Python 3, like working with data types, dictionaries, lists, and Python functions.

Choosing Between OrderedDict and dict

For years, Python dictionaries were unordered data structures. Python developers were used to this fact, and they relied on lists or other sequences when they needed to keep their data in order. With time, developers found a need for a new type of dictionary, one that would keep its items ordered.

Core Python developers wanted to fill in the gap and provide a dictionary that could preserve the order of inserted keys. That, in turn, allowed for a more straightforward implementation of specific algorithms that rely on this property.

Note: In this tutorial, you’ll focus on the implementations of dict and OrderedDict that CPython provides.

The current regular dictionary is based on the design I proposed several years ago. The primary goals of that design were compactness and faster iteration over the dense arrays of keys and values. Maintaining order was an artifact rather than a design goal. The design can maintain order but that is not its specialty.

It is still my goal to have collections.OrderedDict have a different design with different performance characteristics than regular dicts. It has some order specific methods that regular dicts don’t have (such as a move_to_end() and a popitem() that pops efficiently from either end). The OrderedDict needs to be good at those operations because that is what differentiates it from regular dicts. (Source)

In Python 3.7, the items-ordered feature of dict objects was declared an official part of the Python language specification. So, from that point on, developers could rely on dict when they needed a dictionary that keeps its items ordered.

At the time of writing, some features of OrderedDict still made it valuable and different from a regular dict :

There’s at least one more reason to continue using OrderedDict in your code: backward compatibility. Relying on regular dict objects to preserve the order of items will break your code in environments that run versions of Python older than 3.6.

It’s difficult to say if dict will fully replace OrderedDict soon. Nowadays, OrderedDict still offers interesting and valuable features that you might want to consider when selecting a tool for a given job.

Getting Started With Python’s OrderedDict

Python’s OrderedDict is a dict subclass that preserves the order in which key-value pairs, commonly known as items, are inserted into the dictionary. When you iterate over an OrderedDict object, items are traversed in the original order. If you update the value of an existing key, then the order remains unchanged. If you remove an item and reinsert it, then the item is added at the end of the dictionary.

Being a dict subclass means that it inherits all the methods a regular dictionary provides. OrderedDict also has additional features that you’ll learn about in this tutorial. In this section, however, you’ll learn the basics of creating and using OrderedDict objects in your code.

Creating OrderedDict Objects

You can also pass an iterable of items as an argument to the constructor of OrderedDict :

If you use a regular dictionary as an initializer to an OrderedDict object and you’re on Python 3.6 or beyond, then you get the following behavior:

The order of items in the OrderedDict object matches the order in the original dictionary. On the other hand, if you’re using a Python version lower than 3.6, then the order of items is unknown:

Since dictionaries in Python 3.5 don’t remember the order of their items, you don’t know the order in the resulting ordered dictionary until the object is created. From this point on, the order is maintained.

You can create an ordered dictionary by passing keyword arguments to the class constructor:

Since Python 3.6, functions retain the order of keyword arguments passed in a call. So the order of the items in the above OrderedDict matches the order in which you pass the keyword arguments to the constructor. In earlier Python versions, that order is unknown.

Managing Items in an OrderedDict

Since OrderedDict is a mutable data structure, you can perform mutating operations on its instances. You can insert new items, update and remove existing items, and so on. If you insert a new item into an existing ordered dictionary, then the item is added to the end of the dictionary:

If you delete an item from an existing ordered dictionary and insert that same item again, then the new instance of the item is placed at the end of the dictionary:

If you remove the (‘one’, 1) item and insert a new instance of the same item, then the new item is added to the end of the underlying dictionary.

If you reassign or update the value of an existing key-value pair in an OrderedDict object, then the key maintains its position but gets a new value:

Iterating Over an OrderedDict

Iterating in Reversed Order With reversed()

You can use reversed() with the items, keys, and values of an OrderedDict object:

Every loop in this example uses reversed() to iterate through different elements of an ordered dictionary in reverse order.

Regular dictionaries also support reverse iteration. However, if you try to use reversed() with a regular dict object in a Python version lower than 3.8, then you get a TypeError :

If you need to iterate over the items in a dictionary in reverse order, then OrderedDict is a good ally. Using a regular dictionary dramatically reduces your backward compatibility because reverse iteration wasn’t added to regular dictionaries until Python 3.8.

Exploring Unique Features of Python’s OrderedDict

With an ordered dictionary, you have access to the following extra and enhanced methods:

OrderedDict and dict also behave differently when they’re tested for equality. Specifically, when you compare ordered dictionaries, the order of items matters. That’s not the case with regular dictionaries.

Sorting the dictionary by values would be an interesting exercise, so expand the block below and give it a try!

Exercise: Sort the Dictionary by Values Show/Hide

Sort the following dictionary by values:

As a useful hint for implementing a solution, consider using a lambda function.

You can expand the block below to see a possible solution.

Solution: Sort the Dictionary by Values Show/Hide

You can use a lambda function to retrieve the value of each key-value pair in letters and use that function as the key argument to sorted() :

Testing for Equality Between Dictionaries

When you test two OrderedDict objects for equality in a Boolean context, the order of items plays an important role. For example, if your ordered dictionaries contain the same set of items, then the result of the test depends on their order:

If you try this same example using regular dictionaries, then you’ll get a different result:

Here, when you test two regular dictionaries for equality, you get True if both dictionaries have the same set of items. In this case, the order of items doesn’t change the final result.

Finally, equality tests between an OrderedDict object and a regular dictionary don’t take the order of items into account:

When you compare ordered dictionaries with regular dictionaries, the order of items doesn’t matter. If both dictionaries have the same set of items, then they compare equally, regardless of the order of their items.

Appending New Attributes to a Dictionary Instance

You can use this dynamically added function to iterate through the dictionary keys in sorted order without altering the original order in letters :

This is just an example of how useful this feature of OrderedDict can be. Note that you can’t do something similar with a regular dictionary:

Merging and Updating Dictionaries With Operators

Python 3.9 added two new operators to the dictionary space. Now you have merge ( | ) and update ( |= ) dictionary operators. These operators also work with OrderedDict instances:

As its name suggests, the merge operator merges the two dictionaries into a new one that contains the items of both initial dictionaries. If the dictionaries in the expression have common keys, then the rightmost dictionary’s values will prevail.

In this example, you use the dictionary update operator to update Newton’s lifetime information. The operator updates a dictionary in place. If the dictionary that provides the updated data has new keys, then those keys are added to the end of the original dictionary.

Considering Performance

Performance is an important subject in programming. Knowing how fast an algorithm runs or how much memory it uses are common concerns. OrderedDict was initially coded in Python and then written in C to maximize efficiency in its methods and operations. These two implementations are currently available in the standard library. However, the Python implementation serves as an alternative if the C implementation isn’t available for some reason.

Both implementations of OrderedDict involve using a doubly linked list to capture the order of items. Despite having linear time for some operations, the linked list implementation in OrderedDict is highly optimized to preserve the fast times of the corresponding dictionary methods. That said, the operations on an ordered dictionary are O(1) but with a greater constant factor compared to regular dictionaries.

In general, OrderedDict has lower performance than regular dictionaries. Here’s an example that measures the execution time of several operations on both dictionary classes:

In this script, you compute the average_time() that it takes to run several common operations on a given dictionary. The for loop uses time.pref_counter() to measure the execution time of the set of operations. The function returns the average time, in nanoseconds, that it takes to run the selected set of operations.

Note: If you’re interested in knowing other ways to time your code, then you can check out Python Timer Functions: Three Ways to Monitor Your Code.

If you run this script from your command line, then you get an output similar to this:

As you see in the output, operations on dict objects are faster than operations on OrderedDict objects.

Regarding memory consumption, OrderedDict instances have to pay a storage cost because of their ordered list of keys. Here’s a script that gives you an idea of this memory cost:

In this example, you use sys.getsizeof() to measure the memory footprint in bytes of two dictionary objects. In the output, you can see that the regular dictionary occupies less memory than its OrderedDict counterpart.

Selecting the Right Dictionary for the Job

Here’s a summary of the more relevant differences and features of both classes that you should consider when you’re deciding which one to use:

Building a Dictionary-Based Queue

A use case in which you should consider using an OrderedDict object rather than a dict object is when you need to implement a dictionary-based queue. Queues are common and useful data structures that manage their items in a FIFO manner. This means that you push in new items at the end of the queue, and old items pop out from the beginning of the queue.

Typically, queues implement an operation to add an item to their end, which is known as an enqueue operation. Queues also implement an operation to remove items from their beginning, which is known as a dequeue operation.

To create a dictionary-based queue, fire up your code editor or IDE, create a new Python module called queue.py and add the following code to it:

Here are some examples of how you can use Queue :

Conclusion

In this tutorial, you learned:

Now you’re in a better position to make an educated decision on whether to use dict or OrderedDict if your code needs an ordered dictionary.

In this tutorial, you coded an example of how to implement a dictionary-based queue, which is a use case that shows that OrderedDict can still be of value in your daily Python coding adventures.

How to Loop Through a Nested Dictionary with Python?

If we have to work with data in the form of key-value pair we know that the right Python data type (structure) to perform this is a Python dictionary. Below we show a way to define a little python dictionary called “ d ”.

The dictionary keys can be several types of data, but not a list or a dictionary as they are mutable.

Instead, the dictionary values can be lists or even another dictionary. This last case is what we called a nested dictionary. As we can see in the example below the key ‘ name ’ has dictionary as value.

Sometimes we may need to go through all the values in a dictionary even if they are nested. Here we are going to see some methods to do it and we are going to show it by printing each key-value pair.

As an example, let’s use a simple data structure that simulates the data of a programming course for children as shown in the figure.

In Python, we can write this structure as:

Finally, we will extract some conclusions considering also the results obtained by testing these methods with a test dictionary built with 10,000 entries and with random nesting in each entry.

Table of Contents

Method 1: With recursion

Recursion is a form to go through all the branches and sub-branches of a tree data structure like we have in this case.

The main idea is to get each pair key-value from the dictionary and evaluate if the value is a dictionary, a nested dictionary, as we saw before. If the value is a “ dict ” type the dict_walk function is called again but with the value as the argument.

This will occur each time the value of the key-value pair would be a dictionary and this is what we called “recursion”.

It´s what we try to show in the figure below:

In Python we can implement this idea in the following way:

As we see, the argument of the dict_walk function is the dictionary saved in the variable called “ course ”.

Then “ d.item ” returns the items of the dictionary as (key, value) pairs that are saved in “ k ” and “ v ” respectively in each loop. Then we can use two options to resolve whether “ v ”, the value, is a dictionary:

Finally, when “ v ” would not be a dictionary we simply print the pair “ k ” “ v ”. The “ print ” inside the “ if ” is just to show each nested key.

The output of this program is:

But the code in example 2 does not show the nested keys as in example 1 and that’s why it’s a bit faster.

Anyway if we use dictionary comprehension as in example 3 we will get the same output as in example 1.

It must also be said that this last example was the slowest in method 1 to process the 10,000-entry test dictionary with random nesting.

Method 2: Iterating and Using a List as a Stack

Then, extract with pop() the last pair and if the value is a dictionary add its key-value pairs to the stack with “ extend ”.

This is we show in the next figure:

Note that using a list as a stack implies using it in such a way that the last item added to the list is the first to be output, this is called LIFO (last in, first out).

Therefore, the characteristic of this method is that it goes through and displays the dictionary in reverse order, from the last to the first.

A way to make it go through the dictionary backward, from the beginning to the end, would be to add and remove elements at the beginning of the list but it would be less efficient because the list would have to move all its elements continuously while there are nestings.

This method also does not show the nested keys except for the last one and is therefore very similar in speed to example 2 of method 1 but perhaps less clear to see.

Method 3: Implementing a generator

In easy words, this method returns one dictionary element at a time.

If in this element (a pair key-value) the value is a dictionary we apply recursion until the value isn’t a dictionary.

This is the process we try to show in the next figure and is similar, in a certain way, to what we have seen in method 1:

A generator works similar to a function, but instead of using “ return ” it uses “ yield “.

This means that each time the generator is called, it returns what is under the first yield. The next time it will return what is under the second yield and so on.

The difference between yield and return is that yield returns something but does not continue the process until the generator is called again. And when it is called again it can continue from where it was last time because the state (for example the value of the local variables) is saved.

In this case, we are going to make, in addition, that if the value is a dictionary the generator calls itself (with yield from) recursively until it finds one that is not.

The fact that a generator works element by element implies memory saving. Anyway, in our time tests, it was always the slowest method.

The Python code could be:

The first yield after the if is to be able to show the nested keys, as in the other methods, but it is not essential.

Another possibility is using the ABC module. This provides some abstract base classes that, as said in the Python documentation, can be used to test whether a class or instance provides a particular interface, for example, if it is hashable or if it is a mapping.

A dictionary corresponds to the ABC class called “ Mutable.Mapping “, which in turn is a subclass of “ Mapping “.

This would allow us, in any of the previous methods, although we are going to exemplify it only for the third one, one more option to check if something is a dictionary.

In addition “ Mutable.Mapping ” and more generically “ Mapping ” allow us to work with many other classes that work like a dictionary.

That is, for example, we can work with a custom class that implements a mapping but that is not the built-in Python dictionary structure.

Finally in this case, with ABC, we have to use “ isinstance() ” function but not “ type() ” inside the “ if ” statement.

A Bonus Tip

This is a little variant that can work with many of the above methods.

As said in the Python documentation the objects returned by d.items() are view objects and they provide a dynamic view on the dictionary’s entries, which means that when the dictionary changes, the view reflects these changes.

Perhaps this is not necessary in your program and you could also iterate directly over each dictionary key as shown in this last example:

Here we applied this tip to the recursion method but we can implement in some others ones.

Conclusion

Most notable in our tests with a 10,000-entry dictionary with random nestings in each entry was that:

The highest memory peak is similar in methods 1 and 3 but method 2 is almost the double. Therefore in terms of memory savings it seems better to use the recursive or with generator methods.

On the other hand in terms of speed, it could be said that methods 1 and 2 are more similar but method 3 was always shown to be about 30% slower.

For all this, if I had to choose, I would start by trying method 1 with either of the two variants, using d.items() or iterating directly on the dictionary as indicated in the additional tip.

Related Tutorials

Why Finxter?

Learning Resources

Python Dictionary Comprehensions (With Examples)

Learn all about Python dictionary comprehensions, including how to create dictionaries, using conditionals (if-else statements), and how to nest comprehensions with easy to follow steps and examples!

Dictionary Comprehensions are similar to Python List Comprehensions. If you want to learn about those as well, check out our tutorial here!

Table of Contents

What are Dictionaries (dicts) in Python?

Dictionaries (or, dicts) in Python are unordered collections of items. Other compound data types (such as lists or tuples) have only a value as an element, a dictionary has a key:value pair as its element.

Dictionaries allow you to easily retrieve values when you know the key.

If you want to learn everything you need to know about dictionaries in Python, check out Real Python’s comprehensive guide to dictionaries.

How Do You Create a Python Dictionary?

All you need to do to create a dictionary in Python is to place items into curly braces, separated by a comma.

Let’s create a dictionary for the book Harry Potter and the Philosopher’s Stone:

How to Access Elements from a Python Dictionary?

Instead of using indexing as other container types do, dictionaries use keys. Keys can be used either inside a square bracket or using the get() method.

The get() method returns None instead of KeyError when the key is not found.

What are Python Dictionary Comprehensions?

Python dictionary comprehensions are concise ways to create dictionaries, without the use of for-loops.

If you want to learn more about For Loops in Python, check out our complete guide!

They are similar to list comprehensions in Python. However, instead of creating lists, they create dictionaries.

Why Use Python Dict Comprehensions?

Dictionary comprehensions are often more concise and easier to read than writing complex for-loops to accomplish the same thing.

Every dictionary comprehension can be written as a for-loop (but not every for-loop can be written as a dictionary comprehension.

For-loops, however, are lengthy and can be difficult to follow.

Because they tend to be quite a bit shorter than for-loops, comprehensions make the code more Pythonic.

Dict comprehensions in Python aim to make code more readable, while not requiring you to write an explicit for-loop.

How Do You Write a Dictionary Comprehension in Python?

Similar to list comprehensions in Python, dictionary comprehensions follow the pattern below:

Let’s explore this in a little more detail:

Let’s try a simple example:

Dictionary Comprehension Example: Creating Squares of Numbers

Imagine you are tasked to create a dictionary for the numbers 1 through 5, where:

We could write the following code:

This returns the following dictionary:

Dictionary Comprehension Example: Changing from Kilograms to Pounds

Imagine we had a dictionary that contained a weights for items in kilograms and we wanted to convert those weights to pounds:

This returns the following output:

How Do You Add Conditions (if-else statements) to Python Dictionary Comprehensions?

In most pieces of code, conditions are used as solutions to problems. Python Dictionary Comprehensions become even more powerful when we add conditions to them, such as if and if-else statements.

Adding IF Statements to Python Dict Comprehensions

If we had a dictionary that included key-value pairs of, for example, people and their age, we could filter the dictionary to only include people older than 25:

Let’s take a look at how this is written:

The IF statement follows the iterable item.

Adding Multiple IF Statements

If we want to add multiple if statements (similar to a nested if statement in a for-loop), we simply chain them together.

For example, if we wanted to filter our ages list to only include people younger than 25 and having an even age (where the age modulus 2 returns 0), we could write:

This returns the following:

If we wanted to chain more if statements, we simply write them in order.

Tip: Chaining if statements is the same as creating an AND statement.

Python Dictionary Comprehension If Else

Using IF-ELSE statements can make dictionary comprehensions even more powerful. Using our earlier example, if we wanted to label the ages as odd or even, we could write the following:

This returns the following:

The structure here is a little different. The IF-ELSE statement is applied directly to the value and is placed in brackets. It is used to transform a value, rather than to remove a key-value pair, in this case.

Nested Dictionary Comprehension in Python

The Value in the Key:Value pair can also be another dictionary comprehension.

Say we wanted to have a dictionary that contains keys of the values of 1 through 5, and each value is another dictionary that contains the key multiplied by intervals of 10 from 10 through 50.

This can be accomplished by writing the following:

This returns the following:

Nested dictionary comprehensions can be tricky to understand, so don’t worry if you don’t fully follow this example!

It’s important to note that for nested dictionary comprehensions, Python starts with the outer loop and then moves (per item) into the inner loop.

How Do You Use the Enumerate Function with Python Dictionary Comprehensions?

The Python enumerate function is useful for identifying the index of an item in a list, tuple, or string.

This is particularly useful when combined with a dictionary comprehension, as you can create a dictionary that identifies the index or a particular item.

Let’s try this with an example. We’ll create a list of items and can create a dictionary that identifies the index of each item.

Dictionary Comprehension Example: Using the Enumerate Function

This returns the following:

This is particularly helpful if we want to know the index of an item. We can them simply use the get() method we learned earlier to retrieve the index.

If we wanted to flip the key:value pair around, so that the index number is first, we could write:

Which returns the following:

Examples of Python Dictionary Comprehensions

Extracting a Subset of a Dictionary

If you want to extract a subset of dictionary key:value pairs from a larger dictionary, this is possible with a dictionary comprehension.

Let’s take a look at an example. In the code below, we want to extract a, b, c from the larger dictionary.

This returns the following:

Remove Items for a Dictionary

We use dictionary comprehensions to remove items from a dictionary as well. Say we have a dictionary that includes ages for people and we wanted to remove two particular people.

This returns the following:

Reverse Key:Value in Dictionary

We can use dictionary comprehensions to reverse the key:value items of a dictionary. Take a look at the code below:

Let’s use an example to demonstrate this:

This returns the following:

Warnings with Python Dictionary Comprehensions

Dictionary comprehensions are very Pythonic in how they written, but can also get far more complicated to read than for-loops. It may be better to write a longer for-loop that makes the code easier to follow, rather than fitting it all on a single line.

Remember, future-readability is important!

Conclusion

Congratulations! You now know everything you need to know about Python dictionary comprehensions! In this post, you learned what dictionaries are, how to write dictionary comprehensions, adding conditionals, nesting comprehensions, and covered off some examples.

If you have any questions, feel free to ask in the comments below or contact us via social media!

If you want to learn more about Python, check out our eBook!

To learn more about related topics, check out the tutorials below:

Does «for key in dict» in python always iterate in a fixed order?

Does the python code

add one thing: during multiple runs, the variable dict remains unchanged, i.e., generate once and read multiple times.

2 Answers 2

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Intrinsically, a dictionary has no order in which it stores it keys. So you can not rely on the order. (I wouldn’t assume the order to be unchanged even when the environment is identical).

One of the few reliable ways:

EDIT: Response to your comment: Python does not store keys in a random fashion. All the documentation says is that, you should not rely on this order. It depends on the implementation how the keys are ordered. What I will say here about your question is: If you are relying on this order, you are probably doing something wrong. In general you should/need not rely on this at all. 🙂

Python Loop Through a Dictionary

Loop Through a Dictionary

You can loop through a dictionary by using a for loop.

When looping through a dictionary, the return value are the keys of the dictionary, but there are methods to return the values as well.

Example

Print all key names in the dictionary, one by one:

Example

Print all values in the dictionary, one by one:

Example

You can also use the values() function to return values of a dictionary:

Example

Loop through both keys and values, by using the items() function:

Related Pages

We just launched
W3Schools videos

COLOR PICKER

Get certified
by completing
a course today!

CODE GAME

Report Error

If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:

Thank You For Helping Us!

Your message has been sent to W3Schools.

Top Tutorials

Top References

Top Examples

Web Courses

W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

Python «extend» for a dictionary

What is the best way to extend a dictionary with another one while avoiding the use of a for loop? For instance:

8 Answers 8

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

The «oneliner way», altering neither of the input dicts, is

are reasonably frequent occurrences in my code.

Originally submitted by Alex Martelli

Have you tried using dictionary comprehension with dictionary mapping:

Another way of doing is by Using dict(iterable, **kwarg)

Will add keys and values from b to a, overwriting if there’s already a value for a key.

Python Dictionaries: Different way to iterate through a dict

I am searching for a different way to access every key in a dictionary within a for loop. Underneath, there is an example code, where I iterate through a dictionary and access every key with the help of a counter and a if statement. Is there another way to access the keys, without a counter or an if statement?

3 Answers 3

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

There is no need for the loop if you already expect name, surname and email.

We can keep iterating to improve the solution:

And even more (if you want to use a protected keyword like dict, naming convention is to use an underscore after it):

And with list comprehensions:

If you want minimal changes to what you have done so far, you can just get list of keys and use the index value (counter variable in your case), something like this:

Sample Run:

Another Note: You’re naming the variable as dict You should avoid that since it’s a keyword in Python

Lets start with the fact that you are not trying to iterate over a dictionary but to create a list containing dictionary entries from a CSV format string. secondly there are a lot of python syntactic mistakes and errors in your code. Refrain from using reserved word such as «dict» as parameter names.

You can use this code snippet as a start if it helps you but I recommend brushing up on python syntax and best practices.

This can be done also using list comprehension, but is much less readable

Not the answer you’re looking for? Browse other questions tagged python dictionary or ask your own question.

Linked

Related

Hot Network Questions

Subscribe to RSS

To subscribe to this RSS feed, copy and paste this URL into your RSS reader.

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

Python dict() — A Simple Guide with Video

Python’s built-in dict() function creates and returns a new dictionary object from the comma-separated argument list of key = value mappings. For example, dict(name = ‘Alice’, age = 22, profession = ‘programmer’) creates a dictionary with three mappings: <'name': 'Alice', 'age': 22, 'profession': 'programmer'>. A dictionary is an unordered and mutable data structure, so it can be changed after creation.

Read more about dictionaries in our full tutorial about Python Dictionaries.

Table of Contents

Usage

Learn by example! Here are some examples of how to use the dict() built-in function:

You can pass an arbitrary number of those comma-separated key = value pairs into the dict() constructor.

Video dict()

Syntax dict()

You can use the dict() method with an arbitrary number of key=value arguments, comma-separated.

Interactive Shell Exercise: Understanding dict()

Consider the following interactive code:

Exercise: Guess the output before running the code.

But before we move on, I’m excited to present you my new Python book Python One-Liners (Amazon Link).

If you like one-liners, you’ll LOVE the book. It’ll teach you everything there is to know about a single line of Python code. But it’s also an introduction to computer science, data science, machine learning, and algorithms. The universe in a single line of Python!

The book was released in 2020 with the world-class programming book publisher NoStarch Press (San Francisco).

The dict() function has many different options to be called with different types of arguments. You’ll learn different ways to use the dict() function next.

How to Create an Empty Dictionary?

You can create an empty dictionary by using Python’s built-in dict() function without any argument. This returns an empty dictionary. As the dictionary is a mutable data structure, you can add more mappings later by using the dPython for dict = value syntax.

How to Create a Dictionary Using Only Keyword Arguments?

You can create a dictionary with initial key: value mappings by using a list of comma-separated arguments such as in dict(name = ‘Alice’, age = 22) to create the dictionary <'name': 'Alice', 'age': 22>. These are called keyword arguments because each argument value has its associated keyword.

How to Create a Dictionary Using an Iterable?

You can initialize your new dictionary by using an iterable as an input for the dict(iterable) function. Python expects that the iterable contains (key, value) pairs. An example iterable is a list of tuples or a list of lists. The first values of the inner collection types are the keys and the second values of the inner collection types are the values of the new dictionary.

You can fix this ValueError by passing only two values in the inner collections. For example use a list of tuples with only two but not three tuple elements.

How to Create a Dictionary Using an Existing Mapping Object?

If you already have a mapping object such as a dictionary mapping keys to values, you can pass this object as an argument into the dict() function. Python will then create a new dictionary based on the existing key: value mappings in the argument. The resulting dictionary will be a new object so if you change it, the changes are not reflected in the original mapping object.

How to Create a Dictionary Using a Mapping Object and Keyword Arguments?

Interestingly, you can also pass a mapping object into the dict() function and add some more key: value mappings using keyword arguments after the first mapping argument. For example, dict(<'Alice': 22>, Bob = 23) creates a new dictionary with both key:value mappings <'Alice': 22, 'Bob': 23>.

How to Create a Dictionary Using an Iterable and Keyword Arguments?

Similarly, you can also pass an iterable of (key, value) tuples into the dict() function and add some more key: value mappings using keyword arguments after the first mapping argument. For example, dict([(‘Alice’, 22)], Bob = 23) creates a new dictionary with both key:value mappings <'Alice': 22, 'Bob': 23>.

Summary

Python’s built-in dict() function creates and returns a new dictionary object from the comma-separated argument list of key = value mappings.

For example, dict(name = ‘Alice’, age = 22, profession = ‘programmer’) creates a dictionary with three mappings: <'name': 'Alice', 'age': 22, 'profession': 'programmer'>.

A dictionary is an unordered and mutable data structure, so it can be changed after creation.

I hope you enjoyed the article! To improve your Python education, you may want to join the popular free Finxter Email Academy:

Do you want to boost your Python skills in a fun and easy-to-consume way? Consider the following resources and become a master coder!

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

🚀 If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com. He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.

I am trying to create a dictionary by using a for loop. I have an ordered list, and I am trying to match up the values from the list to ordered numbers. For Example:

I am just having trouble making the for loop.

So in the for loop I essentially want to make the count variable the key, and have the corresponding item in the list as the value. Then I would add one to count, and continue. Also I am sorry if my code is a little unclear in the for loop. That isn’t actual code, but is just a general idea of what I was looking for. Can anyone help me? Thank you.

4 Answers 4

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

You can use enumerate:

or, using dictionary comprehension:

You can do this in one line without using a For loop or a Counter variable:

2) Then I created the dictionary

3) Then in a For loop over the entries I made recFile (the file record) from the name of the file, removing the fullstop (but you could have made it from whatever you were looping over)

4) I then created the dictionary entry for each photo/movie

Iterating Over Dictionary Key Values Corresponding to List in Python

Working in Python 2.7. I have a dictionary with team names as the keys and the amount of runs scored and allowed for each team as the value list:

I would like to be able to feed the dictionary into a function and iterate over each team (the keys).

Here’s the code I’m using. Right now, I can only go team by team. How would I iterate over each team and print the expected win_percentage for each team?

Thanks for any help.

5 Answers 5

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

You have several options for iterating over a dictionary.

If you iterate over the dictionary itself ( for team in league ), you will be iterating over the keys of the dictionary. When looping with a for loop, the behavior will be the same whether you loop over the dict ( league ) itself, or league.keys() :

You can also iterate over both the keys and the values at once by iterating over league.items() :

You can even perform your tuple unpacking while iterating:

You can very easily iterate over dictionaries, too:

Iterate through dictionary values?

Hey everyone I’m trying to write a program in Python that acts as a quiz game. I made a dictionary at the beginning of the program that contains the values the user will be quizzed on. Its set up like so:

So I defined a function that uses a for loop to iterate through the dictionary keys and asks for input from the user, and compares the user input to the value matched with the key.

This is working fine output looks like this:

So what I would like to be able to do is have a separate function that asks the question the other way, providing the user with the resolution numbers and having the user enter the name of the display standard. So I want to make a for loop but I don’t really know how to (or if you even can) iterate over the values in the dictionary and ask the user to input the keys.

I’d like to have output that looks something like this:

I’ve tried playing with for value in PIX0.values() and thats allowed me to iterate through the dictionary values, but I don’t know how to use that to «check» the user answers against the dictionary keys. If anyone could help it would be appreciated.

EDIT: Sorry I’m using Python3.

Python: Print items of a dictionary line by line (4 Ways)

In this article, we will discuss different ways to print line by line the contents of a dictionary or a nested dictionary in python.

As dictionary contains items as key-value pairs. So, first, let’s create a dictionary that contains student names and their scores i.e.

Now to print this dictionary, we directly pass it in the print function i.e.

the output will be like,

Although it printed the contents of the dictionary, all the key-value pairs printed in a single line. If we have big dictionaries, then it can be hard for us to understand the contents. Therefore, we should print a dictionary line by line. Let’s see how to do that,

Print a dictionary line by line using for loop & dict.items()

dict.items() returns an iterable view object of the dictionary that we can use to iterate over the contents of the dictionary, i.e. key-value pairs in the dictionary and print them line by line i.e.

This approach gives us complete control over each key-value pair in the dictionary. We printed each key-value pair in a separate line.

Frequently Asked Questions

All you need to know about Priting dictionaries

Print a dictionary line by line by iterating over keys

We can iterate over the keys of a dictionary one by one, then for each key access its value and print in a separate line i.e.

Output:

Although by this approach we printed all the key value pairs line by line this is not an efficient method as compared to the previous one because to access one key-value pair, we are performing two operations.

Print a dictionary line by line using List Comprehension

In a single line using list comprehension & dict.items(), we can print the contents of a dictionary line by line i.e.

Learn more about Python Dictionaries

Print a dictionary line by line using json.dumps()

In python, json module provides a function json.dumps() to serialize the passed object to a json like string. We can pass the dictionary in json.dumps() to get a string that contains each key-value pair of dictionary in a separate line. Then we can print that string,

We passed the dictionary object and count of indent spaces in json.dumps(). It returned a json like formatted string. Remember to import the json module for this approach.

Now, what if we have a nested python dictionary?

Printing nested dictionaries line by line in python

Suppose we have a nested dictionary that contains student names as key, and for values, it includes another dictionary of the subject and their scores in the corresponding subjects i.e.

If print this dictionary by passing it to the print() function,

Then the output will be like,

It printed all the contents in a single line. Therefore, it is tough to understand the contents. Now to print the contents of a nested dictionary line by line, we need to do double iteration i.e.

Output:

We first iterated over the items, i.e. key/value pairs of the dictionary, and for each pair printed the key. As value field is another dictionary, so we again iterated over the key-value pairs in this dictionary and printed its contents i.e. key/value pairs in separate lines.

Print nested dictionary line by line using json.dumps()

We can do this in a single line using json module’s dumps() function i.e.

Output:

Are you looking to make a career in Data Science with Python?

Data Science is the future, and the future is here now. Data Scientists are now the most sought-after professionals today. To become a good Data Scientist or to make a career switch in Data Science one must possess the right skill set. We have curated a list of Best Professional Certificate in Data Science with Python. These courses will teach you the programming tools for Data Science like Pandas, NumPy, Matplotlib, Seaborn and how to use these libraries to implement Machine learning models.

Checkout the Detailed Review of Best Professional Certificate in Data Science with Python.

Remember, Data Science requires a lot of patience, persistence, and practice. So, start learning today.

Iterate over nested dictionary

Is there an easy way of iterating over nested dictionary, which may consist of other objects like lists, tuples, then again dictionaries so that iteration covers all the elements of these other objects?

For example, if I type a key of a nested dictionary object, I would get it all listed in the Python interpreter.

[edit] here is example dictionary:

sorry for being unreadable, but I did the best that I could.

6 Answers 6

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

A generator version of Graddy’s recurse() answer above that should not explode on strings, and also gives you the compound key (cookie crumb trail?) showing how you arrived at a certain value:

produces output (using the example dictionary provided in the question):

Iterate Over Dictionary

The two setups using print(i, j) and print(i) return the same result. Are there cases when one should be used over the other or is it correct to use them interchangeably?

3 Answers 3

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Both are different if remove parenthesis in print because you are using python 2X

In Python 3, print(i, j) and print(i) does not return the same result.

print(i) prints a tuple containing the dictionary key followed by its value.

items() returns a view object which allows you to iterate over the (key, value) tuples. So basically you can just manipulate them as what you do with tuples. The document may help:

iter(dictview) Return an iterator over the keys, values or items (represented as tuples > of (key, value)) in the dictionary.

Python Dictionaries

Use Python Dictionaries Like a Pro

Python programming language is widely used by developers in data science projects. To complete such projects, understanding data structures plays an important role. Python has several built-in data structures such as lists, sets, tuples, and dictionaries, in order to support the developers with ready to use data structures.

In this article, I will try to explain why and when to use Python dictionaries, meanwhile giving you some hints about the correct usage of the dictionary methods.

Let’s understand the Python dictionaries in detail with step-by-step explanations and examples.

What is a Python Dictionary?

In a nutshell, a dictionary can be defined as a collection of data stored in key/value pairs. Keys must be an immutable data type (such as string, integer or tuple), while values in a dictionary can be any Python data type.

Duplicate keys are not allowed. If the same key is used twice in the same dictionary, then the last occurrence will override the first.

Data stored in a dictionary can be modified so they are called mutable objects. They are unordered which means that the order in which we specified the items is not maintained. (They are ordered in version 3.7 onwards)

As they are dynamic, they can grove or shrink when needed.

When to use Python Dictionaries?

As you now know what is a Python dictionary, it is time to explore when to use them in your code.

Here is a list helping you to understand when to use Python dictionaries;

How to Create a Python Dictionary?

There are many ways of creating and initializing the dictionaries. As shown in the below code snippet, the easiest way of creating dictionaries is using curly brackets or dict() method directly;

If you have two iterable objects (for example list objects), you can use zip() function to create a dictionary. See the example below;

fromkeys() method is another way of creating dictionaries. It takes an iterable object and creates a dictionary with specified value as shown in the below code snippet;

What is a Python Dictionary Comprehensions?

Python dictionary comprehensions provide an elegant way of creating dictionaries. They make your code easier to read and more Pythonic. They shorten the code required in dictionary initialisation and they can be used to substitute ‘for’ loops.

The general syntax for dictionary comprehensions is:

Adding Conditionals to a Dictionary Comprehension

You can extend the use of dictionary comprehensions with conditional statements. You can see below the use of multiple ‘if’ conditionals, ‘else-if’ conditionals in dictionary comprehensions;

Time Complexity of Dictionary Operations

Getting, setting and deleting an item in a dictionary has O(1) time complexity which means that no matter how big is your dictionary, the time it takes to access an item is constant.

Iterating over a dictionary has O(n) time complexity means that the time it takes to perform this task linearly proportional to the number of items contained in the dictionary.

How to Access Values in a Dictionary

If you try to access an element with a key which does not exist in your dictionary, you get a KeyError. Knowing the proper way of accessing the elements inside the dictionary is important for not to have KeyErrors during runtime.

To avoid the KeyError, access the elements of a dictionary with get() method. Alternatively, you can check the existence of the key with ‘in’ keyword.

How to Insert an Item Into a Dictionary?

Below code snippet shows many examples of adding items into your dictionary;

What are the Dictionary methods?

There are many methods contained in the Python dictionaries helping you to perform different tasks on the dictionary objects. I listed them below with their short definitions;

How to Remove an Item From a Dictionary?

To remove an item from a dictionary object, you can use ‘del’ keyword or pop() method. In addition, you can use dictionary comprehensions to remove items of a dictionary. Check below code snippet for the implementation of those methods with examples;

How to Copy Dictionaries?

You can use the copy() method to get a shallow copy of an existing dictionary. A shallow copy means a new dictionary will be populated with references to the objects in the existing dictionary.

To create a deep copy, ‘copy.deepcopy(dict)’ method should be used. It creates a fully independent clone of the original dictionary with all of its elements.

See below to understand how you can implement shallow copy and deep copy methods on dictionary objects;

How to Merge Dictionaries?

You can merge dictionaries with a custom function containing dict.copy() and dict.update() methods.

In Python 3.5 and onwards, you can merge dictionaries with unpacking them using ‘ **’ operator.

The simplest and easiest way of merging dictionaries is using the merging operator ‘|’ which is available in Python 3.9+

Below code snippet shows implementations of all above methods with examples;

How to Sort Items In a Dictionary?

Python dictionaries are unordered up to version 3.7 so even if you sort the (key, value) pairs, you wouldn’t be able to store them in a dictionary by preserving the ordering. To preserve the ordering, we can store the sorted dictionary in an OrderedDict

See below to explore how you can sort the dictionaries by key and by value;

How to Loop Through a Dictionary?

Python dictionary methods; values(), keys(), and items() provide access to the elements contained inside a dictionary. You can use them in for loops to iterate through the dictionaries.

In addition, dictionary comprehensions can also be used for iteration as shown below;

Conclusion and Key Takeaways

As data structures are fundamental parts of our programs, it is really important to have a solid understanding of Python dictionaries to create efficient programs.

I explained why and when to use the dictionaries, some of the key takeaways are listed below;

Python One Line Dictionary

Python’s dictionary data structure is one of the most powerful, most underutilized data structures in Python. Why? Because checking membership is more efficient for dictionaries than for lists, while accessing elements is easier for dictionaries than for sets.

In this tutorial, you’ll learn how to perform four common dictionary operations in one line of Python code. By studying these problems, you’ll not only learn how to use dictionaries in Python, but you’ll become a better coder overall. So, let’s dive into the first problem: creating a dictionary from a list in one line.

Table of Contents

Python Create Dictionary From List in One Line

Challenge: Create a dictionary from a list in one line of Python.

Example: Say, you want to have the list indices as keys and the list elements as values.

Solution: There are multiple ways to accomplish this task. Let’s learn the most Pythonic one next:

Try it yourself in our interactive code shell:

Exercise: Explore the enumerate() function further by printing its output!

Python One Line For Loop to Create Dictionary

Challenge: How to create a dictionary from all elements in a list using a single-line for loop?

Example: Say, you want to replace the following four-liner code snippet with a Python one-liner.

How do you accomplish this?

Solution: Use dictionary comprehension to replace the for loop construct with a single line of Python.

Dictionary Comprehension is a concise and memory-efficient way to create and initialize dictionaries in one line of Python code. It consists of two parts: expression and context. The expression defines how to map keys to values. The context loops over an iterable using a single-line for loop and defines which (key,value) pairs to include in the new dictionary.

You can learn about dictionary comprehension in my full video tutorial:

Python Print Dictionary One Line

Challenge: How can you print a dictionary in a well-structured way using only a single line of Python code (without using multiple lines to create the output)?

Solution: Use the pretty print function!

Printing the dictionary this way, doesn’t change the dictionary in any way but makes it more readable on the Python shell!

Iterate Over Dictionary Python One Line

Challenge: How to iterate over a dictionary in Python in one line?

Example: Say, you want to go over each (key, value) pair of a dictionary like this:

But you want to do it in a single line of Python code! How?

Solution: Use the dict.items() method to obtain the iterable. Then, use a single-line for loop to iterate over it.

The output is the same while the code is much more concise. The items() method of a dictionary object creates an iterable of (key, value) tuple pairs from the dictionary.

Python Update Dictionary in One Line

Challenge: Given a dictionary and a (key, value) pair. The key may or may not already exist in the dictionary. How to update the dictionary in one line of Python?

Solution: Use the square bracket notation dictPython for dict = value to create a new mapping from key to value in the dictionary. There are two cases:

Challenge 2: But what if you want to update only if the key didn’t exist before. In other words, you don’t want to overwrite an existing mapping?

Solution: In this case, you can use the check if key in dict to differentiate the two cases:

Now, you may want to write this in a single line of code. You can do it the naive way:

An better alternative is the dictionary.setdefault() method:

You can simply ignore the return value to update a key in a dictionary if it isn’t already present.

The age.setdefault(‘Alice’, 20) only inserts the key ‘Alice’ if it isn’t already present (in which case it would associate the value 20 to it). But because it already exists, the command has no side effects and the new value does not overwrite the old one.

Where to Go From Here?

Enough theory. Let’s get some practice!

Coders get paid six figures and more because they can solve problems more effectively using machine intelligence and automation.

To become more successful in coding, solve more real problems for real people. That’s how you polish the skills you really need in practice. After all, what’s the use of learning theory that nobody ever needs?

You build high-value coding skills by working on practical coding projects!

Do you want to stop learning with toy projects and focus on practical code projects that earn you money and solve real problems for people?

🚀 If your answer is YES!, consider becoming a Python freelance developer! It’s the best way of approaching the task of improving your Python skills—even if you are a complete beginner.

If you just want to learn about the freelancing opportunity, feel free to watch my free webinar “How to Build Your High-Income Skill Python” and learn how I grew my coding business online and how you can, too—from the comfort of your own home.

While working as a researcher in distributed systems, Dr. Christian Mayer found his love for teaching computer science students.

To help students reach higher levels of Python success, he founded the programming education website Finxter.com. He’s author of the popular programming book Python One-Liners (NoStarch 2020), coauthor of the Coffee Break Python series of self-published books, computer science enthusiast, freelancer, and owner of one of the top 10 largest Python blogs worldwide.

His passions are writing, reading, and coding. But his greatest passion is to serve aspiring coders through Finxter and help them to boost their skills. You can join his free email academy here.

how to create a new dictionary in for loop?

Above code produces following output :

But I am expecting below output :

Apparantely python modifies the existing dictionary only and does not create a new one. What can I do to solve this issue?

Is there exist a way to create a new dictionary object from existing one? Is there any other collection which is more suitable for this?

2 Answers 2

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

As has been pointed out, it doesn’t matter what you do, when in the loop you have:

This said the problem is that you are modifying the only dictionary. You want to create a new one for each iteration:

However there isn’t much point in having the og_dict outside the loop at this point:

To answer your broader question: the kind of behaviour you are looking for is typical of functional languages which have persistent data structures. However in imperative languages having an operation that copies & updates would be a simple way to shoot yourself on the foot by creating tons of unwanted copies.

All built-in cointainers act the same as dict : update methods simply modify the current object and you have to explicitly copy the object to avoid the side effects.

I am doing the following:

This looks very hackish to me. I want to know if there is an elegant/better way of doing this.

3 Answers 3

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

I often use this little utility:

For your use case:

Here are two solutions adapted from earlier answers of mine.

Either, you can just get the list of items from the dictionary and create new dict s from slices of that list. This is not optimal, though, as it does a lot of copying of that huge dictionary.

Alternatively, you can use some of the itertools module’s functions to yield (generate) new sub-dictionaries as you loop. This is similar to @georg’s answer, just using a for loop.

Example usage. for both cases:

Not the answer you’re looking for? Browse other questions tagged python dictionary or ask your own question.

Linked

Related

Hot Network Questions

Subscribe to RSS

To subscribe to this RSS feed, copy and paste this URL into your RSS reader.

By clicking “Accept all cookies”, you agree Stack Exchange can store cookies on your device and disclose information in accordance with our Cookie Policy.

Python Dictionary: How To Create And Use, With Examples

The Python dictionary is one of the language’s most powerful data types. In other programming languages and computer science in general, dictionaries are also known as associative arrays. They allow you to associate one or more keys to values. If you are familiar with JSON, you might feel right at home. The syntax of a dictionary strongly resembles the syntax of a JSON document.

Table of contents

Creating a Python Dictionary

Let’s look at how we can create and use a Python dictionary in the Python REPL:

A dictionary is created by using curly braces. Inside these braces, we can add one or more key-value pairs. When adding more than one key-value pair, the pairs are separated by commas. The first dictionary in our example associates keys (names like Jack and Pete) with values (their phone numbers). The second dictionary is an empty one.

Access and delete a key-value pair

Now that you’ve seen how to initialize a dictionary, let’s see how we can add and remove entries to an already existing one:

Default values and dict.get()

With the get-method, you don’t have to surround the operation with a try… except. It’s ideal when working with configuration data that is parsed from YAML or JSON files, where your software offers defaults for unset configuration items.

Overwrite dictionary entries

To overwrite an entry, simply assign a new value to it. You don’t need to del() it first. E.g.:

Using try… except

If a requested key does not exist, an exception of type KeyError is thrown:

Valid dictionary values

You can put anything in a dictionary. You’re not limited to numbers or strings. In fact, you can put dictionaries and Python lists inside your dictionary and access the nested values in a very natural way:

Python’s JSON decoding and encoding library uses this feature of Python when parsing more complex JSON documents. It creates nested trees of lists, dictionaries, and other valid data types.

Valid dictionary keys

A more likely use case is the use of numbers as keys. For example, consider this registration of runners in a marathon:

More ways to create a Python dictionary

Depending on your data source, there are more advanced ways to initialize a dictionary that might come in handy.

Using the dict() constructor

The dict() function builds a dictionary from a sequence or list of key-value pairs (tuples):

Dictionary Comprehensions

Analogous to list comprehensions, you can also use dictionary comprehensions to create a new dictionary. While a list only contains values, a dictionary contains key/value pairs. Hence, dictionary comprehensions need to define both. Other than that, the syntax is similar:

Please read my article on list comprehensions for a more detailed explanation of comprehensions.

Using dict.fromkeys

See the following code:

Parse a JSON object to a dictionary

As explained in the section on working with JSON, you can also decode JSON data into a dictionary like this:

Check if a key exists in a Python dictionary

You can check if a key exists inside a dictionary with the in and not in keywords:

Getting the length of a Python dictionary

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

Dictionary view objects

Some built-in dictionary methods return a view object, offering a window on your dictionary’s keys and values. Before we start using such view objects, there’s an important concept you need to understand: values in a view object change as the content of the dictionary changes.

dict.keys() and dict.values()

This is best illustrated with an example, in which we use two of these views: keys() and values(). Keys returns a view on all the keys of a dictionary, while values() returns a view on all its values:

If that didn’t work, here’s the non-interactive version:

dict.items(): loop through a Python dictionary

The items() method of a dictionary returns an iterable view object, offering both the keys and values, as can be seen below. You can loop through this object with a simple Python for-loop:

Alternatively, you can use the keys() and values() methods to loop through just the keys or values. Both functions return an iterable view object.

More ways to get all the keys

We’ve seen the dict.keys() method, which returns a view object containing a list of all the dictionary keys. The advantage of this object is that it stays in sync with the dictionary. It’s perfect for looping over all the keys, but you still might opt for the list or sorted methods though, because those return a native list that you can manipulate as well.

There are two other easy ways to get all the keys from a dictionary:

list() returns all the keys in insertion order, while sorted() returns all the keys sorted alphabetically.

Merging dictionaries

If you’re running Python 3.9 or later, you can use the newly introduced merging operator for dictionaries:

If you’re still on a Python version between 3.5 and 3.9, you can merge two dictionaries using the following method:

Comparing Python dictionaries

If you need to compare two dictionaries, you can simply use a comparison operator like this:

This looks and sounds trivial, but it’s not! A dictionary can contain objects of any type, after all! Consequently, Python has to walk through all the keys and values and individually compare them.

You might wonder if a dictionary with the same keys and values, inserted in another order, is the same. Let’s check this:

They are the same to Python, despite having a different order.

Good to know: the order of dictionaries is guaranteed to be insertion order since Python 3.7. In other words, it means that the order of the dictionary is determined by the order in which you insert items.

Built-in Python dictionary methods

Each dictionary inherits a number of handy built-in functions, as listed in the following table:

Method	What is does	Example
clear()	Remove all key/value pairs (empty the dictionary)	phone_numbers.clear()
get(key)	Get a single item with the given key, with an optional default value	phone_numbers.get(‘Martha’, ‘Unknown person’)
items()	Returns a view object containing key-value pairs from the dictionary	phone_numbers.items()
keys()	Returns a view object with a list of all keys from the dictionary	phone_numbers.keys()
values()	Returns a view_object with a list of all values from the dictionary	phone_numbers.values()
pop(key, default_value)	Returns and removes the element with the specified key	phone_numbers.pop(‘Martha’)
popitem()	Returns and removes the last inserted item (Python 3.7+) or a random item	phone_numbers.popitem()
setdefault(key, value)	Returns the value of the specified key. If the key does not exist, it’s inserted with the given value	phone_numbers.setdefault(‘John Doe’, 1234)
update(iterable)	Add all pairs from given iterable, e.g. a dictionary	phone_numbers.update(<"Alina": 1234, "Alice", 2345>)

The built-in methods of a Python dictionary

Conclusion

You’ve learned what a Python dictionary is, how to create dictionaries, and how to use them. We’ve looked at many practical use cases involving Python dictionaries with example code. If there’s still something missing, or simply to learn even more about dictionaries, you can head over to the official manual page at Python.org.

Related posts you might like

Python Courses

Are you enjoying this free tutorial? Please also have a look at my premium courses. They offer a superior user experience with small, easy-to-digest lessons and topics, progress tracking, quizzes to test your knowledge, and practice sessions. Each course will earn you a downloadable course certificate.

Python Fundamentals I is a course for beginners that will get you started with Python in no time. Learn all the essentials, test your progress with quizzes and assignments, and bring it all together with the final course project!

12. Dictionaries

By Bernd Klein. Last modified: 29 Jun 2022.

Introduction

We have already become acquainted with lists in the previous chapter. In this chapter of our online Python course we will present the dictionaries, the operators and the methods on dictionaries. Python programs or scripts without lists and dictionaries are nearly inconceivable. Dictionaries and their powerful implementations are part of what makes Python so effective and superior. Like lists, they can be easily changed, can be shrunk and grown ad libitum at run time. They shrink and grow without the necessity of making copies. Dictionaries can be contained in lists and vice versa.

But what’s the difference between lists and dictionaries? A list is an ordered sequence of objects, whereas dictionaries are unordered sets. However, the main difference is that items in dictionaries are accessed via keys and not via their position.

Dictionaries don’t support the sequence operation of the sequence data types like strings, tuples and lists. Dictionaries belong to the built-in mapping type, but so far, they are the sole representative of this kind!

At the end of this chapter, we will demonstrate how a dictionary can be turned into one list, containing (key,value)-tuples or two lists, i.e. one with the keys and one with the values. This transformation can be done reversely as well.

Live Python training

Enjoying this page? We offer live Python training courses covering the content of this site.

Examples of Dictionaries

Our first example is a dictionary with cities located in the US and Canada and their corresponding population. We have taken those numbers from the «List of North American cities by population» from Wikipedia.

If we want to get the population of one of those cities, all we have to do is to use the name of the city as an index. We can see that dictonaries are enclosed in curly brackets. They contain key value pairs. A key and its corresponding value are separated by a colon:

OUTPUT:

We can access the value for a specific key by putting this key in brackets following the name of the dictionary:

Python Dictionary

In this tutorial, you’ll learn everything about Python dictionaries; how they are created, accessing, adding, removing elements from them and various built-in methods.

Video: Python Dictionaries to Store key/value Pairs

Python dictionary is an unordered collection of items. Each item of a dictionary has a key/value pair.

Dictionaries are optimized to retrieve values when the key is known.

Creating Python Dictionary

Creating a dictionary is as simple as placing items inside curly braces <> separated by commas.

An item has a key and a corresponding value that is expressed as a pair (key: value).

While the values can be of any data type and can repeat, keys must be of immutable type (string, number or tuple with immutable elements) and must be unique.

As you can see from above, we can also create a dictionary using the built-in dict() function.

Accessing Elements from Dictionary

Output

Changing and Adding Dictionary elements

Dictionaries are mutable. We can add new items or change the value of existing items using an assignment operator.

If the key is already present, then the existing value gets updated. In case the key is not present, a new (key: value) pair is added to the dictionary.

Output

Removing elements from Dictionary

The popitem() method can be used to remove and return an arbitrary (key, value) item pair from the dictionary. All the items can be removed at once, using the clear() method.

We can also use the del keyword to remove individual items or the entire dictionary itself.

Output

Python Dictionary Methods

Methods that are available with a dictionary are tabulated below. Some of them have already been used in the above examples.

Here are a few example use cases of these methods.

Output

Python Dictionary Comprehension

Dictionary comprehension is an elegant and concise way to create a new dictionary from an iterable in Python.

Here is an example to make a dictionary with each item being a pair of a number and its square.

Output

This code is equivalent to

Output

A dictionary comprehension can optionally contain more for or if statements.

An optional if statement can filter out items to form the new dictionary.

Here are some examples to make a dictionary with only odd items.

Output

To learn more dictionary comprehensions, visit Python Dictionary Comprehension.

Other Dictionary Operations

Dictionary Membership Test

Output

Iterating Through a Dictionary

We can iterate through each key in a dictionary using a for loop.

Output

Dictionary Built-in Functions

Here are some examples that use built-in functions to work with a dictionary.

Python Dictionary

What is Python dictionary?

Dictionaries are Python’s implementation of a data structure, generally known as associative arrays, hashes, or hashmaps.

You can think of a dictionary as a mapping between a set of indexes (known as keys) and a set of values. Each key maps to a value. The association of a key and a value is called a key:value pair or sometimes an item.

As an example, we’ll build a dictionary that stores employee record.

Create a Dictionary

The dict() Constructor

You can convert two-value sequences into a dictionary with Python’s dict() constructor. The first item in each sequence is used as the key and the second as the value.

When the keys are simple strings, it is sometimes easier to specify key:value pairs using keyword arguments.

Other Ways to Create Dictionaries

There are lots of other ways to create a dictionary.

You can use dict() function along with the zip() function, to combine separate lists of keys and values obtained dynamically at runtime.

You’ll often want to create a dictionary with default values for each key. The fromkeys() method offers a way to do this.

There is one more way to create a dictionary based on existing dictionary, called Dictionary comprehension.

Important Properties of a Dictionary

Dictionaries are pretty straightforward, but here are a few points you should be aware of when using them.

Keys must be unique:

A key can appear in a dictionary only once.

Even if you specify a key more than once during the creation of a dictionary, the last value for that key becomes the associated value.

Notice that the first occurrence of ‘name’ is replaced by the second one.

Key must be immutable type:

You can use any object of immutable type as dictionary keys – such as numbers, strings, booleans or tuples.

An exception is raised when mutable object is used as a key.

Value can be of any type:

There are no restrictions on dictionary values. A dictionary value can be any type of object and can appear in a dictionary multiple times.

Access Dictionary Items

The order of key:value pairs is not always the same. In fact, if you write the same example on another PC, you may get a different result. In general, the order of items in a dictionary is unpredictable.

But this is not a problem because the items of a dictionary are not indexed with integer indices. Instead, you use the keys to access the corresponding values.

If you refer to a key that is not in the dictionary, you’ll get an exception.

Add or Update Dictionary Items

Adding or updating dictionary items is easy. Just refer to the item by its key and assign a value. If the key is already present in the dictionary, its value is replaced by the new one.

If the key is new, it is added to the dictionary with its value.

Merge Two Dictionaries

Use the built-in update() method to merge the keys and values of one dictionary into another. Note that this method blindly overwrites values of the same key if there’s a clash.

Remove Dictionary Items

There are several ways to remove items from a dictionary.

Remove an Item by Key

If you know the key of the item you want, you can use pop() method. It removes the key and returns its value.

If you don’t need the removed value, use the del statement.

Remove Last Inserted Item

The popitem() method removes and returns the last inserted item.

In versions before 3.7, popitem() would remove a random item.

Remove all Items

To delete all keys and values from a dictionary, use clear() method.

Get All Keys, Values and Key:Value Pairs

There are three dictionary methods that return all of the dictionary’s keys, values and key-value pairs: keys(), values(), and items(). These methods are useful in loops that need to step through dictionary entries one by one.

All the three methods return iterable object. If you want a true list from these methods, wrap them in a list() function.

Iterate Through a Dictionary

If you use a dictionary in a for loop, it traverses the keys of the dictionary by default.

To iterate over the values of a dictionary, index from key to value inside the for loop.

Check if a Key or Value Exists

If you want to know whether a key exists in a dictionary, use in and not in operators with if statement.

in Operator on List vs Dictionary

The in operator uses different algorithms for lists and dictionaries. For lists, it uses a search algorithm. As the list gets longer, the search time gets longer. For dictionaries, Python uses a different algorithm called Hash Table, which has a remarkable property: the operator takes the same amount of time, regardless of how many items are in the dictionary.

Find Dictionary Length

To find how many key:value pairs a dictionary has, use len() method.

Python Dictionary Methods

Python has a set of built-in methods that you can invoke on dictionary objects.

Python Dictionary Methods

Method	Description
clear()	Removes all items from the dictionary
copy()	Returns a shallow copy of the dictionary
fromkeys()	Creates a new dictionary with the specified keys and values
get()	Returns the value of the specified key
items()	Returns a list of key:value pair
keys()	Returns a list of all keys from dictionary
pop()	Removes and returns single dictionary item with specified key.
popitem()	Removes and returns last inserted key:value pair from the dictionary.
setdefault()	Returns the value of the specified key, if present. Else, inserts the key with a specified value.
update()	Updates the dictionary with the specified key:value pairs
values()	Returns a list of all values from dictionary

Built-in Functions with Dictionary

Python also has a set of built-in functions that you can use with dictionary objects.

Filter dict to contain only certain keys?

I’ve got a dict that has a whole bunch of entries. I’m only interested in a select few of them. Is there an easy way to prune all the other ones out?

20 Answers 20

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Constructing a new dict:

Uses dictionary comprehension.

Note that this, unlike jnnnnn’s version, has stable performance (depends only on number of your_keys) for old_dict s of any size. Both in terms of speed and memory. Since this is a generator expression, it processes one item at a time, and it doesn’t looks through all items of old_dict.

Removing everything in-place:

Slightly more elegant dict comprehension:

Here’s an example in python 2.6:

The filtering part is the if statement.

This method is slower than delnan’s answer if you only want to select a few of very many keys.

You can do that with project function from my funcy library:

Also take a look at select_keys.

This one liner lambda should work:

Here’s an example:

It’s a basic list comprehension iterating over your dict keys (i in x) and outputs a list of tuple (key,value) pairs if the key lives in your desired key list (y). A dict() wraps the whole thing to output as a dict object.

All pieced of code performance are measured with timeit using number=1000, and collected 1000 times for each piece of code.

For python 3.6 the performance of three ways of filter dict keys almost the same. For python 2.7 code 3 is slightly faster.

Given your original dictionary orig and the set of entries that you’re interested in keys :

which isn’t as nice as delnan’s answer, but should work in every Python version of interest. It is, however, fragile to each element of keys existing in your original dictionary.

Based on the accepted answer by delnan.

What if one of your wanted keys aren’t in the old_dict? The delnan solution will throw a KeyError exception that you can catch. If that’s not what you need maybe you want to:

only include keys that excists both in the old_dict and your set of wanted_keys.

have a default value for keys that’s not set in old_dict.

This function will do the trick:

Just like delnan’s version, this one uses dictionary comprehension and has stable performance for large dictionaries (dependent only on the number of keys you permit, and not the total number of keys in the dictionary).

And just like MyGGan’s version, this one allows your list of keys to include keys that may not exist in the dictionary.

And as a bonus, here’s the inverse, where you can create a dictionary by excluding certain keys in the original:

Note that unlike delnan’s version, the operation is not done in place, so the performance is related to the number of keys in the dictionary. However, the advantage of this is that the function will not modify the dictionary provided.

Edit: Added a separate function for excluding certain keys from a dict.

If we want to make a new dictionary with selected keys removed, we can make use of dictionary comprehension
For example:

This seems to me the easiest way:

I like doing this to unpack the values too:

We can also achieve this by slightly more elegant dict comprehension:

Dictionary Objects¶

This subtype of PyObject represents a Python dictionary object.

This instance of PyTypeObject represents the Python dictionary type. This is the same object as dict in the Python layer.

Return true if p is a dict object or an instance of a subtype of the dict type. This function always succeeds.

Return true if p is a dict object, but not an instance of a subtype of the dict type. This function always succeeds.

Return a new empty dictionary, or NULL on failure.

Return a types.MappingProxyType object for a mapping which enforces read-only behavior. This is normally used to create a view to prevent modification of the dictionary for non-dynamic class types.

Empty an existing dictionary of all key-value pairs.

Return a new dictionary that contains the same key-value pairs as p.

Return the object from dictionary p which has a key key. Return NULL if the key key is not present, but without setting an exception.

Note that exceptions which occur while calling __hash__() and __eq__() methods will get suppressed. To get error reporting use PyDict_GetItemWithError() instead.

Changed in version 3.10: Calling this API without GIL held had been allowed for historical reason. It is no longer allowed.

Variant of PyDict_GetItem() that does not suppress exceptions. Return NULL with an exception set if an exception occurred. Return NULL without an exception set if the key wasn’t present.

Note that exceptions which occur while calling __hash__() and __eq__() methods and creating a temporary string object will get suppressed. To get error reporting use PyDict_GetItemWithError() instead.

New in version 3.4.

Return a PyListObject containing all the items from the dictionary.

Return a PyListObject containing all the keys from the dictionary.

Return a PyListObject containing all the values from the dictionary p.

Return the number of items in the dictionary. This is equivalent to len(p) on a dictionary.

The dictionary p should not be mutated during iteration. It is safe to modify the values of the keys as you iterate over the dictionary, but only so long as the set of keys does not change. For example:

Словари (dict) и работа с ними. Методы словарей

Сегодня я расскажу о таком типе данных, как словари, о работе со словарями, операциях над ними, методах, о генераторах словарей.

Чтобы работать со словарём, его нужно создать. Сделать это можно несколькими способами. Во-первых, с помощью литерала:

Во-вторых, с помощью функции dict:

В-третьих, с помощью метода fromkeys:

В-четвертых, с помощью генераторов словарей, которые очень похожи на генераторы списков.

Теперь попробуем добавить записей в словарь и извлечь значения ключей:

Как видно из примера, присвоение по новому ключу расширяет словарь, присвоение по существующему ключу перезаписывает его, а попытка извлечения несуществующего ключа порождает исключение. Для избежания исключения есть специальный метод (см. ниже), или можно перехватывать исключение.

Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: встроенные функции, ключевые слова (например, циклы for и while), а также специальные методы словарей.

Python dict() Function

Python dict() Function is used to create a Python dictionary, a collection of key-value pairs.

Python3

Output:

A dictionary is a mutable data structure i.e. the data in the dictionary can be modified. Dictionary is an indexed data structure i.e. the contents of a dictionary can be accessed by using indexes, here in the dictionary the key is used as an index.

Example 1: Creating dictionary using keyword arguments

We can pass keyword arguments as a parameter with the required values that will be keys and values of the dictionary.

Syntax:

Python3

Output:

Example 2: Creating deep-copy of the dictionary using dict()

Creating a new instance (deep copy) of dictionary using dict().

Syntax:

Python3

Output:

Example 3: Creating dictionary using iterables

The keys and values can be passed to dict() in form of iterables like lists or tuples to form a dictionary and keyword arguments can also be passed to dict().

Словари в Python и методы работы с ними

В одной из прошлых статей я разбирал списки в Python и методы работы с ними. Сегодня мы узнаем, как работать со словарями в Python и изучим их методы.

Что такое словарь

Словари (dict) хранят в себе ключи и их объекты, где ключ – это имя объекта в словаре. Их могут называть ассоциативными массивами или хеш-таблицами.

Как мы знаем, в списках доступ к элементам осуществляется по индексу, который является неотрицательным числом. Индекс в списках создается автоматически при добавлении новых элементов, а индексами в словарях служат ключи, и их мы должны объявлять сами.

Для каких целей нам будут полезны словари?

Подсчет каких-то предметов, где ключи – названия предметов, а объект – их количество.

Для экономии памяти, если есть массив, который использует не все индексы по порядку.

Установка соответствий между объектами, сортировка.

Хранение данных разных объектов (например: ключ – ID пользователя ВКонтакте, а объект – массив с данными).

Ключом может быть произвольный неизменяемый тип данных: различные числа, строки, кортежи. Ключом в словаре не может быть множество, но может быть неизменяемый элемент типа frozenset. Значением элемента словаря может быть любой изменяемый или неизменяемый тип данных.

Создание словаря в Python

Пустой словарь в Python, как и в JavaScript, можно создать двумя способами: через функцию dict() или с помощью фигурных скобок. Рассмотрим на примере:

Теперь создадим уже заполненный словарь через функцию и фигурные скобки:

Изменение словаря

Добавим в наш словарь объект. Для этого нам нужно придумать значение ключу. Рассмотрим на примере:

Для удаления ключа и его объекта в словаре используют метод del, указывая имя ключа в квадратных скобках:

Перебор элементов словарей в Python

Для вывода всех ключей и значений по порядку используем цикл с оператором in:

Для вывода значения по ключу используем имя словаря и квадратные скобки с именем нужного ключа:

Методы словарей в Python

copy() – создание копии словаря. Рассмотрим на примере:

get() – получение значения по ключу. Рассмотрим на примере:

clear() – очистка словаря. Рассмотрим на примере:

keys() – получение всех ключей словаря. Рассмотрим на примере:

values() – получение всех значений элементов словаря. Пример:

items() – получение всех элементов словаря, включая ключи. Рассмотрим на примере:

pop() – удаляет и возвращает значение ключа. Рассмотрим на примере:

popitem() – удаляет и возвращает имя и значение ключа. Пример:

setdefault() – получение значения по ключу, если такой ключ присутствует в словаре. Когда такого ключа нет, он создается со значением None (если оно не указано в свойствах). Рассмотрим на примере:

update(<>) – обновить значения по ключам, добавление новых ключей:

Мы изучили словари в Python и методы работы с ними. Надеюсь, статья была полезной для вас. Удачи!

Словари в Python (dict)

У местная аналогия для словаря в языке Python — обычный толковый словарь, где каждому отдельному слову (ключу) соответствует его определение (значение).

А теперь разберёмся подробнее, как в Python устроены словари и как с ними работать.

Что такое словарь и как он устроен

Словари в Python можно считать реализацией структуры данных, более известной как ассоциативный массив.

Способ хранения словаря Python в памяти

Рассмотрим сначала то, как выглядит структура отдельно взятого элемента словаря в pycore_dict.h :

Теперь перейдем к облику самой C-структуры словаря в Python:

Выходит, что, при объявлении нового словаря, в памяти создается объект, состоящий из следующих блоков:

Как и в случае со списками, объект словаря хранит лишь указатели, а не сами значения

Базовая работа со словарями

Объявление словаря

Объявить словарь Python 3 можно несколькими способами. Но сначала рассмотрим наиболее простую ситуацию и создадим пустой словарь:

Теперь объявим и инициализируем словарь из трех элементов через соответствующий литерал и выведем на экран значение третьего элемента:

Помимо литерального объявления, в Python существует возможность объявлять словари при помощи функции dict() :

inventory_dict = dict(right_hand=’sword’, left_hand=’shield’) inventory_dict >

Чуть более хитрые способы создания словарей:

# словарь из десяти элементов со значениями, равными 0 zero_array_dict = dict.fromkeys([‘a0’, ‘b0’, ‘c0’, ‘d0’], 0) zero_array_dict >

key_list = [‘marvel_hero’, ‘dc_hero’] value_list = [‘Spiderman’, ‘Flash’] superhero_dict = dict(zip(key_list, value_list)) superhero_dict >

Обращение к элементу словаря в Python

Извлечь значение элемента словаря можно единственным образом — обратившись к нему по его ключу:

hero_inventory = dict(strong_right_hand=’sword’, strong_left_hand=’shield +3′) what_in_right_hand = hero_inventory[‘strong_right_hand’] # или так: what_in_right_hand = hero_inventory.get(‘strong_right_hand’) print(what_in_right_hand) > sword

В отличие от списков, номеров позиций в словарях нет:

print(any_dict[1]) > Traceback (most recent call last): File «

«, line 1, in print(any_dict[1]) NameError: name ‘any_dict’ is not defined

💭 Подобная ошибка возникнет и в том случае, если вы, по какой-то причине, вдруг решите извлечь значение по несуществующему ключу.

Добавление нового элемента в словарь

Для того чтобы добавить в словарь новые данные достаточно новому ключу этого словаря назначить какое-либо значение. Добавление выглядит так:

superhero_dict = <'dc_hero': 'Flash'>superhero_dict[‘dark_horse_hero’] = ‘Hellboy’ print(superhero_dict) >

Аналогичным образом можно произвести замену существующего значения по его ключу:

superhero_dict[‘dc_hero’] = ‘Batwoman’ print(superhero_dict) >

Удаление элемента из словаря

Для того чтобы удалить запись в словаре воспользуемся оператором del :

# запись “’dark_horse_hero’: ‘Hellboy’” исчезнет. Прости, Красный! del superhero_dict[‘dark_horse_hero’] print(superhero_dict) >

Проверка на наличие ключа в словаре Python

Как отмечалось выше, обращение по несуществующему ключу вызывает ошибку в работе интерпретатора. Поэтому, наличие ключа в словаре следует проверять. За это дело отвечает оператор in :

if ‘marvel_hero’ in superhero_dict: print («Да, такой ключ есть») else: print(«Этот ключ в словаре отсутствует!») > Да, такой ключ есть # запись с ключом ‘dark_horse_hero’ была удалена нами чуть выше if ‘dark_horse_hero’ in superhero_dict: print («Да, такой ключ есть») else: print(«Этот ключ в словаре отсутствует!») > Этот ключ в словаре отсутствует!

💡 Кстати говоря, использование метода get() позволяет корректно обработать ситуацию, когда запрашивается значение по несуществующему ключу. Достаточно в качестве второго параметра написать значение по умолчанию:

my_hero = superhero_dict.get(‘dark_horse_hero’, ‘Этот ключ в словаре отсутствует!’) print(my_hero) > Этот ключ в словаре отсутствует!

Длина словаря в Python

Стоит помнить, что словарь — это лишь набор отображений, а не последовательность, однако количество записей в нём мы все еще можем получить, воспользовавшись функцией len() :

treasure = dict(t1=’gold’, t2=’necklace’) num_of_items = len(treasure) print(num_of_items) > 2

Не самая богатая добыча! 🙄

Сортировка словаря

Так как словарь состоит из пар, то и отсортировать его можно, как по ключам, так и по значениям.

Сортировка по значению А вот — один из вариантов сортировки словаря по значениям:

👉 Здесь стоит учитывать, что, сама по себе, запись sorted(elements.items(), key= lambda x: x[1]) будет возвращать не словарь, а отсортированный список кортежей. Поэтому более правильным вариантом будет:

Перебор словаря в Python

Не является великой тайной и тот факт, что словарь, являющийся, по сути своей, набором пар (т.е. коллекцией), можно всячески итерировать. Один из способов — перебор по ключам:

Объединение словарей

Когда заходит речь об объединении двух словарей, то обязательно следует упомянуть, что для пары сущностей типа «словарь» оператор «+»не определен. Причина этого становится довольно очевидной — стоит лишь вспомнить, что словарь не является последовательностью, а также задуматься над тем, какая именно операция на множестве словарей должна быть реализована этим самым оператором «+». Поэтому как-то так:

dict_1 = <'010120': 55000, '030420': 8500, '170420': 30000>dict_2 = <'050520': 2900, '160520': 16573>print(dict_1 + dict_2) Traceback (most recent call last): File «test.py», line 4, in print(dict_1 + dict_2) TypeError: unsupported operand type(s) for +: ‘dict’ and ‘dict’

💭 Если бы showcase_2 содержал ключи, присутствующие в showcase_1, то значения, ассоциированные с этими ключами, в результирующем словаре были бы взяты именно из showcase_2.

Ограничения

Создавая словарь, вы не должны забывать о некоторых ограничениях, накладываемых, в основном, на его ключи.

Методы словарей в Python

Перечислим основные словарные методы, которые помогут вам при работе с этим типом данных.

# clear() farewell_dict = <'a': 'word', 'b': 3, 'c': 'x', 'd': 1, 'e': 12>farewell_dict.clear() print(farewell_dict) > <> # get() seasons = <'winter': 'cold', 'summer': 'hot', 'autumn': 'cold'>print(seasons.get(‘winter’, ‘Такого ключа в словаре нет’)) > cold seasons_2 = <'spring': 'warm'>print(seasons_2.get(‘nonexistent_key’, ‘Этот ключ отсутствует’)) > Этот ключ отсутствует seasons_3 = <'winter': 'surprice_warm'>print(seasons_3.get(‘nonexistent_key’)) > None # items() pairs_dict = <'41': 41, '42': 42, '43': 43>print(pairs_dict.items()) > dict_items([(’41’, 41), (’42’, 42), (’43’, 43)]) # keys() promo_dict = <'modelA': 100000, 'modelB': 300000, 'modelC': 120000>print(promo_dict.keys()) > dict_keys([‘modelA’, ‘ modelB’, ‘modelC’]) # values() palette = <'color1': 'red', 'color2': 'white', 'color3': 'purple'>print(palette.values()) > dict_values([‘red’, ‘white’, ‘purple’]) # pop() id_dict = <'Alex': 101546, 'Rachel': 116453, 'Johanna': 144172>print(id_dict.pop(‘Alex’)) > 101546 print(id_dict) > <'Rachel': 116453, 'Johanna': 144172># Ключ, само собой, должен присутствовать в словаре. # popitem() another_dict = <'t': 16, 'g': 53, 'y': 112, 'h': 23>print(another_dict.popitem()) > (‘h’, 23) print(another_dict) > <'t': 16, 'g': 53, 'y': 112># update() first_dictionary = <'p': 55, 'o': 44, 'i': 33>second_dictionary = <'l': 22, 'k': 11, 'p': 'changed'>first_dictionary.update(second_dictionary) print(first_dictionary) > <'p': 'changed', 'o': 44, 'j': 33, 'l': 22, 'k': 11># copy() some_dict = <'z': 1, 'x': 3, 'v': 12, 'n': 33>copy_dict = some_dict.copy() print(copy_dict) >

Приведение Python-словарей к другим типам

dict → json

Чтобы сериализовать словарь в json формат, сперва необходимо импортировать сам модуль json:

Теперь можно развлекаться. Существует два схожих метода:

dict → list

medicine_chest = dict(top_part=’potion’, bot_part=’bandage’) medicine_list = [] for key, con in medicine_chest.items(): temp = Python for dict medicine_list.append(temp) print(medicine_list) > [[‘top_part’, ‘potion’], [‘bot_part’, ‘ bandage’]]

dict → string

food_machine = dict(tier_1=’juice’, tier_2=’chocolate’) f_machine_str = str(food_machine) print(f_machine_str) >

Генератор словарей

В Python существует возможность создавать словари с помощью генераторов. Генераторы выполняют цикл, отбирают key:value пары на каждой итерации и заполняют, таким образом, новый словарь.

Создадим словарь, где нескольким элементам ряда натуральных чисел приводятся в соответствие их квадраты:

Также генератор удобен, когда нужно инициализировать какой-то имеющийся список ключей:

list_of_keys = [‘q’, ‘w’, ‘e’, ‘r’, ‘t’] generated_dict = print(generated_dict) >

Вложенные словари

Отдельного упоминания заслуживает тот факт, что элемент словаря может принимать в качестве значения другой словарь:

# где-то улыбается один Xzibit nesting_d = <'fk': <'input_lvl_one': <'input_lvl_two': 42>>> print(nesting_d[‘fk’][‘input_lvl_one’][‘input_lvl_two’]) > 42

💭 Число уровней вложенности словарей неограниченно!

Альтернативы словарям

OrderedDict

defaultdict

Counter

Counter — подтип словаря, подсчитывающий и хранящий количество совпадающих неизменяемых элементов последовательности. Однако Counter() обладает и своими небезынтересными методами:

Наверно вы заметили, что словари и списки (о которых, кстати, вы можете почитать в нашей предыдущей статье » Списки в Python «) схожи как, внешне, так и в том, что могут изменять свой размер по необходимости.

Вообще говоря, и списки и словари — это изменяемые объекты, однако операции, провоцирующие изменения для этих типов данных, различны. Различаются они ещё и тем, что элементы словарей сохраняются по ключам, а не по позициям. Так или иначе, оба типа коллекций входят в число наиболее важных и часто применяемых на практике в языке Python.

Accessing elements of Python dictionary by index

Consider a dict like

How do I access for instance a particular element of this dictionary? for instance, I would like to print the first element after some formatting the first element of Apple which in our case is ‘American’ only?

Additional information The above data structure was created by parsing an input file in a python function. Once created however it remains the same for that run.

I am using this data structure in my function.

So if the file changes, the next time this application is run the contents of the file are different and hence the contents of this data structure will be different but the format would be the same. So you see I in my function I don’t know that the first element in Apple is ‘American’ or anything else so I can’t directly use ‘American’ as a key.

11 Answers 11

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

Given that it is a dictionary you access it by using the keys. Getting the dictionary stored under «Apple», do the following:

And getting how many of them are American (16), do like this:

If the questions is, if I know that I have a dict of dicts that contains ‘Apple’ as a fruit and ‘American’ as a type of apple, I would use:

as others suggested. If instead the questions is, you don’t know whether ‘Apple’ as a fruit and ‘American’ as a type of ‘Apple’ exist when you read an arbitrary file into your dict of dict data structure, you could do something like:

or better yet so you don’t unnecessarily iterate over the entire dict of dicts if you know that only Apple has the type American:

In all of these cases it doesn’t matter what order the dictionaries actually store the entries. If you are really concerned about the order, then you might consider using an OrderedDict :

As I noticed your description, you just know that your parser will give you a dictionary that its values are dictionary too like this:

So you have to iterate over your parent dictionary. If you want to print out or access all first dictionary keys in sampleDict.values() list, you may use something like this:

If you use the example you gave in the question, I mean:

The output for the first code is:

And the output for the second code is:

EDIT 1:

I know this is 8 years old, but no one seems to have actually read and answered the question.

As a bonus, I’d like to offer kind of a different solution to your issue. You seem to be dealing with nested dictionaries, which is usually tedious, especially when you have to check for existence of an inner key.

There are some interesting libraries regarding this on pypi, here is a quick search for you.

In your specific case, dict_digger seems suited.

You can’t rely on order of dictionaries, but you may try this:

If you want the order to be preserved you may want to use this: http://www.python.org/dev/peps/pep-0372/#ordered-dict-api

Simple Example to understand how to access elements in the dictionary:-

Create a Dictionary

Few people appear, despite the many answers to this question, to have pointed out that dictionaries are un-ordered mappings, and so (until the blessing of insertion order with Python 3.7) the idea of the «first» entry in a dictionary literally made no sense. And even an OrderedDict can only be accessed by numerical index using such uglinesses as mydict[mydict.keys()[0]] (Python 2 only, since in Python 3 keys() is a non-subscriptable iterator.)

As to the question of selecting and «formatting» items, if you know the key you want to retrieve in the dictionary you would normally use the key as a subscript to retrieve it ( my_var = mydict[‘Apple’] ).

If you really do want to be able to index the items by entry number (ignoring the fact that a particular entry’s number will change as insertions are made) then the appropriate structure would probably be a list of two-element tuples. Instead of

but if you know you are looking for the key «Apple», why wouldn’t you just use a dict instead?

You could introduce an additional level of indirection by cacheing the list of keys, but the complexities of keeping two data structures in synchronisation would inevitably add to the complexity of your code.

Python Dictionary index – Complete tutorial

In this Python tutorial, we will discuss the Python Dictionary index. Here we will also cover the below examples:

Python dictionary index

Example:

Let’s take an example and check how to access the index value in a Python dictionary.

In the above code, we will first initialize a dictionary and assign them a character in the list. Now use the indexing syntax list[index] and assign them dict.items() function as an argument.

Here is the Screenshot of the following given code

This is how to access the Python dictionary index.

Python dictionary index of key

Example:

Let’s take an example and check how to access the keys from the dictionary using the list[index] method.

Here is the Screenshot of the following given code

How to access keys from a Python dictionary

In this example, we will use the Python list() function with the keys(), values() and items() function to perform this particular task.

Example:

In the above code First, we will be initializing a dictionary along with that initialize a find_key string and assign them a key as a “Germany”. Use list()+keys()+index() to access the required key index in dictionary.

Here is the Screenshot of the following given code

This is how to access keys from a Python dictionary.

Python dictionary index value

Example:

In the above code First, we will be initializing a list and Use the dictionary comprehension+ enumerate() function to access the required index value from a dictionary.

Here is the Screenshot of the following given code

This is how to access index values in a Python dictionary.

How to access Values from Python dictionary

Example:

Let’s take an example and check how to access the values from a dictionary using the index in Python

Here is the Screenshot of the following given code

This is another way to access Values from the Python dictionary.

Python dictionary index range

Example:

In the above code first, we will be initializing a dictionary and assign them a key-value pairs element along with that initializing a range number and using the loop method to iterate values through all keys and print the result.

Here is the Screenshot of the following given code

Check dictionary index range

Let us see how to use filter() and lambda() functions in Python dictionary index range.

Example:

Note: In this example, we can perform the task of filtering using filter() and lambda functions.

Here is the Screenshot of the following given code

Python dictionary index multiple keys

Example:

Here is the Screenshot of the following given code

Check multiple keys from dictionary using index

By using the list[index] function we will get the index value from the given dictionary.

Example:

Let’s take an example and check how to access the multiple keys from the dictionary using the index.

In the above example, we will use the multiple time list[index] function and it will return the key at index in the list.

Here is the Screenshot of the following given code

Python dictionary index exists

Example:

Here is the Screenshot of the following given code

The above code, we can use to check if index exists in Python dictionary.

Python dictionary index number

Example:

Here is the Screenshot of the following given code

This is how to get index number from a dictionary in Python.

Python dictionary get index from value

Example:

Let’s take an example and check how to get the index value

In the above code first, we will be initializing a list and using the dict() +zip() function to access the required index value from a dictionary

Here is the screenshot of the following given code

The above code, we can use to get index from value in Python dictionary.

Python dictionary index vs get

Syntax:

Here is the Syntax of get() function

Example:

Here is the Screenshot of the following given code

Python list dict find index

Example:

Let’s take an example and check how to find an index from a Python dictionary.

Here is the Screenshot of the following given code

You may like the following Python tutorials:

In this Python tutorial, we will discuss the Python Dictionary index. Here we will also see the Python create string examples:

Python is one of the most popular languages in the United States of America. I have been working with Python for a long time and I have expertise in working with various libraries on Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… I have experience in working with various clients in countries like United States, Canada, United Kingdom, Australia, New Zealand, etc. Check out my profile.

Iterate Through Dictionary Python: Step-By-Step Guide

The items() method, the keys() method, and the values() method return values you can use to iterate through a dictionary in Python. items() returns both the keys and values in a Python dictionary. keys() returns the keys in a dictionary. values() returns the values in a dictionary. You can also use a for loop to iterate through a Python dictionary.

When you’re working with d ictionaries, you may want to iterate through the values you have stored.

Find Your Bootcamp Match

Select your interest
First name

Last name

Email

Phone number

By continuing you agree to our Terms of Service and Privacy Policy, and you consent to receive offers and opportunities from Career Karma by telephone, text message, and email.

For instance, say you’re creating a program for a librarian that shows a specific book’s title, description, author, and other relevant information. You would want to iterate through the dictionary storing that data so you can display it to the user of your profgram.

There are a few ways you can iterate through a dictionary. This tutorial will discuss how to iterate through a dictionary using a for loop, items(), and keys(). We’ll also explore an example of each of these approaches being used to iterate through a dictionary.

Dictionary Refresher

Python dictionaries store data in a key-value structure. This means that each value is assigned a key that can be used to reference that particular value.

Here’s an example of a dictionary in Python:

Our dictionary uses colons (:) throughout, which separate our keys and values. The words on the left of the colons are the keys, which in this case are title, author, date_published, and in_stock. These keys are all formatted as strings.

Python Iterate Through Dictionary

You can iterate through a Python dictionary using the keys(), items(), and values() methods. keys() returns an iterable list of dictionary keys. items() returns the key-value pairs in a dictionary. values() returns the dictionary values. You can also use a for loop to iterate over a dictionary.

Say wanted to know how many books your library had in stock. You may want to iterate through every dictionary to calculate the total of each book’s quantity.

Iterate Using for Loop

Dictionaries are iterable objects, which means you can iterate through them like any other object. Perhaps the simplest way to iterate through a dictionary is to use a Python for loop. This loop allows you to run through each value in the dictionary individually.

Let’s say you are writing a program for a librarian. You want to print out the keys and values of a specific book to the console. Each key-value pair should be printed to the console on a new line. You could accomplish this task using the following code:

Our code returns the following:

To start, we declare a Python variable called book which stores four keys and values. This variable stores a value in the dictionary data type.

Then, we declare a for loop that iterates through each value in our dictionary. The for loop prints out both the key and the value associated with that key to the console.

Iterate Using items()

dictionary.items() converts each key-value pair in a dictionary into a tuple. Using a for loop and the items() method you can iterate over all of the keys and values in a list.

Let’s say that we still want to iterate through our book dictionary. But we want our values to appear as a list of tuples. We could do so using the following code:

Our code returns a list of tuples:

We define a for loop that iterates through our book dictionary using items(). items() converts each key-value pair into a tuple, which we can then access in our for loop. As you can see, each key-value pair was printed to the console as a tuple.

This approach can be useful if you want to convert each value in your dictionary to a tuple while you are iterating.

Iterate Using keys()

Often, you may only want to iterate through the keys of a dictionary.

The librarian with whom we are working has asked us to compile a list of the information the library stores on each book. In our terms, this means the librarian wants a list of the keys stored in our dictionary.

We could use the Python dictionary keys() method to get a list of keys and print them out to the console. Here’s the code we would use to accomplish this task:

Our code returns:

In our code, we define a for loop that uses keys() to find the keys in our dictionary. Then, the loop iterates through each of those keys and prints them to the console. As you can see, our code returned the names of our four keys.

Iterate Using values()

The Python dictionary values() method can be used to iterate through a dictionary’s values in Python. This method works in the same way as keys(), but instead returns the values in a dictionary.

Our librarian wants us to print out the values of each item in the book dictionary entry for The Great Gatsby to the console. We could do so using the following code:

Our code returns:

«Career Karma entered my life when I needed it most and quickly helped me match with a bootcamp. Two months after graduating, I found my dream job that aligned with my values and goals in life!»

Venus, Software Engineer at Rockbot

Find Your Bootcamp Match

View the Repl.it from this tutorial:

Conclusion

To iterate through a dictionary in Python, there are four main approaches you can use: create a for loop, use items() to iterate through a dictionary’s key-value pairs, use keys() to iterate through a dictionary’s keys, or use values() to iterate through a dictionary’s values.

This tutorial discussed how to use these four approaches to iterate through a dictionary in Python. We also explored an example of each of these methods in action. You’re now ready to start iterating through Python dictionaries like a professional!

For information on top Python courses, training programs, and learning resources, check out our How to Learn Python guide.

Python dictionary keys. «In» complexity

Quick question to mainly satisfy my curiosity on the topic.

I am writing some large python programs with an SQlite database backend and will be dealing with a large number of records in the future, so I need to optimize as much as I can.

For a few functions, I am searching through keys in a dictionary. I have been using the «in» keyword for prototyping and was planning on going back and optimizing those searches later as I know the «in» keyword is generally O(n) (as this just translates to python iterating over an entire list and comparing each element). But, as a python dict is basically just a hash map, is the python interpreter smart enough to interpret:

It is basically the same operation but the top would be O(n) and the bottom would be O(1).

It’s easy for me to use the bottom version in my code, but then I was just curious and thought I would ask.

5 Answers 5

Trending sort

Trending sort is based off of the default sorting method — by highest score — but it boosts votes that have happened recently, helping to surface more up-to-date answers.

It falls back to sorting by highest score if no posts are trending.

Switch to Trending sort

You may ask where this is guaranteed.

If you really need to prove it to yourself, you can test every implementation you care about (with a profiler, or by using some type with a custom __hash__ and __eq__ that logs calls, or…), or read the source.

While we’re at it, note that this:

So, the right thing to write is:

More generally, this is not true:

I know the «in» keyword is generally O(n) (as this just translates to python iterating over an entire list and comparing each element

Источники:

• http://towardsdatascience.com/3-ways-to-iterate-over-python-dictionaries-using-for-loops-14e789992ce5
• http://webdevblog.ru/kak-perebrat-slovar-v-python/
• http://semakin.dev/2020/07/iterate_over_dict/
• http://www.stackvidhya.com/iterate-through-dictionary-python/
• http://kanoki.org/2019/12/04/how-to-iterate-through-a-python-dictionary/
• http://thispointer.com/different-ways-to-iterate-loop-over-a-dictionary-in-python/
• http://pythonguides.com/iterate-through-dictionary-python/
• http://www.w3schools.com/python/python_dictionaries_loop.asp
• http://realpython.com/python-for-loop/
• http://realpython.com/python-dicts/
• http://docs.python.org/3/tutorial/datastructures.html
• http://www.dataquest.io/blog/python-dictionaries/
• http://blog.finxter.com/python-dictionary/
• http://www.geeksforgeeks.org/python-dictionary/
• http://stackoverflow.com/questions/53366393/performance-in-python-3-dictionary-iteration-dictkey-vs-dict-items
• http://stackoverflow.com/questions/20319892/python-iterating-over-a-large-dictionary
• http://stackoverflow.com/questions/27259504/refer-to-dictionary-element-in-for-loop
• http://www.askpython.com/python/dictionary/python-dictionary-dict-tutorial
• http://realpython.com/python-ordereddict/
• http://blog.finxter.com/how-to-loop-through-a-nested-dictionary-with-python/
• http://datagy.io/python-dictionary-comprehensions/
• http://stackoverflow.com/questions/19288420/does-for-key-in-dict-in-python-always-iterate-in-a-fixed-order
• http://www.w3schools.com/python/gloss_python_loop_dictionary_items.asp
• http://stackoverflow.com/questions/577234/python-extend-for-a-dictionary
• http://stackoverflow.com/questions/66830344/python-dictionaries-different-way-to-iterate-through-a-dict
• http://blog.finxter.com/python-dict/
• http://stackoverflow.com/questions/43505921/python-trying-to-create-a-dictionary-through-a-for-loop
• http://stackoverflow.com/questions/7409078/iterating-over-dictionary-key-values-corresponding-to-list-in-python
• http://stackoverflow.com/questions/30446449/iterate-through-dictionary-values
• http://thispointer.com/python-4-ways-to-print-items-of-a-dictionary-line-by-line/
• http://stackoverflow.com/questions/8335096/iterate-over-nested-dictionary
• http://stackoverflow.com/questions/48585577/iterate-over-dictionary
• http://towardsdatascience.com/python-dictionaries-651acb069f94
• http://blog.finxter.com/python-one-line-dictionary/
• http://stackoverflow.com/questions/35830612/how-to-create-a-new-dictionary-in-for-loop
• http://stackoverflow.com/questions/28022223/how-to-iterate-over-a-dictionary-n-key-value-pairs-at-a-time
• http://python.land/python-data-types/dictionaries
• http://python-course.eu/python-tutorial/dictionaries.php
• http://www.programiz.com/python-programming/dictionary
• http://www.learnbyexample.org/python-dictionary/
• http://stackoverflow.com/questions/3420122/filter-dict-to-contain-only-certain-keys
• http://docs.python.org/3/c-api/dict.html
• http://pythonworld.ru/tipy-dannyx-v-python/slovari-dict-funkcii-i-metody-slovarej.html
• http://www.geeksforgeeks.org/python-dict-function/
• http://timeweb.com/ru/community/articles/slovari-v-python-i-metody-raboty-s-nimi
• http://pythonchik.ru/osnovy/slovari-v-python
• http://stackoverflow.com/questions/5404665/accessing-elements-of-python-dictionary-by-index
• http://pythonguides.com/python-dictionary-index/
• http://careerkarma.com/blog/iterate-through-dictionary-python/
• http://stackoverflow.com/questions/17539367/python-dictionary-keys-in-complexity