どのように混ざり合の辞書に単。

https://stackoverflow.com/questions/38987

09-06-2019
|

質問

私はPythonの辞書を書きたい単一の表現を返しますこれら二つの辞書が合併。の update() 方法である私が、必要な場合に返され、その結果ではなく改変、辞書名またを設定できる。

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = x.update(y)
>>> print(z)
None
>>> x
{'a': 1, 'b': 10, 'c': 11}

方法を教えてください最終的に統合辞に z, ない x?

（エキストラ-クリア後一勝紛争の取り扱い dict.update() は何かを探しているものといたします。

解決

たいのですが混ざり合はPythonの辞書に単。

のための辞書 x や y, z なshallowly統合辞書の値から y 交換からのもの x.

Python3.5以:
```
z = {**x, **y}
```

Python2日(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)

説明

と言いてdictsび出すためのものではありませんが合併して新しい辞を変更せずに、元のdicts:

x = {'a': 1, 'b': 2}
y = {'b': 3, 'c': 4}

望みの結果は新しい辞書z の価値を合併し、第二の辞の値を上書きするからです。

>>> z
{'a': 1, 'b': 3, 'c': 4}

新しい構文のために、この提案 PEP448 やとしてのPython3.5, は、

z = {**x, **y}

では実際は単一の表現です。

ことがありますのでご了承できる統合と文字表記など

z = {**x, 'foo': 1, 'bar': 2, **y}

現在:

>>> z
{'a': 1, 'b': 3, 'foo': 1, 'bar': 2, 'c': 4}

いて実施してリリーススケジュール3.5PEP478, したことを決意（というよりリアムら新Python3.5 書きします。

しかし、多くの組織がPython2は、いいことに下位互換です。の古典的Pythonic方は、Python2は、Pythonの3.0 3.4は、このとして二段階のプロセス:

z = x.copy()
z.update(y) # which returns None since it mutates z

両方のアプローチ y は二の次、三の次で、その価値を置き換えま x'sの値は、このように 'b' ポイント 3 当社の最終結果です。

なPython3.5がしたいシングル表現

がまだの方はPython3.5、書く必要がある後方互換のコードがありますので、 シングル表現, 最performantが正しいアプローチを入れて機能：

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)

することもできる機能を統合未定義数dictsで、非常に大きな番号:

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

この機能はまた、Python2 3すべてのdicts.例えば指dicts a へ g:

z = merge_dicts(a, b, c, d, e, f, g)

キーと値のペア g まが優先するものとしますdicts a へ f, います。

批評のその他の回答

なの項目で検索条件を絞り込の受け答え:

z = dict(x.items() + y.items())

Python2を作成します二つのリストごとにメモリー辞を第一覧にメモリと同じ長さの長さの第二として捨てて表作成の辞書名またを設定した Python3に、この失敗 がんに加え 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())).この廃棄物の資源を計算す。

同様に、euの items() Python3(viewitems() Python2.7)も失敗した時の値はunhashableオブジェクト(のようなリストなど)を行います。ている場合も値をhashable, 以降、設定は意味的に順序付け、動作は未定義について優先されます。うんこ

>>> c = dict(a.items() | b.items())

こうしたことを考えると何が起きるの値unhashable:

>>> x = {'a': []}
>>> y = {'b': []}
>>> dict(x.items() | y.items())
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unhashable type: 'list'

以下に例を示しますyべてに優先すが、クライアント側に特別な設定値xを保持により任意の順序を設定:

>>> x = {'a': 2}
>>> y = {'a': 1}
>>> dict(x.items() | y.items())
{'a': 2}

他のhackで利用するべきではありません:

z = dict(x, **y)

この dict コンストラクタは、非常に高速、省メモリも少しで以上の二つのステップ)がないかを正確に何が起こるかを理解するの辞でしたキーワード引数として渡される辞書のコンストラクタで読みづらくな目的の利用ではないPythonic.

