Рубрики
Без рубрики

Словарь Python – окончательное руководство

Все, что вам нужно знать, чтобы начать работу с лучшими структурой данных: словари Python [Bonus Video] + [Бесплатная форматная книга PDF]

Автор оригинала: Adam Murphy.

Python поставляется с несколькими встроенными типами данных. Это основополагающие строительные блоки всего языка. Они были оптимизированы и совершенны в течение многих лет. В этом всеобъемлющем уроке мы рассмотрим один из самых важных: словарь (или Dict для короткого).

Для вашего удобства я создал всеобъемлющее электронную книгу 8000 слов, которую вы можете Скачать прямо как PDF с высоким разрешением (Открывается в новом окне).

Если не указано иначе я буду использовать Python 3.8 по всему. Функциональность словаря изменилась за последние несколько версий Python. Если вы используете версию, отличную от 3.8, вы, вероятно, получите разные результаты.

Чтобы проверить, какую версию Python вы запущены, введите следующее в окне терминала (Rebals 3.8).

$ python --version
Python 3.8.0

Вот минимальный пример, который показывает, как использовать словарь в интерактивной оболочке Python. Не стесняйтесь играть!

Упражнение : Добавьте 2 яблока и 3 апельсины в корзину фруктов! Сколько фруктов в вашей корзине?

Python словарь видеоурок

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

Вот ссылка на Курс Фрилансера Python Если вы хотите начать быть вашим собственным боссом с Python.

Словарь Python – почему это так полезно?

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

В реальной жизни словарь – это книга, полная слов в алфавитном порядке. Помимо каждого слова – это определение. Если у него много значений, есть много определений. Каждое слово выглядит точно один раз.

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

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

Мы применяем это отображение все время в реальной жизни: в нашем телефоне мы набрали имена наших друзей на свои номера телефонов.

В наших умах мы сопоставляем имя человека к своему лицу.

Мы отображаем слова к их значению.

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

Структура словаря Python

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

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

Теперь мы выверем тот же список, что и выше, используя терминологию словаря Python.

  • Словарь Python – это коллекция Объекты (ключи и значения)
  • Каждый ключ имеет связанное значение
  • Клавиша может иметь много значений
  • По мере изменения времени в ключа могут быть добавлены больше значений (значения являются Musable)
  • Ключ не может измениться (ключи неизменяются)
  • Каждый ключ появляется ровно
  • Ключи могут иметь одинаковое значение

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

Python создать словарь

Есть два способа создать словарь в Python:

  1. Фигурные брекеты {}
  2. Dict () конструктор

Фигурные скобки { }

my_dict = {key1: value1,
           key2: value2,
           key3: value3,
           key4: value4,
           key5: value5}

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

Вы можете написать все пары на той же линии. Я положил каждый на отдельную строку, чтобы помочь читабельности.

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

names_and_countries = {'Adam': 'Argentina',
                       'Beth': 'Bulgaria',
                       'Charlie': 'Colombia',
                       'Dani': 'Denmark',
                       'Ethan': 'Estonia'}

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

Вариант 1 – самый быстрый на тип

my_dict = dict(key1=value1,
               key2=value2,
               key3=value3,
               key4=value4,
               key5=value5)

Так что имена_and_Countries становится

names_and_countries = dict(Adam='Argentina',
                           Beth='Bulgaria',
                           Charlie='Colombia',
                           Dani='Denmark',
                           Ethan='Estonia')

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

Вариант 2 – самый медленный на тип, лучше всего используется с ZIP ()

my_dict = dict([(key1, value1),
                (key2, value2),
                (key3, value3),
                (key4, value4),
                (key5, value5)])

names_and_countries становится

names_and_countries = dict([('Adam', 'Argentina'),
                            ('Beth', 'Bulgaria'),
                            ('Charlie', 'Colombia'),
                            ('Dani', 'Denmark'),
                            ('Ethan', 'Estonia')])

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

Вариант 2 с ZIP () – список Python для диктографии

Если у вас есть два списка и хотите сделать из них словарь, сделайте это

names = ['Adam', 'Beth', 'Charlie', 'Dani', 'Ethan']
countries = ['Argentina', 'Bulgaria', 'Colombia', 'Denmark', 'Estonia']
 
# Keys are names, values are countries
names_and_countries = dict(zip(names, countries))
 
>>> names_and_countries
{'Adam': 'Argentina',
'Beth': 'Bulgaria',
'Charlie': 'Colombia',
'Dani': 'Denmark',
'Ethan': 'Estonia'}

Если у вас есть более двух списков, сделайте это

names = ['Adam', 'Beth', 'Charlie', 'Dani', 'Ethan']
countries = ['Argentina', 'Bulgaria', 'Colombia', 'Denmark', 'Estonia']
ages = [11, 24, 37, 75, 99]
 
# Zip all values together
values = zip(countries, ages)
 
# Keys are names, values are the tuple (countries, ages)
people_info = dict(zip(names, values))
 
>>> people_info
{'Adam': ('Argentina', 11),
'Beth': ('Bulgaria', 24),
'Charlie': ('Colombia', 37),
'Dani': ('Denmark', 75),
'Ethan': ('Estonia', 99)}

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

Доступ к пары ключа-значений

Есть 2 способа доступа к данным в наших словарях:

  • Обозначение кронштейна []
  • Метод get ()

Обозначение кронштейна []

# Get value for the key 'Adam'
>>> names_and_countries['Adam']
'Argentina'
 
# Get value for the key 'Charlie'
>>> names_and_countries['Charlie']
'Colombia'
 
