Содержание

Python. Урок 9. Словари (dict)

Словари (dict) – это одна из наиболее часто используемых структур данных, позволяющая хранить объекты, для доступа к которым используется ключ. В этом уроке будут рассмотрены операции создания, удаления, работы со словарями и их методы.

Что такое словарь (dict) в Python?

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

Создание, изменение, удаление словарей и работа с его элементами

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

>>> d1 = dict()
>>> print(type(d1))
<class 'dict'>
>>> d2 = {}
>>> print(type(d2))
<class 'dict'>

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

>>> d1 = dict(Ivan="manager", Mark="worker")
>>> print(d1)
{'Mark': 'worker', 'Ivan': 'manager'}
>>> d2 = {"A1":"123", "A2":"456"}
>>> print(d2)
{'A2': '456', 'A1': '123'}

Добавление и удаление элемента
Чтобы добавить элемент в словарь нужно указать новый ключ и значение.

>>> d1 = {"Russia":"Moscow", "USA":"Washington"}
>>> d1["China"]="Beijing"
>>> print(d1)
{'Russia': 'Moscow', 'China': 'Beijing', 'USA': 'Washington'}

Для удаления элемента из словаря можно воспользоваться командой del.

>>> d2 = {"A1":"123", "A2":"456"}
>>> del d2["A1"]
>>> print(d2)
{'A2': '456'}

Работа со словарем
Проверка наличия ключа в словаре производится с помощью оператора in.

>>> d2 = {"A1":"123", "A2":"456"}
>>> "A1" in d2
True
>>> "A3" in d2
False

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

>>> d1 = {"Russia":"Moscow", "USA":"Washington"}
>>> d1["Russia"]
'Moscow'

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

У словарей доступен следующий набор методов.

clear()
Удаляет все элементы словаря.

>>> d2 = {"A1":"123", "A2":"456"}
>>> print(d2)
{'A2': '456', 'A1': '123'}
>>> d2.clear()
>>> print(d2)
{}

copy()
Создается новая копия словаря.

>>> d2 = {"A1":"123", "A2":"456"}
>>> d3 = d2.copy()
>>> print(d3)
{'A1': '123', 'A2': '456'}
>>> d3["A1"]="789"
>>> print(d2)
{'A2': '456', 'A1': '123'}
>>> print(d3)
{'A1': '789', 'A2': '456'}

fromkeys(seq[, value])
Создает новый словарь с ключами из seq и значениями из value. По умолчанию value присваивается значение None.

get(key)
Возвращает значение из словаря по ключу key.

>>> d = {"A1":"123", "A2":"456"}
>>> d.get("A1")
'123'

items()
Возвращает элементы словаря (ключ, значение) в отформатированном виде.

>>> d = {"A1":"123", "A2":"456"}
>>> d.items()
dict_items([('A2', '456'), ('A1', '123')])

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.keys()
dict_keys(['A2', 'A1'])

pop(key[, default])
Если ключ key есть в словаре, то данный элемент удаляется из словаря и возвращается значение по этому ключу, иначе будет возвращено значение default. Если default не указан и запрашиваемый ключ отсутствует в словаре, то будет вызвано исключение KeyError.

>>> d = {"A1":"123", "A2":"456"}
>>> d.pop("A1")
'123'
>>> print(d)
{'A2': '456'}

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.popitem()
('A2', '456')
>>> print(d)
{'A1': '123'}

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

>>> d = {"A1":"123", "A2":"456"}
>>> d.setdefault("A3", "777")
'777'
>>> print(d)
{'A2': '456', 'A3': '777', 'A1': '123'}
>>> d.setdefault("A1")
'123'
>>> print(d)
{'A2': '456', 'A3': '777', 'A1': '123'}

update([other])
Обновить словарь парами (key/value) из other, если ключи уже существуют, то обновить их значения.

>>> d = {"A1":"123", "A2":"456"}
>>> d.update({"A1":"333", "A3":"789"})
>>> print(d)
{'A2': '456', 'A3': '789', 'A1': '333'}

values()
Возвращает значения элементов словаря.

>>> d = {"A1":"123", "A2":"456"}
>>> d.values()
dict_values(['456', '123'])

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.

<<< Python. Урок 8. Кортежи (tuple)   Python. Урок 10. Функции в Python>>>

devpractice.ru

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

Словарем в языке программирования 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 Конвертация строки в словарь

all-python.ru

Словари (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() — возвращает значения в словаре.

pythonworld.ru

Основы работы со словарями(dict) python: get(), keys(), update(), items()

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

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

Для создания словаря в Python необходимо передать последовательность элементов внутри фигурных скобок {}, разделив их запятыми (,). Каждый элемент имеет ключ и значение, выраженное парой «ключ: значение».

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

Следующие примеры показывают, как создавать словари Python:

Создание пустого словаря:

dict_sample = {}

Cловарь, где ключи являются целыми числами:

dict_sample = {1: 'mango', 2: 'pawpaw'}

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

dict_sample = {'fruit': 'mango', 1: [4, 6, 8]}

Можно также создать словарь, явно вызвав метод dict():

dict_sample = dict({1:'mango', 2:'pawpaw'})

Словарь можно создать с помощью последовательности, как в примере внизу:

dict_sample = dict([(1,'mango'), (2,'pawpaw')])

Словари могут быть вложенными. Это значит, что можно создавать словари внутри существующего словаря. Например:

Тест на знание python

Что выведет этот код?

Продолжить

Какой будет результат выполнения этого кода?

Продолжить

Верно ли данное утверждение: «В Python есть два типа чисел: целые числа и числа с плавающей точкой»?

Продолжить

Какое значение вернет код colors[2] ?

Продолжить

Какой будет результат выполнения этого кода?

Продолжить

Продолжить

{{title}}

{{image}}

{{content}}

{{/global}}

Поделиться результатами через

dict_sample = {
1: {'student1': 'Nicholas', 'student2': 'John', 'student3': 'Mercy'}, 
2: {'course1': 'Computer Science', 'course2': 'Mathematics', 'course3': 'Accounting'}
}

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio', 'year': 2012}

Доступ к элементами

Чтобы получить доступ к элементам словаря, нужно передать ключ в квадратных скобках []. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
x = dict_sample["model"] 
print(x)

Вывод:

Premio

Был создан словарь dict_sample. Затем была создана переменная x. Ее значение — это значение ключа ["model"] из словаря.

Вот другой пример:

dict = {'Name': 'Mercy', 'Age': 23, 'Course': 'Accounting'} 
print("Student Name:", dict['Name']) 
print("Course:", dict['Course']) 
print("Age:", dict['Age'])

Вывод:

Student Name: Mercy 
Course: Accounting 
Age: 23

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
x = dict_sample.get("model")
print(x)

Вывод:

Premio

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

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

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
dict_sample["Capacity"] = "1800CC" 
print(dict_sample)

Вывод:

{'Capacity': '1800CC', 'year': 2012, 'Company': 'Toyota', 'model': 'Premio'}

У нового элемента ключ "Capacity" и значение — "180CC". Он был добавлен в качестве первого элемента словаря.

Вот другой пример. Для начала нужно создать пустой словарь:

MyDictionary = {} 
print("An Empty Dictionary: ") 
print(MyDictionary)

Вывод:

An Empty Dictionary:

Словарь ничего не возвращает, потому что в нем ничего не хранится. Добавим в нему элементы, один за одним:

MyDictionary[0] = 'Apples' 
MyDictionary[2] = 'Mangoes' 
MyDictionary[3] = 20 
print("\n3 elements have been added: ") 
print(MyDictionary)

Вывод:

3 elements have been added: {0: 'Apples', 2: 'Mangoes', 3: 20}

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

MyDictionary[0] = 'Apples'

В этом примере 0 является ключом, а "Apples" — значение.

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

MyDictionary['Values'] = 1, "Pairs", 4 
print("\n3 elements have been added: ") 
print(MyDictionary)

Вывод:

3 elements have been added: {'Values': (1, 'Pairs', 4)}

В этом примере название ключа — "Value", а все что после знака = — его значения в формате множества (Set).

Помимо добавления новых элементов в словарь, их можно обновлять или изменять. Об этом в следующем разделе.

Обновление элементов

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 

dict_sample["year"] = 2014 

print(dict_sample)

Вывод:

{'year': 2014, 'model': 'Premio', 'Company': 'Toyota'}

В этом примере видно, что было обновлено значение ключа "year" с 2012 на 2014.

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

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

Ключевое слово del можно использовать для удаления элемента с конкретным ключом. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
}
del dict_sample["year"] 
print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

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

