Словари и их методы в 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 — шпаргалка для начинающих

0 ∞

  • Словари и инструменты для работы с данными Python
  • Как создать словарь в Python
  • Как добавить данные в словарь Python?
  • Как отфильтровать словарь Python
  • Операции над словарями Python
  • Как происходит сортировка словаря Python?
  • Сравнение словарей со списками Python, массивами NumPy и Pandas DataFrames

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

В этом руководстве мы рассмотрим следующие темы:

  • как создать словарь, используя фигурные скобки и двоеточия;
  • как загрузить данные в словарь с помощью библиотек urllib и random;
  • как фильтровать словарь с помощью цикла for и специальных итераторов для перебора ключей и значений словаря;
  • как выполнять операции со словарем для получения или удаления значений, и как использовать значения словаря для подмножества значений из него;
  • как сортировать словарь с помощью библиотеки re и как в этом могут помочь функции OrderedDict и лямбда-функции;
  • сравним словари Python со списками, массивами NumPy и Pandas DataFrames.

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

Словари можно распознать по фигурным скобкам {} и разделению двоеточием : ключа и значения для каждого элемента.

Переменная fruit в приведенном ниже коде является допустимым словарем. Получить доступ к элементу Python словаря можно, поместив ключ между квадратными скобками [].Также можно использовать метод .get(), чтобы сделать то же самое:

 

