|=在对象对之间执行 就地 +操作。特别是，在：

• 集：联合操作
• dicts：更新操作
• 计数器：联合（多集）操作
• 数字：按位或，二进制运算

在大多数情况下，它与|运营商有关。请参阅下面的示例。

套

例如，两个分配集的并集s1并s2共享以下等价表达式：

>>> s1 = s1 | s2                                           # 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'}

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

字典

在Python 3.9+中，字典之间提出了新的合并 ( |) 和更新 ( ) 运算符。|=注意：这些与上面提到的集合运算符不同。

给定两个分配的 dictsd1和之间的操作d2：

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

d1等价于：

1. 分配的合并权限操作
2. 就地合并权限（更新）操作；相当于d1.update(d2)

例子

在这里，我们将 merge( |) 和 update( |=) 应用于 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）的数学数据结构有关。它基本上是（对象，多重性）键值对的字典。

给定两个分配的计数器c1和之间的操作c2：

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

c1等价于：

1. 分配的联合操作
2. 就地联合操作

多重集的并集包含每个条目的最大多重性。请注意，这与两个集合之间或两个常规字典之间的行为方式不同。

例子

在这里，我们将 union ( |) 和就地 union ( |=) 应用于 Counters ：

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})

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

数字

最后，您可以进行二进制数学运算。

给定两个分配的数字n1和之间的操作n2：

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

n1等价于：

1. 分配的按位或运算
2. 就地按位或运算

例子

在这里，我们将按位 OR ( |) 和就地按位 OR ( |=) 应用于 numbers ：

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

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

>>> # In-place Bitwise OR, |=
>>> n1 |= n2
>>> n1
1

审查

本节简要回顾一些按位数学。在最简单的情况下，按位或运算比较两个二进制位。它将始终返回1，除非两个位都是0.

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

我们现在将这个想法扩展到二进制数之外。给定任意两个整数（没有小数部分），我们应用按位 OR 并得到一个整数结果：

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

如何？一般来说，按位运算遵循一些“规则”：

1. 内部比较二进制等价物
2. 应用操作
3. 将结果作为给定类型返回

让我们将这些规则应用于上面的常规整数。

(1) 比较二进制等价物，这里视为字符串（0b表示二进制）：

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

(2) 对每一列应用按位或运算（0当两者都是0，否则1）：

01010
10000
-----
11010

(3) 返回给定类型的结果，例如以 10 为底，十进制：

>>> int(0b11010)
26

内部二进制比较意味着我们可以将后者应用于任何基数的整数，例如十六进制和八进制：

>>> a = 10                                   # 10, dec
>>> b = 0b10000                              # 16, bin
>>> c = 0xa                                  # 10, hex
>>> d = 0o20                                 # 16, oct

>>> a | b
26
>>> c | d
26

也可以看看

• 重载__ior__()方法以迭代MutableSet抽象基类中的可迭代对象的示例
• R. Hettinger 的OrderedSet 配方（分别参见第 3 行和第 10 行）
• Python-ideas上关于为什么要使用|=更新集合的线程
• Dive in Python 3的B.8 节关于 Python 运算符的特殊方法
• 就地二进制运算符回退到常规方法，请参阅 cpython 源代码（eval.c和abstract.c）。谢谢@asotille。

+就地按位或运算符不能应用于文字；将对象分配给名称。

++特殊方法返回与其对应运算符相同的操作。