Объединение словарей python: Python объединить два словаря | Expert Coders
Python | Слияние двух словарей
Существуют различные способы объединения словарей с использованием различных функций и конструкторов в Python. В этой статье мы обсудим несколько способов объединения словарей.
- Использование метода update ()
Используя метод update () в Python, один список можно объединить в другой. Но при этом второй список объединяется с первым списком, и новый список не создается. Возвращает Нет .
Пример:def
Merge(dict1, dict2):
return
(dict2.update(dict1))
dict1
=
{
'a'
:
10
,
'b'
:
8
}
dict2
=
{
'd'
:
6
,
'c'
:
4
}
print
(Merge(dict1, dict2))
print
(dict2)
Выход:
None {'c': 4, 'a': 10, 'b': 8, 'd': 6}
- Использование ** в Python
Обычно это считается уловкой в Python, где одно выражение используется для объединения двух словарей и сохраняется в третьем словаре. Единственное выражение **. Это не влияет на два других словаря. ** подразумевает, что аргумент является словарем. Использование ** [двойная звезда] — это ярлык, который позволяет передавать несколько аргументов в функцию напрямую, используя словарь. Для получения дополнительной информации обратитесь к ** kwargs в Python . Используя это, мы сначала передаем все элементы первого словаря в третий, а затем передаем второй словарь в третий. Это заменит дубликаты ключей первого словаря.
Пример:def
Merge(dict1, dict2):
res
=
{
*
*
dict1,
*
*
dict2}
return
res
dict1
=
{
'a'
:
10
,
'b'
:
8
}
dict2
=
{
'd'
:
6
,
'c'
:
4
}
dict3
=
Merge(dict1, dict2)
print
(dict3)
Выход:
{'b': 8, 'a': 10, 'c': 4, 'd': 6}
Рекомендуемые посты:
Python | Слияние двух словарей
0.00 (0%) 0 votes
Как объединить два словаря Python
В предыдущем уроке мы узнали о словарях Python и увидели, что они считаются неупорядоченными наборами с парой key/value
, где ключи используются для доступа к элементам, а не к позиции, как, например, в списках .
В этом кратком совете я собираюсь показать вам, как объединить (объединить) два словаря вместе.
Метод обновления ()
Допустим, у нас есть следующие два словаря:
1 2 | dict1 = {‘bookA’: 1, ‘bookB’: 2, ‘bookC’: 3} dict2 = {‘bookC’: 2, ‘bookD’: 4, ‘bookE’: 5} |
Как мы можем объединить эти два словаря в один словарь? В этом отношении мы можем использовать функцию update([other])
. Как указано в документации Python:
Обновите словарь парами ключ / значение из других , перезаписав существующие ключи. Возврат
None
.
update()
принимает либо другой объект словаря, либо итерацию пар ключ / значение (в виде кортежей или других итераций длиной два). Если заданы аргументы ключевого слова, словарь обновляется этими парами ключ / значение:d.update(red=1, blue=2)
.
Итак, чтобы объединить два вышеупомянутых словаря, мы можем набрать следующее:
dict2.update(dict1)
Скажем, что вы набрали следующее утверждение, чтобы просмотреть результаты:
print dict2.update(dict1)
В этом случае вы получите None
! Это потому, что функция update()
не возвращает новый словарь. Чтобы получить результат конкатенации, просто введите следующее:
print dict2
В этом случае вы получите следующий вывод:
{'bookA': 1, 'bookB': 2, 'bookC': 3, 'bookD': 4, 'bookE': 5}
Что делать, если мы сделали следующее?
1 2 | dict1.update(dict2) print dict1 |
В этом случае вы получите следующий вывод:
{'bookA': 1, 'bookB': 2, 'bookC': 2, 'bookD': 4, 'bookE': 5}
Обратите внимание, что в первом случае, dict2.update(dict1)
, мы обновляем словарь dict2
ключ / значение из dict1
и перезаписываем любые существующие ключи. Существующий ключ, как мы можем заметить, это 'bookC'
, который в этом случае будет иметь значение 3
, поскольку мы обновляем пары ключ / значение из dict1
. Это будет полностью изменено в последнем случае, dict1.update(dict2)
, где мы обновляем словарь dict1
ключ / значение из dict2
.
Однако существует проблема в использовании update()
для объединения двух словарей. Проблема заключается в том, что оригинальный словарь может быть изменен. Другими словами, в первом случае, например, dict2.update(dict1)
, оригинальная версия dict2
может быть изменена, а в последнем случае dict1.update(dict2)
оригинальная версия dict1
может быть изменена. То есть вы можете использовать update()
для объединения двух словарей, если вы не заинтересованы в сохранении исходной версии словаря, который вам нужно обновить. Под оригинальной версией здесь я подразумеваю сохранение значения ключа.
Объединение двух словарей в одном выражении
Другой способ, который вы можете использовать для объединения двух словарей, где вы можете выполнить такую задачу в одном выражении, заключается в следующем:
print dict(dict2, **dict1)
Результат этого утверждения:
{'bookA': 1, 'bookB': 2, 'bookC': 3, 'bookD': 4, 'bookE': 5}
Таким образом, dict1
переопределяет dict2
. Если мы хотим, чтобы dict2
переопределил dict1
, мы dict1
:
print dict(dict1, **dict2)
Выход в этом случае будет:
{'bookA': 1, 'bookB': 2, 'bookC': 2, 'bookD': 4, 'bookE': 5}
Сохранение ключевых значений
Возвращаясь к предыдущему вопросу о сохранении значений ключей, как мы можем объединить два словаря, сохраняя оригиналы каждого словаря?
Обходной путь для этого может быть следующим (взятый из ответа в этом потоке StackOverflow ):
01 02 03 04 05 06 07 08 09 10 | from itertools import chain from collections import defaultdict dict1 = {‘bookA’: 1, ‘bookB’: 2, ‘bookC’: 3} dict2 = {‘bookC’: 2, ‘bookD’: 4, ‘bookE’: 5} dict3 = defaultdict(list) for k, v in chain(dict1.items(), dict2.items()): dict3[k].append(v)
for k, v in dict3.items(): print(k, v) |
Выход в этом случае будет:
1 2 3 4 5 | (‘bookA’, [1]) (‘bookB’, [2]) (‘bookC’, [3, 2]) (‘bookD’, [4]) (‘bookE’, [5]) |
Итак, как вы можете видеть из этого краткого совета, очень легко объединить два словаря с помощью Python, и это становится немного сложнее, если мы хотим сохранить значения одного и того же ключа в каждом словаре.
Выучить питон
Изучите Python с нашим полным руководством по питону, независимо от того, начинаете ли вы или начинающий программист, ищущий новые навыки.
Как объединить два словаря в одном выражении?
Решение
Как я могу объединить два словаря Python в одном выражении?
Для словарей x
и y
, словарь z
становится мелко объединенным со значениями, y
заменяющими значения из x
.
В Python 3.5 или выше:
z = {**x, **y}
В Python 2 (или 3.4 или ниже) напишите функцию:
def merge_two_dicts(x, y): z = x.copy() # start with x's keys and values z.update(y) # modifies z with y's keys and values & returns None return z
и сейчас:
z = merge_two_dicts(x, y)
объяснение
Скажем, у вас есть два диктата, и вы хотите объединить их в новый, не изменяя исходные:
x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}
Желаемый результат — получить новый словарь ( z
) со слитыми значениями, а значения второго dict перезаписывают значения из первого.
>>> z
{'a': 1, 'b': 3, 'c': 4}
Новый синтаксис для этого, предложенный в PEP 448 и доступный с Python 3.5 ,
z = {**x, **y}
И это действительно единственное выражение.
Обратите внимание, что мы можем объединить и с буквенной нотацией:
z = {**x, 'foo': 1, 'bar': 2, **y}
и сейчас:
>>> z
{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}
Теперь он показывает, как реализовано в графике выпуска 3.5, PEP 478 , и теперь он появился в документе « Что нового в Python 3.5» .
Тем не менее, поскольку многие организации все еще используют Python 2, вы можете сделать это обратно совместимым образом. Классически Pythonic способ, доступный в Python 2 и Python 3.0-3.4, состоит в том, чтобы сделать это как двухэтапный процесс:
z = x.copy()
z.update(y) # which returns None since it mutates z
В обоих подходах y
будет второе, и его значения будут заменять x
значения, что 'b'
будет указывать на 3
наш конечный результат.
Еще не на Python 3.5, но хочу одно выражение
Если вы еще не используете Python 3.5 или вам нужно написать обратно совместимый код, и вы хотите, чтобы это было в одном выражении , самый эффективный и правильный подход — поместить его в функцию:
def merge_two_dicts(x, y):
"""Given two dicts, merge them into a new dict as a shallow copy."""
z = x.copy()
z.update(y)
return z
и тогда у вас есть одно выражение:
z = merge_two_dicts(x, y)
Вы также можете создать функцию для слияния неопределенного числа диктовок от нуля до очень большого числа:
def merge_dicts(*dict_args):
"""
Given any number of dicts, shallow copy and merge into a new dict,
precedence goes to key value pairs in latter dicts.
"""
result = {}
for dictionary in dict_args:
result.update(dictionary)
return result
Эта функция будет работать в Python 2 и 3 для всех диктов. например , с учетом dicts a
на g
:
z = merge_dicts(a, b, c, d, e, f, g)
и ключевые пары значений в g
будет иметь приоритет над dicts a
до f
, и так далее.
Критика других ответов
Не используйте то, что вы видите в ранее принятом ответе:
z = dict(x.items() + y.items())
В Python 2 вы создаете два списка в памяти для каждого dict, создаете третий список в памяти с длиной, равной длине первых двух вместе взятых, а затем отбрасываете все три списка для создания dict. В Python 3 это не удастся, потому что вы добавляете два dict_items
объекта вместе, а не два списка —
>>> c = dict(a.items() + b.items())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'dict_items' and 'dict_items'
и вам придется явно создавать их в виде списков, например z = dict(list(x.items()) + list(y.items()))
. Это пустая трата ресурсов и вычислительной мощности.
Точно так же принятие объединения items()
в Python 3 ( viewitems()
в Python 2.7) также не удастся, если значения являются объектами, которые не подлежат изменению (например, списки). Даже если ваши значения являются хэшируемыми, так как наборы семантически неупорядочены, поведение не определено в отношении приоритета. Так что не делай этого:
>>> c = dict(a.items() | b.items())
Этот пример демонстрирует, что происходит, когда значения не различимы:
>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'
Вот пример, где у должен иметь приоритет, но вместо этого значение из x сохраняется из-за произвольного порядка множеств:
>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}
Еще один хак, который вы не должны использовать:
z = dict(x, **y)
При этом используется dict
конструктор, и он очень быстр и эффективен в использовании памяти (даже немного больше, чем наш двухэтапный процесс), но если вы точно не знаете, что здесь происходит (то есть второй dict передается в качестве аргументов ключевого слова dict конструктор), его трудно читать, это не предполагаемое использование, и поэтому это не Pythonic.
Вот пример использования исправления в Django .
Dicts предназначены для получения хешируемых ключей (например, frozensets или кортежей), но этот метод не работает в Python 3, когда ключи не являются строками.
>>> c = dict(a, **b)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings
Из списка рассылки создатель языка Гвидо ван Россум написал:
Я согласен с объявлением dict ({}, ** {1: 3}) незаконным, поскольку в конце концов это злоупотребление ** механизмом.
а также
Очевидно, что dict (x, ** y) используется как «крутой хак» для «вызова x.update (y) и возврата x». Лично я нахожу это более презренным, чем крутым.
Это мое понимание (а также понимание создателя языка ), что предполагаемое использование dict(**y)
для создания диктов в целях читабельности, например:
dict(a=1, b=10, c=11)
вместо
{'a': 1, 'b': 10, 'c': 11}
Ответ на комментарии
Несмотря на то, что говорит Гвидо,
dict(x, **y)
это соответствует спецификации dict, которая, между прочим. работает как для Python 2, так и для 3. Тот факт, что это работает только для строковых ключей, является прямым следствием того, как работают параметры ключевых слов, а не коротким переходом к dict. Также использование оператора ** в этом месте не является злоупотреблением механизмом, фактически ** был разработан именно для передачи слов в качестве ключевых слов.
Опять же, это не работает для 3, когда ключи не являются строками. Неявный контракт вызова заключается в том, что пространства имен принимают обычные диктовки, в то время как пользователи должны передавать только ключевые аргументы, которые являются строками. Все другие призывные силы принуждали его. dict
нарушил эту последовательность в Python 2:
>>> foo(**{('a', 'b'): None})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: foo() keywords must be strings
>>> dict(**{('a', 'b'): None})
{('a', 'b'): None}
Это несоответствие было плохим, учитывая другие реализации Python (Pypy, Jython, IronPython). Таким образом, это было исправлено в Python 3, так как это использование может быть серьезным изменением.
Я утверждаю, что это злонамеренная некомпетентность — намеренно писать код, который работает только в одной версии языка или работает только при определенных произвольных ограничениях.
Больше комментариев:
dict(x.items() + y.items())
до сих пор является наиболее читаемым решением для Python 2. Читаемость имеет значение.
Мой ответ: на merge_two_dicts(x, y)
самом деле кажется мне намного понятнее, если мы действительно обеспокоены читаемостью. И он не является совместимым с форвардом, так как Python 2 все более и более устарел.
{**x, **y}
похоже не обрабатывает вложенные словари. содержимое вложенных ключей просто перезаписывается, а не сливается […]. В итоге я сгорел от этих ответов, которые не сливаются рекурсивно, и я был удивлен, что никто не упомянул об этом. В моей интерпретации слова «слияние» эти ответы описывают «обновление одного слова другим», а не слияние.
Да. Я должен отослать вас обратно к вопросу, который требует поверхностного слияния двух словарей, причем значения первого перезаписываются значениями второго — в одном выражении.
Предполагая два словаря словарей, один может рекурсивно объединить их в одну функцию, но вы должны быть осторожны, чтобы не изменять указания из любого источника, и самый надежный способ избежать этого — сделать копию при назначении значений. Поскольку ключи должны быть хэшируемыми и, следовательно, обычно неизменяемыми, копировать их бессмысленно:
from copy import deepcopy
def dict_of_dicts_merge(x, y):
z = {}
overlapping_keys = x.keys() & y.keys()
for key in overlapping_keys:
z[key] = dict_of_dicts_merge(x[key], y[key])
for key in x.keys() - overlapping_keys:
z[key] = deepcopy(x[key])
for key in y.keys() - overlapping_keys:
z[key] = deepcopy(y[key])
return z
Использование:
>>> x = {'a':{1:{}}, 'b': {2:{}}}
>>> y = {'b':{10:{}}, 'c': {11:{}}}
>>> dict_of_dicts_merge(x, y)
{'b': {2: {}, 10: {}}, 'a': {1: {}}, 'c': {11: {}}}
Поиск непредвиденных обстоятельств для других типов значений выходит за рамки этого вопроса, поэтому я укажу вам на мой ответ на канонический вопрос «Словари слияния словарей» .
Менее производительный, но правильный Ad-hocs
Эти подходы менее эффективны, но они обеспечат правильное поведение. Они будут гораздо менее производительными, чем copy
и / update
или новая распаковка, потому что они выполняют итерацию по каждой паре ключ-значение на более высоком уровне абстракции, но они действительно уважают порядок приоритета (последние имеют приоритет)
Вы также можете связать слова вручную в их понимании:
{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7
или в Python 2.6 (и, возможно, уже в 2.4, когда были введены выражения генератора):
dict((k, v) for d in dicts for k, v in d.items())
itertools.chain
объединит итераторы в пары ключ-значение в правильном порядке:
import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))
Анализ производительности
Я собираюсь провести анализ производительности только тех случаев, когда известно, что они ведут себя правильно.
import timeit
Следующее сделано в Ubuntu 14.04
В Python 2.7 (система Python):
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.5726828575134277
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.163769006729126
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.iteritems(), y.iteritems()))))
1.1614501476287842
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
2.2345519065856934
В Python 3.5 (deadsnakes PPA):
>>> min(timeit.repeat(lambda: {**x, **y}))
0.4094954460160807
>>> min(timeit.repeat(lambda: merge_two_dicts(x, y)))
0.7881555100320838
>>> min(timeit.repeat(lambda: {k: v for d in (x, y) for k, v in d.items()} ))
1.4525277839857154
>>> min(timeit.repeat(lambda: dict(itertools.chain(x.items(), y.items()))))
2.3143140770262107
>>> min(timeit.repeat(lambda: dict((k, v) for d in (x, y) for k, v in d.items())))
3.2069112799945287
Ресурсы по словарям
Автор: Aaron Hall
Размещён: 10.11.2014 10:11
объединение коллекций, добавление и удаление элементов / Хабр
Продолжим изучать общие принципы работы со стандартными коллекциями (модуль collections в ней не рассматривается) Python. Будут рассматриваться способы объединения и обновления коллекций с формированием новой или изменением исходной, а также способы добавлять и удалять элементы в изменяемые коллекции.
Для кого: для изучающих Python и уже имеющих начальное представление о коллекциях и работе с ними, желающих систематизировать и углубить свои знания, сложить их в целостную картину.
Оглавление:
- Объединение строк, кортежей, списков, словарей без изменения исходных.
- Объединение множеств без изменения исходных.
- Объединение списка, словаря и изменяемого множества с изменением исходной коллекции.
- Добавление и удаление элементов изменяемых коллекций.
- Особенности работы с изменяемой и не изменяемой коллекцией.
1. Объединение строк, кортежей, списков, словарей без изменения исходных
Рассмотрим способы объединения строк, кортежей, списков, словарей без изменения исходных коллекций — когда из нескольких коллекций создаётся новая коллекция того же тип без изменения изначальных.
- Объединение строк (string) и кортежей (tuple) возможна с использованием оператора сложения «+»
str1 = 'abc' str2 = 'de' str3 = str1 + str2 print(str3) # abcde tuple1 = (1, 2, 3) tuple2 = (4, 5) tuple3 = tuple1 + tuple2 print(tuple3) # (1, 2, 3, 4, 5)
- Для объединения списков (list) возможны три варианта без изменения исходного списка:
- Добавляем все элементы второго списка к элементам первого, (аналог метод .extend() но без изменения исходного списка):
a = [1, 2, 3] b = [4, 5] c = a + b print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, 4, 5]
- Добавляем второй список как один элемент без изменения исходного списка (аналог метода.append() но без изменения исходного списка):
a = [1, 2, 3] b = [4, 5] c = a + [b] print(a, b, c) # [1, 2, 3] [4, 5] [1, 2, 3, [4, 5]]
- Добавляем все элементы второго списка к элементам первого, (аналог метод .extend() но без изменения исходного списка):
- UPD: Способ добавленный longclaps в комментариях:
a, b = [1, 2, 3], [4, 5] c = [*a, *b] # работает на версии питона 3.5 и выше print(c) # [1, 2, 3, 4, 5]
- Со словарем (dict) все не совсем просто.
Сложить два словаря чтобы получить третий оператором + Питон не позволяет «TypeError: unsupported operand type(s) for +: ‘dict’ and ‘dict’».
Это можно сделать по-другому комбинируя методы .copy() и .update():
dict1 = {'a': 1, 'b': 2} dict2 = {'c': 3, 'd': 4} dict3 = dict1.copy() dict3.update(dict2) print(dict3) # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
В Питоне 3.5 появился новый более изящный способ:dict1 = {'a': 1, 'b': 2} dict2 = {'c': 3, 'd': 4} dict3 = {**dict1, **dict2} print(dict3) # {'a': 1, 'c': 3, 'b': 2, 'd': 4}
2. Объединение множеств без изменения исходных
Для обоих типов множеств (set, frozenset) возможны различные варианты комбинации множеств (исходные множества при этом не меняются — возвращается новое множество).
# Зададим исходно два множества (скопировать перед каждым примером ниже)
a = {'a', 'b'}
b = { 'b', 'c'} # отступ перед b для наглядности
- Объединение (union):
c = a.union(b) # c = b.union(a) даст такой же результат # c = a + b # Обычное объединение оператором + не работает # TypeError: unsupported operand type(s) for +: 'set' and 'set' c = a | b # Альтернативная форма записи объединения print(c) # {'a', 'c', 'b'}
- Пересечение (intersection):
c = a.intersection(b) # c = b.intersection(a) даст такой же результат c = a & b # Альтернативная форма записи пересечения print(c) # {'b'}
Пересечение более 2-х множеств сразу:a = {'a', 'b'} b = { 'b', 'c'} c = { 'b', 'd'} d = a.intersection(b, c) # Первый вариант записи d = set.intersection(a, b, c) # Второй вариант записи (более наглядный) print(d) # {'b'}
- Разница (difference) — результат зависит от того, какое множество из какого вычитаем:
c = a.difference(b) # c = a - b другой способ записи дающий тот же результат print(c) # {'a'} c = b.difference(a) # c = b - a другой способ записи дающий тот же результат print(c) # {'c'}
- Симметричная разница (symmetric_difference) Это своего рода операция противоположная пересечению — выбирает элементы из обеих множеств которые не пересекаются, то есть все кроме совпадающих:
c = b.symmetric_difference(a) # c = a.symmetric_difference(b) # даст такой же результат c = b ^ a # Альтернативная форма записи симметричной разницы print(c) # {'a', 'c'}
3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции
- Для списка
- Добавляем все элементы второго списка к элементам первого с измением первого списка методом .extend():
a.extend(b) # a += b эквивалентно a.extend(b) print(a, b) # [1, 2, 3, 4, 5] [4, 5]
- Добавляем второй список как один элемент с изменением первого списка методом .append():
a.append(b) # a += [b] эквивалентно a.append(b) print(a, b) # [1, 2, 3, [4, 5]] [4, 5]
- Добавляем все элементы второго списка к элементам первого с измением первого списка методом .extend():
- Для изменения словаря с добавления элементов другого словаря используется метод .update().
Обратите внимание: для совпадающих ключей словаря при этом обновляются значения:
dict1 = {'a': 1, 'b': 2} dict2 = {'a': 100, 'c': 3, 'd': 4} dict1.update(dict2) print(dict1) # {'a': 100, 'c': 3, 'b': 2, 'd': 4}
- Для изменяемого множества (set) кроме операций, описанных в предыдущем разделе, также возможны их аналоги, но уже с изменением исходного множества — эти методы заканчиваются на _update. Результат зависит от того, какое множество каким обновляем.
- .difference_update()
a = {'a', 'b'} b = { 'b', 'c'} a.difference_update(b) print(a, b) # {'a'} {'b', 'c'} a = {'a', 'b'} b = { 'b', 'c'} b.difference_update(a) print(a, b) # {'a', 'b'} {'c'}
- .intersection_update()
a = {'a', 'b'} b = { 'b', 'c'} a.intersection_update(b) print(a, b) # {'b'} {'b', 'c'} a = {'a', 'b'} b = { 'b', 'c'} b.intersection_update(a) print(a, b) # {'b', 'a'} {'b'}
- .symmetric_difference_update()
a = {'a', 'b'} b = { 'b', 'c'} a.symmetric_difference_update(b) print(a, b) # {'c', 'a'} {'c', 'b'} a = {'a', 'b'} b = { 'b', 'c'} b.symmetric_difference_update(a) print(a, b) # {'a', 'b'} {'c', 'a'}
4 Добавление и удаление элементов изменяемых коллекций
Добавление и удаление элементов в коллекцию возможно только для изменяемых коллекций: списка (list), множества (только set, не frozenset), словаря (dict). Причём для списка, который является индексированной коллекцией, также важно на какую позицию мы добавляем элемент.Примечания:
- Примеры использования метода .insert(index, element)
my_list = [1, 2, 3] my_list.insert(0, 0) # index = 0 - вставляем в начало print(my_list) # [0, 1, 2, 3] my_list.insert(10, 4) # Индекс выходит за границы списка - просто добавим в конец print(my_list) # [0, 1, 2, 3, 4] my_list.insert(-10, -1) # Индекс выходит за границы в минус - добавим в начало print(my_list) # [-1, 0, 1, 2, 3, 4] my_list = [1, 2, 3] my_list.insert(1, 1.5) # Вставим между 1 и 2 (индексация с нуля!) # То есть вставляется на позицию с указанным индексом, а то значение что на ней было # и те что правее - сдвигаются на 1 индекс вправо print(my_list) # [1, 1.5, 2, 3]
- Примеры использования оператора del
# Работает со списком my_list = [1, 2, 3, 4, 5, 6, 7] del my_list[1] # Удаление элемента по индексу print(my_list) # [1, 3, 4, 5, 6, 7] del my_list[-3:-1] # Удаление элементов выбранных срезом print(my_list) # [1, 3, 4, 7] # del my_list[10] # IndexError: list assignment index out of range # Работает со словарем my_dict = {'a': 1, 'b': 2, 'c': 3} del my_dict['b'] print(my_dict) # {'a': 1, 'c': 3} # del my_dict['z'] # KeyError при попытке удалить не сушествующий
- Удаление и добавление элементов списка срезом рассматривается во второй статье.
- Пример работы .append() и .extend() рассматривается в третьей главе этой статьи.
5 Особенности работы с изменяемой и не изменяемой коллекцией
- Строка неизменяемая коллекция — если мы ее меняем — мы создаем новый объект!
str1 = 'abc' print(str1, id(str1)) # abc 140234080454000 str1 += 'de' print(str1, id(str1)) # abcde 140234079974992 - Это НОВЫЙ объект, с другим id!
Пример кода с двумя исходно идентичными строками.str1 = 'abc' str2 = str1 print(str1 is str2) # True - это две ссылки на один и тот же объект! str1 += 'de' # Теперь переменная str1 ссылается на другой объект! print(str1 is str2) # False - теперь это два разных объекта! print(str1, str2) # abcde abc - разные значения
- Список изменяем и тут надо быть очень внимательным, чтобы не допустить серьезную ошибку! Сравните данный пример с примером со строками выше:
list1 = [1, 2, 3] list2 = list1 print(list1 is list2) # True - это две ссылки на один и тот же объект! # А дальше убеждаемся, насколько это важно: list1 += [4] print(list1, list2) # [1, 2, 3, 4] [1, 2, 3, 4] # изменилось значение ОБЕИХ переменных, так как обе переменные ссылаются на один объект!
А если нужна независимая копия, с которой можно работать отдельно?list1 = [1, 2, 3] list2 = list(list1) # Первый способ копирования list3 = list1[:] # Второй способ копирования list4 = list1.copy() # Третий способ копировани - только в Python 3.3+ print(id(list1), id(list2), id(list3), id(list4)) # все 4 id разные, что значит что мы создали 4 разных объекта list1 += [4] # меняем исходный список print(list1, list2, list3, list4) # [1, 2, 3, 4] [1, 2, 3] [1, 2, 3] [1, 2, 3] # как мы и хотели - изменив исходный объект, его копии остались не тронутыми
Приглашаю к обсуждению:
- Если я где-то допустил неточность или не учёл что-то важное — пишите в комментариях, важные комментарии будут позже добавлены в статью с указанием вашего авторства.
- Если какие-то моменты не понятны и требуется уточнение — пишите ваши вопросы в комментариях — или я или другие читатели дадут ответ, а дельные вопросы с ответами будут позже добавлены в статью.
- .difference_update()
Python | Объединение двух списков словарей
Python, Программы Python
Учитывая два списка словарей, задача состоит в том, чтобы объединить эти два списка словарей на основе некоторого значения.
Способ № 1: Использование defaultdict
и extend
для объединения двух списков словарей на основе school_id .
|
Выход:
[{‘school_id’: 1, ‘roll_no’: [‘123445’, ‘1212’]}, {‘school_id’: 2, ‘roll_no’: [‘HA-4848231’, ‘473427’]}, {‘school_id’: 5, ‘roll_no’: [‘092112’]}]
Способ № 2: Использование только extend()
.
|
Выход:
[{‘school_id’: 1, ‘roll_no’: [‘123445’, ‘1212’]}, {‘school_id’: 2, ‘roll_no’: [‘HA-4848231’, ‘473427’]}, {‘school_id’: 5, ‘roll_no’: [‘092112’]}]
Рекомендуемые посты:
Python | Объединение двух списков словарей
0.00 (0%) 0 votes
3.x — Python: объединение двух словарей с равными ключами с использованием for-loop [duplicate]
Мне просто нужно было объединить словарный номер неизвестного номера и после того, как мы увидели ответы на этот вопрос, появились более универсальные решения:
1) словари значений:
dic1 = {'A': 1, 'B': 1, 'C': 1}
dic2 = {'A': 2, 'B': 2, 'C': 2}
dic3 = {'D': 3, 'E': 3, 'F': 3}
def combineDictVal(*args):
result = {}
for dic in args:
for key in (result.viewkeys() | dic.keys()):
if key in dic:
result.setdefault(key, []).append(dic[key])
return result
print combineDictVal(dic1, dic2, dic3)
Результат : {'A': [1, 2], 'C': [1, 2], 'B': [1, 2], 'E': [3], 'D': [3], 'F': [3]}
2) словари списков (различие находится в append / extend *):
dic1 = {'A': [1, 2], 'B': [1, 2], 'C': [1, 2]}
dic2 = {'A': [3, 4], 'B': [3, 4], 'C': [3, 4]}
dic3 = {'D': [5, 6], 'E': [5, 6], 'F': [5, 6]}
def combineDictList(*args):
result = {}
for dic in args:
for key in (result.viewkeys() | dic.keys()):
if key in dic:
result.setdefault(key, []).extend(dic[key])
return result
print combineDictList(dic1, dic2, dic3)
Результат: {'A': [1, 2, 3, 4], 'C': [1, 2, 3, 4], 'B': [1, 2, 3, 4], 'E': [5, 6], 'D': [5, 6], 'F': [5, 6]}
3) Universal для int / lists:
dic1 = {'A': 1, 'B': 1, 'C': [1, 1]}
dic2 = {'A': 2, 'B': [2, 2], 'C': 2}
dic3 = {'D': 3, 'E': 3, 'F': [3, 3]}
def combineDict(*args):
result = {}
for dic in args:
for key in (result.viewkeys() | dic.keys()):
if key in dic:
if type(dic[key]) is list:
result.setdefault(key, []).extend(dic[key])
else:
result.setdefault(key, []).append(dic[key])
return result
print combineDict(dic1, dic2, dic3)
Результат:
{'A': [1, 2], 'C': [1, 1, 2], 'B': [1, 2, 2], 'E': [3], 'D': [3], 'F': [3, 3]}
Эти решения не являются максимально возможными, однако они ясны и работают нормально. Надеюсь, это поможет кому-то.
Python | Объедините значения двух словарей, имеющих одинаковый ключ
Словарь — это неупорядоченная, изменяемая и индексируемая коллекция. В Python словари написаны в фигурных скобках и имеют ключи и значения. Он широко используется в повседневном программировании, веб-разработке и машинном обучении. Объединение словарей — очень распространенная задача в операциях со словарем.
Давайте посмотрим, как объединить значения двух словарей, имеющих одинаковый ключ.
Метод № 1: Использование Counter
Счетчик — это специальный подкласс словаря, который в большинстве случаев выполняет те же действия, что и словарь.
|
Выход:
initial 1st dictionary Counter({‘akshat’: 15, ‘manjeet’: 10, ‘akash’: 5, ‘nikhil’: 1})
initial 2nd dictionary Counter({‘m’: 15, ‘akash’: 7, ‘akshat’: 5})
final dictionary Counter({‘akshat’: 20, ‘m’: 15, ‘akash’: 12, ‘manjeet’: 10, ‘nikhil’: 1})
Способ № 2: Использование dict() and items
Этот метод для Python версии 2.
|
Выход:
(‘initial 1st dictionary’, “{‘manjeet’: 10, ‘nikhil’: 1, ‘akshat’: 15, ‘akash’: 5}”)
(‘initial 2nd dictionary’, “{‘m’: 15, ‘akshat’: 5, ‘akash’: 7}”)
(‘final dictionary’, “{‘nikhil’: 1, ‘m’: 15, ‘manjeet’: 10, ‘akshat’: 20, ‘akash’: 12}”)
Метод № 3: Использование диктов и понимания
|
Выход:
initial 1st dictionary {‘nikhil’: 1, ‘akshat’: 15, ‘akash’: 5, ‘manjeet’: 10}
initial 2nd dictionary {‘akshat’: 5, ‘akash’: 7, ‘m’: 15}
final dictionary {‘nikhil’: 1, ‘akshat’: 20, ‘akash’: 12, ‘m’: 15, ‘manjeet’: 10}
Рекомендуемые посты:
Python | Объедините значения двух словарей, имеющих одинаковый ключ
0.00 (0%) 0 votes
Как объединить два или более словарей в Python? — thispointer.com
В этой статье мы обсудим различные способы объединения двух и более словарей. Кроме того, обрабатывайте сценарии, в которых нам нужно сохранить значения общих ключей, а не перезаписывать их.
Объединить два словаря с помощью dict.update ()
В Python класс Dictionary предоставляет функцию update (), т.е.
dict.update ([other])
Он принимает другой словарь или объект Iterable (набор пар ключ-значение) в качестве аргумента.Затем объединяет содержимое этого переданного словаря или Iterable в текущий словарь.
Давайте воспользуемся этой функцией update () для объединения двух словарей.
Предположим, у нас есть два словаря, т.е.
# Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11}
Оба словаря имеют общий ключ «Sam» с разными значениями. Теперь давайте объединим содержимое dict2 в dict1 i.е.
# Слить содержимое dict2 в dict1 dict1.update (dict2) print ('Обновленный словарь 1:') печать (dict1)
Теперь содержимое dict1 :
{'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 11}
Все элементы в dict2 добавляются к dict1 . Ключи, общие для обоих словарей, будут содержать значения, как в dict2 . В основном словарь, который мы передаем в update () в качестве аргумента, переопределит значения общего ключа.Следовательно, «Сэм» сейчас имеет значение 20.
Еще одно важное замечание: у нас не было нового словаря. Содержимое dict1 изменилось, и теперь, помимо существующего содержимого, оно также имеет содержимое dict2 . Что, если мы хотим объединить содержимое двух словарей или словарей в новый словарь? Посмотрим, как это сделать.
Объединить два или более словарей, используя ** kwargs
** варгс
Используя ** kwargs, мы можем отправлять в функцию пары ключ-значение переменной длины.Когда мы применяем ** к словарю, он расширяет содержимое словаря как набор пар ключ-значение.
Например, если у нас есть словарь, то есть
dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10}
Когда мы применяем ** к этому словарю, он десериализует содержимое словаря в набор пар ключ / значение, то есть
** dict1
эквивалентно,
«Ритика»: 5, «Сэм»: 7, «Джон»: 10
Итак, давайте использовать ** kwargs для объединения двух или более словарей.
Предположим, у нас есть два словаря, т.е.
# Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11}
Теперь объедините содержимое dict1 и dict2 в новый словарь dict3 , т.е.
# Объедините содержимое dict2 и dict1 с dict3 dict3 = {** dict1, ** dict2} print ('Словарь 3:') печать (dict3)
Содержание нового словаря
Словарь 3: {'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 11}
Как это работало?
** dict1 & ** dict2 расширил содержимое обоих словарей до набора пар ключ-значение i.е.
dict3 = {'Ritika': 5, 'Sam': 7, 'John': 10, 'Aadi': 8, 'Sam': 20, 'Mark': 11}
Поэтому создается новый словарь, содержащий данные из обоих словарей.
И dict1, и dict2, имели один общий ключ «Sam». В dict3 значение для этого общего ключа «Sam» такое же, как в dict2 , потому что мы передали ** dict2 в качестве второго аргумента.
Объединить три словаря
Аналогичным образом мы можем объединить 3 словаря i.е.
# Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11} # Создать второй словарь dict3 = {'Mark': 18, 'Rose': 22, 'Wong': 22} # Объединить содержимое dict3, dict2 и dict1 с dict4 dict4 = {** dict1, ** dict2, ** dict3} print ('Словарь 3:') печать (dict4)
Выход:
Словарь 4: {'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 18, 'Rose': 22, 'Wong': 22}
До сих пор мы видели, что при объединении словарей значения общих ключей переопределяются.Что, если мы хотим сохранить все ценности?
Объединить два словаря и сложить значения общих ключей
Предположим, у нас есть два словаря с общим ключом, т.е.
# Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11}
Теперь мы хотим объединить эти словари таким образом, чтобы он сохранял все значения для общих ключей в списке, то есть
def mergeDict (dict1, dict2): '' 'Объединяйте словари и сохраняйте значения общих ключей в списке' '' dict3 = {** dict1, ** dict2} для ключа значение в dict3.Предметы(): если ввести dict1 и ввести dict2: dict3 [ключ] = [значение, dict1 [ключ]] return dict3 # Объединить словари и добавить значения общих ключей в список dict3 = mergeDict (dict1, dict2) print ('Словарь 3:') print (dict3)
Вывод :
{'Ritika': 5, 'Sam': [20, 7], 'John': 10, 'Aadi': 8, 'Mark': 11}
Оба словаря имели общий ключ «Сэм». В объединенном словаре dict3 оба значения «Sam» из dict1 и dict2 объединены в список.
Мы можем использовать эту функцию для объединения 3 словарей и сохранения всех значений для общих ключей, т.е.
# Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11} # Третий словарь dict3 = {'Mark': 18, 'Rose': 22, 'Wong': 22} # Объединить 3 словаря и сохранить значения общих ключей в списке finalDict = mergeDict (dict3, mergeDict (dict1, dict2)) print ('Последний словарь:') печать (finalDict)
Вывод:
Окончательный словарь: {'Mark': [11, 18], 'Rose': 22, 'Wong': 22, 'Ritika': 5, 'Sam': [20, 7], 'John': 10, 'Aadi': 8 }
Учебное пособие по словарю Python — Серия:
Подпишитесь вместе с нами, чтобы присоединиться к списку из более чем 2000 программистов и получать последние советы и руководства на свой почтовый ящик через нашу еженедельную рассылку.
Полный пример выглядит следующим образом:
def mergeDict (dict1, dict2): '' 'Объединяйте словари и сохраняйте значения общих ключей в списке' '' dict3 = {** dict1, ** dict2} для ключа значение в dict3.items (): если ввести dict1 и ввести dict2: dict3 [ключ] = [значение, dict1 [ключ]] return dict3 def main (): # Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11} print ('Словарь 1:') печать (dict1) print ('Словарь 2:') печать (dict2) print ('*** Объединить два словаря с помощью update () ***') # Объединить содержимое dict2 в dict1 dict1.обновление (dict2) print ('Обновленный словарь 1:') печать (dict1) print ('*** Объединить два словаря с помощью ** трюка ***') # Создать первый словарь dict1 = {'Ritika': 5, 'Sam': 7, 'John': 10} # Создать второй словарь dict2 = {'Aadi': 8, 'Sam': 20, 'Mark': 11} # Объединить содержимое dict2 и dict1 с dict3 dict3 = {** dict1, ** dict2} print ('Словарь 3:') печать (dict3) print ('*** Объединить 3 словаря с помощью ** трюка ***') # Создать второй словарь dict3 = {'Mark': 18, 'Rose': 22, 'Wong': 22} # Объединить содержимое dict3, dict2 и dict1 с dict4 dict4 = {** dict1, ** dict2, ** dict3} print ('Словарь 4:') печать (dict4) print ('*** Объединить два словаря и сложить значения общих ключей ***') # Создать второй словарь # Объединить содержимое dict2 и dict1 с dict3 печать (dict1) печать (dict2) # Объединить словари и добавить значения общих ключей в список dict3 = mergeDict (dict1, dict2) print ('Словарь 3:') печать (dict3) dict3 = {'Mark': 18, 'Rose': 22, 'Wong': 22} печать (dict3) # Объединить 3 словаря и сохранить значения общих ключей в списке finalDict = mergeDict (dict3, mergeDict (dict1, dict2)) print ('Последний словарь:') печать (finalDict) если __name__ == '__main__': главный()
Вывод:
Словарь 1: {'Ritika': 5, 'Sam': 7, 'John': 10} Словарь 2: {'Aadi': 8, 'Sam': 20, 'Mark': 11} *** Объедините два словаря с помощью update () *** Обновленный словарь 1: {'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 11} *** Объедините два словаря, используя ** трюк *** Словарь 3: {'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 11} *** Объедините 3 словаря, используя ** трюк *** Словарь 4: {'Ritika': 5, 'Sam': 20, 'John': 10, 'Aadi': 8, 'Mark': 18, 'Rose': 22, 'Wong': 22} *** Объедините два словаря и сложите значения общих ключей *** {'Ritika': 5, 'Sam': 7, 'John': 10} {'Aadi': 8, 'Sam': 20, 'Mark': 11} Словарь 3: {'Ritika': 5, 'Sam': [20, 7], 'John': 10, 'Aadi': 8, 'Mark': 11} {'Марк': 18, 'Роза': 22, 'Вонг': 22} Заключительный словарь: {'Mark': [11, 18], 'Rose': 22, 'Wong': 22, 'Ritika': 5, 'Sam': [20, 7], 'John': 10, 'Aadi': 8 }
.
Python | Слияние двух словарей
Существуют различные способы объединения словарей с помощью различных функций и конструкторов в Python. В этой статье мы обсудим несколько способов объединения словарей.
С помощью метода update ()
Используя метод update () в Python, один список может быть объединен с другим. Но в этом случае второй список объединяется с первым списком, и новый список не создается. Он возвращает Нет .
Пример:
Python3
|
Выход:
Нет {'c': 4, 'a': 10, 'b': 8, 'd': 6}
Использование ** в Python
Это обычно считается уловкой в Python, когда одно выражение используется для объединения двух словарей и сохраняется в третьем словаре.Единственное выражение — **. Это не влияет на два других словаря. ** означает, что аргумент является словарем. Использование ** [двойная звездочка] — это ярлык, который позволяет передавать несколько аргументов функции напрямую, используя словарь. Для получения дополнительной информации обратитесь к ** kwargs в Python. Используя это, мы сначала передаем все элементы первого словаря в третий, а затем второй словарь в третий. Это заменит повторяющиеся ключи первого словаря.
Пример:
Python3
|
Выход:
{'b': 8, 'a': 10, 'c': 4, 'd': 6}
Использование | в Python 3.9
В последнем обновлении Python теперь мы можем использовать «|» оператор для объединения двух словарей. Это очень удобный способ объединения словарей.
Пример:
.
Python | Объедините значения двух словарей с одинаковым ключом
Словарь — это неупорядоченный, изменяемый и индексируемый сборник. В Python словари записываются в фигурные скобки, у них есть ключи и значения. Он широко используется в повседневном программировании, веб-разработке и машинном обучении. Объединение словарей — очень распространенная задача при работе со словарем.
Давайте посмотрим, как объединить значения двух словарей с одинаковым ключом.
Метод № 1: Использование счетчика
Счетчик — это специальный подкласс словаря, который в большинстве случаев выполняет действия, аналогичные словарю.
, , |
Выход:
начальный 1-й словарный счетчик ({'akshat': 15, 'manjeet': 10, 'akash': 5, 'nikhil': 1})
начальный 2-й словарный счетчик ({'m': 15, 'akash': 7, 'akshat': 5})
final Dictionary Counter ({'akshat': 20, 'm': 15, 'akash': 12, 'manjeet': 10, 'nikhil': 1}))
Метод № 2: Использование dict () и элементов
Этот метод предназначен для Python версии 2.
, |
Выход:
('начальный 1-й словарь', «{'manjeet': 10, 'nikhil': 1, 'akshat': 15, 'akash': 5}»)
('начальный 2-й словарь', «{'m': 15 , 'akshat': 5, 'akash': 7} »)
('final dictionary',« {'nikhil': 1, 'm': 15, 'manjeet': 10, 'akshat': 20, 'akash ': 12} ”)
Метод № 3: Использование понимания dict и установка
, |
Выход:
начальный 1-й словарь {'nikhil': 1, 'akshat': 15, 'akash': 5, 'manjeet': 10}
начальный 2-й словарь {'akshat': 5, 'akash': 7, 'm': 15 }
final Dictionary {'nikhil': 1, 'akshat': 20, 'akash': 12, 'm': 15, 'manjeet': 10}
Если вам нравится GeeksforGeeks и вы хотите внести свой вклад, вы также можете написать статью, используя свой вклад.geeksforgeeks.org или отправьте свою статью по адресу [email protected]. Посмотрите свою статью на главной странице GeeksforGeeks и помогите другим гикам.
Пожалуйста, улучшите эту статью, если вы обнаружите что-то неправильное, нажав кнопку «Улучшить статью» ниже.
Теги статей:
.