# KeyError if you search for a key not in the dictionary
>>> names_and_countries['Zoe']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'Zoe'

Введите ключ в квадратные скобки, чтобы получить соответствующее значение. Если вы входите в ключ не в словаре, Python поднимает KeyError Отказ

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

# Not the first element of the dictionary
>>> names_and_countries[0]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 0
 
# Not the last element
>>> names_and_countries[-1]
Traceback (most recent call last):
  File "", line 1, in 
KeyError: -1
 
# You cannot slice
>>> names_and_countries['Adam':'Dani']
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unhashable type: 'slice'

Python ожидает, что все между кронштейнами – ключ. Так что для первых двух примеров у нас есть KeyError потому что ни 0, ни -1 не клавиши в словаре. Но можно использовать 0 или -1 в качестве ключа, как мы скоро увидим.

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

Если мы попытаемся нарезать наш словарь, Python поднимает Типеррор Отказ Мы объясняем, почему в разделе хеширования.

Давайте посмотрим на второй метод для доступа к данным, хранящимся в нашем словаре.

Словарь Python Get () метод

# Get value for the key 'Adam'
>>> names_and_countries.get('Adam')
'Argentina'
 
# Returns None if key not in the dictionary
>>> names_and_countries.get('Zoe')
 
# Second argument returned if key not in dictionary
>>> names_and_countries.get('Zoe', 'Name not in dictionary')
'Name not in dictionary'
 
# Returns value if key in dictionary
>>> names_and_countries.get('Charlie', 'Name not in dictionary')
'Colombia'

Получить () Метод принимает два аргумента:

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

Это работает как нотация кронштейна. Но это никогда не поднимет KeyError Отказ Вместо этого он возвращает ни один, либо объект, который вы вводите в качестве второго аргумента.

Это чрезвычайно выгодно, если вы итерация по словарю. Если вы используете нотацию кронштейна и столкнитесь с ошибкой, вся итерация остановится. Если вы используете Get (), ошибка не будет повышена, а итерация завершится.

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

Python Dict ключей

В реальных словарях написание слов не меняется. Это сделало бы довольно сложно использовать один, если они сделали. То же самое относится и к словарям Python. Ключи не могут измениться. Но они могут быть больше, чем просто строки. На самом деле, ключи могут быть любыми неизменными типами данных: строка, int, float, bool или кортеж.

>>> string_dict = {'hi': 'hello'}
>>> int_dict = {1: 'hello'}
>>> float_dict = {1.0: 'hello'}
>>> bool_dict = {True: 'hello', False: 'goodbye'}
>>> tuple_dict = {(1, 2): 'hello'}
 
# Tuples must only contain immutable types
>>> bad_tuple_dict = {(1, [2, 3]): 'hello'}
Traceback (most recent call last):
  File "", line 1, in 
TypeError: unhashable type: 'list'

Это второй раз, когда мы видели «TypeError: Недастимый тип: 'Список'" Отказ Так что же означает «несчастье»?

Что такое хеширование в Python?

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

# Python 3.8 (different versions may give different results)
>>> hash('hello world!')
1357213595066920515
 
# Same result as above
>>> hash('hello world!')
1357213595066920515
 
# If we change the object, we change the hash value
>>> hash('goodbye world!')
-7802652278768862152

Когда мы создаем пару ключ-значение, Python создает пару HASH-значения на заднем плане

# We write
>>> {'hello world!': 1}
 
# Python executes in the background
>>> {hash('hello world!'): 1}
 
# This is equivalent to
>>> {1357213595066920515: 1}

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

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

В Python концепция хеширования подходит только при обсуждении словарей. Принимая во внимание, что Musicable VS неизменных типов данных придумывают повсюду. Таким образом, мы говорим, что вы можете использовать только неизменные типы данных в качестве клавиш, а не говорящие «Hashable» типов данных.

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

>>> does_this_work = {'hello': 1,
   			   hash('hello'): 2}
 
>>> does_this_work['hello']
1
 
>>> does_this_work[hash('hello')]
2

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

Значения словаря Python

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

>>> crazy_dict = {11.0: ('foo', 'bar'),
                  'baz': {1: 'a', 2: 'b'},
                  (42, 55): {10, 20, 30},
                  True: False}
 
# Value of the float 11.0 is a tuple
>>> crazy_dict[11.0]
('foo', 'bar')
 
# Value of the string 'baz' is a dictionary
>>> crazy_dict.get('baz')
{1: 'a', 2: 'b'}
 
# Value of the tuple (42, 55) is a set
>>> crazy_dict[(42, 55)]
{10, 20, 30}
 
# Value of the Bool True is the Bool False
>>> crazy_dict.get(True)
False

Примечание : Вы должны использовать нотацию брекетов для ввода словаря, как это. Если вы попытаетесь использовать Dict () Конструктор, вы получите SyntaxErrors (если только вы не используете многословный метод и введите список кортежей … Но зачем ли вы это сделать?).

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

Python вложенные словари

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

# Returns a dict
>>> crazy_dict.get('baz')
{1: 'a', 2: 'b'}
 
# Chain another method to access the values of this dict
>>> crazy_dict.get('baz').get(1)
'a'
 
>>> crazy_dict.get('baz')[2]
'b'

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

Python Добавить в словарь

>>> names_and_countries
{'Adam': 'Argentina', 
'Beth': 'Bulgaria', 
'Charlie': 'Colombia', 
'Dani': 'Denmark', 
'Ethan': 'Estonia'}
 