Другой способ удалить пару ключ-значение — функция pop() с ключом записи в виде аргумента. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
dict_sample.pop("year") 
print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

Функция pop() была вызвана добавлением ее к названию словаря. В этом случае будет удалена запись с ключом "year".

Функция popitem() удаляет последний элемент в словаре. Для нее не нужно указывать конкретный ключ. Примеры:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
dict_sample.popitem() 
print(dict_sample)

Вывод:

{'Company': 'Toyota', 'model': 'Premio'}

Последней записью в словаре была "year". Она пропала из словаря после вызова функции popitem().

Что делать, если нужно удалить целый словарь? Это будет сложно и займет много времени, если пользоваться этими методами к каждому ключу. Вместо этого можно использовать ключевое слово del для целого словаря. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
del dict_sample 
print(dict_sample)

Вывод:

NameError: name 'dict_sample' is not defined

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

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
dict_sample.clear() 
print(dict_sample)

Вывод:

{}

Код вернет пустой словарь, поскольку все его элементы уже удалены.

Другие распространенные методы словарей

Метод len()

С помощью этого метода можно посчитать количество элементов в словаре. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
print(len(dict_sample))

Вывод:

3

В этом словаре три записи, поэтому метод вернет 3.

Метод copy()

Этот метод возвращает копию существующего словаря. Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
x = dict_sample.copy() 

print(x)

Вывод:

{'Company': 'Toyota', 'year': 2012, 'model': 'Premio'}

Была создана копия словаря dict_sample. Она присвоена переменной x. Если вывести x в консоль, то в ней будут те же элементы, что и в словаре dict_sample.

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

Метод items()

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

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 

for k, v in dict_sample.items(): 
    print(k, v)

Вывод:

('Company', 'Toyota') 
('model', 'Premio') 
('year', 2012)

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 

x = dict_sample.items() 

print(x) 

dict_sample["model"] = "Mark X" 

print(x)

Вывод:

dict_items([('Company', 'Toyota'), ('model', 'Premio'), ('year', 2012)]) 
dict_items([('Company', 'Toyota'), ('model', 'Mark X'), ('year', 2012)])

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

Метод fromkeys()

Этот метод возвращает словарь с указанными ключами и значениями. У него следующий синтаксис:

dictionary.fromkeys(keys, value)

Значение требуемого параметра keys — итерируемые объекты. Оно отвечает за ключи нового словаря. Значение для параметра value указывать необязательно. Оно отвечает за значение по умолчанию для всех ключей. По умолчанию — None.

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

name = ('John', 'Nicholas', 'Mercy') 
age = 25 

dict_sample = dict.fromkeys(name, age) 

print(dict_sample)

Вывод:

{'John': 25, 'Mercy': 25, 'Nicholas': 25}

В коде вверху определены ключи и одно значение. Метод fromkeys() перебирает ключи и объединяет их со значением для создания заполненного словаря.

Значение для параметра keys является обязательным. В следующем примере показано, что происходит, если параметр values не определен:

name = ('John', 'Nicholas', 'Mercy')

dict_sample = dict.fromkeys(name) 

print(dict_sample)

Вывод:

{'John': None, 'Mercy': None, 'Nicholas': None}

Используется значение по умолчанию, None.

Метод setdefault()

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

У метода следующий синтаксис:

dictionary.setdefault(keyname, value)

В этой функции параметр keyname является обязательным. Он обозначает название ключа, значение которого нужно вернуть. Параметр value необязательный. Если в словаре уже есть ключ, параметр не будет иметь никакого эффекта. Если ключ не существует, тогда значение функции станет значением ключа. Значение по умолчанию — None.

Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 

x = dict_sample.setdefault("color", "Gray") 
print(x)

Вывод:

Gray

В словаре нет ключа color. Метод setdefault() вставляет этот ключ вместе со значением "Gray".

Следующий пример показывает, как работает метод, если такой ключ уже есть:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
x = dict_sample.setdefault("model", "Allion") 
print(x)

Вывод:

Premio

Значение "Allion" не повлияло на словарь, потому что у ключа уже есть значение.

Метод keys()

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

Для использования метода нужно всего лишь использовать его с именем словаря, как показано ниже:

