|=개체 쌍간에 제자리 ⁺ 작업을 수행 합니다. 특히,

• 세트 : 노조 작업
• dicts : 업데이트 작업
• counters : 합집합 (다중 집합) 작업
• 숫자 : 비트 OR , 이진 연산

대부분의 경우 |운영자 와 관련이 있습니다. 아래 예를 참조하십시오.

세트

예를 들어, 두 개의 할당 된 세트의 노조 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 이상 에서는 사전 사이에 새로운 병합 ( |) 및 업데이트 ( |=) 연산자가 제안됩니다. 참고 : 이들은 위에서 언급 한 집합 연산자와 동일하지 않습니다.

두 개의 할당 된 딕셔너리 d1와 d2:

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

다음을 d1통해 동등합니다.

1. 지정된 병합 권한 작업
2. 적절한 병합 권한 (업데이트) 작업 에 상응d1.update(d2)

예

여기서 우리는 dicts에 merge ( |) 및 update ( |=)를 적용합니다 .

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

카운터

이는 다중 집합 (mset) collections.Counter이라고하는 수학적 데이터 구조와 관련이 있습니다. 기본적으로 (객체, 다중도) 키-값 쌍의 사전입니다.

두 개의 할당 된 카운터 사이에 주어진 연산 c1과 c2:

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

다음을 c1통해 동등합니다.

1. 할당 된 노동 조합
2. 인플레 이스 노조 작업

다중 집합 의 합집합 에는 항목 당 최대 다중도 가 포함됩니다. 이것은 두 세트 사이 또는 두 일반 dict 사이에서와 같은 방식으로 작동하지 않습니다.

예

여기서 우리는 counters에 union ( |)과 in-place union ( |=)을 적용합니다 .

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

번호

마지막으로 이진 수학을 할 수 있습니다.

두 개의 할당 된 번호 사이에 주어진 연산 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 연산은 두 이진 비트를 비교합니다. 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) 각 열에 비트 OR 연산을 적용합니다 ( 0둘 다 0, else 인 경우 1).

01010
10000
-----
11010

(3) 주어진 유형 (예 : 10 진수, 10 진수)으로 결과를 반환합니다.

>>> int(0b11010)
26

내부 이진 비교는 우리가 16 진수와 8 진수와 같은 모든 밑의 정수에 후자를 적용 할 수 있음을 의미합니다.

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

또한보십시오

• 메서드 를 오버로드하여__ior__()MutableSet 추상 기본 클래스 에서 반복 가능 항목을 반복 하는 예
• R. Hettinger의 OrderedSet 레시피 (각각 3 행과 10 행 참조)
• 파이썬 아이디어에 스레드 사용하는 이유에 |=세트를 업데이트
• 파이썬 3에서 다이빙의 섹션 B.8 파이썬 사업자의 특별한 방법에 대한

⁺ _{내부 비트 OR 연산자는 리터럴에 적용 할 수 없습니다. 이름에 개체를 할당합니다.}

⁺⁺ _{특수 메서드는 해당 연산자와 동일한 작업을 반환합니다.}

답변

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

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

32 = 10 0000
10 = 00 1010

10 0000 | 00 1010 = 10 1010.

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