# Add key-value pair 'Zoe': 'Zimbabwe'
>>> names_and_countries['Zoe'] = 'Zimbabwe'
 
# Add key-value pair 'Fred': 'France'
>>> names_and_countries['Fred'] = 'France'
 
# Print updated dict
>>> names_and_countries
{'Adam': 'Argentina', 
'Beth': 'Bulgaria', 
'Charlie': 'Colombia', 
'Dani': 'Denmark', 
'Ethan': 'Estonia', 
'Zoe': 'Zimbabwe',     # Zoe first
'Fred': 'France'}      # Fred afterwards

Наш словарь отражает заказ, который мы добавили пары сначала показ зои, а затем Фреда.

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

>>> my_dict['new_key']

Затем (перед нажатием возврата) используйте оператор назначения «=» и укажите значение.

>>> my_dict['new_key'] = 'new_value'

Вы не можете назначить новые пары ключа-значений через Получить () метод, потому что это функциональный вызов.

>>> names_and_countries.get('Holly') = 'Hungary'
File "", line 1
SyntaxError: cannot assign to function call

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

# Delete the Zoe entry
>>> del names_and_countries['Zoe']
 
# Change Ethan's value
>>> names_and_countries['Ethan'] = 'DIFFERENT_COUNTRY'
 
>>> names_and_countries
{'Adam': 'Argentina', 
'Beth': 'Bulgaria', 
'Charlie': 'Colombia', 
'Dani': 'Denmark', 
'Ethan': 'DIFFERENT_COUNTRY',  # Ethan has changed
'Fred': 'France'}    		  # We no longer have Zoe

Как и в случае других подменных типах данных, будьте осторожны при использовании дель Заявление в петля Отказ Это изменяет словарь на месте и может привести к непреднамеренным последствиям. Лучшая практика – создать копию словаря и изменить копию. Или вы можете использовать, мой личный любимый, Словарь поведение (который мы будем охватывать позже) – мощная функция похожа на популярную Функция понимания списка в Python Отказ

Способ копирования Python Dict Copy

>>> my_dict = {'a': 1, 'b': 2}
 
# Create a shallow copy
>>> shallow_copy = my_dict.copy()
 
# Create a deep copy
>>> import copy
>>> deep_copy = copy.deepcopy(my_dict)

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

Проверка членства словаря

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

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

# Name obviously not in our dict
>>> 'INCORRECT_NAME' in names_and_countries
False
 
# We know this is in our dict
>>> 'Adam' in names_and_countries
True
 
# Adam's value is in the dict... right?
>>> names_and_countries['Adam']
'Argentina'
>>> 'Argentina' in names_and_countries
False

Мы ожидаем, что неверное_Нам не находиться в нашем диктоме, а Адам, чтобы быть в нем. Но почему «Аргентина» возвращает ложь? Мы только что видели, что это ценность Адама?!

Помните в начале статьи, которую я сказал, что словари – это карты? Они отображают из чего мы знаем (ключ) к чему-то, чего мы не (значение). Поэтому, когда мы спрашиваем, есть ли что-то в нашем словаре, мы спрашиваем, является ли это ключом. Мы не спрашиваем, это ценность.

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

  1. Это слово «facetious» в этом словаре?
  2. Это слово означает «отсутствие серьезных намерений; обеспокоен чем-то несущественным, забавным или легкомысленным в это толковый словарь?

Очевидно, первый – победитель, и это поведение по умолчанию для Python.

>>> 'something' in my_dict

Мы проверяем, есть ли «что-то» – это ключ в my_dict.

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

Методы словаря Python – ключи, значения и элементы

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

  • .keys () – итерация по ключам словаря
  • .values () – итерация по ценностям словаря
  • . items () – итерация по поводу ключей и значений словаря

Примечание: мы изменили страну Этану обратно в Эстонию для чтения.

>>> names_and_countries.keys()
dict_keys(['Adam', 'Beth', 'Charlie', 'Dani', 'Ethan', 'Fred'])
 
>>> names_and_countries.values()
dict_values(['Argentina', 'Bulgaria', 'Colombia', 'Denmark', 'Estonia', 'France'])
 
>>> names_and_countries.items()
 
 
dict_items([('Adam', 'Argentina'), 
            ('Beth', 'Bulgaria'), 
            ('Charlie', 'Colombia'), 
            ('Dani', 'Denmark'), 
            ('Ethan', 'Estonia'), 
            ('Fred', 'France')])

Теперь мы можем проверить членство в ключах и ценностях:

# Check membership in dict's keys
>>> 'Adam' in names_and_countries
True
>>> 'Adam' in names_and_countries.keys()
True
 
# Check membership in the dict's values
>>> 'Argentina' in names_and_countries.values()
True
 
# Check membership in either keys or values???
>>> 'Denmark' in names_and_countries.items()
False

Вы не можете проверить ключи и значения одновременно. Это потому, что Предметы () Возвращает передачу от кортежей. Как «Дания» не кортеж, он вернет ложь.

>>> for thing in names_and_countries.items():
  	  print(thing)
('Adam', 'Argentina')
('Beth', 'Bulgaria')
('Charlie', 'Colombia')
('Dani', 'Denmark')
('Ethan', 'Estonia')
 
# True because it's a tuple containing a key-value pair
>>> ('Dani', 'Denmark') in names_and_countries.items()
True

Python Loop через словарь – обзор

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

>>> for name in names_and_countries.keys():
        print(name)
Adam
Beth
Charlie
Dani
Ethan
Fred
 
>>> for country in names_and_countries.values():
        print(f'{country} is wonderful!')
