Содержание

Добавление нового элемента в словарь в Python



Я хочу добавить элемент в существующий словарь в Python. Например, это мой словарь:

default_data = {
            'item1': 1,
            'item2': 2,
}

Я хочу добавить новый пункт, такой что:

default_data = default_data + {'item3':3}

Как я могу этого достичь?

python dictionary items
Поделиться Источник brsbilgic     20 июня 2011 в 19:07

3 ответа


  • Добавление в словарь Python

    def countFrequency(L): fdict = {} for x in range(0, len(L)): for key, value in fdict: if L[x] == fdict[str(x)]: value = value + 1 else: fdict[L[x]] = 1 return fdict Я пытаюсь подсчитать частоту встречаемости определенного символа в данной строке и создать из этого словарь. По какой-то причине…

  • Добавление нового элемента в словарь из нескольких потоков

    У меня есть проблема с добавлением нового элемента в статический словарь при использовании его из нескольких потоков. Есть идеи, где я делаю это неправильно? Инициализация словаря: public static class Server { public static volatile Dictionary<int, List<SomeClass>> Values; } Попытка…



1268

default_data['item3'] = 3

Легко, как пай.

Еще одно возможное решение:

default_data.update({'item3': 3})

что хорошо, если вы хотите вставить несколько элементов одновременно.

Поделиться Chris Eberle     20 июня 2011 в 19:08


Поделиться GreenMatt     20 июня 2011 в 19:09



24

Мне пришло в голову, что вы, возможно, на самом деле спрашиваете, как реализовать оператор

+ для словарей, кажется, работает следующее:

>>> class Dict(dict):
...     def __add__(self, other):
...         copy = self.copy()
...         copy.update(other)
...         return copy
...     def __radd__(self, other):
...         copy = other.copy()
...         copy.update(self)
...         return copy
... 
>>> default_data = Dict({'item1': 1, 'item2': 2})
>>> default_data + {'item3': 3}
{'item2': 2, 'item3': 3, 'item1': 1}
>>> {'test1': 1} + Dict(test2=2)
{'test1': 1, 'test2': 2}

Обратите внимание , что это больше накладных расходов, чем использование dict[key] = value или dict.update(), поэтому я бы рекомендовал не использовать это решение, если вы все равно не собираетесь создавать новый словарь.

Поделиться Andrew Clark     20 июня 2011 в 19:36


  • python словарь списков, добавление нового ключа

    Я создаю словарь списков, используя целые числа в качестве ключа в python. Однако следующий код дает мне Т нет. t = y.get(1,[]).append(1) (Но когда я сделаю counter[c] = counter.get(c,0) + 1 , это сработает.) Кто-нибудь может помочь?

  • Добавление нового ключа в существующий словарь python

    У меня есть словарь: oldDict = {‘a’: ‘apple’, ‘b’: ‘boy’, ‘c’: ‘cat’} Мне нужен новый словарь с одним из значений в старом словаре в качестве нового ключа и всеми элементами в качестве значений: newDict = {‘apple’: {‘a’: ‘apple’, ‘b’: ‘boy’, ‘c’: ‘cat’}} Я пытался сделать это: newDict[‘apple’] =…


Похожие вопросы:


Добавление нового элемента в словарь в Linq