dictionary.keys()

Например:

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 
x = dict_sample.keys() 

print(x)

Вывод:

dict_keys(['model', 'Company', 'year'])

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

dict_sample = {
  "Company": "Toyota", 
  "model": "Premio", 
  "year": 2012 
} 

for k in dict_sample.keys(): 
    print(k)

Вывод:

Company  
model  
year

Выводы

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

pythonru.com

урок по работе со словарями для начинающих ~ PythonRu

Предыдущий урок: Множества (set)

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

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

Доступ к элементам

Вы можете получить доступ к элементам словаря ссылаясь на его ключевое название.
Получим значение по ключу “model” :

x = thisdict["model"]

Существует так же метод под названием get() который даст вам тот же результат.

x = thisdict.get("model")

Изменить значение

Вы можете поменять значение указанного элемента ссылаясь на ключевое название.
Поменяем “year” на “2018”:

thisdict = {  
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["year"] = 2018
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 2018}

Цикл for по словарю

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

for x in thisdict:
    print(x)

Вывод:

brand
model
year

Выведем значения словаря, один за одним:

Тест на знание python

Какой будет результат выполнения этого кода?

Продолжить

Какой будет результат выполнения кода — print(type(lambda: None)) ?

Продолжить

Какой ввод НЕ приведет к ошибке?

Продолжить

Что выведет этот код?

Продолжить

Что выведет этот код?

Продолжить

Продолжить

{{title}}

{{image}}

{{content}}

{{/global}}

Поделиться результатами через

for x in thisdict:  
    print(thisdict[x])

Вывод:

Ford
Mustang
1964

Вы так же можете использовать функцию values() для возврата значений словаря:

for x in thisdict.values():
    print(x)

Вывод:

Ford
Mustang
1964

Пройдем по ключам и значениям, используя функцию items():

for x, y in thisdict.items():
    print(x, y)

Вывод:

brand Ford
model Mustang
year 1964

Длина словаря

Для того, чтобы определить сколько элементов есть в словаре, используйте метод len().

print(len(thisdict))

Вывод:

3

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

Добавление элементов в словарь выполняется с помощью нового ключа:

thisdict =  {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict["color"] = "red" 
print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964, 'color': 'red'}

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

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

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.pop("model")

Метод popitem() удаляет последний элемент:

thisdict =  {
"brand": "Ford",
"model":  "Mustang",
"year":  1964
}
thisdict.popitem()

Ключевое слово del удаляет элемент по ключу:

thisdict =  {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
del thisdict["model"]
print(thisdict)

Вывод:

{'brand': 'Ford', 'year': 1964}

Ключевое слово del может так же удалить полностью весь словарь:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}  
del thisdict  
print(thisdict)  

Ключевое слово clear() очищает словарь:

thisdict = {
"brand": "Ford",
"model": "Mustang",
"year": 1964
}
thisdict.clear()  
print(thisdict)

Вывод:

{}

Конструктор dict()

Вы так же можете использовать конструктор dict() для создания нового словаря.

thisdict = dict(brand="Ford", model="Mustang", year=1964)


print(thisdict)

Вывод:

{'brand': 'Ford', 'model': 'Mustang', 'year': 1964}

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

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

Метод Значение
clear() Удаляет все элементы из словаря
copy() Делает копию словаря
fromkeys() Возвращает словарь с указанными ключами и значениями
get() Возвращает значение по ключу
items() Возвращает список, содержащий tuple для каждой пары ключ-значение
keys() Возвращает список, содержащий ключи словаря
pop() Удаляет элементы по ключу
popitem() Удаляет последнюю пару ключа со значением
setdefault() Задает значение по ключу. Если ключа нет в словаре, добавляет его с указанным значением или None
update() Обновляет словарь, добавляя пары ключ-значение
values() Возвращает список всех значений в словаре

Далее: Условные выражения и конструкция if

pythonru.com

Программирование на Python: Часть 4. Словари

Сергей Яковлев
Опубликовано 09.08.2010

Серия контента:

Этот контент является частью # из серии # статей:

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

Следите за выходом новых статей этой серии.

Этот контент является частью серии:

Следите за выходом новых статей этой серии.