Argentina is wonderful!
Bulgaria is wonderful!
Colombia is wonderful!
Denmark is wonderful!
Estonia is wonderful!
France is wonderful!
 
>>> for name, country in names_and_countries.items():
        print(f'{name} is from {country}.')
Adam is from Argentina.
Beth is from Bulgaria.
Charlie is from Colombia.
Dani is from Denmark.
Ethan is from Estonia.
Fred is from France.

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

# Best practice
>>> for descriptive_key, descriptive_value in my_dict.items():
        # do something
 
# Bad practice (but you will see it 'in the wild'!)
>>> for key, value in my_dict.items():
        # do something

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

# Iterating over the dict is the same as dict.keys()
>>> for thing in names_and_countries:
        print(thing)
Adam
Beth
Charlie
Dani
Ethan
Fred

Примечание к воспроизводимости

# Works with general Python types
>>> for key in object:
        # do something
 
# Works only with dictionaries
>>> for key in object.keys():
        # do something

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

Python Dict HAS_KEY.

Метод has_key () является исключительным для Python 2. Это возвращает True, если ключ находится в словаре и ложь, если нет.

Python 3 Удалил эту функциональность в пользу следующего синтаксиса:

>>> if key in d:
        # do something

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

Красивые печатающие словари с использованием PPRINT ()

Встроенный PPRINT модуль содержит функцию PPRINT. Это будет «довольно печатать» ваш словарь. Он сортирует ключи в алфавитном порядке и печатает каждую пару клавишу на новой строке.

>>> from pprint import pprint
>>> messy_dict = dict(z='Here is a really long key that spans a lot of text', a='here is another long key that is really too long', j='this is the final key in this dictionary')
 
>>> pprint(messy_dict)
{'a': 'here is another long key that is really too long',
'j': 'this is the final key in this dictionary',
'z': 'Here is a really long key that spans a lot of text'}

Это не меняет словарь вообще. Теперь это гораздо более читаемо.

Словари Python и файлы JSON

Нам нужно кодировать и декодировать все эти данные Отказ

Общий файл, с которым вы будете взаимодействовать с файлом JSON. Это означает для объекта JavaScript. Они используются для структурирования и отправки данных в веб-приложениях.

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

Python Dict до json

>>> import json
>>> my_dict = dict(a=1, b=2, c=3, d=4)
 
>>> with open('my_json.json', 'w') as f:
   	 json.dump(my_dict, f)

Приведенный выше код берет my_dict и пишет это в файл my_json.json В текущем каталоге.

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

Python json, чтобы обнять

У нас есть файл my_json.json В нашем текущем рабочем каталоге.

>>> import json
>>> with open('my_json.json', 'r') as f:
        new_dict = json.load(f)
 
>>> new_dict
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Примечание : Пары ключа-значений в JSON всегда преобразуются в строки при законе в Python. Легко изменить любой объект в строку, и приводит к меньшему количеству ошибок при кодировании и декодировании файлов. Но это означает, что иногда файл, который вы загружаете, и файл, который вы начали, не идентичны.

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

Вот быстрый обзор:

  1. Dict.clear () – Удалить все пары ключа-значений из дикта
  2. Dict.Update () – объединить два словаря вместе
  3. Dict.pop () – Удалить ключ и вернуть его значение
  4. DICK.POPITEM () – Удалите Pair Pair-Value Key и верните ее в виде кортежа

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

Dict.clear () – Удалить все пары ключа-значений из дикта

>>> A = dict(a=1, b=2)
>>> A.clear()
>>> A
{}

Призывая это к диктому удаляет все пары ключа-значений на месте. Диктовый сейчас пуст.

Dict.Update () – объединить два словаря вместе

>>> A = dict(a=1, b=2)
>>> B = dict(c=3, d=4)
>>> A.update(B)
>>> A
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> B
{'c': 3, 'd': 4}

Мы только что обновили А. Таким образом, все пары клавишных значений из B были добавлены в A. B не изменились.

Если A и B некоторые ключи, ценность B заменит а. Это связано с тем, что A обновляется B и поэтому принимает все значения B (не наоборот).

>>> A = dict(a=1, b=2)
>>> B = dict(b=100)
>>> A.update(B)
 
# A now contains B's values
>>> A
{'a': 1, 'b': 100}
 
# B is unchanged
>>> B
{'b': 100}

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

>>> A = dict(a=1, b=2)
# Sequence of tuples
>>> B = [('c', 3), ('d', 4)]
>>> A.update(B)
>>> A
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
 
>>> A = dict(a=1, b=2)
# Pass key-value pairs as keyword arguments
>>> A.update(c=3, d=4)
>>> A
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Dict.pop () – Удалить ключ и вернуть его значение

>>> A = dict(a=1, b=2)
>>> A.pop('a')
1
>>> A
{'b': 2}

Если вы попробуете позвонить Dict.pop () с ключом, который не находится в словаре, Python поднимает jeeRor.

>>> A.pop('non_existent_key')
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'non_existent_key'

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

>>> A.pop('non_existent_key', 'not here')
'not here'

DICK.POPITEM () – Удалите Pair Pair-Value Key и верните ее в виде кортежа

>>> A = dict(a=1, b=2, c=3)
# Your results will probably differ
>>> A.popitem()
('c', 3)
>>> A
{'a': 1, 'b': 2}
>>> A.popitem()
('b', 2)
>>> A
{'a': 1}

Если словарь пуст, Python поднимает jeeRor.

>>> A = dict()
>>> A.popitem()
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'popitem(): dictionary is empty'