Я хотел бы добавить новый элемент в свой словарь в моем коде, public PvmPivotResponse Report_GetGmrToTypeOfIPP(int ProjectPeriodId, int ResearchGroupId) { PvmPivotResponse retVal = new…


Python словарь нуждается в синхронизации?

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


Как сделать в jquery добавление нового элемента?

У меня есть: <li class=active><a href=/>Start</a></li> Как сделать в jquery добавление нового элемента: <li class=active><a…


Добавление в словарь Python

def countFrequency(L): fdict = {} for x in range(0, len(L)): for key, value in fdict: if L[x] == fdict[str(x)]: value = value + 1 else: fdict[L[x]] = 1 return fdict Я пытаюсь подсчитать частоту…


Добавление нового элемента в словарь из нескольких потоков

У меня есть проблема с добавлением нового элемента в статический словарь при использовании его из нескольких потоков. Есть идеи, где я делаю это неправильно? Инициализация словаря: public static…


python словарь списков, добавление нового ключа

Я создаю словарь списков, используя целые числа в качестве ключа в python. Однако следующий код дает мне Т нет. t = y.get(1,[]).append(1) (Но когда я сделаю counter[c] = counter.get(c,0) + 1 , это…


Добавление нового ключа в существующий словарь python

У меня есть словарь: oldDict = {‘a’: ‘apple’, ‘b’: ‘boy’, ‘c’: ‘cat’} Мне нужен новый словарь с одним из значений в старом словаре в качестве нового ключа и всеми элементами в качестве значений:…


Добавление нового значения ключа в существующий словарь в Python

я создал словарь в Python. Employee = dict(EmpName=Peter, Empid=456, Designation=Country Head) теперь, если я хочу добавить в тот же словарь что-то вроде этого. Employee.update(EmpName=Suresh,…


Как присоединить список к словарю списков в качестве нового элемента-python?

Может быть простой вопрос: В python у меня есть список словарей, и я хочу добавить список в качестве нового элемента в каждый словарь в списке? Например у меня есть список словарей: list_dict…


Сложность добавления нового элемента в std::list

Какова сложность вставки нового элемента в список STL с помощью метода insert()? Всегда ли это O(1)? Если нет, то что от этого зависит? Можно ли сказать, что добавление нового элемента в список с…

Словари (dict) и работа с ними. Методы словарей

Сегодня я расскажу о таком типе данных, как словари, о работе со словарями, операциях над ними, методах, о генераторах словарей.

Словари в Python — неупорядоченные коллекции произвольных объектов с доступом по ключу. Их иногда ещё называют ассоциативными массивами или хеш-таблицами.

Чтобы работать со словарём, его нужно создать. Сделать это можно несколькими способами. Во-первых, с помощью литерала:

>>> d = {}
>>> d
{}
>>> d = {'dict': 1, 'dictionary': 2}
>>> d
{'dict': 1, 'dictionary': 2}

Во-вторых, с помощью функции dict:

>>> d = dict(short='dict', long='dictionary')
>>> d
{'short': 'dict', 'long': 'dictionary'}
>>> d = dict([(1, 1), (2, 4)])
>>> d
{1: 1, 2: 4}

В-третьих, с помощью метода fromkeys:

>>> d = dict.fromkeys(['a', 'b'])
>>> d
{'a': None, 'b': None}
>>> d = dict.fromkeys(['a', 'b'], 100)
>>> d
{'a': 100, 'b': 100}

В-четвертых, с помощью генераторов словарей, которые очень похожи на генераторы списков.

>>> d = {a: a ** 2 for a in range(7)}
>>> d
{0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36}

Теперь попробуем добавить записей в словарь и извлечь значения ключей:

>>> d = {1: 2, 2: 4, 3: 9}
>>> d[1]
2
>>> d[4] = 4 ** 2
>>> d
{1: 2, 2: 4, 3: 9, 4: 16}
>>> d['1']
Traceback (most recent call last):
  File "", line 1, in
    d['1']
KeyError: '1'

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

Что же можно еще делать со словарями? Да то же самое, что и с другими объектами: встроенные функции, ключевые слова (например, циклы for и while), а также специальные методы словарей.

Методы словарей

dict.clear() — очищает словарь.

dict.copy() — возвращает копию словаря.

classmethod dict.fromkeys(seq[, value]) — создает словарь с ключами из seq и значением value (по умолчанию None).

dict.get(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а возвращает default (по умолчанию None).

dict.items() — возвращает пары (ключ, значение).

dict.keys() — возвращает ключи в словаре.

dict.pop(key[, default]) — удаляет ключ и возвращает значение. Если ключа нет, возвращает default (по умолчанию бросает исключение).

dict.popitem

() — удаляет и возвращает пару (ключ, значение). Если словарь пуст, бросает исключение KeyError. Помните, что словари неупорядочены.

dict.setdefault(key[, default]) — возвращает значение ключа, но если его нет, не бросает исключение, а создает ключ со значением default (по умолчанию None).

dict.update([other]) — обновляет словарь, добавляя пары (ключ, значение) из other. Существующие ключи перезаписываются. Возвращает None (не новый словарь!).

dict.values() — возвращает значения в словаре.

Словари. Курс «Python. Введение в программирование»

В языке программирования Python словари (тип dict) представляют собой еще одну разновидность структур данных наряду со списками и кортежами. Словарь — это изменяемый (как список) неупорядоченный (в отличие от строк, списков и кортежей) набор элементов «ключ:значение».

«Неупорядоченный» – значит, что последовательность расположения пар не важна, в следствие чего обращение к элементам по индексам невозможно.

В других языках структуры, схожие со словарями, называются по-другому. Например, в Java подобный тип данных называется отображением.

Чтобы представление о словаре стало более понятным, проведем аналогию с обычным словарем, например, англо-русским. На каждое английское слово в таком словаре есть русское слово-перевод: cat – кошка, dog – собака, table – стол и т. д. Если англо-русский словарь описать с помощью Python, то английские слова можно сделать ключами, а русские – их значениями:

{'cat': 'кошка', 'dog': 'собака', 'bird': 'птица'}

Обратите внимание на фигурные скобки, именно с их помощью определяется словарь. Синтаксис словаря на Питоне описывается такой схемой:

В словаре доступ к значениям осуществляется

не по индексам, а по ключам, которые заключаются в квадратные скобки (по аналогии с индексами списков):

>>> a['cat']
'кошка'
>>> a['bird']
'птица'

Словари, как и списки, являются изменяемым типом данных: позволительно изменять, добавлять и удалять элементы (пары «ключ:значение»). Изначально словарь можно создать пустым (например, d = {}) и потом заполнить его элементами. Добавление и изменение имеет одинаковый синтаксис: словарь[ключ] = значение. Ключ может быть как уже существующим (тогда происходит изменение значения), так и новым (происходит добавление элемента словаря). Удаление элемента осуществляется с помощью встроенной оператора del языка Python.

>>> a = {}
>>> a[1] = 2.34
>>> a[2] = 4.88
>>> a
{1: 2.34, 2: 4.88}
>>> a[1] = 3.01 
>>> a
{1: 3.01, 2: 4.88}
>>> del a[2]
>>> a
{1: 3.01}

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

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

>>> nums = {'one': (1, 'I'), 'two': (2, 'II')}
>>> person1 = {'name': 'Tom', 'data': [4, 2.5]}
>>> person1['data'][0]
4

Перебор элементов словаря в цикле for

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

>>> nums
{1: 'one', 2: 'two', 3: 'three'}
>>> for i in nums:
...     print(i)
...
1
2
3

Но по ключам всегда можно получить значения:

>>> for i in nums:
...     print(nums[i])
...
one
two
three

С другой стороны у словаря как класса есть метод items(), который создает особую структуру, состоящую из кортежей. Каждый кортеж включает ключ и значение:

>>> n = nums.items()
>>> n
dict_items([(1, 'one'), (2, 'two'), (3, 'three')])

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

>>> for key, value in nums.items():
...     print(key, 'is', value)
...
1 is one
2 is two
3 is three

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

>>> v_nums = []
>>> for v in nums.values():
...     v_nums.append(v)
...
>>> v_nums
['one', 'two', 'three']

Методы словаря

Кроме рассмотренных выше трех методов items(), keys() и values() словари обладают еще восемью. Это методы clear(), copy(), fromkeys(), get(), pop(), popitem(), setdefault(), update().

Метод clear() удаляет все элементы словаря, но не удаляет сам словарь. В итоге остается пустой словарь:

>>> nums
{'one': (1, 'I'), 'two': (2, 'II')}
>>> nums.clear()
>>> nums
{}

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

>>> n1 = {'a': 1, 'b': 2}
>>> n2 = n1
>>> n3 = n1.copy()
>>> n2['c'] = 3
>>> n1
{'a': 1, 'b': 2, 'c': 3}
>>> n2
{'a': 1, 'b': 2, 'c': 3}
>>> n3
{'a': 1, 'b': 2}

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

>>> a = [1, 2, 3]
>>> c = dict.fromkeys(a)
>>> c
{1: None, 2: None, 3: None}
>>> d = dict.fromkeys(a, 10)
>>> d
{1: 10, 2: 10, 3: 10}
>>> c
{1: None, 2: None, 3: None}

Метод get() позволяет получить элемент по его ключу:

Равносильно nums[1].

Метод pop() удаляет из словаря элемент по указанному ключу и возвращает значение удаленной пары. Метод popitem() не принимает аргументов, удаляет и возвращает произвольный элемент.

>>> nums.pop(1)
'one'
>>> nums
{2: 'two', 3: 'three'}
>>> nums.popitem()
(2, 'two')
>>> nums
{3: 'three'}

С помощью setdefault() можно добавить элемент в словарь:

>>> nums.setdefault(4, 'four')
'four'
>>> nums
{3: 'three', 4: 'four'}

Равносильно nums[4] = 'four', если элемент с ключом 4 отсутствует в словаре. Если он уже есть, то nums[4] = 'four' перезапишет старое значение, setdefault() – нет.

С помощью update() можно добавить в словарь другой словарь:

>>> nums.update({6: 'six', 7: 'seven'})
>>> nums
{3: 'three', 4: 'four', 6: 'six', 7: 'seven'}

Также метод обновляет значения существующих ключей. Включает еще ряд особенностей.

Практическая работа

  1. Создайте словарь, связав его с переменной school, и наполните данными, которые бы отражали количество учащихся в разных классах (1а, 1б, 2б, 6а, 7в и т. п.). Внесите изменения в словарь согласно следующему: а) в одном из классов изменилось количество учащихся, б) в школе появился новый класс, с) в школе был расформирован (удален) другой класс. Вычислите общее количество учащихся в школе.

  2. Создайте словарь, где ключами являются числа, а значениями – строки. Примените к нему метод items(), полученный объект dict_items передайте в написанную вами функцию, которая создает и возвращает новый словарь, «обратный» исходному, т. е. ключами являются строки, а значениями – числа.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

добавление элементов и сортировка, объединение и поиск

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

Создание

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

a = {1: "one", 2: "two", 3: "three"}
print(a)

{1: 'one', 2: 'two', 3: 'three'}

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

a = dict(one = 1, two = 2, three = 3)
print(a)

{'one': 1, 'two': 2, 'three': 3}

Как и в прошлый раз, функция print отображает содержимое словаря a. В данном случае имеется пары объектов, представленных также в виде чисел и строк.

Добавление элемента

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

a = {1: "one", 2: "two", 3: "three"}
a[4] = "four"
print(a)

{1: 'one', 2: 'two', 3: 'three', 4: 'four'}

В приведенном выше коде применяется оператор присваивания, благодаря чему новая пара (4 : “four”) помещается в конец уже созданной ранее коллекции a.

Объединение словарей

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

a = {1: "one", 2: "two", 3: "three"}
b = {4: "four", 5: "five"}
a.update(b)
print(a)

{1: 'one', 2: 'two', 3: 'three', 4: 'four', 5: 'five'}

Результатом работы метода print станет вывод на экран обновленного содержимого словаря под названием a.

После объединения, новые элементы были автоматически записаны в конец коллекции.

Удаление элемента

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

a = {1: "one", 2: "two", 3: "three"}
del a[3]
print(a)

{1: 'one', 2: 'two'}

Так как операция получила ключ 3, в результате ее работы удалилось и значение three.

Получение размера

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

a = {1: "one", 2: "two", 3: "three"}
print(len(a))

3

Стоит заметить, что функция len возвращает точное количество пар, но не объектов. В этом случае имеется словарь, который содержит в себе ровно 3 пары.

Перебор словаря

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

Перебор элементов можно осуществить с целью получения для последующей обработки:

  • Пар ключ-значение;
  • Перебор всех ключей;
  • Перебор значений.

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

a = {1: "one", 2: "two", 3: "three"}
for key, value in a.items():
    print(key, ":", value)

1 : one
2 : two
3 : three

Чтобы получить только ключи, следует применить метод keys, вызывав его на словаре.

a = {1: "one", 2: "two", 3: "three"}
for key in a.keys():
    print(key)

1
2
3

Аналогичным образом нужно поступить, чтобы вывести только значения словаря. Однако в таком случае в цикле for используется метод values.

a = {1: "one", 2: "two", 3: "three"}
for val in a.values():
    print(val)

one
two
three

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

Поиск

Проверить наличие определенного ключа можно при помощи операции in. Для этого достаточно вывести результат ее выполнения для словаря по имени a.

a = {1: "one", 2: "two", 3: "three"}
print(2 in a)
print(4 in a)

True
False

Как можно заметить, проверка ключа 2 дала положительный результат (True). Во втором случае вывелось значение False, поскольку ключа 4 в словаре не обнаружено.

Сортировка

Средства языка дают возможность проводить в Python сортировку словаря по ключам и значениям, в зависимости от необходимости. В следующем примере имеется коллекция данных по имени a, в которой содержится информация в произвольном порядке. Ключами здесь выступают числа, а значениями являются строки. Сортировка осуществляется за счет импортированного модуля operator и встроенного метода itemgetter, получающего 0 или 1.

import operator
a = {2 : "two", 3 : "three", 1 : "one"}
b = sorted(a.items(), key = operator.itemgetter(0))
print(b)
b = sorted(a.items(), key = operator.itemgetter(1))
print(b)

[(1, 'one'), (2, 'two'), (3, 'three')]
[(1, 'one'), (3, 'three'), (2, 'two')]

Как можно заметить, аргумент 0 позволяет отсортировать словарь по ключу, в то время как 1 дает возможность вывести его содержимое в алфавитном порядке значений.

Сравнение

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

a = {1: "one", 2: "two", 3: "three"}
b = {4: "four", 5: "five"}
c = {1: "one", 2: "two", 3: "three"}
print(cmp(a, b))
print(cmp(b, c))
print(cmp(a, c))

1
-1
0

Приведенный код продемонстрировал выполнение метода cmp с трема комбинациями аргументов. Как видно из результатов выдачи, функция возвращает 1, если первый больше второго, -1, если наоборот и 0, когда данные полностью идентичны.

Копирование

Метод copy используется для копирования содержимого одного словаря в другой. Данный пример демонстрирует перенос ключей и значений из коллекции a в b.

a = {1: "one", 2: "two", 3: "three"}
b = a.copy()
print(b)

{1: 'one', 2: 'two', 3: 'three'}

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

Очистка

Чтобы избавиться от всех элементов словаря, стоит вызвать для него функцию clear.

a = {1: "one", 2: "two", 3: "three"}
a.clear()
print(a)

{}

В результате получается абсолютно пустой набор данных.

Генератор словарей

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

a = {a: a * a for a in range(5)}
print(a)

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Таким образом, на выходе получается словарь a, включающий в себя ровно 5 пар. Ключами являются числа от 0 до 4, а значениями выступают их математические квадраты.

Конвертация в строку

Словарь можно очень легко преобразовать в строку для более удобной работы с цельным представлением его содержимого. Чтобы сделать это, потребуется функция str. Как можно видеть из результатов выполнения метода type, конвертация прошла успешно.

a = {1: "one", 2: "two", 3: "three"}
b = str(a)
print(b)
print(type(b))

{1: 'one', 2: 'two', 3: 'three'}
<class 'str'>

Аналогичным образом происходит обратное преобразование строки Python в словарь. Важно, чтобы ее текстовое содержимое подходило по структуре под рассматриваемую коллекцию.

a = '{1: "one", 2: "two", 3: "three"}'
b = eval(a)
print(b)
print(type(b))

{1: 'one', 2: 'two', 3: 'three'}
<class 'dict'>

Как видно из примера, метод eval конвертирует весь текст строки в новый словарь.

Вложенные

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

a = {
    "First": {
        1: "one",
        2: "two",
        3: "three"
    },
    "Second": {
        4: "four",
        5: "five"
    }
}
print(a)

{'First': {1: 'one', 2: 'two', 3: 'three'}, 'Second': {4: 'four', 5: 'five'}}

В примере, описанном выше, создается словарь a, включающий в себя два других словаря (First и Second). Те, в свою очередь, содержат несколько пар ключей и значений.

Резюме

Следующая таблица демонстрирует краткую сводку по всем рассмотренным методам для работы со словарями в Python 3. В таблице отображаются названия методов, а также информация о  их назначении.

Название Назначение
update Объединение содержимого двух словарей в один
len Получение размера
items Возвращает пары (ключи и значения)
keys Возвращает ключи
values Возвращает значения
copy Копирует содержимое в другой словарь
clear Полная очистка всех элементов
eval Конвертация строки в словарь

Словари и методы в Python. Добавление списка в словарь

Словарь в Python — неупорядоченная структура данных, позволяющая хранить пары «ключ-значение». В этой статье вы узнаете, как выглядит словарь, какие используются методы при работе с ним, а также о том, как преобразовать список в словарь.

Словарь (dictionary) в Python используется наряду с кортежами и списками, похожие структуры есть и в других языках программирования (ассоциативный массив в PHP, словарь в C#).

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

Вот синтаксис словаря в Python:

    dictionary = { ключ1:значение1, ключ2:значение2, ....}

А вот ещё пример словаря:

dictionary = {'персона': 'человек',
              'марафон': 'гонка бегунов длиной около 26 миль',
              'противостоять': 'оставаться сильным, несмотря на давление',
              'бежать': 'двигаться со скоростью'}

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

gender_dict = {0: 'муж',
               1: 'жен'}

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

dictionary = {(1, 2.0): 'кортежи могут быть ключами',
              1: 'целые числа могут быть ключами',
              'бежать': 'строки тоже', 
              ['носок', 1, 2.0]: 'а списки не могут'}

Получаем данные из словаря

Чтобы получить значения конкретного ключа используют квадратные скобки []. Представим, что у нас в словаре присутствует пара «марафон»: 26.

# берём значение с ключом «марафон»
dictionary['марафон']

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

Как добавлять и обновлять ключи

Добавление в словарь новых пар выполняется просто:

# Добавляем ключ «туфля» со значением «род обуви, который закрывает ногу не выше щиколотки»
dictionary['туфля'] = 'род обуви, который закрывает ногу не выше щиколотки'

Для обновления делаем то же самое:

# Обновляем ключ "туфля" и присваиваем ему значение "хорошая туфля"
dictionary['туфля'] = 'хорошая туфля'

Как удалять ключи

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

# Удаляем значение с ключом "противостоять" из словаря
del dictionary['противостоять']

Методы

Cловари имеют много полезных методов, помогающих в работе. Рассмотрим наиболее популярные.

Update

Метод update() нужен при объявлении нескольких пар одновременно. В качестве аргумента метод принимает другой словарь:

# Добавляем две пары в словарь dictionary, используя метод update
dictionary.update({'бежал': 'бежать в прошедшем времени',
                   'туфли': 'туфля во множественном числе'})

>>> dictionary
{'марафон': 'гонка бегунов длиной около 26 миль',
'персона': 'человек',
'бежал': 'бежать в прошедшем времени',
'бежать': 'двигаться со скоростью',
'туфля': 'род обуви, закрывающей ногу не выше щиколотки',
'туфли': 'туфля во множественном числе'}

Возможно, вы спросите, почему в словаре данные расположены в другом порядке, а не в том, в котором были в него внесены. Ответ прост — словари не упорядочены.

Get

# Представьте, что у нас есть словарь story_count
story_count = {'сто': 100,
               'девяносто': 90,
               'двенадцать': 12,
               'пять': 5}

get() возвратит значение по указанному ключу. А если его нет, то метод вернёт нам None.

# Ключ "двенадцать" существует и метод get в данном случае вернёт 12
story_count.get('двенадцать')

Способ используют при проверке, а есть ли ключи в словаре:

>>> story_count.get('два')
None

Кроме того, вы можете указать значение по умолчанию — оно вернётся вместо None, если ключа не будет в словаре:

# Метод вернёт 0 в случае, если данного ключа не существует
story_count.get('два', 0)

Pop

Метод pop() служит для удаления ключа и возвращения соответствующего ему значения.

>>> story_count.pop('девяносто')
90
>>> story_count
{'двенадцать': 12, 'сто': 100, 'пять': 5}

Keys

Метод keys() необходим, чтобы возвратить коллекцию ключей в словаре:

>>> story_count.keys()
['сто', 'пять', 'двенадцать']

Values

Возвратит коллекцию значений в словаре.

>>> story_count.values()
[100, 12, 5]

Items

Если нужно вернуть пары «ключ — значение», используют items():

>>> dictionary.items()
[('персона', 'человек'),
('бежать', 'двигаться со скоростью'),
('туфля', 'род обуви, закрывающей ногу не выше щиколотки'),
('бежал', 'бежать в прошедшем времени'),
('марафон', 'гонка бегунов длиной около 26 миль'),
('туфли', 'туфля во множественном числе')]

Итерация через словарь

В «Питоне» есть возможность выполнить итерацию в словаре по каждому ключу:

for key in story_count:
   print(key)

Кстати, вместо story_count можно применять story_count.keys().

Внимательно посмотрите на участок кода ниже: в нём цикл for использует метод items(), чтобы получить пары «ключ — значение» на каждую итерацию:

>>> for key, value in dictionary.items():
        print(key, value)
('персона', 'человек')
('бежать', 'двигаться со скоростью')
('туфля', 'род обуви, закрывающей ногу не выше щиколотки')
('бежал', 'бежать в прошедшем времени')
('марафон', 'гонка бегунов длиной около 26 миль')
('туфли', 'туфля во множественном числе')

Словарь и список: выполнение преобразования из списка в словарь

Словарь (dictionary) и список (list) — типы, непохожие по своей структуре. Однако для отдельных видов списка есть возможность преобразования списка в словарь. Для этого используют встроенную функцию dict(). Необходимо, чтобы список хранил набор вложенных списков. Также нужно, чтобы каждый вложенный список состоял из 2-х элементов. В результате во время конвертации списка в словарь 1-й элемент превратится в ключ, 2-й — в значение:

    users_list = [
    ["+111123455", "Tom"],
    ["+384767557", "Bob"],
    ["+958758767", "Alice"]
]
users_dict = dict(users_list)
print(users_dict)  # {"+111123455": "Tom", "+384767557": "Bob", "+958758767": "Alice"}

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

    users_tuple = (
    ("+111123455", "Tom"),
    ("+384767557", "Bob"),
    ("+958758767", "Alice")
)
users_dict = dict(users_tuple)
print(users_dict)

Материал подготовлен специально для OTUS на основании статьи «Python Dictionary and Dictionary Methods».

Интерактивный учебник языка Python

1. Словари

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

Структура данных, позволяющая идентифицировать ее элементы не по числовому индексу, а по произвольному, называется словарем или ассоциативным массивом. Соответствующая структура данных в языке Питон называется dict.

Рассмотрим простой пример использования словаря. Заведем словарь Capitals, где индексом является название страны, а значением — название столицы этой страны. Это позволит легко определять по строке с названием страны ее столицу.

	
# Создадим пустой словать Capitals
Capitals = dict()

# Заполним его несколькими значениями
Capitals['Russia'] = 'Moscow'
Capitals['Ukraine'] = 'Kiev'
Capitals['USA'] = 'Washington'

Countries = ['Russia', 'France', 'USA', 'Russia']

for country in Countries:
    # Для каждой страны из списка проверим, есть ли она в словаре Capitals
    if country in Capitals:
        print('Столица страны ' + country + ': ' + Capitals[country])
    else:
        print('В базе нет страны c названием ' + country)

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

В жизни широко распространены словари, например, привычные бумажные словари (толковые, орфографические, лингвистические). В них ключом является слово-заголовок статьи, а значением — сама статья. Для того, чтобы получить доступ к статье, необходимо указать слово-ключ.

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

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

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

Когда нужно использовать словари

Словари нужно использовать в следующих случаях:

  • Подсчет числа каких-то объектов. В этом случае нужно завести словарь, в котором ключами являются объекты, а значениями — их количество.
  • Хранение каких-либо данных, связанных с объектом. Ключи — объекты, значения — связанные с ними данные. Например, если нужно по названию месяца определить его порядковый номер, то это можно сделать при помощи словаря Num['January'] = 1; Num['February'] = 2; ....
  • Установка соответствия между объектами (например, “родитель—потомок”). Ключ — объект, значение — соответствующий ему объект.
  • Если нужен обычный массив, но масимальное значение индекса элемента очень велико, и при этом будут использоваться не все возможные индексы (так называемый “разреженный массив”), то можно использовать ассоциативный массив для экономии памяти.

Создание словаря

Пустой словарь можно создать при помощи функции dict() или пустой пары фигурных скобок {} (вот почему фигурные скобки нельзя использовать для создания пустого множества). Для создания словаря с некоторым набором начальных значений можно использовать следующие конструкции:

	
Capitals = {'Russia': 'Moscow', 'Ukraine': 'Kiev', 'USA': 'Washington'}
Capitals = dict(Russia = 'Moscow', Ukraine = 'Kiev', USA = 'Washington')
Capitals = dict([("Russia", "Moscow"), ("Ukraine", "Kiev"), ("USA", "Washington")])
Capitals = dict(zip(["Russia", "Ukraine", "USA"], ["Moscow", "Kiev", "Washington"]))
print(Capitals)

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

Работа с элементами словаря

Основная операция: получение значения элемента по ключу, записывается так же, как и для списков: A[key]. Если элемента с заданным ключом нет в словаре, то возникает исключение KeyError.

Другой способ определения значения по ключу — метод get: A.get(key). Если элемента с ключом get нет в словаре, то возвращается значение None. В форме записи с двумя аргументами A.get(key, val) метод возвращает значение val, если элемент с ключом key отсутствует в словаре.

Проверить принадлежность элемента словарю можно операциями in и not in, как и для множеств.

Для добавления нового элемента в словарь нужно просто присвоить ему какое-то значение: A[key] = value.

Для удаления элемента из словаря можно использовать операцию del A[key] (операция возбуждает исключение KeyError, если такого ключа в словаре нет. Вот два безопасных способа удаления элемента из словаря.

	
A = {'ab' : 'ba', 'aa' : 'aa', 'bb' : 'bb', 'ba' : 'ab'}

key = 'ac'
if key in A:
    del A[key]

try:
    del A[key]
except KeyError:
	print('There is no element with key "' + key + '" in dict')
print(A)

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

Еще один способ удалить элемент из словаря: использование метода pop: A.pop(key). Этот метод возвращает значение удаляемого элемента, если элемент с данным ключом отсутствует в словаре, то возбуждается исключение. Если методу pop передать второй параметр, то если элемент в словаре отсутствует, то метод pop возвратит значение этого параметра. Это позволяет проще всего организовать безопасное удаление элемента из словаря: A.pop(key, None).

Перебор элементов словаря

Можно легко организовать перебор ключей всех элементов в словаре:

	
A = dict(zip('abcdef', list(range(6))))
for key in A:
    print(key, A[key])

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

Соответственно, быстро проверить, есть ли значение val среди всех значений элементов словаря A можно так: val in A.values(), а организовать цикл так, чтобы в переменной key был ключ элемента, а в переменной val, было его значение можно так:

	
A = dict(zip('abcdef', list(range(6))))
for key, val in A.items():
    print(key, val)

Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.

Словари и их методы в Python

Что такое словарь

Словарь — неупорядоченная структура данных, которая позволяет хранить пары «ключ — значение». Вот пример словаря на Python:

dictionary = {'персона': 'человек',
              'марафон': 'гонка бегунов длиной около 26 миль',
              'противостоять': 'оставаться сильным, несмотря на давление',
              'бежать': 'двигаться со скоростью'}

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

gender_dict = {0: 'муж',
               1: 'жен'}

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

dictionary = {(1, 2.0): 'кортежи могут быть ключами',
              1: 'целые числа могут быть ключами',
              'бежать': 'строки тоже', 
              ['носок', 1, 2.0]: 'а списки не могут'}

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

Получение данных из словаря

Для получения значения конкретного ключа используются квадратные скобки []. Предположим, что в нашем словаре есть пара 'марафон': 26.

# берём значение с ключом "марафон"
dictionary['марафон']

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

Добавление и обновление ключей

Добавление новых пар в словарь происходит достаточно просто:

# Добавляем ключ "туфля" со значением "род обуви, закрывающей ногу не выше щиколотки"
dictionary['туфля'] = 'род обуви, закрывающей ногу не выше щиколотки'

Обновление существующих значений происходит абсолютно также:

# Обновляем ключ "туфля" и присваиваем ему значение "хорошая туфля"
dictionary['туфля'] = 'хорошая туфля'

Удаление ключей

Для удаления ключа и соответствующего значения из словаря можно использовать del

# Удаляем значение с ключом "противостоять" из словаря
del dictionary['противостоять']

Методы

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

Update

Метод update() пригодится, если нужно обновить несколько пар сразу. Метод принимает другой словарь в качестве аргумента.

# Добавляем две пары в словарь dictionary, используя метод update
dictionary.update({'бежал': 'бежать в прошедшем времени',
                   'туфли': 'туфля во множественном числе'})

 

>>> dictionary
{'марафон': 'гонка бегунов длиной около 26 миль',
'персона': 'человек',
'бежал': 'бежать в прошедшем времени',
'бежать': 'двигаться со скоростью',
'туфля': 'род обуви, закрывающей ногу не выше щиколотки',
'туфли': 'туфля во множественном числе'}

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

Get

# Допустим, у нас есть словарь story_count
story_count = {'сто': 100,
               'девяносто': 90,
               'двенадцать': 12,
               'пять': 5}

Метод get() возвращает значение по указанному ключу. Если указанного ключа не существует, метод вернёт None.

# Ключ "двенадцать" существует и метод get в данном случае вернёт 12
story_count.get('двенадцать')

Метод можно использовать для проверки наличия ключей в словаре:

>>> story_count.get('два')
None

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

# Метод вернёт 0 в случае, если данного ключа не существует
story_count.get('два', 0)

Pop

Метод pop() удаляет ключ и возвращает соответствующее ему значение.

>>> story_count.pop('девяносто')
90
>>> story_count
{'двенадцать': 12, 'сто': 100, 'пять': 5}

Keys

Метод keys() возвращает коллекцию ключей в словаре.

>>> story_count.keys()
['сто', 'пять', 'двенадцать']

Values

Метод values() возвращает коллекцию значений в словаре.

>>> story_count.values()
[100, 12, 5]

Items

Метод items() возвращает пары «ключ — значение».

>>> dictionary.items()
[('персона', 'человек'),
('бежать', 'двигаться со скоростью'),
('туфля', 'род обуви, закрывающей ногу не выше щиколотки'),
('бежал', 'бежать в прошедшем времени'),
('марафон', 'гонка бегунов длиной около 26 миль'),
('туфли', 'туфля во множественном числе')]

 

Итерация через словарь

Вы можете провести итерацию по каждому ключу в словаре.

for key in story_count:
   print(key)

Очевидно, вместо story_count можно использовать story_count.keys().

В примере кода ниже ниже цикл for использует метод items() для получения пары «ключ — значение» на каждую итерацию.

>>> for key, value in dictionary.items():
        print(key, value)
('персона', 'человек')
('бежать', 'двигаться со скоростью')
('туфля', 'род обуви, закрывающей ногу не выше щиколотки')
('бежал', 'бежать в прошедшем времени')
('марафон', 'гонка бегунов длиной около 26 миль')
('туфли', 'туфля во множественном числе')

О словаре и других типах данных Python можно почитать в нашей статье.

Перевод статьи «Python Dictionary and Dictionary Methods»

python — как добавить пару ключей и значений в словарь?

На этот вопрос уже есть ответы :

Закрыт 3 года назад.

Как добавить пару ключ-значение в словарь?. Ниже я упомянул следующий формат?

  {'1_somemessage': [[3L,
                    1л,
                    u'AAA ',
                    1689544L,
                    дата и время.datetime (2010, 9, 21, 22, 30),
                    u'gffggf '],
                   [3L,
                    1л,
                    u'BBB ',
                    1689544L,
                    datetime.datetime (2010, 9, 21, 20, 30),
                    u'ffgffgfg '],
                   [3L,
                    1л,
                    u'CCC ',
                    1689544L,
                    datetime.datetime (2010, 9, 21, 22, 30),
                    u'hjhjhjhj '],
                   [3L,
                    1л,
                    u'DDD ',
                    1689544L,
                    дата и время.datetime (2010, 9, 21, 21, 45),
                    u'jhhjjh ']],
 '2_somemessage': [[4L,
                    1л,
                    u'AAA ',
                    1689544L,
                    datetime.datetime (2010, 9, 21, 22, 30),
                    u'gffggf '],
                   [4L,
                    1л,
                    u'BBB ',
                    1689544L,
                    datetime.datetime (2010, 9, 21, 20, 30),
                    u'ffgffgfg '],
                   [4L,
                    1л,
                    u'CCC ',
                    1689544L,
                    дата и время.datetime (2010, 9, 21, 22, 30),
                    u'hjhjhjhj '],
                   [4L,
                    1л,
                    u'DDD ',
                    1689544L,
                    datetime.datetime (2010, 9, 21, 21, 45),
                    u'jhhjjh ']]}
  

python — Как добавить новые ключи в словарь?

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

Чтобы продемонстрировать, как и как не использовать его, давайте создадим пустой dict с литералом dict, {} :

  my_dict = {}
  

Наилучшая практика 1: индексирование

Чтобы обновить этот словарь одним новым ключом и значением, вы можете использовать нотацию подстрочного индекса (см. Сопоставления здесь), которая обеспечивает назначение элементов:

  my_dict ['новый ключ'] = 'новое значение'
  

my_dict сейчас:

  {'новый ключ': 'новое значение'}
  

Лучшая практика 2: метод обновления

— 2 способа

Мы также можем эффективно обновить dict несколькими значениями, используя метод update .Возможно, мы без необходимости создаем здесь дополнительный dict , поэтому мы надеемся, что наш dict уже был создан и пришел или использовался для другой цели:

  my_dict.update ({'ключ 2': 'значение 2', 'ключ 3': 'значение 3'})
  

my_dict сейчас:

  {'ключ 2': 'значение 2', 'ключ 3': 'значение 3', 'новый ключ': 'новое значение'}
  

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

  my_dict.обновление (foo = 'bar', foo2 = 'baz')
  

и my_dict сейчас:

  {'ключ 2': 'значение 2', 'ключ 3': 'значение 3', 'новый ключ': 'новое значение',
 'foo': 'bar', 'foo2': 'baz'}
  

Итак, теперь мы рассмотрели три Pythonic-способа обновления dict .


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

  >>> d = {}
>>> d.__setitem __ ('фу', 'бар')
>>> d
{'foo': 'bar'}


>>> def f ():
... d = {}
... для i в xrange (100):
... d ['foo'] = я
...
>>> def g ():
... d = {}
... для i в xrange (100):
... d .__ setitem __ ('фу', я)
...
>>> время импорта
>>> число = 100
>>> min (timeit.repeat (f, number = number))
0,0020880699157714844
>>> min (timeit.repeat (g, number = number))
0,005071878433227539
  

Итак, мы видим, что использование нижнего индекса на самом деле намного быстрее, чем использование __setitem__ .Выполнение вещей Pythonic, то есть использование языка так, как он был предназначен для использования, обычно является более читаемым и более эффективным с точки зрения вычислений.

Python Добавить в словарь: Руководство

Словари используются для хранения данных с использованием структуры «ключ-значение» в Python.

Когда вы работаете со словарями, вы можете спросить себя, как мне добавить элемент в словарь? Эта статья ответит на этот вопрос.

Мы разберем основы словарей, как они работают и как вы можете добавить элемент в словарь Python.К концу этого руководства вы станете экспертом по добавлению элементов в словари Python.

Словарь Python: напоминание

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

Найдите свой учебный лагерь Match