ここでの例を用いて remediatedにdjango.

Dicts的にhashableキーコード(例：frozensetsまたはタプル） この方法に失敗したPython3がキーにない文字列です。

>>> c = dict(a, **b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: keyword arguments must be strings

からメーリングリスト, るGuido van Rossum、クリエイター-オブ-ザ-イヤー語、書き:

私はフロント宣言辞({}, **{1:3}) 違法、後では虐待のの**。

や

うdict(x,**y)がって"クール-ハック"と呼 x.update(y)を返し。×個人的に思うのです。怪盗グルーのミニオン危機一発によクールです。

それが私の理解(理解を深めるとともに、クリエイター-オブ-ザ-イヤー語その利用目的のために dict(**y) が作成dicts読みやすさを目的に、例えば:

dict(a=1, b=10, c=11)

の代わりに

{'a': 1, 'b': 10, 'c': 11}

応答コメント

もうGuidoは、 dict(x, **y) はdict仕様、ね.作品の両方のPython2-3ここだけのための文字列のキーが直接の結果のキーワードパラメータの仕事ではない短期再開の辞書名またを設定したもの**オペレーターにこの場を濫用メカニズムを、実際には**を設計した正確に伝dictsといった言葉をキーワードとした

再されているとは思いませんが、仕事のために3キー非文字列です。の暗黙的な呼び出し規約では名前空間経dicts、利用者のみにパスをキーワード引数の文字列です。その他のcallables施行されます。 dict たことの一貫性Python2:

>>> 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).そのたPython3に、この利用が破れます。

また行きたいと思いますので悪意のある能力のなさを意図的に書きるコードだけショールーム:イメージの言語やることだけを与える任意の。

コメント:

dict(x.items() + y.items()) は最も読みや解決のためのPython2.読みやすさです。

回答: merge_two_dicts(x, y) 実際にそうより鮮明に見せなければならない私はまだ実際に懸念を読むなみの対応としてPython2はますます推奨されていません。

{**x, **y} いないよう取扱いを入れ子を生成する事ができます。内容の入れ子キーで上書きされな合併し[...]績で焼けによるこれらの答えない合併を再帰的に、驚きの一言です。私の解釈に"統合"これらの回答の記述"を更新一dict他"は併合.

そうです。いけていなければならないという問いに、私浅合併の 二つの 辞書の最初の値が上書きされる第二の一つの表現です。

と仮定して二つの辞書の辞書うためには以下のようなものが再帰的に統合して単一の機能がおしないように注意することを修正しdictsのいずれかからソースは、何を避けることはコピーを割り当てる際に値です。キーとして必要hashable、通常はその不変なので、そこでのファイルをコピー:

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: {}}}

ら不測の事態のためのその他の値型での範囲を超えたことがあるかどうか分かりませんが点まで私の答えは、標準のさらに細かな質問項目を設けて、"辞書辞書の統合".

少Performantが正しい広告-hocs

これらのアプローチは以下performant、それを正しい行動です。その 少ない performantよ copy や update 新開梱で繰り返し処理を実行して各key-valueペアをもとに、より高いレベルで抽象化がいを尊重し、優先順位(後dictsて優先）

またチェーンのdicts手の中に辞書の解:

{k: v for d in dicts for k, v in d.items()} # iteritems in Python 2.7

やpython2.6(しょうが早くも2.4が発表した):

dict((k, v) for d in dicts for k, v in d.items())

itertools.chain まチェーンの反復子をサーバ上にkey-value形式で格納を正しい順

import itertools
z = dict(itertools.chain(x.iteritems(), y.iteritems()))

性能解析

私のような性能分析の用途既知の行動を修正。

import timeit

以下はUbuntu14.04

Python2.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

Python3.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

資源辞書

私の説明のPythonの 辞書の実施, 更新のための3.6.
回答の追加新しいキー辞書
マッピングの後スクリプト辞書
のPythonの docsに辞書
辞書にもMightier 話によるブロードスでPycon2017
現代はPythonの辞書には、合流なアイデア話によるレイモンドHettingerでPycon2017

他のヒント

このケースではよくお使いいただくためには:

z = dict(x.items() + y.items())

このことは、たいので、最終的に辞 z, し、keyの値 b 適切にオーバーライドによる秒（y)辞の値

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = dict(x.items() + y.items())
>>> z
{'a': 1, 'c': 11, 'b': 10}

ご利用の場合はPythonの3つのみであり、もう少し複雑です。作 z:

>>> z = dict(list(x.items()) + list(y.items()))
>>> z
{'a': 1, 'c': 11, 'b': 10}

代替:

z = x.copy()
z.update(y)

さらに、簡潔に、オプション:

z = dict(x, **y)

注意:これに向けて発信されたさまざまな応答が重要であると指摘している場合 y には、文字列のキーが動作することで濫用であり、CPython実施の詳細に動作しないPython3にPyPy,IronPython、Jython.また、 Guidoではないファン.なおこの技術のみ対応のクロス-実施に携帯コードを意味することは避けます。

こうな気がほとんど確かにいい関係ではないかと思います。したい場合はコピーと合併し、その利用コピー（または deepcopy, ようい)します。二つのコードも読みやすくするために-よりPythonic以上の単線です。項目()+.項目().明示的には関数です。

また、使用します。項目()(塗Python3.0)には、新しいリストが含まれる項目から辞書名またを設定した場合の辞書の規模が大きいものと多くのオーバーヘッドを大きくリストが捨てられないとの統合辞書が作成され、作成されupdate()で作業の効率化がでのdict項によります。

面時間:

>>> timeit.Timer("dict(x, **y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.52571702003479
>>> timeit.Timer("temp = x.copy()\ntemp.update(y)", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
15.694622993469238
>>> timeit.Timer("dict(x.items() + y.items())", "x = dict(zip(range(1000), range(1000)))\ny=dict(zip(range(1000,2000), range(1000,2000)))").timeit(100000)
41.484580039978027

IMOの小さな減速と、最初はしなければなりませんが、その可読性また、キーワード引数辞書を作成しただけで追加されPython2.3では、コピー()およびupdate()また、以前のバージョン.

加後の答えは、いつの相対的なパフォーマンスのこれら二つの選択肢:

z1 = dict(x.items() + y.items())
z2 = dict(x, **y)

マに、少なくとも（常x86_64走Python2.5.2代 z2 なみの短縮やより簡単なも大きくなります。を確認することができるこのために自分の timeit モジュールが付属します。

例1:同じ辞書のマッピングは、20回連続して整数は自分には:

% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z1=dict(x.items() + y.items())'
100000 loops, best of 3: 5.67 usec per loop
% python -m timeit -s 'x=y=dict((i,i) for i in range(20))' 'z2=dict(x, **y)' 
100000 loops, best of 3: 1.53 usec per loop

z2 勝効果を明確にする必要がある3.5います。な辞書も利回りかなり異なる結果が z2 もう出ています。の場合は取得結果に同試験、通 -r 多数以上デフォルトの3.)

例2:非重複する辞書のマッピング252短い文字列に整数の逆:

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z1=dict(x.items() + y.items())'
1000 loops, best of 3: 260 usec per loop
% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z2=dict(x, **y)'               
10000 loops, best of 3: 26.9 usec per loop

z2 勝つの要因10.ことになるかで勝利する気持ちっ！

後の比較方、ちゃんと z1's"業績悪化因子であることを見いだを架構築の両項目にある私のような場合は，シミュレーションがより:

from itertools import chain
z3 = dict(chain(x.iteritems(), y.iteritems()))

数速試験など

% python -m timeit -s 'from itertools import chain; from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z3=dict(chain(x.iteritems(), y.iteritems()))'
10000 loops, best of 3: 66 usec per loop

に導いてくれると結論 z3 するよりもやや高速 z1, などの z2.レコード店ディスクユニオンの価値のすべての余分な文字を入力す

この議論はまだ何かが足りない重要なのは、性能比較ではこれらの代替案の"明"の合併リスト:を使用 update 方法。るようにしていく対等の立場を表現しないよう変更xまたはyさせていただくことになりましたのコピーをxではなく改良したもので場所：

z0 = dict(x)
z0.update(y)

代表的な結果：

% python -m timeit -s 'from htmlentitydefs import codepoint2name as x, name2codepoint as y' 'z0=dict(x); z0.update(y)'
10000 loops, best of 3: 26.9 usec per loop

つまり、 z0 や z2 が本質的に同一である。だと思うこれは偶然なのか。ない....

とんと主張できない純粋なPythonコードになります。やればできるCの拡張モジュール、そしてPythonのあるものに興味をコード(またはバリエーションアプローチ)のPythonコアです。Python用 dict 多くの場最適化事業です。

きのように記述することもできますこと

z0 = x.copy()
z0.update(y)

としてトニーは、驚くべきことではないが)の違いの表記がない測定可能なパフォーマンスへの影響.使用のいずれか、右手に見えます。もちろん、彼は絶対に正しい指摘の声版はるかに分かりやすいものになりました。

思うが、力方法を指定する値をキーが重複が合併し、不正使用のことがなかった重試験を行います。これは明らかではない単に表現で単機能電話します。

def merge(d1, d2, merge_fn=lambda x,y:y):
    """
    Merges two dictionaries, non-destructively, combining 
    values on duplicate keys as defined by the optional merge
    function.  The default behavior replaces the values in d1
    with corresponding values in d2.  (There is no other generally
    applicable merge strategy, but often you'll have homogeneous 
    types in your dicts, so specifying a merge technique can be 
    valuable.)

    Examples:

    >>> d1
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1)
    {'a': 1, 'c': 3, 'b': 2}
    >>> merge(d1, d1, lambda x,y: x+y)
    {'a': 2, 'c': 6, 'b': 4}

    """
    result = dict(d1)
    for k,v in d2.iteritems():
        if k in result:
            result[k] = merge_fn(result[k], v)
        else:
            result[k] = v
    return result

Python3を使用でき ョンにします。ChainMap る団体数dictsまたはその他のマッピングをシングル、updateableビュー：

>>> from collections import ChainMap
>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = ChainMap({}, y, x)
>>> for k, v in z.items():
        print(k, '-->', v)

a --> 1
b --> 10
c --> 11

再帰的に深宇更新dict

def deepupdate(original, update):
    """
    Recursively update a dict.
    Subdict's won't be overwritten but also updated.
    """
    for key, value in original.iteritems(): 
        if key not in update:
            update[key] = value
        elif isinstance(value, dict):
            deepupdate(value, update[key]) 
    return update

デモンストレーション

pluto_original = {
    'name': 'Pluto',
    'details': {
        'tail': True,
        'color': 'orange'
    }
}

pluto_update = {
    'name': 'Pluutoo',
    'details': {
        'color': 'blue'
    }
}

print deepupdate(pluto_original, pluto_update)

出力:

{
    'name': 'Pluutoo',
    'details': {
        'color': 'blue',
        'tail': True
    }
}

コrednaw用編集.

最版思いないものをコピーすることはできない。

from itertools import chain
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
dict(chain(x.iteritems(), y.iteritems()))

このよ dict(x.items() + y.items()) など n = copy(a); n.update(b), は、少なくともCPython.このバージョンも作品をPython3に変更された場合 iteritems() へ items(), は、自動的に行いますの2to3ツールです。

個人的には好きこのバージョンで解説いていた単一の機能的構文です。この問題ではないので完全に明らからyが優先される価値からのx、動いていくと、私は考えているんですが図れます。

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z = dict(x.items() + y.items())
print z

項目のキーの両方の辞書("b")を調整することができるという結果で終えられるように、出力をとします。

Python3.5(PEP448)が可能ですぐに書式]オプション:

x = {'a': 1, 'b': 1}
y = {'a': 2, 'c': 2}
final = {**x, **y} 
final
# {'a': 2, 'b': 1, 'c': 2}

も

final = {'a': 1, 'b': 1, **x, **y}

らの問いて回答数回このグループに参加"ボタンを問題になっています。

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
z4 = {}
z4.update(x)
z4.update(y)

では迅速z0とともに、悪z2は、上記のが理解しやすいと考えています。

def dict_merge(a, b):
  c = a.copy()
  c.update(b)
  return c

new = dict_merge(old, extras)

その日陰とは疑応答、この光のみを合併しdicts Pythonでは、承認される独裁者のための生活 Guido van Rossum ます。他の誰かが示唆され、この半分にもったいないのかたまりをビニール袋に入れます。

print dict_merge(
      {'color':'red', 'model':'Mini'},
      {'model':'Ferrari', 'owner':'Carl'})

受けとる:

{'color': 'red', 'owner': 'Carl', 'model': 'Ferrari'}

たくさんlambdas悪して対応することが可能です。るとともに、要求があればすに記述することができるメモリ効率が高いソリューション一式

x = {'a':1, 'b':2}
y = {'b':10, 'c':11}
z = (lambda a, b: (lambda a_copy: a_copy.update(b) or a_copy)(a.copy()))(x, y)
print z
{'a': 1, 'c': 11, 'b': 10}
print x
{'a': 1, 'b': 2}

示唆されるように、二つのラインまたは書き込み機能があります。

するpythonic.を使用理解:

z={i:d[i] for d in [x,y] for i in d}

>>> print z
{'a': 1, 'c': 11, 'b': 10}

にpython3、 items 方法なリストを返す, ではなく、眺望, る行為のようにセットです。この場合に必要なの設定組合から結と + 動作しません:

dict(x.items() | y.items())

のためのpython3性であるバージョン2.7、 viewitems 方法に作所 items:

dict(x.viewitems() | y.viewitems())

う表記になっていうより自然なフセットに組合運用ではなく連結(のタイトルにします。

編集：

カップルポイントをpython3.最初となっていることに注目してくだ dict(x, **y) トリックな仕事をpython3になるキー y は文字列です。

また、レイモンドHettingerのChainmap 答えかなかできる任意の数のdicts引数として、からのドキュメントもなっているように見えますが、順次見通しのリストのすべてのdicts各ルックアップ:

ルックアップの検索、配下のマッピングを順次までのキーが見られる。

ことができました場合のルックアップのお申し込み：

In [1]: from collections import ChainMap
In [2]: from string import ascii_uppercase as up, ascii_lowercase as lo; x = dict(zip(lo, up)); y = dict(zip(up, lo))
In [3]: chainmap_dict = ChainMap(y, x)
In [4]: union_dict = dict(x.items() | y.items())
In [5]: timeit for k in union_dict: union_dict[k]
100000 loops, best of 3: 2.15 µs per loop
In [6]: timeit for k in chainmap_dict: chainmap_dict[k]
10000 loops, best of 3: 27.1 µs per loop

で約一桁遅いためのルックアップ私はファンのChainmap、以下の実践の場が数多くあるルックアップ

虐待につ表現の解決のためのマシューの解答:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (lambda f=x.copy(): (f.update(y), f)[1])()
>>> z
{'a': 1, 'c': 11, 'b': 10}

おも付いていて設備も良かった表現で虐待を受け lambda バインド名をタプルにオーバーライドラムダの発現を制限します。お気軽に流石.

このままいこもちろんどんなトラブルをコピーして:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> z = (x.update(y), x)[1]
>>> z
{'a': 1, 'b': 10, 'c': 11}

簡単なソリューションitertoolsを維持する（後dictsて優先）

import itertools as it
merge = lambda *args: dict(it.chain.from_iterable(it.imap(dict.iteritems, args)))

での使用:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> merge(x, y)
{'a': 1, 'b': 10, 'c': 11}

>>> z = {'c': 3, 'd': 4}
>>> merge(x, y, z)
{'a': 1, 'b': 10, 'c': 3, 'd': 4}

二辞書

def union2(dict1, dict2):
    return dict(list(dict1.items()) + list(dict2.items()))

n 辞書

def union(*dicts):
    return dict(itertools.chain.from_iterable(dct.items() for dct in dicts))

sum なんとかなると考えています。見 https://mathieularose.com/how-not-to-flatten-a-list-of-lists-in-python/

もの"と"どちらかと言えば、良いこ浅辞書に定義されている方法ここで、実際には、深い辞書をする必要がありません。

例。

a = { 'one': { 'depth_2': True }, 'two': True }
b = { 'one': { 'extra': False } }
print dict(a.items() + b.items())

このようなこと:

{ 'one': { 'extra': False', 'depth_2': True }, 'two': True }

代わりになります:

{'two': True, 'one': {'extra': False}}

て参加していたが'depth_2"と"外"の項目の中に辞書なたがする必要がありません。

使用チェーンにも働きません:

from itertools import chain
print dict(chain(a.iteritems(), b.iteritems()))

このように表示されます:

{'two': True, 'one': {'extra': False}}

深統合するrcwesickたもの。

により作業が合併し、サンプル辞書で汎用的な機構をする必要がありません。私はこの後一度書いている方法はtrueにする必要がありません。

描画のアイデアをここで私は理解機能:

def merge(*dicts, **kv): 
      return { k:v for d in list(dicts) + [kv] for k,v in d.items() }

利用したpython3):

assert (merge({1:11,'a':'aaa'},{1:99, 'b':'bbb'},foo='bar')==\
    {1: 99, 'foo': 'bar', 'b': 'bbb', 'a': 'aaa'})

assert (merge(foo='bar')=={'foo': 'bar'})

assert (merge({1:11},{1:99},foo='bar',baz='quux')==\
    {1: 99, 'foo': 'bar', 'baz':'quux'})

assert (merge({1:11},{1:99})=={1: 99})

を使用してくださlambdaです。

問題はいソリューションの上場日は、統合辞書の値のキー"b"は10ですが、私の考え方では12.その光は、以下の

import timeit

n=100000
su = """
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
"""

def timeMerge(f,su,niter):
    print "{:4f} sec for: {:30s}".format(timeit.Timer(f,setup=su).timeit(n),f)

timeMerge("dict(x, **y)",su,n)
timeMerge("x.update(y)",su,n)
timeMerge("dict(x.items() + y.items())",su,n)
timeMerge("for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k] ",su,n)

#confirm for loop adds b entries together
x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}
for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]
print "confirm b elements are added:",x

結果:

0.049465 sec for: dict(x, **y)
0.033729 sec for: x.update(y)                   
0.150380 sec for: dict(x.items() + y.items())   
0.083120 sec for: for k in y.keys(): x[k] = k in x and x[k]+y[k] or y[k]

confirm b elements are added: {'a': 1, 'c': 11, 'b': 12}

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> x, z = dict(x), x.update(y) or x
>>> x
{'a': 1, 'b': 2}
>>> y
{'c': 11, 'b': 10}
>>> z
{'a': 1, 'c': 11, 'b': 10}

この機能は単一の辞書の読解力:

>>> x = {'a':1, 'b': 2}
>>> y = {'b':10, 'c': 11}
>>> { key: y[key] if key in y else x[key]
      for key in set(x) + set(y)
    }

私の答えはシングル表現として追加機能が必要です。

from collections import Counter
dict1 = {'a':1, 'b': 2}
dict2 = {'b':10, 'c': 11}
result = dict(Counter(dict1) + Counter(dict2))

この解決の問題です。

（Python2.7*のみがより簡単な解Python3*.)

だが嫌いではないインポートする標準ライブラリモジュール出来るようにできてい

from functools import reduce

def merge_dicts(*dicts):
    return reduce(lambda a, d: a.update(d) or a, dicts, {})

（ or a ビットの lambda が必要で dict.update で返します None 成功する)

うかい .update を返します。
ただ単純ヘルパーの機能を解決する問題:

def merge(dict1,*dicts):
    for dict2 in dicts:
        dict1.update(dict2)
    return dict1

例:

merge(dict1,dict2)
merge(dict1,dict2,dict3)
merge(dict1,dict2,dict3,dict4)
merge({},dict1,dict2)  # this one returns a new copy

用dict理解す

x = {'a':1, 'b': 2}
y = {'b':10, 'c': 11}

dc = {xi:(x[xi] if xi not in list(y.keys()) 
           else y[xi]) for xi in list(x.keys())+(list(y.keys()))}

与

>>> dc
{'a': 1, 'c': 11, 'b': 10}

注の文法 if else 内包に

{ (some_key if condition else default_key):(something_if_true if condition 
          else something_if_false) for key, value in dict_.items() }

知っていないんでの具体的な質問で"あなた"ワーライナー")が、なしの回答以上に入ったこの方向のもと、たくさんの応答に関するパフォーマンスの問題を感じまこさんの表情が変わります。

によっては利用の場合ない場合があったので、それをつくる必要がある"リアル"に統合辞書に指定された入力を生成する事ができます。A 眺望ることが十分に多くの場合、.e.オブジェクトある行為 のように 合併された辞書のような計算します。怠け者の統合の辞書のようなもの。

Pythonでは、これはかなり簡単にして行わなければならないコードを終了します。これは、回答に質問することはできない。

z = MergeDict(x, y)

この新しいオブジェクトで行動をとれるように、合併した辞書です定数作成時に、一定のメモリフットプリントを残しながら独自の辞書は変更されません。作成する方法でより安く、他のソリューションを提案します。

もちろん、ご利用の場合、結果は多く、その時点に到達限界をリアルに統合辞書いてのスピードが速くなります。しかしによって違いますので、それぞれご利用の場合.

また、あなたが好む方をしてリアルタイムに統合 dict, その呼び出し dict(z) うに製作することもできますが方よりも高価になる他のソリューションはもちろん、これも特筆).

また、このクラスを使用する種類のcopy-on-write辞書

a = { 'x': 3, 'y': 4 }
b = MergeDict(a)  # we merge just one dict
b['x'] = 5
print b  # will print {'x': 5, 'y': 4}
print a  # will print {'y': 4, 'x': 3}

このコードの MergeDict:

class MergeDict(object):
  def __init__(self, *originals):
    self.originals = ({},) + originals[::-1]  # reversed

  def __getitem__(self, key):
    for original in self.originals:
      try:
        return original[key]
      except KeyError:
        pass
    raise KeyError(key)

  def __setitem__(self, key, value):
    self.originals[0][key] = value

  def __iter__(self):
    return iter(self.keys())

  def __repr__(self):
    return '%s(%s)' % (
      self.__class__.__name__,
      ', '.join(repr(original)
          for original in reversed(self.originals)))

  def __str__(self):
    return '{%s}' % ', '.join(
        '%r: %r' % i for i in self.iteritems())

  def iteritems(self):
    found = set()
    for original in self.originals:
      for k, v in original.iteritems():
        if k not in found:
          yield k, v
          found.add(k)

  def items(self):
    return list(self.iteritems())

  def keys(self):
    return list(k for k, _ in self.iteritems())

  def values(self):
    return list(v for _, v in self.iteritems())

ライセンス： CC-BY-SA と帰属

所属していません StackOverflow