Петля Python через словарь – подробно

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

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

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

Стандартная запись Python для увеличения чисел или добавления к спискам

# Counting
my_num = 0
for thing in other_thing:
    my_num += 1
 
# Appending to lists
my_list = []
for thing in other_thing:
    my_list.append(thing)

Это следует стандартной шаблон:

  1. Инициализировать «пустой» объект
  2. Начните для петли
  3. Добавить вещи к этому объекту

При итерацию по словарю наши ценности могут быть номерами или подобными списком. Таким образом, мы можем добавить или мы можем добавить до значений. Было бы здорово, если наш код последовал за вышеуказанным шаблоном. Но…

>>> my_dict = {}
>>> for thing in other_thing:
        my_dict['numerical_key'] += 1
Traceback (most recent call last):
  File "", line 2, in 
KeyError: 'numerical_key'
 
>>> for thing in other_thing:
        my_dict['list_key'].append(thing)
Traceback (most recent call last):
  File "", line 2, in 
KeyError: 'list_key'

К сожалению, оба поднимают кепки. Python говорит нам, что ключ не существует, и поэтому мы не можем увеличить его значение. Таким образом, мы должны сначала создать пару ключ, прежде чем делать что-либо с ним.

Теперь мы покажем 4 способа решения этой проблемы:

  1. Вручную инициализируйте ключ, если он не существует
  2. Метод get ()
  3. Метод setdefault ()
  4. Defaultdict ()

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

Три друзей – Адам, Белла и Кара, вышли на еду на день рождения Адама. Они хранили свои заказы на стартер, главные и напитки в одном списке. Цена каждого товара находится в другом списке. Мы будем использовать эти данные, чтобы построить разные словари.

people = ['Adam', 'Bella', 'Cara',
          'Adam', 'Bella', 'Cara',
          'Adam', 'Bella', 'Cara',]
 
food = ['soup', 'bruschetta', 'calamari',   # starter
        'burger', 'calzone', 'pizza',       # main
        'coca-cola', 'fanta', 'water']      # drink
 
# Cost of each item in £
prices = [3.20, 4.50, 3.89,
          12.50, 15.00, 13.15,
          3.10, 2.95, 1.86]
 
# Zip data together to allow iteration
# We only need info about the person and the price
meal_data = zip(people, prices)

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

Вручную инициализировать ключ

# Initialise empty dict
total = {}
 
# Iterate using descriptive object names
for (person, price) in meal_data:
 
    # Create new key and set value to 0 if key doesn't yet exist
    if person not in total:
        total[person] = 0
    
    # Increment the value by the price of each item purchased.
    total[person] += price
 
>>> total
{'Adam': 18.8, 'Bella': 22.45, 'Cara': 18.9}

Мы пишем, если утверждение, которое проверяет, есть ли ключ уже в словаре. Если это не так, мы устанавливаем значение 0. Если оно есть, Python не выполняет оператор IF. Затем мы увеличиваем, используя ожидаемый синтаксис.

Это хорошо работает, но требует довольно нескольких строк кода. Конечно, мы можем сделать лучше?

Python Dict Get () метод при итерации

# Reinitialise meal_data as we have already iterated over it
meal_data = zip(people, prices)
 
total = {}
for (person, price) in meal_data:
 
    # get method returns 0 the first time we call it
    # and returns the current value subsequent times
    total[person] = total.get(person, 0) + price
 
>>> total
{'Adam': 18.8, 'Bella': 22.45, 'Cara': 18.9}

У нас есть это до одной линии!

Мы проходим Get () второе значение, которое возвращается, если ключ не находится в словаре. В этом случае мы выбираем 0, как приведенный выше пример. Первый раз, когда мы звоним в Get (), он возвращается 0. Мы только что инициализировали пару ключ! В той же линии мы добавляем «цена». В следующий раз мы позвоним Get (), он возвращает текущее значение, и мы снова можем добавить на «цену».

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

Python Dict SetDefault () Метод

Синтаксис этого метода делает его отличным выбором для изменения значения ключа через Добавить () метод.

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

meal_data = zip(people, prices)
total = {}
for (person, price) in meal_data:
 
    # Set the initial value of person to 0
    total.setdefault(person, 0)
 
    # Increment by price
    total[person] += price
 
0
0
0
3.2
4.5
3.89
15.7
19.5
17.04
>>> total
{'Adam': 18.8, 'Bella': 22.45, 'Cara': 18.9}

Это работает, но требует больше линий кода, чем Get () и печатает много номеров на экран. Почему это?

Метод SetDefault () принимает два аргумента:

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

Поэтому SetDefault (человек, 0) устанавливает значение по умолчанию человека, который будет 0.

Это всегда возвращает одну из двух вещей:

  1. Текущее значение ключа
  2. Если ключ не существует, он возвращает значение по умолчанию

Вот почему цифры напечатаны на экран. Они являются ценностями «человека» на каждой итерации.

Очевидно, что это не самый удобный метод для нашей текущей проблемы. Если мы сделаем 100К итераций, мы не хотим, что количество 100K напечатано на экран.

Таким образом, мы рекомендуем использовать метод GET () для численных расчетов.

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

meal_data = zip(people, prices)
individual_bill = {}
 
for (person, price) in meal_data:
 
    # Set default to empty list and append in one line!
    individual_bill.setdefault(person, []).append(price)
 
>>> individual_bill
{'Adam': [3.2, 12.5, 3.1], 
'Bella': [4.5, 15.0, 2.95], 
'Cara': [3.89, 13.15, 1.86]}

Теперь мы видим истинную силу SetDefault ()! Как метод получения в нашем численном примере, мы инициализируем значение по умолчанию и измените его в одной строке!

Примечание. SetDefault () рассчитывает значение по умолчанию каждый раз, когда он называется. Это может быть проблемой, если ваше значение по умолчанию дорого вычислять. Get () вычисляет только значение по умолчанию, если ключ не существует. Таким образом, Get () – лучший выбор, если ваше значение по умолчанию дорого. Поскольку большинство значений по умолчанию являются «Zeros», такие как 0, [] и {}, это не проблема для большинства случаев.

Мы видели три решения проблемы сейчас. У нас есть код до 1 строки. Но синтаксис для каждого был отличаться от того, что мы хотим. Теперь давайте посмотрим что-то, что решает проблему точно так, как мы ожидаем: введя по умолчаниюДикту!

Python defaultdict ()

Давайте решим нашу проблему численного приверения:

# Import from collections module
from collections import defaultdict
 
meal_data = zip(people, prices)
 
# Initialise with int to do numerical incrementation
total = defaultdict(int)
 
# Increment exactly as we want to!
for (person, price) in meal_data:
    total[person] += price
 
>>> total
defaultdict(, {'Adam': 18.8, 'Bella': 22.45, 'Cara': 18.9})

Успех!! Но как насчет нашего списка проблемы?

from collections import defaultdict
 
meal_data = zip(people, prices)
 
# Initialise with list to let us append
individual_bill = defaultdict(list)
 
for (person, price) in meal_data:
    individual_bill[person].append(price)
 
>>> individual_bill
defaultdict(, {'Adam': [3.2, 12.5, 3.1], 
                             'Bella': [4.5, 15.0, 2.95], 
                             'Cara': [3.89, 13.15, 1.86]})

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

Defaultdict – это то же самое, что обычный словарь Python, кроме:

  1. Требуется вызывающий тип данных в качестве аргумента
  2. Когда он впервые соответствует ключу, значение по умолчанию устанавливается как «ноль» для этого типа данных. Для INT это 0, для списка это пустой список [] etc ..

Таким образом, вы никогда не получите KeyError! Плюс и инициализация значений по умолчанию заботится автоматически!

Теперь мы решили проблему, используя тот же синтаксис для списков и цифр!

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

Python defaultdict () особые случаи

Выше мы сказали, что невозможно получить keyError при использовании defaultdict. Это правда, если вы правильно инициализируете свое Dict.

# Initialise without an argument
>>> bad_dict = defaultdict()
>>> bad_dict['key']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'key'
 
# Initialise with None
>>> another_bad_dict = defaultdict(None)
>>> another_bad_dict['another_key']
Traceback (most recent call last):
  File "", line 1, in 
KeyError: 'another_key'

Допустим, вы инициализируете defaultdict без каких-либо аргументов. Затем Python поднимает jeeRror, если вы называете ключ не в словаре. Это то же самое, что и инициализация ни с кем и побеждает всю цель по умолчаниюДам.

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

>>> none_dict = defaultdict(lambda: None)
>>> none_dict['key']
>>>

Обратите внимание, что вы не можете увеличить или не принести ни к одному. Убедитесь, что вы выбираете свое значение по умолчанию, чтобы соответствовать проблеме, которую вы решаете!

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

Упорядоченный

Ранее мы сказали, что словари сохраняют свой заказ от Python 3.7. Так почему нам нужно что-то называемое заказным?

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

>>> from collections import OrderedDict
 
# Normal dicts preserve order but don't use it for comparison
>>> normal1 = dict(a=1, b=2)
>>> normal2 = dict(b=2, a=1)
>>> normal1 == normal2
True
 
# OrderedDicts preserve order and use it for comparison
>>> ordered1 = OrderedDict(a=1, b=2)
>>> ordered2 = OrderedDict(b=2, a=1)
>>> ordered1 == ordered2
False

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

Прилавок()

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

>>> import this

Я сохранил его в списке Zen_Words, где каждый элемент является одним словом.

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

>>> from collections import defaultdict
>>> word_count = defaultdict(int)
>>> for word in zen_words:
        word_count[word] += 1
 
# Define function to return the second value of a tuple
>>> def select_second(tup):
        return tup[1]
 
# Reverse=True - we want the most common first
# word_count.items() - we want keys and values
# sorted() returns a list, so wrap in dict() to return a dict
 
>>> dict(sorted(word_count.items(), reverse=True, key=select_second))
{'is': 10, 
'better': 8, 
'than': 8, 
'to': 5, 
...}

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

Для краткости мы будем включать в себя самые основные случаи использования и пусть Reader Puruse Документы самих себя.

>>> from collections import Counter
>>> word_count = Counter(zen_words)
>>> word_count
Counter({'is': 10, 'better': 8, 'than': 8, 'to': 5, ...})

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

>>> letters = Counter(['a', 'b', 'c', 'c', 'c', 'c', 'd', 'd', 'a'])
>>> letters
Counter({'c': 4, 'a': 2, 'd': 2, 'b': 1})
 
# Count of a missing key is 0
>>> letters['z']
0

Обратный ()

В Python 3.8 они представили обратный () Функция для словарей! Возвращает итератор. Это итерации по словарю в противоположном порядке, к тому, как были добавлены пары ключевых ценностей. Если пары ключа-значений не имеют порядка, обратный () не дадут им никаких дополнительных заказов. Если вы хотите отсортировать ключи в алфавитном порядке, например, используйте отсортировано () Отказ

# Python 3.8
 
# Reverses the order key-value pairs were added to the dict
>>> ordered_dict = dict(a=1, b=2, c=3)
>>> for key, value in reversed(ordered_dict.items()):
        print(key, value)
c 3
b 2
a 1
 
# Does not insert order where there is none.
>>> unordered_dict = dict(c=3, a=1, b=2)
>>> for key, value in reversed(unordered_dict.items()):
        print(key, value)
b 2
a 1
c 3
 
# Order unordered_dict alphabetically using sorted()
>>> dict(sorted(unordered_dict.items()))
{'a': 1, 'b': 2, 'c': 3}

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

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

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

Мы уже видели, что если у вас есть два списка, вы можете создать словарь из них, используя Dict (zip ()).

names = ['Adam', 'Beth', 'Charlie', 'Dani', 'Ethan']
countries = ['Argentina', 'Bulgaria', 'Colombia', 'Denmark', 'Estonia']
 
dict_zip = dict(zip(names, countries))
 
>>> dict_zip
{'Adam': 'Argentina',
'Beth': 'Bulgaria',
'Charlie': 'Colombia',
'Dani': 'Denmark',
'Ethan': 'Estonia'}

Мы также можем сделать это, используя A для цикла

>>> new_dict = {}
>>> for name, country in zip(names, countries):
        new_dict[name] = country
 
>>> new_dict
{'Adam': 'Argentina',
'Beth': 'Bulgaria',
'Charlie': 'Colombia',
'Dani': 'Denmark',
'Ethan': 'Estonia'}

Мы инициализируем наши переменные Dict и Iterator с описательными именами. Итерацию по обеим спискам одновременно мы их вместе сжимаем. Наконец, мы добавляем пары ключа-значений по желанию. Это занимает 3 строки.

Использование понимания превращает это в одну строку.

dict_comp = {name: country for name, country in zip(names, countries)}
 
>>> dict_comp
{'Adam': 'Argentina',
'Beth': 'Bulgaria',
'Charlie': 'Colombia',
'Dani': 'Denmark',
'Ethan': 'Estonia'}

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

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

Вот распространенная ошибка

dict_comp_bad = {name: country 
                 for name in names 
                 for country in countries}
 
>>> dict_comp_bad
{'Adam': 'Estonia',
'Beth': 'Estonia',
'Charlie': 'Estonia',
'Dani': 'Estonia',
'Ethan': 'Estonia'}

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

bad_dict = {}
for name in names:
    for country in countries:
        bad_dict[name] = country
 
>>> bad_dict
{'Adam': 'Estonia',
'Beth': 'Estonia',
'Charlie': 'Estonia',
'Dani': 'Estonia',
'Ethan': 'Estonia'}

Теперь мы будем использовать лучший друг ошибчаса: оператор печати!

# Don't initialise dict to just check for loop logic
for name in names:
    for country in countries:
        print(name, country)
Adam Argentina
Adam Bulgaria
Adam Colombia
Adam Denmark
Adam Estonia
Beth Argentina
Beth Bulgaria
Beth Colombia
...
Ethan Colombia
Ethan Denmark
Ethan Estonia

Здесь мы удаляем словарь, чтобы проверить, что на самом деле происходит в цикле. Теперь мы видим проблему! Проблема заключается в том, что мы вложили в петли. Цикл говорит: для каждого имени пару его с каждой страной. Поскольку можно появиться только словарные ключи, значение перезаписывается на каждую итерацию. Таким образом, значение каждого ключа является окончательным, который появляется в цикле – «Эстония».

Решение состоит в том, чтобы удалить вложенные для циклов и использовать ZIP () вместо этого.

Python вложенные словари с пониманием словаря

nums = [0, 1, 2, 3, 4, 5]
 
dict_nums = {n: {'even': n % 2 == 0,
                 'square': n**2,
                 'cube': n**3,
                 'square_root': n**0.5}
             for n in nums}
 
# Pretty print for ease of reading
>>> pprint(dict_nums)
{0: {'cube': 0, 'even': True, 'square': 0, 'square_root': 0.0},
1: {'cube': 1, 'even': False, 'square': 1, 'square_root': 1.0},
2: {'cube': 8, 'even': True, 'square': 4, 'square_root': 1.4142135623730951},
3: {'cube': 27, 'even': False, 'square': 9, 'square_root': 1.7320508075688772},
4: {'cube': 64, 'even': True, 'square': 16, 'square_root': 2.0},
5: {'cube': 125, 'even': False, 'square': 25, 'square_root': 2.23606797749979}}

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

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

>>> nums = [0, 1, 2, 3, 4, 5]
>>> wrong_dict = {'number': num, 'square': num ** 2 for num in nums}
  File "", line 1
    wrong_dict = {'number': num, 'square': num ** 2 for num in nums}
                                                    ^
SyntaxError: invalid syntax

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

If-Elif – иначе заявления

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
 
# Just the even numbers
even_squares = {n: n ** 2 for n in nums
                if n % 2 == 0}
 
# Just the odd numbers
odd_squares = {n: n ** 2 for n in nums
               if n % 2 == 1}
 