fruit = {"apple" : 5, "pear" : 3, "banana" : 4, "pineapple" : 1,https://www.datacamp.com/community/tutorials/python-dictionary-tutorial "cherry" : 20}
# Получаем доступ к словарю `fruit` непосредственно (без использования get) и выводим значение "banana"
print(_____["______"])
# Выбираем один из 5 фруктов и показываем, что оба способа извлечения дают аналогичные результаты
print(fruit["_____"] == fruit.get("_____"))

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

Используемые данные — это отзывы на Amazon о книге Донны Тартт «The Goldfinch». Они были сохранены в простом файле с разделителями. Таблица содержит четыре столбца: оценка, URL-адрес, заголовок отзыва и текст отзыва.

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

 

import urllib
import random
# Загружаем данные из удаленного места (URL-адреса)
file = urllib.request.urlopen("https://gist.githubusercontent.com/twielfaert/a0972bf366d9aaf6cb1206c16bf93731/raw/dde46ad1fa41f442971726f34ad03aaac85f5414/Donna-Tartt-The-Goldfinch.csv")
f = file.read()
# Преобразуем битовый поток в строки
text = f.decode(encoding='utf-8',errors='ignore')
# Разбиваем эту одну строку на концах линий
lines = text.split("n")
# Инициализируем словарь
reviews = {}
# Заполняем словарь
for line in lines:
  l = line.strip().split("t")
  # Это просто тестовые данные, чтобы посмотреть, что входит в словарь
  score = l[0] 
  id = l[1]
  title = l[2]
  review = l[3]
  reviews[id] = {"score" : score, "title" : title, "review" : review}
# Берем случайный ключ из словаря и выводим его значение

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

 

# Подсчитываем количество строк в файле
print("Количество строк: " + str(len(lines)))
# Подсчитываем количество ключей в словаре; оно должно равняться количеству строк в файле
print("Количество ключей словаря: " + str(len(reviews.keys())))

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

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

Элементы словаря Python имеют не только ключ и значение, но и специальный итератор для их перебора. Вместо for item in dictionary необходимо использовать for key, value in dictionary.items(). При этом должны использоваться две переменные, ключ и значение, а не одна.

Существуют отдельные итераторы для ключей (.keys()) и значений (.values()).

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

 

# Сохраняем ключи отзывов с низкой оценкой (1.0) в списке
lowscores = []
for key, value in reviews.items():
  if float(value["score"]) == 1.0: # Convert score to float
    lowscores.append(key)
# Выводим все записи с низкой оценкой
for item in __________:
  print(reviews[____])

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

Во-первых, мы используем ключи, хранящиеся в lowscores, для создания нового словаря. Чтобы сделать это, есть два способа: первый — извлекаем только соответствующие элементы из исходного словаря с помощью метода .get(), оставляя исходный словарь без изменений. Второй — использовать метод .pop(), который удаляет извлеченные записи из исходного словаря.

Код для подмножества может выглядеть следующим образом: subset = dict([(k, reviews.get(k)) for k in lowscores]). Такое написание может показаться незнакомым, потому что цикл задан одной строкой кода. Этот стиль называется «генерацией словаря». На самом деле это цикл for, который перебирает элементы lowscores, извлекает значения из отзывов и использует их для заполнения нового словаря.

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

 

# Метод с использованием цикла for для создания подмножества словаря
forloop = {}
for k in lowscores:
  forloop[k] = reviews[k]
# Добавляем специальный метод извлечения релевантных элементов из словаря `reviews`
dictcomp = {k : reviews. ___(k) for k in lowscores}
# Удостоверимся, что эти объекты аналогичны
print(forloop == ________)

Предположим, что теперь вы хотите изменить словарь Python 3, чтобы оценки выступали в качестве ключей словаря, а не идентификаторов. Можно использовать для этого цикл for, указав как ключи, так и значения, и создав новый вложенный словарь. Нужно будет извлечь «score» из исходного вложенного словаря, чтобы использовать его в качестве нового ключа.

Чтобы упростить код, мы создаем в отдельной строке новый вложенный словарь как новый объект newvalues. После чего заполняем scoredict идентификаторами в качестве ключей и объектами из словаря newvalues в качестве значений:

 

from collections import defaultdict
scoredict = defaultdict(list)
for key, value in reviews.items():
  newvalues = {'id' : key, "title" : value['title'], "review" : value['review']}
  # Используем 'score' из значений (!) из исходного словаря в качестве ключей для только что созданного  словаря
  scoredict[_____['_____']]. append(newvalues)
# Выводим ключи словаря, чтобы удостовериться, что это на самом деле оценки из отзывов
print(scoredict.keys())

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

Нам нужно немного обработать текст отзывов, удалив HTML-теги и конвертировав заглавные буквы в словах в нижний регистр. Для первой задачи мы используем регулярное выражение, которое удаляет все теги: re.sub(«», «»). Регулярные выражения — это полезный инструмент при работе с текстовыми данными. Они довольно сложны для компиляции и заслуживают отдельного руководства.

Но в нашем примере нужно просто определить наборы символов, которые начинаются с символа <, за которым следует произвольное количество символов, после чего стоит символ >. И заменить их на пустые кавычки «» (ничего).

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

Затем мы создаем частотный словарь, используя defaultdict вместо обычного словаря. Это гарантирует, что каждый «ключ» уже инициализирован, и можно просто увеличивать его частоту, начиная с 1.

Если вы не используете defaultdict, Python может выдать ошибку при первом увеличении частоты (с 0 до 1), потому что ключ еще не существует. Этого можно избежать, предварительно проверив, существует ли ключ в Python словаре, прежде чем увеличивать значение его частоты. Но это решение не такое элегантное, как defaultdict:

 

import re
# Импортируем defaultdict
from collections import ___________
freqdict = defaultdict(int)
for item in lowscores:
  review = reviews[item]["review"]
  cleantext = re.sub(r'<.*?>', '', review).strip(). split() # Remove HTML tags and split the review by word (space separated)
  for word in cleantext:
   # Конвертируем все буквы в нижний регистр
    word = word.lower()
    # Заполняем следующую строку, чтобы увеличить частоту на один:
    freqdict[word] += _
print(freqdict)

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

Функция sorted принимает три аргумента. Первый — это объект, который нужно отсортировать, наш частотный словарь. При этом необходимо помнить, что доступ к парам ключ-значение в словаре возможен только через функцию . items(). Если вы забудете об этом, Python даже не выдаст предупреждение, а только вернет первый ключ, который встретит. Другими словами: если вы перебираете словарь, и ваш код ведет себя странным образом, проверьте, добавлена ли функция .items().

Второй аргумент указывает, какую часть первого аргумента следует использовать для сортировки: key=lambda item: item[1]. Но вам придется более углубленно изучить язык Python, чтобы понять, что это такое. Первая часть довольно понятна: вы хотите, чтобы ключи сортировались.

Но что там делает lambda? Она является анонимной функцией, то есть это функция без имени, которая не может быть вызвана извне. Это альтернативный способ обработки через цикл целого ряда объектов с помощью одной функции. В данном случае используется значение словаря (item[1], при item[0] выступающем в качестве ключа) в качестве аргумента для сортировки.

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

Прямо сейчас вы были бы разочарованы словами, которые располагаются в самом верху списка отсортированных элементов. Это были бы просто «функциональные слова», такие как «the», «and», «a» и т. д. В английском, как и во многих других языках, эти слова употребляются достаточно часто. Но при этом они совершенно бессмысленны сами по себе.

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

Можно поэкспериментировать и посмотреть, в каких частях Python словаря можно найти интересные слова:

 

from collections import OrderedDict
# Создаем словарь Ordered
ordict = OrderedDict(sorted(freqdict. items(), key=lambda item: item[1], reverse=True))
# Игнорируем верхние 10%
top10 = int(len(ordict.keys())/10)
# Выводим 100 слов из верхних 90%
print(list(ordict.items())[top10:top10+100])

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

Такие библиотеки, как Pandas, позволяют обработчикам данных работать быстрее и эффективнее. Им больше не нужно беспокоиться о деталях более низкого уровня, касающихся того, как хранятся данные. Но Pandas также использует словари (наряду с другими расширенными структурами данных, такими как массив NumPy) для хранения данных.

Даже при применении Pandas иногда рекомендуется использовать словари. Например, когда значения необходимо просто сопоставить, и вам не нужны функции Pandas ни для чего другого. Использование объекта Pandas в таких случаях просто неэффективно и излишне.

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

Вадим Дворниковавтор-переводчик статьи «Python Dictionary Tutorial»

Пожалуйста, оставьте ваши мнения по текущей теме материала. За комментарии, подписки, дизлайки, лайки, отклики огромное вам спасибо!

Работа со словарями Python: шпаргалка | by Mahbubul Alam

Photo by Eddy Klaus on Unsplash

Доступ, редактирование и просмотр элементов словаря

Опубликовано в

·

Чтение: 4 мин.

·

14 марта 2021 г. 90 005

Некоторые основы

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

Если мы хотим записать цены на некоторые товары в продуктовом магазине, обычно мы записываем их на листе бумаги следующим образом:

 яйца - 4,99 
 банан - 1,49 
 сыр - 4,5 
 баклажан - 2,5 
 хлеб - 3,99

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

 {"яйца": 4,99, 
 "банан": 1,49, 
 "сыр": 4,5, 
 "баклажан": 2,5, 
 "хлеб": 3,99 }

Обратите внимание на различия. В словаре

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

Теперь в первых элементах у нас есть {"яйца": 4.99} , но на самом деле яйца могут иметь несколько значений — одно для коричневых яиц, одно для белых яиц и одно для органических яиц — и словари python позволяют добавлять в словарь более одного значения, например, {«яйца»: [ 3,99, 4,99, 5,50]} .

Давайте дадим этому словарю имя и поиграем с ним:

 product_items = {"eggs": [3.99, 4.99, 5.50], 
 "banana": 1.49, 
 "cheese": 4.5, 
 "баклажан": 2.5 , 
 "bread": 3.99}

Вы можете открыть свой IDE/текстовый редактор и следовать приведенным ниже кодам для работы с только что созданным словарем.

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

Мы создали наш первоначальный словарь из 5 элементов, но мы можем расширить его, добавив больше элементов:

 product_items["onion"] = 3,50 
 Вышло: {"яйца": [3,99, 4,99, 5,50], "банан": 1,49, "сыр": 4,5, "баклажан": 2,5, "хлеб": 3,99, "лук": 3,50}

Можно добавить несколько элементов аналогичным образом.

Можно и наоборот — удалить один или несколько пунктов из этого списка. Есть несколько способов сделать это:

Удалить последний элемент с помощью метода popitem() :

 product_items.popitem()Out: {"яйца": [3.99, 4.99, 5.50], "банан": 1,49, "сыр": 4,5, "баклажан": 2,5, "хлеб": 3,99}

Или удалить элемент по его ключевому имени, используя только метод pop() :

 product_items. pop("banana")Out: {"eggs": [3.99, 4.99, 5.50], "cheese": 4.5, "баклажан": 2.5, "хлеб": 3.99}

И, наконец, вы можете очистить весь словарь (то есть сделать его пустым) с помощью метода clear() и удалить весь словарь с помощью ключевого слова del (просто будьте осторожны, если вам когда-нибудь придется его использовать).

Вам может быть интересно, где можно найти все эти методы? Просто нажмите клавишу «Tab» на клавиатуре, и все методы появятся.

Доступ к методам словаря в Python

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

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

Для доступа ко всем ключам:

 product_items.keys()Out: dict_keys(['eggs', 'banana', 'cheese', 'баклажан', 'bread'])

Вместо этого для доступа ко всем значениям:

 product_items.values()Out: dict_values([[3.99, 4.99, 5.5], 1.49, 4.5, 2.5, 3.99])

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

 # доступ к значениям по ключу 
 product_items["banana"]# или 
 product_items.get("banana")Out: 1.49

А как же яйца? У нас есть три разные цены на яйца. Мы можем выбрать доступ ко всем ценам:

 food_items.get("eggs")Out: [3.99, 4.99, 5.5]

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

 food_items. get("eggs")[0]Out: 3.99

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

Еще несколько методов и функций

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

Чтобы получить количество элементов в словарь:

 len(grocery_items)Out: 5

Чтобы изменить значение ключа:

 product_items.update({"banana": 0.85})

Чтобы преобразовать ключи в список:

 list(grocery_items )Out: ['яйца', 'банан', 'сыр', 'баклажан', 'хлеб']

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

 "potato" в product_itemsOut: False

И, наконец, для возврата строкового представления словаря:

 str(grocery_items)Out: "{ 'яблоко': 2,5, 'апельсин': 4,99, 'банан': 0,59}"

Перебор словаря в цикле

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

Простой цикл для вывода всех ключей:

 for i in product_items: 
 print(i)Out: 
 яйца 
 банан 
 сыр 
 баклажан 
 хлеб

Или для 9004 8 петля для условной фильтрации ключей словаря:

 for i in product_items.keys(): 
 if i.startswith("e"): 
 print(i)Out: 
 яйца 
 баклажаны

Понятия словаря

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

Например, чтобы распечатать значения словаря:

 [x вместо x в product_items.values()]Out: 
 [[3.99, 4.99, 5.5], 1.49, 4.5, 2.5, 3.99]

Сводка

Подводя итог, мы рассмотрели в этой статье:

  • Словари Python — это итерируемые объекты с парами ключ-значение
  • словарей можно редактировать для добавления, удаления и обновления значений
  • элементов словаря можно получить доступ с помощью таких методов, как . keys() , .values() и .items()
  • словари являются итерируемыми объектами , поэтому Python допускает вместо циклов или словарных понятий.

Я упустил многие другие методы и функции, но я надеюсь, что это даст преимущество для создания шпаргалки для работы с объектами словаря Python.

Если у вас есть комментарии, не стесняйтесь записывать их ниже или связаться со мной через Medium, Twitter или LinkedIn.

Словарь Python - GeeksforGeeks

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

Пример словаря на Python

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

Python3

902 69

Dict = { 1 : 9004 7 «Гики» , 2 : «Для» , 3 : «Гики» }

печать ( Dict )

Вывод: 

 {1: "Гики", 2: "Для", 3 : "Вундеркинды"}

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

В Python словарь можно создать, поместив последовательность элементов в фигурные скобки {} , разделенные запятой. Словарь содержит пары значений, одно из которых является ключом, а другой соответствующий парный элемент — его Key:value . Значения в словаре могут иметь любой тип данных и могут дублироваться, тогда как ключи не могут повторяться и должны быть неизменяемыми .

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

Python3

Dict = { 1 : 9004 7 «Гики» , 2 : «Для» , 3 : 'Geeks' }

print ( "\nСловарь с использованием целочисленных ключей: " )

печать ( Dict )

 

Dict = { «Имя» : «Гики» 90 047 , 1 : [ 1 , 2 , 3 , 4 ]}

print ( "\nСловарь с использованием смешанных ключей: " 9004 7)

печать ( Dict )

Вывод: 

 Словарь с использованием целочисленных ключей:
{1: "Гики", 2: "За", 3: "Гики"}
Словарь с использованием Mixed Keys:
{'Name': 'Geeks', 1: [1, 2, 3, 4]}

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

 

Python3

Dict = {}

печать ( "Пустой словарь: " )

печать ( Dict )

 

Dict = dict ({ 1 : «Гики» , 2 : «Для» , 900 47 3 : «Гики» })

печать ( "\nСловарь с использованием dict(): " )

print ( Dict ) 90 048

 

Дикт = Дикт ( [( 1 , 'Гики' ), ( 2 , 'Для' )] )

print ( "\nСловарь с каждым пунктом в паре: " )

печать ( Dict )

Вывод: 

 Пустой словарь:
{}
Словарь с использованием dict():
{1: "Гики", 2: "За", 3: "Гики"}
Словарь с каждым пунктом в паре:
{1: "Гики", 2: "Для"}
Сложности для создания словаря:

Временная сложность: O(len(dict))

Пространственная сложность: O(n)

Вложенный словарь

Python3

Dict = { 90 047 1 : «Гики» , 2 : «Для» ,

         3 : { «А» : «Добро пожаловать» 900 47 , 'Б' : 'К' , 'С' : «Гики» }}

 

печать ( Dict 900 47 )

Вывод: 

 {1: "Гики", 2: 'For', 3: {'A': 'Welcome', 'B': 'To', 'C': 'Geeks'}}

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

Добавление элементов может быть выполнено несколькими способами . В словарь можно добавить одно значение за раз, определив значение вместе с ключом, например. Дикт[Ключ] = ‘Значение’. Обновление существующего значения в словаре можно выполнить с помощью встроенного метод update() . Вложенные ключевые значения также могут быть добавлены в существующий словарь.

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

Python3

Dict = {}

печать ( "Пустой словарь: " )

печать ( Dict )

 

Dict [ 0 ] = «Гики»

Dict [ 2 ] = 'Для'

Dict [ 3 ] = 1

print ( "\nСловарь после добавления 3-х элементов: " )

печать ( Dict )

 

Dict 90 047 [ 'Набор значений' ] = 2 , 3 , 4

печать ( "\nСловарь после добавления 3-х элементов: " )

печать ( Dict )

 

Dict [ 2 ] = «Добро пожаловать»

печать ( "\nОбновленное значение ключа: " )

печать ( Dict )

 

Dict [ 5 ] = { 'Вложенный' : { '1' : 'Жизнь' , '2' : "Гики" }}

печать ( 9 0047 «\nДобавление вложенного ключа: » )

печать ( Dict )

Вывод: 

 Пустой словарь:
{}
Словарь после добавления 3 элементов:
{0: "Гики", 2: "За", 3: 1}
Словарь после добавления 3 элементов:
{0: "Гики", 2: "За", 3: 1, "Набор значений": (2, 3, 4)}
Обновленное значение ключа:
{0: "Гики", 2: "Добро пожаловать", 3: 1, "Набор значений": (2, 3, 4)}
Добавление вложенного ключа:
{0: "Знатоки", 2: "Добро пожаловать", 3: 1, "Value_set": (2, 3, 4), 5:
{'Вложенные': {'1': 'Жизнь', '2': 'Гики'}}}
Сложности для добавления элементов в словарь:

Временная сложность: O(1)/O(n)

Пространственная сложность: O(1)

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

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

Python3

 

Dict = { 1 900 47 : «Гики» , «имя» : «Для» , 3 : «Гики» 90 048 }

 

print ( "Доступ к элементу с помощью ключ:" )

печать ( Dict [ 'имя' ]) 90 005

 

print ( "Доступ к элементу с помощью ключа:" )

печать ( Dict [ 1 ])

90 268

Вывод: 

 Доступ к элементу с помощью ключа:
Для
Доступ к элементу с помощью ключа:
Компьютерщики

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

Сложности для доступа к элементам в словаре:

Временная сложность: O(1)

Пространственная сложность: O(1)

Python3

Dict 90 048 = { 1 : «Гики» , 'имя' : 'Для' , 3 : 'Гики' 9 0048 }

 

print ( "Доступ к элементу с помощью получить: " )

print ( Dict .get( 3 ))

Вывод: 

 Доступ к элементу с помощью get:
Компьютерщики

Доступ к элементу вложенного словаря

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

Python3

Dict = { 'Dict1' : { 1 : "Компьютерщики" },

900 47          'Dict2' : { 'Имя' : ' For' }}

 

print ( Dict [ 'Dict1' 9 0047 ])

печать ( Dict [ 'Dict1' ][ 1 ])

print ( Dict [ 'Dict2' 90 048 ][ 'Имя' ])

Вывод: 

 {1: "Гики"}
Компьютерщики
Для

Удаление элементов с помощью ключевого слова del

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

Python3

 

Dict = { 1 : «Гики» 9004 7 , 'имя' : 'Для' , 3 : 'Geeks' }

 

печать ( "Словарь =" )

печать ( Dict )

дель ( Dict [ 1 ])

печать ( "Данные после де letion Dictionary=" )

print ( Dict )

Выход 

Словарь = {1: 'Компьютерщики', 'имя': 'Для', 3: 'Гики'}
Данные после удаления Dictionary={'name': 'For', 3: 'Geeks'}

Словарные методы 9 0224
Метод Описание
dic. clear() Удалить все элементы из словаря
dict.copy() Возвращает копию словаря
dict.get(key, default = «None»)  Возвращает значение указанного ключа
dict.items()  Возвращает список, содержащий кортеж для каждой пары значений ключа
dict.keys()  Возвращает список, содержащий ключи словаря
dict.update(dict2) Обновляет словарь с указанными парами ключ-значение
dict.values()  Возвращает список всех значений словаря
pop()  Удалить элемент с указанным ключом
popItem() Удаляет последнюю вставленную пару ключ-значение
 dict.setdefault(key,default= «None») установить для ключа значение по умолчанию, если ключ не указан в словаре
dict.has_key(key) возвращает true, если словарь содержит указанный ключ.
dict.get(ключ, по умолчанию = «Нет») используется для получения значения, указанного для переданного ключа.

Python3

dict1 = { 1 : "Питон" , 2 : "Ява" , 9004 8 3 : "Рубин" , 4 : "Scala" }

 

dict2 = dict1.copy()

print (dict2)

 

dict1.clear()

печать (dict1)

 

print (dict2. get( 1 ))

  9 0005

печать (dict2.items())

 

печать (dict2.keys())

 

dict2.pop( 4 )

печать 9004 7 (dict2)

 

dict2.popitem()

печать (dict2)

 

dict2.update({ 3 : "Скала" }) 9 0048

печать (дикт2)

 

печать (dict2.values())

Вывод: 

 {1: "Python", 2: "Java", 3: "Ruby", 4: "Scala"}
{}
питон
dict_items([(1, 'Python'), (2, 'Java'), (3, 'Ruby'), (4, 'Scala')])
dict_keys([1, 2, 3, 4])
{1: "Питон", 2: "Ява", 3: "Рубин"}
{1: "Питон", 2: "Ява"}
{1: "Питон", 2: "Ява", 3: "Скала"}
dict_values(['Python', 'Java', 'Scala'])

{ «@context»: «https://schema.

No related posts.