После списков словарь является самым гибким встроенным типом. Если список — это упорядоченная коллекция, то словарь — неупорядоченная. Основные особенности словарей:

  1. Доступ осуществляется по ключу, а не по индексу. По аналогии со списком, в словаре можно получить доступ к элементам в цикле по ключам.
  2. Значения словаря хранятся в неотсортированном порядке, более того, ключи могут храниться не в том порядке, в котором они добавляются.
  3. По аналогии со списками, словарь может хранить вложенные словари. Словарь может хранить в качестве значений объекты любого типа (heterogeneous). Ключ в словаре — immutable тип, может быть строкой, целым числом, float либо кортежем, состоящим из указанных типов.
  4. Словари реализованы как хеш-таблицы с быстрым доступом.
  5. Словари, так же как и списки, хранят ссылки на объекты, а не сами объекты.

Сегодня мы рассмотрим следующие темы.

  1. Что такое словарь.
  2. Функции/методы словаря.
  3. Операции со словарем.
  4. Примеры.

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

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

Основные операции над словарем — сохранение с заданным ключом и извлечение по нему значения. Также можно удалить пару key: value с помощью инструкции del.

Метод keys() для словаря возвращает список всех используемых ключей в произвольном порядке; для сортировки списка нужно применить метод sort(). Для определения наличия определенного ключа есть метод has_key(), который в версии 3.0 успеет устареть — вместо него есть оператор in. Добавление нового объекта в словарь не требует предварительных проверок: если ранее ключу уже соответствовало некоторое значение, оно будет перезаписано.

Пример — словарь в качестве телефонного справочника:

>>> dic = {'vanya' : 23323223, 'smith' : 32232332}
>>> dic['fedya'] = 33332222
>>> dic
{'vanya': 23323223, 'fedya': 33332222, 'smith': 32232332}
>>> dic['smith']
32232332
>>> del dic['vanya']
>>> dic
{'fedya': 33332222, 'smith': 32232332}
>>> dic.keys()
['fedya', 'smith']
>>> dic.has_key('fedya')
True

Создать словарь можно несколькими способами:

  1. Обычное выражение — оно удобно, если словарь статичен:
        D = {'name': 'mel', 'age': 45}
  2. Динамический вариант создания на лету:
        D = {}
        D['name'] = 'mel'
        D['age'] = 45
  3. С помощью функции dict() — ключи при этом должны быть строками. С помощью этой функции можно избавить себя от обязательного условия заключать ключ в кавычки. В примере приведены четыре варианта создания одного и того же словаря:
        d1 = dict(id=1948, name="Washer", size=3)
        d2 = dict({"id": 1948, "name": "Washer", "size": 3})
        d3 = dict([("id", 1948), ("name", "Washer"), ("size", 3)])
        d4 = dict(zip(("id", "name", "size"), (1948, "Washer", 3)))
  4. С помощью fromkeys() — создает словарь по списку ключей с пустыми значениями:
        D = {}.fromkeys(['name', 'age'],123)
  5. С помощью конструктора:
        d = dict((x, x**2) for x in xrange(5))

2. Функции/методы словаря

dict() — создание словаря;

len() — возвращает число пар;

clear() — удаляет все значения из словаря;

copy() — создает псевдокопию словаря;

deepcopy() — создает полную копию словаря;

fromkeys() — создание словаря;

get() — получить значение по ключу;

has_key() — проверка значения по ключу;

items() — возвращает список значений;

iteriyems() — возвращает итератор;

keys() — возвращает список ключей;

iterkeys() — возвращает итератор ключей;

pop() — извлекает значение по ключу;

popitem() — извлекает произвольное значение;

update() — изменяет словарь;

values() — возвращает список значений;

itervalues() — возвращает итератор на список значений.

in — оператор, проверяет наличие значения по ключу;

del — оператор, удаляет пару по ключу;

dict() — конструирует словарь с помощью последовательности.

Например, создать словарь с помощью списка кортежей:

>>> items = [('name','sveta'),('age',20)]
>>> d = dict(items)
>>> d
{'age': 20, 'name': 'sveta'}

>>> len(d)
2

in() — оператор проверки вхождения.

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

Проверить наличие в базе данных телефона по имени:

people = {'Alice': {'phone': '2341', 'addr': 'Foo drive 23' },
          'Beth':  {'phone': '9102', 'addr': 'Bar street 42'}}
name = 'Alice'          
key = 'phone'
if name in people: 
  print "%s phone is %s" % (name, people[name][key])
>>> Alice phone is 2341

copy()

Пример создания копии словаря:

>>> x = {"user":'admin','attr':[1,2,3]}
>>> y = x.copy()
>>> y
{'user': 'admin', 'attr': [1, 2, 3]}

Метод copy() не делает полного копирования: если мы, например, сделаем операцию:

>>> x['attr'].remove(1)

то с удивлением обнаружим, что удаление атрибута произойдет также и в копии.

Чтобы этого не произошло, нужно использовать метод deepcopy().

>>> from copy import deepcopy
>>> y = x.deepcopy()

fromkeys() — создает словарь по заданным ключам с пустыми значениями:

>>> {}.fromkeys(['name', 'age'])
{'age': None, 'name': None}

Можно все значения заполнить по умолчанию:

>>> {}.fromkeys(['name', 'age'],123)
{'age': 123, 'name': 123}

get() — получает значение по ключу, в случае отсутствия дает None:

>>> d = {}
>>> print d.get('name')
None

has_key() — проверяет, есть ли в словаре значение по данному ключу:

>>> d = {}
>>> d.has_key('name')
False

items() — возвращает список значений:

for key, value in d.items():
        print(key, value)

iteriyems() — возвращает итератор — выдает тот же результат:

>>> for k, v in d.iteritems():
...     print k, v

keys() — возвращает список ключей;

iterkeys() — возвращает итератор ключей:

>>> d.keys()
['url', 'title']
>>> d.iterkeys()
<dictionary-keyiterator object at 0xb7c4dd00>

pop() — извлекает значение по ключу с последующим удалением:

>>> d.pop('title')
>>> d
{'url': 'http://www.python.org'}

popitem() — извлекает произвольное значение с последующим удалением:

>>> d = {'title': 'Python Web Site', 'url': 'http://www.python.org', 'www': 'python'}
>>> d.popitem()
>>> d
{'www': 'python', 'title': 'Python Web Site'}

update() — изменяет значение по ключу:

>>> d2 = {'www':'python.org'}
>>> d.update(d2)
>>> d
{'www': 'python.org', 'title': 'Python Web Site'}

values() — возвращает список значений:

>>> d={}
>>> d[1]=1
>>> d[2]=2
>>> d[3]=3
>>> d
{1: 1, 2: 2, 3: 3}
>>> d.values()
[1, 2, 3]

del — оператор удаляет пару ключ: значение по ключу:

>>> del d[2]
>>> d
{1: 1, 3: 3}

3. Операции

Поскольку словари представляют собой мапы (map), а не последовательности, к ним
нельзя применить конкатенацию или срезы.

К словарям можно применять стандартные операторы сравнения:

    <, <=, ==, !=, >=, >

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

>>> table = {'Python': 'Guido van Rossum',
...          'Perl':     'Larry Wall',
...          'Tcl':      'John Ousterhout' }
>>> for lang in table:
...     print(lang, table[lang])
..
>>> Tcl     John Ousterhout
>>> Python  Guido van Rossum
>>> Perl    Larry Wall

Словари хорошо подходят для хранения многомерных массивов или матриц:

>>> Matrix = {}
>>> Matrix[(2, 3, 4)] = 88
>>> Matrix[(7, 8, 9)] = 99
>>>
>>> X = 2; Y = 3; Z = 4
>>> Matrix[(X, Y, Z)]
88
>>> Matrix
{(2, 3, 4): 88, (7, 8, 9): 99}

С помощью словарей можно хранить структурированную информацию в виде записей:

>>> man = {'name': 'Serg',
...        'jobs': ['programmer', 'writer'],
...        'web': 'www.iakovlev.org',
...        'home': {'city': 'Moscow', 'zip':129000}}
>>> man['name']
Serg
>>> man['jobs'][1]
'writer'

4. Примеры

Пример 1. Подсчитаем, сколько раз в строке встречается каждый символ:

def histogram(s):
    d = dict()
    for c in s:
        if c not in d:d[c] = 1
        else:d[c] += 1
    return d
hist = histogram('how many times')
>>> {'a': 1,'e': 1,'i': 1,'h': 1,'m': 2,'o': 1,'n': 1,'s': 1,'t': 1,'w': 1,'y': 1}

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

def invert_dict(d):
    inv = dict()
    for key in d:
        val = d[key]
        if val not in inv:inv[val] = [key]
        else:inv[val].append(key)
    return inv
print invert_dict(hist)
>>> {1: ['a', 'e', 'i', 'h', 'o', 'n', 's', 't', 'w', 'y'], 2: [' ', 'm']}

Пример 2. Подсчитать частоту повторов каждого уникального слова в файле:

import string
import sys
words = {}
strip = string.whitespace + string.punctuation + string.digits + "\"'"
filename = 'file'
for line in open(filename):
    for word in line.lower().split():
        word = word.strip(strip)
        if len(word) > 2:
            words[word] = words.get(word, 0) + 1
for word in sorted(words):
    print("'{0}' occurs {1} times".format(word, words[word]))

Пример 3. Сортировка словаря по ключам:

author = {"php":"Rasmus Lerdorf",\
    "perl":"Larry Wall",\
    "tcl":"John Ousterhout",\
    "awk":"Brian Kernighan",\
    "java":"James Gosling",\
    "parrot":"Simon Cozens",\
    "python":"Guido van Rossum"}
#Либо так:
langs = author.keys()
langs.sort()
for language in langs:
    print language," - ",author[language]
#либо так:
for key in sorted(author.iterkeys()):
    print "%s: %s" % (key, author[key])
   
>>> awk  -  Brian Kernighan
>>> java  -  James Gosling
>>> parrot  -  Simon Cozens
>>> perl  -  Larry Wall
>>> php  -  Rasmus Lerdorf
>>> python  -  Guido van Rossum
>>> tcl  -  John Ousterhout

Пример 4. Как инвертировать словарь, т.е. поменять ключи со значениями:

def invert_dict_nonunique(d):
    newdict = {}
    for k, v in d.iteritems():
        newdict.setdefault(v, []).append(k)
    return newdict
d = {'child1': 'parent1','child2': 'parent1','child3': 'parent2','child4': 'parent2'}
print invert_dict_nonunique(d)
>>> {'parent2': ['child3', 'child4'], 'parent1': ['child1', 'child2']}

Заключение

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

Код примеров проверялся на версии питона 2.6.

Предыдущая статья. Следующая статья.

Ресурсы для скачивания

Подпишите меня на уведомления к комментариям

www.ibm.com

Как добавить значения в словарь Python

Ваша формулировка, похоже, показывает, что вы не правильно поняли, что такое dict на python. Это также затрудняет нам понимание того, чего вы хотите.

Например:

I want to add values to my dictionary keys.

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

Даже ваш оригинальный пример не помогал, так как это недействительный синтаксис:

>>> {"Object": "Computer", "Mouse"}
SyntaxError: invalid syntax

Словарь диктата — это ключ и ценности.

В dict каждый ключ имеет значение и только один.

Итак, вот вопрос, на который вы должны ответить: что такое "Mouse"? ключ или значение dictio, или ни один из них?

Либо вы хотели:

>>> {"Object": "Computer", "Mouse": "A Sample Value"}

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

>>> dictio["Mouse"] = "A Sample Value"

Или, возможно, вы захотели «добавить» другое значение к уже сохраненному значению для ключа "Object" в словаре. Но «добавление» значения неоднозначно, если говорить о значении в dict, поскольку словари содержат только одно значение для одного ключа!

  • Вы хотите, чтобы текущее значение строки было объединено с новым?
  • Или вы хотите заменить текущее строковое значение на список значений? (Если да, то начальное значение должно было быть первым из одного элемента).

Полученный в результате dict с использованием списка в качестве значения для ключа "Object" будет:

>>> {"Object": ["My Computer", "Mouse"]}

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

Обратите внимание: если я хочу начать с оригинального dictio чтобы получить предыдущий результат, я должен заменить значение "Computer" (строки типа) на другое значение другого типа: ["My Computer", "Mouse"] ( это список значений).

Так что это можно сделать следующим образом:

>>> dictio["Object"] = [dictio["Object"], "Mouse"]

Но это не очень естественно, и вы, вероятно, захотите начать с такого dictio:

>>> dictio = {"Object": ["Mouse"]}

Затем «добавление» значения в список больше не является двусмысленным. И тогда было бы проще добиться:

>>> dictio["Object"].append("Mouse")

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

qa-help.ru