>>> even_dict
{0: 0, 2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
 
>>> odd_dict
{1: 1, 3: 9, 5: 25, 7: 49, 9: 81}

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

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

# Use parenthesis to aid readability
different_vals = {n: ('even' if n % 2 == 0 else 'odd')
                  for n in range(5)}
 
>>> different_vals
{0: 'even', 1: 'odd', 2: 'even', 3: 'odd', 4: 'even'}

Мы можем получить действительно сложное и использовать формулировки, если/иначе в определениях ключевых значений, так и после цикла!

# Change each key using an f-string
{(f'{n}_cubed' if n % 2 == 1 else f'{n}_squared'): 
 
# Cube odd numbers, square even numbers
 (n ** 3 if n % 2 == 1 else n ** 2)
 
# The numbers 0-10 inclusive
 for n in range(11)
 
# If they are not multiples of 3
 if n % 3 != 0}
 
{'1_cubed': 1, '2_squared': 4, '4_squared': 16, '5_cubed': 125, '7_cubed': 343, '8_squared': 64, '10_squared': 100}

Это относительно просто сделать это с использованием понятных. Попытка сделать это с контуром для цикла или Dict (), будет гораздо сложнее.

Слияние двух словарей

Допустим, у нас есть два словаря A и B. Мы хотим создать словарь, C, который содержит все пары клавишных значений A и B. Как мы это делаем?

>>> A = dict(a=1, b=2)
>>> B = dict(c=3, d=4)
 
# Update method does not create a new dictionary
>>> C = A.update(B)
>>> C
>>> type(C)

 
>>> A
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Использование Merge не работает. Это изменяет на месте и так не возвращает ничего.

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

# Python >= 3.5
>>> A = dict(a=1, b=2)
>>> B = dict(c=3, d=4)
>>> C = {**A, **B}
>>> C
{'a': 1, 'b': 2, 'c': 3, 'd': 4}

Мы используем ** Перед каждым словарем «распаковать» все пары клавишных значений.

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

A = dict(a=1, b=2)
B = dict(c=3, d=4)
C = dict(e=5, f=6)
D = dict(g=7, h=8)
>>> all_the_dicts = {**A, **B, **C, **D}
>>> all_the_dicts
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8}

Наконец, что произойдет, если Dicts делит пары ключа-значений?

>>> A = dict(a=1, b=2)
>>> B = dict(a=999)
>>> B_second = {**A, **B}
>>> A_second = {**B, **A}
 
# Value of 'a' taken from B
>>> B_second
{'a': 999, 'b': 2}
 
# Value of 'a' taken from A
>>> A_second
{'a': 1, 'b': 2}

Как всегда в том случае с словарями Python, значение ключа продиктовано его последним заданием. Сначала Dict B_Second принимает ценности, затем занять B. Таким образом, любые общие ключи от A и B будут перезаписаны значениями B. Наоборот верно для a_second.

ПРИМЕЧАНИЕ. Если значение ключа переопределяется, позиция этой клавиши в Dict не меняется.

>>> D = dict(g=7, h=8)
>>> A = dict(a=1, g=999)
>>> {**D, **A}
 
# 'g' is still in the first position despite being overridden with A's value
{'g': 999, 'h': 8, 'a': 1}

Вывод

Теперь вы знаете почти все, что вам нужно будет знать, чтобы использовать словари Python. Отличная работа! Пожалуйста, добавьте в закладки этой страницы и обратитесь к ней так часто, как вам нужно!

Если у вас есть какие-либо вопросы, опубликуйте их в комментариях, и мы вернемся к вам как можно быстрее.

Если вы любите Python и хотите стать фрилансером, есть нет лучшего курса там, чем этот :

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

об авторе

Эта статья способна предоставлена пользователем Finxter Адам Мерфи (Ученый данные, Бабушка Python Code ):

Я являюсь самоучками программистом с первой степенью класса в математике из Университета Дарема и кодировал с июня 2019 года.

Я хорошо разбираюсь в основах SUB STRACKING и DATA SCAIL и может получить широкий спектр информации из Web очень быстро.

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

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

Если вы хотите нанять Адама, проверьте его Профиль намного !

использованная литература

  1. https://www.dictionary.com/
  2. https://tinyurl.com/yg6kgy9h
  3. https://stackoverflow.com/questions/7886355/defaultdictnone
  4. https://www.datacamp.com/community/tutorials/python-dictionary-tutorial
  5. https://docs.python.org/3.8/tutorial/datastructures.html#dictionaries
  6. https://stackoverflow.com/questions/526125/why-is-python-ordering-my-dictionary-like-so
  7. https://stackoverflow.com/a/378987/11829398
  8. https://en.wikipedia.org/wiki/Hash_function
  9. https://docs.python.org/2/library/collections.html#collections.OrderedDict
  10. https://www.quora.com/What-are-hashable-types-in-Python
  11. https://hg.python.org/cpython/file/default/Objects/dictobject.c
  12. https://www.dictionary.com/browse/facetious?s=t
  13. https://thispointer.com/python-how-to-copy-a-dictionary-shallow-copy-vs-deep-copy/
  14. https://docs.python.org/3.8/library/collections.html#collections.Counter
  15. https://stackoverflow.com/questions/12309269/how-do-i-write-json-data-to-a-file
  16. https://realpython.com/python-dicts/#built-in-dictionary-methods
  17. https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression

Куда пойти отсюда?

Поздравляю! Вы успешно освоили словари в Python! Теперь давайте погрузимся в наборы Python.

Expert Writer & Content Creator – наука о науке и машине. – Я помогаю образовательным компаниям создавать привлечение в блоге и видеоконтентах преподавания данных науки для начинающих. В отличие от моих конкурентов, я узнаю новые концепции каждый день и так понимаю, что это нравится быть студентом. Мои статьи легко понять, эффективны и приятно читать. Мои видео достойны, участвуют и подробно. – Работать со мной, пожалуйста, обратитесь к Upwork https://tinyurl.com/hire-adam-murphy

Читайте ещё по теме: