Pythonで| =（ior）は何をしますか？

Googleでは検索を許可しない|=ため、関連するドキュメントを見つけることができません。誰か知ってる？

|=オブジェクトのペア間でインプレース⁺操作を実行します。特に、次の間：

• セット：ユニオン演算
• dicts：更新操作
• カウンター：ユニオン（マルチセット）演算
• 数値：ビットごとのOR、二項演算

ほとんどの場合、それは|オペレーターに関連しています。以下の例を参照してください。

セット

たとえば、2つの割り当てられたセットの和集合は、次の同等の式s1をs2共有します。

>>> s1 = s1 | s12                                          # 1
>>> s1 |= s2                                               # 2
>>> s1.__ior__(s2)                                         # 3

ここで、の最終値s1は次のいずれかと同等です。

1. 割り当てられたOR演算
2. インプレースOR演算
3. 特別なメソッド⁺⁺によるインプレースOR演算

例

ここでは、セットに OR（|）とインプレースOR（|=）を適用します。

>>> s1 = {"a", "b", "c"}
>>> s2 = {"d", "e", "f"}

>>> # OR, | 
>>> s1 | s2
{'a', 'b', 'c', 'd', 'e', 'f'}
>>> s1                                                     # `s1` is unchanged
{'a', 'b', 'c'}

>>> # Inplace OR, |=
>>> s1 |= s2
>>> s1                                                     # `s1` is reassigned
{'a', 'b', 'c', 'd', 'e', 'f'}

辞書

Python 3.9+、新たなマージ（|）および更新（|=）演算子は、辞書間で提案されています。注：これらは上記の集合演算子と同じではありません。

2枚の割り当てられたdictsの間での操作を考慮するd1とd2：

>>> d1 = d1 | d2                                           # 1
>>> d1 |= d2                                               # 2

ここで、d1は次と同等です：

1. 割り当てられたマージ権操作
2. インプレースマージ権（更新）操作。に相当d1.update(d2)

例

ここでは、dictsにマージ（|）と更新（|=）を適用します。

>>> d1 = {"a": 0, "b": 1, "c": 2}
>>> d2 = {"c": 20, "d": 30}

>>> # Merge, | 
>>> d1 | d2
{"a": 0, "b": 1, "c": 20, "d": 30}
>>> d1 
{"a": 0, "b": 1, "c": 2}

>>> # Update, |=
>>> d1 |= d2
>>> d1 
{"a": 0, "b": 1, "c": 20, "d": 30}

カウンター

collections.Counter呼ばれる数学的なデータ構造に関連しているマルチセット（MSET）。これは基本的に、（オブジェクト、多重度）キーと値のペアのディクテーションです。

割り当てられた2つのカウンターc1との間の操作を指定c2：

>>> c1 = c1 | c2                                           # 1
>>> c1 |= c2                                               # 2

ここで、c1は次と同等です：

1. 割り当てられた共用体演算
2. インプレースユニオン操作

マルチセットの和集合には、エントリごとの最大多重度が含まれています。これは、2つのセット間または2つの通常の辞書間と同じように動作しないことに注意してください。

例

ここでは、カウンターに|ユニオン（|=）とインプレースユニオン（）を適用します。

import collections as ct


>>> c1 = ct.Counter({2: 2, 3: 3})
>>> c2 = ct.Counter({1: 1, 3: 5})

>>> # Union, |    
>>> c1 | c2
Counter({2: 2, 3: 5, 1: 1})
>>> c1
Counter({2: 2, 3: 3})

>>> # Inplace Union, |=
>>> c1 |= c2
>>> c1
Counter({2: 2, 3: 5, 1: 1})

数字

最後に、バイナリ演算を行うことができます。

2つの割り当てられた数値n1との間の操作を指定n2：

>>> n1 = n1 | n2                                           # 1
>>> n1 |= n2                                               # 2

ここで、n1は次と同等です：

1. 割り当てられたビットごとのOR演算
2. インプレースのビットごとのOR演算

例

ここでは、ビットごとのOR（|）とインプレースのビットごとのOR（|=）を数値に適用します。

>>> n1 = 0
>>> n2 = 1

>>> # Bitwise OR, |
>>> n1 | n2
1
>>> n1
0

>>> # Inplace Bitwise OR, |=
>>> n1 |= n2
>>> n1
1

レビュー

このセクションでは、ビットごとの数学について簡単に説明します。最も単純なケースでは、ビット単位のOR演算は2つのバイナリビットを比較します。1両方のビットがの場合を除いて、常に戻ります0。

>>> assert 1 == (1 | 1) == (1 | 0) == (0 | 1)
>>> assert 0 == (0 | 0)

このアイデアを2進数に拡張しました。任意の2つの整数（小数部の欠落）が与えられた場合、ビット単位のORを適用して、整数の結果を取得します。

>>> a = 10 
>>> b = 16 
>>> a | b
26

どうやって？一般に、ビット単位の演算はいくつかの「規則」に従います。

1. 同等のバイナリを内部的に比較する
2. 操作を適用する
3. 指定された型として結果を返します

これらのルールを上記の通常の整数に適用してみましょう。

（1）ここでは文字列（0bバイナリを示す）として見られるバイナリの同等のものを比較します。

>>> bin(a)
'0b1010'
>>> bin(b)
'0b10000'

（2）各列にビットごとのOR演算を適用します（0両方の場合0、そうでない場合1）：

01010
10000
-----
11010

（3）与えられた型で結果を返します。

>>> int(0b11010)
26

内部のバイナリ比較は、後者を任意の底の整数に適用できることを意味します。

>>> c = 0xa
>>> d = 0o32
>>> c | d
26

こちらもご覧ください

• メソッドをオーバーロード__ior__()して、MutableSet抽象基本クラスで反復可能オブジェクトを反復処理する例
• R.ヘッティンガーのOrderedSetレシピ（それぞれ3行目と10行目を参照）
• パイソン-アイディアのスレッドを使用する理由の|=セットを更新します
• Pythonの3ダイブのセクションB.8 Pythonの演算子の特殊な方法で

⁺ _{インプレースのビットごとのOR演算子はリテラルに適用できません。オブジェクトを名前に割り当てます。}

⁺⁺ _{特別なメソッドは、対応する演算子と同じ演算を返します。}

Pythonや他の多くのプログラミング言語で|は、ビット単位のOR演算です。|=ある|よう+=であり+、すなわち操作とasignmentの組み合わせは、。

のvar |= value略ですvar = var | value。

一般的な使用例は、2つのセットをマージすることです。

>>> a = {1,2}; a |= {3,4}; print(a)
{1, 2, 3, 4}

セットで使用すると、ユニオン演算を実行します。

これは、現在の変数と他の変数との単なるOR演算です。ビーイングT=TrueとF=False、グラフィカル出力を参照してください。

r    s    r|=s
--------------
T    T    T
T    F    T
F    T    T
F    F    F

例えば：

>>> r=True
>>> r|=False
>>> r
True
>>> r=False
>>> r|=False
>>> r
False
>>> r|=True
>>> r
True

代入の左側と右側のバイナリビットORを実行し、結果を左側の変数に格納します。

http://docs.python.org/reference/expressions.html#binary-bitwise-operations

それはビットごとです。32 |= 10画像32と10がバイナリであるとしましょう。

32 = 10 0000
10 = 00 1010

今| isまたは、ビットごとまたは2つの数値に対して

つまり、1または0-> 1、0または0-> 0です。これをチェーンで続けます

10 0000 | 00 1010 = 10 1010.

次に、バイナリを10進数に変更します（10 1010 = 42）。

| =については、既知の例を考えてみてくださいx +=5。それは意味x = x + 5,私たちが持っている場合、したがってx |= 5、それは意味しますx = x bitwiseor with 5。

ユースケースを与えるには（他の回答に時間を費やした後）：

def process(item):
   return bool(item) # imagine some sort of complex processing taking place above

def any_success(data): # return True if at least one is successful
    at_least_one = False
    for item in data:
       at_least_one |= process(item)
    return at_least_one

>>> any_success([False, False, False])
False
>>> any_success([True, False, False])
True
>>> any_success([False, True, False])
True

基本的にany短絡なし：すべてのアイテムを処理し、少なくとも1つの成功などを記録する必要がある場合に便利です。

この回答の警告も参照してください

Pythonでは、| =（ior）はユニオン演算のように機能します。たとえば、x = 5とx | = 5の場合、両方の値が最初にバイナリ値に変換され、次に結合演算が実行されて、答えが5になります。