Что может быть ключом в словаре python
Поговорим о словарях. Не тех, конечно, что составили Даль или Ожегов, а о словарях в Python. Словарь в Python — это неупорядоченный набор элементов. Давайте на примере разберемся, что это такое и как работает.
Создать пустой словарь можно с помощью фигурных скобок. Или с помощью функции dict().
Но давайте наполним наш словарь данными и посмотрим, как это работает. Вот, например, словарь, в котором хранятся данные о трех о публичных должностных лицах с самым высоким декларируемым доходом. Имя должностного лица это ключ, а доход — это значение.
И мы можем обращаться к словарям в питоне именно по ключу. Сначала указываем словарь, затем в квадратных скобках ключ. Вернется значение.
Через ключ же в словарь можно и добавлять новые элементы. Давайте добавим Владимира Путина и его декларируемый доход за 2019 год. И сразу проверим, добавился ли он в словарь.
Только важно понимать, что между уже известными вам списками и словарями есть существенная разница. Списки — это упорядоченный набор данных, а словари — неупорядоченный. Поэтому элементы в словаре не имеют индекса. Нельзя посмотреть, каким по счет идет Владимир Путин, и использовать этот номер, чтобы обратиться к нему. Подобная попытка закончится ошибкой.
Эта ошибка означает, что в словаре нет такого ключа как 3, число которое мы пытались использовать в качестве индекса элемента. Обращаться к словарям можно только по ключу. Поэтому, если значения, которое вы указываете в квадратных скобках, нет в словаре — получите такую же ошибку. Но есть еще один способ, как можно получать значения из словаря, но не опасаться при этом ошибок. Это метод .get().
В скобочках вы указываете ключ, значение которого хотите получить, а через запятую указываете то, что хотите получить в случае, если такого ключа нет в словаре. В примере мы получим строку «нет ключа» в ответ. Если через запятую не указывать ничего, то по умолчанию будет возвращаться None.
В словарях ключами и значениями могут быть разные типы данных. Например, и то, и другое может быть числом. Только если ваш ключ — это число, то указывать его в квадратных скобках при обращении нужно тоже как число. Если вы укажете его в кавычках, то это будет уже другое значение. Вы снова получите ошибку, что такого ключа нет в словаре.
Значениями в словаре так же могут быть и списки. Давайте теперь в словарь добавим элемент, ключом которого будет снова Владимир Путин, а значение — его декларируемый доход за последние три года в виде списка.
Обратите внимание, что запись с Владимиром Путиным, где был доход только за 2019 год исчезла, осталась только последняя добавленная нами запись с доходами за последние три года. Дело в том, что в словаре не может существовать двух элементов с одинаковым ключом. Если вы добавите элемент с ключом, который уже есть в словаре, то он просто перезапишется.
Удалять элемент из словаря можно с помощью .pop(). В скобках нужно указать ключ элемента. Он удалится, и вам вернется удаленное значение. Давайте попробуем удалить Владимира Путина хотя бы из словаря.
Еще словари хороши тем, что мы можем получить отдельно список всех ключей и всех значение. Для первого нам поможем метод .keys(), а для второго — .values().
Создадим новый словарь, в котором у нас будут храниться доходы за последние три года Владимира Путина и Дмитрия Медведева. И напишем небольшой код, который будет перебирать элементы этого словаря и печатать нам сообщение о том, у кого каким за последние три года был минимальный доход. И для решения этой задачки нам потребуется еще один метод словаря .items(). Если метод .keys() позволял нам получить список всех ключей, этот список мы могли перебирать, по аналогии же работает .values(), то .items() позволяет попарно перебирать и ключ, и значение.
Нам осталось только перебирая ключи и значения, определить минимальный доход и вывести сообщение на экран. Для этого используем функцию min(), которая вернет минимальное значение из списка и print().
Это и есть основные методы словаря, которые чаще всего используются в работе. Еще больше методов словаря можете посмотреть здесь. А ссылка на тетрадку Jupyter Notebook как всегда на нашем GitHub здесь.
Python Dictionary — A Complete Guide
Python dictionary is an unordered collection of items. Each item is a key-value pair.
Dictionaries can be used to represent labeled data.
For example, you can represent a student as a dictionary:
With dictionaries, it is easy to access, modify, and delete entries.
In this guide, you learn everything about dictionaries in Python.
How to Define a Python Dictionary
A Python dictionary is a mapping from a key to its associated value. A dictionary is known as an associative array because of this.
There are many ways you can create a dictionary in Python:
- Add comma-separated key-value pairs inside of curly braces.
- Convert a list of tuples to a dictionary.
- Define a dictionary using keyword arguments.
- Create a dictionary incrementally.
1. Comma-Separated Key-Value Pairs
This is the most basic way to create a dictionary in Python—Add keys and associated values inside of a set of curly braces. Each key should be followed by a colon that separates it from the value.
Also, don’t forget to add commas between these key-value pairs.
Here is how it looks like. For example, let’s create a student dictionary:
2. Convert a List of Tuples to a Dictionary Using the dict() Function
You can also define the above dictionary this way:
The pairs, such as (“name”, “Alice”) are known as tuples. The built-in dict() function knows that it should convert these to key-value pairs, such as “name”: “Alice” .
3. Define a Dictionary Using Keyword Arguments
If the dictionary keys are strings, you can use the dict() function to create a new dictionary this way:
4. Create a Dictionary Incrementally
The previous examples assume you know what you want to put into the dictionary right away.
But if this is not the case you can create a dictionary incrementally. This means you can define an empty dictionary and add entries to it on the fly.
For example, let’s build the student dictionary incrementally:
How to See the Contents of a Python Dictionary
You just learned four ways to create a dictionary in Python.
Now that you have your first dictionary created, you may want to see that it really contains the elements you want.
To do this, you can print the dictionary similar to how you’d print a list.
Given the student dictionary, here is how to see its contents:
You may be bothered by the fact that there are no line breaks in the output. At the end of this guide, you will learn how to pretty-print a Python dictionary.
How to Access Python Dictionary Values
Python list elements are accessed via the index using square brackets. For example names[0] .
Unlike lists, dictionaries are accessed with the key. Similar to accessing list elements, a dictionary key name is passed into a set of square brackets ( [] ).
Let’s continue with the student dictionary from the previous chapter
To access the name of the student, you can call:
Let’s print this to see it really works:
If you try to access a non-existent element in the dictionary, an exception is raised:
How to Add a New Key-Value Pair Into a Dictionary
To add a new entry to a dictionary, you need to “access” it with square brackets and assign a value to it.
For example, let’s add the haircolor as a new entry into the student dictionary:
Now you can verify that this addition really took place by printing the haircolor of the student:
How to Update a Key-Value Pair In a Dictionary
If you want to update an existing entry in a dictionary, access the entry using the square brackets. Then assign a value to it.
For example, let’s change the age of the student from 23 to 24 :
How to Delete a Key-Value Pair From a Dictionary
To delete an entry from a dictionary, use the del statement.
For example, let’s get rid of that haircolor :
Now you can verify that the changes we made took place by printing out the dictionary:
The haircolor is gone.
Valid Python Dictionary Key Types
So far you have only used a string as a key to the dictionary.
Using strings as keys is a very common way to deal with dictionaries. But it is worthwhile to know you can use other types as keys too.
The dictionary keys can be almost any type. For example:
- String
- Integer
- Float
- Boolean
- Tuple
- Function
- Object
Also, you can have dictionaries with mixed types. In other words, you can have keys of any type in the same dictionary.
Let’s see a (stupid) example:
Creating entries this way is usually meaningless. But hey at least you now know it works.
Restrictions on Dictionary Keys
Previously you saw you can use almost anything as a dictionary key in Python.
But there are two main restrictions when it comes to dictionary keys.
- No duplicate keys. A dictionary is a key-value mapping. Having duplicate keys would be a contradiction. Think about a student having two names…
- A dictionary key must be immutable. This makes it possible to use a for example a tuple as a dictionary key. But a list or another dictionary cannot be used as a key. If you are wondering what makes integers, strings, or other types immutable, read this article.
Restrictions on Dictionary Values
There are no restrictions to dictionary values. Not a single one.
You can have duplicate values, immutable and mutable values, and so on.
For instance, you can have a new dictionary as a value:
Dictionary Operators
Next, you are going to learn useful operations you can perform on dictionaries.
Let’s continue with the student dictionary from earlier sections:
In Statement
To check if a specific key exists in a dictionary, use the in statement.
For example, let’s check if a student has a key age :
This can be useful. As you may remember, if you try to access a non-existent key, an error is thrown. If you don’t handle this error properly, your program crashes.
This is where you can use the in statement to check if a key exists before accessing the value.
Len() Function
To check the length of a dictionary, use the built-in len() method.
For example, the student dictionary contains five entries. But if you want to check this without calculating the entries yourself, use the len() function:
Python Dictionary Methods
Python dictionary has a bunch of useful built-in methods. These can help you save time when working with dictionaries.
These methods are:
- dict.clear()
- dict.copy()
- dict.fromkeys()
- dict.get()
- dict.items()
- dict.keys()
- dict.pop()
- dict.popitem()
- dict.setdefault()
- dict.update()
- dict.values()
Let’s go through each method in more detail with an example.
dict.clear()
This method wipes out the whole dictionary:
dict.copy()
Use copy() method to create a copy of the dictionary.
dict.fromkeys()
Use the fromkeys() method to create a dictionary from a list of keys that all have the same value.
For instance, let’s initialize the weekly precipitation dictionary such that the daily precipitation starts from 0.0 for each day of the week:
dict.get()
To get a value corresponding to a key, you can use the get() method:
In case you are trying to get a value that does not exist, the get() method returns None by default:
Sometimes you may want to change this default value to something else than None such as False . You can do this by giving the optional second parameter to the get() method:
dict.items()
The items() method returns a view object, that is, the keys and values as a list of tuples inside a view object.
If you don’t enjoy the view object, you can convert it to a list with the list() method. Just replace print(player_items) with print(list(player_items)) .
dict.keys()
The keys() method returns all the dictionary keys as a list inside a view object. For example:
You can convert this view object into a list with the list() method by replacing print(player_keys) with print(list(player_keys)) .
dict.pop()
Use pop() method to remove an element with a specific key.
dict.popitem()
Use popitem() to remove the item that was last inserted into the dictionary. In earlier versions than Python 3.7, the popitem() method removes a random item. The popitem() method returns the removed element as a tuple.
dict.setdefault()
The setdefault() gets a value of a specific key. If the key does not exist, the setdefault() method inserts a new key-value pair into the dictionary.
dict.update()
The update() method inserts items to the dictionary. For example:
dict.values()
The values() method returns a list of the dictionary values as a view object. For example:
You can convert a view object to a list with the list() method by replacing print(player_values) with print(list(player_values)) .
How to Loop Through Python Dictionaries
You can loop through a dictionary using a for loop.
To be able to loop the dictionary, you need to use the dict.items() method.
In the following, you are going to loop through a student dictionary and print the entries.
To loop through a dictionary using a for loop:
Dictionary Comprehensions
Python has a shorthand for looping through dictionaries, called dictionary comprehension.
In some situations, this shorthand can make your code more readable while saving some lines of code.
The syntax of dictionary comprehension looks like this:
Let’s see some examples
Example 1 — Create a Dictionary from a List
Let’s create a dictionary based on a numbers list.
In the new dictionary, a number is a key and the value is the number as a string. Furthermore, let’s only include even numbers:
This works all fine but by using dictionary comprehension, this all can be achieved with one line!
Example 2 — Operating on an Existing Dictionary
Let’s see another example.
Here you have a dictionary and you want to create a new one based on it.
Let’s directly use a dictionary comprehension:
Common Python Dictionary Tasks
How to Sort a Dictionary by Value
As of Python 3.7, the insertion order is preserved in dictionaries. This means it is possible to sort a dictionary. Notice that older versions of Python do not support sorting dictionaries. This is because the dictionaries are unordered.
In Python 3.7 or higher, you can sort a dictionary by value using the sorted() function.
For example, let’s sort the data by participants’ ages (dictionary values):
At this point, you don’t need to worry about the lambda inside the sorted() function call. But if you want to learn what it does, read this article.
How to Sort a Dictionary by Key
As of Python 3.7, the insertion order is preserved in dictionaries. This means it is indeed possible to sort a dictionary.
Notice that the older versions of Python do not support sorting dictionaries. This is because the dictionaries are unordered by design.
You can sort a dictionary by key using the sorted() function.
For example, let’s sort a dictionary of name-age pairs alphabetically based on the name key:
How to Pretty-Print a Python Dictionary
During this guide, you have printed dictionaries into the console. But the result looks pretty messy because it is on a single line.
When you print larger dictionaries, it becomes infeasible to understand the result. This is where pretty printing can help you.
Python has a built-in pprint module. You can import it and use it to pretty-print a dictionary.
For example, let’s go back to the student dictionary:
Let’s print this dictionary into the console:
The output looks ugly:
Let’s fix this with the pprint . Without digging too deep into the details, here is how the program looks:
Какие значения могут быть ключами словаря?
Документация гласит, что ключами могут быть только неизменяемые типы данных. Почему в данном случае не возникает ошибка?
Попробую ответить, т.к. вопрос интересный и сам не знал почему.
Коротко: причина в наличии магическом методе __hash__
Если мы используем словарь как ключ:
То получаем ошибку:
Но, вообще-то, эту же ошибку получим, если попробуем получить хеш:
У не хешируемых типов, магический метод __hash__ отсутствует:
Вот так выглядит наличие этого метода:
Мы это легко проверим на нашем классе Test :
ℹ️ Выходит, что у классов, по-умолчанию, есть метод __hash__ , поэтому их можно использовать в ключах словаря и в других местах (типа множеств), реализованных через хеши
[ Сборник задач ]
Тема 5. Работа со словарями
Словари (dict) в языке Python – наиболее распространенный тип данных. Они буквально везде (в классах, модулях, функциях), поэтому сделаны максимально эффективными.
Для решения заданий необходимо повторить: свойства, стандартные операции со словарями, как их создавать, каковы требования к ключам и значениям, как копировать, обновлять, распаковывать, какими способами можно просматривать содержимое.
Для углубленного погружения в тему следует ознакомиться с типами defaultdict , OrderedDict , Counter , ChainMap , UserDict из встроенного модуля collections . В некоторых случаях они могут пригодиться, существенно сократив длину кода.
Читайте также
1. Какими способами можно получить доступ к значению ключа, не изменяя при этом словарь?
Стандартный способ доступа к значению словаря – через квадратные скобки.
Пример – Интерактивный режим
>>> my_dict = <121: 'Значение 1', 'key2': 'Значение 2', 'key 3': 'Значение 3'>
>>> my_dict[121]
Значение 1
>>> my_dict[‘key 3’]
Значение 3
Как видим, если ключ представлен в виде числа, то его пишем без кавычек.
Если обратимся к несуществующему ключу, то получим в ответ ошибку KeyError . Второй метод возврата значения словаря позволяет избежать подобного. Он основан на методе get() . Если передать только один параметр – ключ, то поведение метода аналогично квадратным скобкам, но не возникнет ошибки при обращении к несуществующему элементу, а просто вернется None . Если задать второй аргумент, то вместо None отобразится он.
Пример – Интерактивный режим
>>> my_dict = <'k1': 120, 'k2': 'Nice key', 'k3': [1, 2, 99]>
>>> my_dict.get(‘k2’)
Nice key
>>> my_dict.get(‘k4’)
None
>>> my_dict.get(‘k4’, ‘Нет такого ключа’)
‘Нет такого ключа’
>>> my_dict
Главное требование к имени ключа словаря в Python – он должен быть хешируем. По сути, это означает его неизменяемость, немутируемость. К немутабельным объектам относят: строки, числа, булевы значения, кортежи, frozenset и некоторые другие. Также, в словаре не может быть двух ключей с одинаковыми наименованиями.
Если задать неверный тип для ключа, то возникнет ошибка TypeError , говорящая о нехешируемости элемента.
Пример – Интерактивный режим
>>> my_dict = <1.1: 120, 'k2': 'Nice key', (2, 4): [1, 2, 99], True: 71, frozenset(<9, 1>): ‘Значение’>
>>> my_dict[1.1]
120
>>> my_dict[(2, 4)]
[1, 2, 99]
>>> my_dict[True]
71
>>> my_dict[frozenset(<9, 1>)]
‘Значение’
>>> my_dict[[1, 2, 3]] = 1 # Появится ошибка, говорящая о неверном ключе
TypeError: unhashable type: ‘list’
Метод pop() удаляет элемент словаря и возвращает его значение. Если передать второй параметр, то при попытке удаления несуществующего ключа будет получен этот параметр в качестве результата выполнения.
Пример – Интерактивный режим
>>> my_dict = <1.1: 120, 'k2': 'Nice key', 'k3': 300, 22: 'Value'>
>>> my_dict.pop(1.1)
120
>>> my_dict
<'k2': 'Nice key', 'k3': 300, 22: 'Value'>
>>> my_dict.pop(1.1, ‘Ключа нет или он уже был удален ранее’)
Ключа нет или он уже был удален ранее
>>> my_dict
<'k2': 'Nice key', 'k3': 300, 22: 'Value'>
>>> my_dict.pop(1.1) # Возникнет ошибка KeyError: 1.1
KeyError: 1.1
Методы keys() , items() , values() еще называют объектами views (объекты просмотра словаря). Они позволяют просматривать все элементы словаря и имеют некоторые особенности:
1. keys() – возвращает список ключей в исходном порядке, все элементы уникальны, ведут себя как множество (set) : могут объединяться, пересекаться и т.п., являются итерабельными, их нельзя менять напрямую и вызывать по индексу
2. values() – контейнер со значениями словаря, в котором элементы могут повторяться (т.е. не ведет себя как множество). В остальном, свойства аналогичны методу keys()
3. items() – список элементов словаря в виде кортежей, где первым идет ключ, а вторым объектом – значение. Если значения словаря неизменямые, то контейнер items() будет обладать свойствами сета. Остальные особенности совпадают с keys()
Немаловажная специфика объектов views – они динамично меняются при любых изменениях словаря.
Приведем примеры, которые поясняют озвученное.
Пример – Интерактивный режим
>>> my_dict = <1: 'value 1', 2: 'value 2', 3: 'value 3', 4: 'value 4'>
>>> keys = my_dict.keys()
>>> keys # Порядок ключей сохраняется
dict_keys([1, 2, 3, 4])
# Объект keys итерируемый
for element in keys:
____print(element)
1
2
3
4
# Нельзя обратиться к элементу по индексу или добавить / удалить новые
# keys[0] # Ошибка TypeError
# keys[0] = 121 # Ошибка TypeError
# del keys[0] # Ошибка TypeError
>>> values = my_dict.values()
>>> values # Порядок значений сохраняется
dict_values([‘value 1’, ‘value 2’, ‘value 3’, ‘value 4’])
>>> items = my_dict.items()
>>> items # Порядок пар «ключ: значение» сохраняется
dict_items([(1, ‘value 1’), (2, ‘value 2’), (3, ‘value 3’), (4, ‘value 4’)])
Бывают ситуации, когда необходимо копировать словарь. Для этого есть масса способов. При копировании создается новый объект, который не связан с исходным. Посмотрим примеры.
# Первый способ копирования
>>> my_dict_copy_1 = my_dict.copy()
>>> my_dict_copy_1
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> id(my_dict_copy_1)
12344608
# Второй способ копирования
my_dict_copy_2 = dict(my_dict)
>>> my_dict_copy_2
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> id(my_dict_copy_2)
12344666
# Третий способ копирования
my_dict_copy_3 = <**my_dict>
>>> my_dict_copy_3
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> id(my_dict_copy_3)
1234674
# Четвертый способ копирования — самый медленный по времени
my_dict_copy_4 =
>>> my_dict_copy_4
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> id(my_dict_copy_4)
12344879
На основании проведенного эксперимента получается, что копировать словари безопасно. Однако не зря в качестве примера для ключа 4 был присвоен список. Если его изменить (добавить, удалить элементы), то все остальные копии изменятся соответствующе. В этом и есть опасность копирования словарей (приведенные способы еще называют поверхностным копированием): если есть мутабельные объекты, то их изменение повлечет за собой модификацию копий. А мы этого не хотим. Решение проблемы: глубокое копирование.
Пример – Интерактивный режим
>>> from copy import deepcopy
>>> my_dict = <1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> my_dict_copy_1 = my_dict.copy()
>>> my_dict_deepcopy = deepcopy(my_dict)
# Добавим к первому словарю новый элемент в список ключа » 4 »
>>> my_dict[4].append(1000)
>>> my_dict
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4, 1000]>
>>> my_dict_copy_1
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4, 1000]>
>>> my_dict_deepcopy
Как видим, при глубоком копировании мы максимально безопасно проводим изоляцию нужного объекта. Однако злоупотреблять методикой не стоит без надобности, так как она достаточно медленная.
Пользователям Python новых версий очень удобно: словари всегда выводятся в том порядке ключей и значений, в котором они были представлены при создании объекта. Теперь мы уверены, что первый или последний ключ будут оставаться на своих местах.
Тем не менее, в модуле collections есть особый тип словаря: OrderedDict . Он гарантирует порядок ключей и значений. Но зачем? Ведь эта функция уже итак реализована в обычном словаре.
Во-первых, пользователи старых версий Python могут получить эту фичу. Следовательно, уже есть оправдание этой структуры данных.
Да и те, кто пользуется новой версией Пайтона, могут получить некоторые дополнительные фишки при использовании OrderedDict : здесь есть уникальные методы, которых отсутствуют у dict .
Пример – Интерактивный режим
>>> from collections import OrderedDict
>>> standard_dict = <1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> ordered_dict = OrderedDict(<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>)
# Порядок ключей и значений одинаков
>>> standard_dict
<1: 'value 1', 2: 'value 2', 3: 'value 3', 4: [2, 3, 4]>
>>> ordered_dict
OrderedDict([(1, ‘value 1’), (2, ‘value 2’), (3, ‘value 3’), (4, [2, 3, 4])])
# Словари являются равными, так как имеют одинаковые элементы
>>> standard_dict == ordered_dict
True
# Зато OrderedDict имеет свою специфику
# Обратное представление
>>> for key in reversed(ordered_dict):
____print(key)
4
3
2
1