Разное

Объединение словарей python: Python объединить два словаря | Expert Coders

Содержание

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

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

  1. Использование метода 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}
    
  2. Использование ** в 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. Объединение строк, кортежей, списков, словарей без изменения исходных.
  2. Объединение множеств без изменения исходных.
  3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции.
  4. Добавление и удаление элементов изменяемых коллекций.
  5. Особенности работы с изменяемой и не изменяемой коллекцией.

1. Объединение строк, кортежей, списков, словарей без изменения исходных

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

  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)
    

  2. Для объединения списков (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]]
      

  3. UPD: Способ добавленный longclaps в комментариях:
    a, b = [1, 2, 3], [4, 5]
    c = [*a, *b]  # работает на версии питона 3.5 и выше
    print(c)      # [1, 2, 3, 4, 5]

  4. Со словарем (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 для наглядности

  1. Объединение (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'}
    

  2. Пересечение (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'}
    

  3. Разница (difference) — результат зависит от того, какое множество из какого вычитаем:
    c = a.difference(b)      # c = a - b другой способ записи дающий тот же результат
    print(c)                 # {'a'}
    c = b.difference(a)      # c = b - a другой способ записи дающий тот же результат
    print(c)                 # {'c'}
    

  4. Симметричная разница (symmetric_difference) Это своего рода операция противоположная пересечению — выбирает элементы из обеих множеств которые не пересекаются, то есть все кроме совпадающих:
    c = b.symmetric_difference(a)   
    # c = a.symmetric_difference(b)       # даст такой же результат
    c = b ^ a                             # Альтернативная форма записи симметричной разницы
    print(c)        		      # {'a', 'c'}
    

3. Объединение списка, словаря и изменяемого множества с изменением исходной коллекции

  1. Для списка
    • Добавляем все элементы второго списка к элементам первого с измением первого списка методом .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]
      
  2. Для изменения словаря с добавления элементов другого словаря используется метод .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}
    

  3. Для изменяемого множества (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 Особенности работы с изменяемой и не изменяемой коллекцией

    1. Строка неизменяемая коллекция — если мы ее меняем — мы создаем новый объект!
      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 - разные значения
      

    2. Список изменяем и тут надо быть очень внимательным, чтобы не допустить серьезную ошибку! Сравните данный пример с примером со строками выше:
      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]  
      # как мы и хотели - изменив исходный объект, его копии остались не тронутыми
      
    Приглашаю к обсуждению:

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

Python | Объединение двух списков словарей

Python, Программы Python

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

Способ № 1: Использование defaultdict и extend для объединения двух списков словарей на основе school_id .

  

from collections import defaultdict

  

Input1 = [{'roll_no': ['123445', '1212'], 'school_id': 1},

          {'roll_no': ['HA-4848231'], 'school_id': 2}]

  

Input2 = [{'roll_no': ['473427'], 'school_id': 2},

          {'roll_no': ['092112'], 'school_id': 5}]

  

  

temp = defaultdict(list

  

for elem in Input1:

    temp[elem['school_id']].extend(elem['roll_no'])

  

for elem in Input2:

    temp[elem['school_id']].extend(elem['roll_no'])

  

Output = [{"roll_no":y, "school_id":x} for x, y in temp.items()]

  

print(Output)

Выход:

[{‘school_id’: 1, ‘roll_no’: [‘123445’, ‘1212’]}, {‘school_id’: 2, ‘roll_no’: [‘HA-4848231’, ‘473427’]}, {‘school_id’: 5, ‘roll_no’: [‘092112’]}]

Способ № 2: Использование только extend() .

  

Input1 = [{'roll_no': ['123445', '1212'], 'school_id': 1},

          {'roll_no': ['HA-4848231'], 'school_id': 2}]

Input2 = [{'roll_no': ['473427'], 'school_id': 2},

          {'roll_no': ['092112'], 'school_id': 5}]

  

for elm2 in Input2:

  

    for elm1 in Input1:

        if elm2['school_id'] == elm1['school_id']:

            elm1['roll_no'].extend(elm2['roll_no'])

            break

    else:

        Input1.append(elm2)

  

print(Input1)

Выход:

[{‘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
Счетчик — это специальный подкласс словаря, который в большинстве случаев выполняет те же действия, что и словарь.

  

from collections import Counter

  

ini_dictionary1 = Counter({'nikhil': 1, 'akash' : 5,

                     'manjeet' : 10, 'akshat' : 15})

ini_dictionary2 = Counter({'akash' : 7, 'akshat' : 5,

                                          'm' : 15})

  

print ("initial 1st dictionary", str(ini_dictionary1))

print ("initial 2nd dictionary", str(ini_dictionary2))

  

final_dictionary = ini_dictionary1 + ini_dictionary2

  

print ("final dictionary", str(final_dictionary))

Выход:

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.

  

  

ini_dictionary1 = {'nikhil': 1, 'akash' : 5,

              'manjeet' : 10, 'akshat' : 15}

ini_dictionary2 = {'akash' : 7, 'akshat' : 5,

                                    'm' : 15}

  

print ("initial 1st dictionary", str(ini_dictionary1))

print ("initial 2nd dictionary", str(ini_dictionary2))

  

final_dictionary = dict(ini_dictionary1.items() + ini_dictionary2.items() +

                    [(k, ini_dictionary1[k] + ini_dictionary2[k])

                    for k in set(ini_dictionary2)

                    & set(ini_dictionary1)])

  

print ("final dictionary", str(final_dictionary))

Выход:

(‘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: Использование диктов и понимания

  

ini_dictionary1 = {'nikhil': 1, 'akash' : 5

              'manjeet' : 10, 'akshat' : 15}

ini_dictionary2 = {'akash' : 7, 'akshat' : 5

                                    'm' : 15}

  

print ("initial 1st dictionary", str(ini_dictionary1))

print ("initial 2nd dictionary", str(ini_dictionary2))

  

final_dictionary =  {x: ini_dictionary1.get(x, 0) + ini_dictionary2.get(x, 0)

                    for x in set(ini_dictionary1).union(ini_dictionary2)}

  

print ("final dictionary", str(final_dictionary))

Выход:

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

def Слияние (dict1, dict2):

возврат (dict2.update (dict1))

dict1 = { 'a' : 10 , 'b' : 8 }

dict2 = { 'd' : 6 , 'c' : 4 }

печать (объединить (dict1, dict2))

печать (dict2)

Выход:

 Нет
{'c': 4, 'a': 10, 'b': 8, 'd': 6} 

Использование ** в Python

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

Пример:

Python3

def Слияние (dict1, dict2):

res = { * * dict1, * * dict2}

возврат res

dict1 = { 'a' : 10 , 'b' : 8 }

dict2 = { 'd' : 6 , 'c' : 4 }

dict3 = Слияние (dict1, dict2)

печать (dict3)

Выход:

 {'b': 8, 'a': 10, 'c': 4, 'd': 6} 

Использование | в Python 3.9

В последнем обновлении Python теперь мы можем использовать «|» оператор для объединения двух словарей. Это очень удобный способ объединения словарей.

Пример:

.

Python | Объедините значения двух словарей с одинаковым ключом

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

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

Метод № 1: Использование счетчика
Счетчик — это специальный подкласс словаря, который в большинстве случаев выполняет действия, аналогичные словарю.

из коллекций импорт Счетчик

ini_dictionary1 = Счетчик ({ 'нихил' : 1 , 'акаш' : 5

,

'manjeet' : 10 , 'akshat' : 15 })

ini_dictionary2 = Счетчик ({ 'akash' : 7 , 'akshat' : 5

,

м : 15 })

print ( "начальный 1-й словарь" , str (ini_dictionary1))

print ( "начальный 2-й словарь" , str (ini_dictionary2))

final_dictionary = ini_dictionary1 + ini_dictionary2

печать ( "конечный словарь" , str (final_dictionary))

Выход:

начальный 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.

ini_dictionary1 = { «нихил» : 1 , «акаш» : 5

,

'manjeet' : 10 , 'akshat' : 15 }

ini_dictionary2 = { «акаш» : 7 , «акшат» : 5 ,

м : 15 }

print ( "начальный 1-й словарь" , str (ini_dictionary1))

print ( "начальный 2-й словарь" , str (ini_dictionary2))

final_dictionary = dict (ini_dictionary1.items () + ini_dictionary2.items () +

[(k, ini_dictionary1 [k] + ini_dictionary2 [k])

для k в набор (ini_dictionary2)

и набор (ini_dictionary1)])

печать ( "конечный словарь" , str (final_dictionary))

Выход:

('начальный 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 и установка

ini_dictionary1 = { «нихил» : 1 , «акаш» : 5

,

'manjeet' : 10 , 'akshat' : 15 }

ini_dictionary2 = { «акаш» : 7 , «акшат» : 5 ,

м : 15 }

print ( "начальный 1-й словарь" , str (ini_dictionary1))

print ( "начальный 2-й словарь" , str (ini_dictionary2))

final_dictionary = {x: ini_dictionary1.get (x, 0 ) + ini_dictionary2.get (x, 0 )

для x в набор (ini_dictionary1) .union (ini_dictionary2)}

печать ( "конечный словарь" , str (final_dictionary))

Выход:

начальный 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 и помогите другим гикам.

Пожалуйста, улучшите эту статью, если вы обнаружите что-то неправильное, нажав кнопку «Улучшить статью» ниже.

Теги статей:

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *