Was macht | = (ior) in Python?

Google lässt mich nicht suchen, |=daher habe ich Probleme, relevante Dokumentationen zu finden. Weiß jemand Bescheid?

|=führt eine In-Place ⁺ -Operation zwischen Objektpaaren durch. Insbesondere zwischen:

• Sätze : eine Vereinigung Betrieb
• dicts : ein Update Betrieb
• Zähler : eine Vereinigung (von Multimengen ) Betrieb
• Zahlen : eine bitweise ODER- binäre Operation

In den meisten Fällen hängt es mit dem |Bediener zusammen. Siehe Beispiele unten.

Sets

Zum Beispiel die Vereinigung von zwei zugewiesenen Mengen s1und s2die folgenden äquivalenten Ausdrücke:

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

wo der Endwert von s1 entweder äquivalent ist durch:

1. eine zugewiesene ODER-Operation
2. eine In-Place-OP-Operation
3. eine In-Place-OR-Operation über eine spezielle Methode ⁺⁺

Beispiel

Hier wenden wir OR ( |) und das Inplace OR ( |=) auf Mengen an :

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

Wörterbücher

In Python 3.9+ neues Merge ( |) und Update (|= Operatoren ) zwischen Wörterbüchern vorgeschlagen. Hinweis: Dies sind nicht die gleichen wie die oben genannten Set-Operatoren.

Gegebene Operationen zwischen zwei zugewiesenen Dikten d1und d2:

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

wo d1ist äquivalent über:

1. eine zugewiesene Zusammenführungsrechtsoperation
2. eine direkte Zusammenführungsrechtsoperation (Aktualisierung); gleichwertigd1.update(d2)

Beispiel

Hier wenden wir merge ( |) und update ( |=) auf Diktate an :

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

Zähler

Das collections.Counterhängt mit einer mathematischen Datenstruktur zusammen, die als Multiset bezeichnet wird (mset) bezeichnet wird. Es ist im Grunde ein Diktat von (Objekt, Multiplizität) Schlüssel-Wert-Paaren.

Gegebene Operationen zwischen zwei zugewiesenen Zählern c1und c2:

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

wo c1ist äquivalent über:

1. eine zugewiesene Gewerkschaftsoperation
2. eine In-Place-Gewerkschaftsoperation

Eine Vereinigung von Multisets enthält die maximalen Multiplizitäten pro Eintrag. Beachten Sie, dass sich dies nicht wie zwischen zwei Sätzen oder zwischen zwei regulären Diktaten verhält.

Beispiel

Hier wenden wir union ( |) und die in-place union ( |=) auf Zähler an :

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

Zahlen

Zuletzt können Sie binäre Mathematik machen.

Gegebene Operationen zwischen zwei zugewiesenen Nummern n1und n2:

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

wo n1ist äquivalent über:

1. eine zugewiesene bitweise ODER-Verknüpfung
2. eine bitweise ODER-Verknüpfung an Ort und Stelle

Beispiel

Hier wenden wir bitweises ODER ( |) und das bitweise ODER ( |=) an Ort und Stelle auf Zahlen an :

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

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

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

Rezension

In diesem Abschnitt wird kurz auf die bitweise Mathematik eingegangen. Im einfachsten Fall vergleicht die bitweise ODER-Verknüpfung zwei Binärbits. Es wird immer zurückgegeben, 1außer wenn beide Bits sind 0.

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

Wir erweitern diese Idee nun über Binärzahlen hinaus. Bei zwei beliebigen Integralzahlen (ohne Bruchkomponenten) wenden wir das bitweise ODER an und erhalten ein Integralergebnis:

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

Wie? Im Allgemeinen folgen die bitweisen Operationen einigen "Regeln":

1. intern binäre Äquivalente vergleichen
2. Wenden Sie die Operation an
3. Geben Sie das Ergebnis als angegebenen Typ zurück

Wenden wir diese Regeln auf unsere regulären Ganzzahlen an.

(1) Vergleichen Sie binäre Äquivalente, die hier als Zeichenfolgen betrachtet werden ( 0bbezeichnet binär):

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

(2) Wenden Sie eine bitweise ODER-Verknüpfung auf jede Spalte an ( 0wenn beide 0, sonst 1):

01010
10000
-----
11010

(3) Geben Sie das Ergebnis in dem angegebenen Typ zurück, z. B. Basis 10, dezimal:

>>> int(0b11010)
26

Der interne binäre Vergleich bedeutet, dass wir letztere auf ganze Zahlen in jeder Basis anwenden können, z. B. hexadezimal und oktal:

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

Siehe auch

• Ein Beispiel für das Überladen der __ior__()Methode zum Iterieren von Iterables in einer MutableSetabstrakten Basisklasse
• R. Hettingers OrderedSet-Rezept (siehe Zeilen 3 bzw. 10)
• Ein Thread zu Python-Ideen, warum |=ein Set aktualisiert werden soll
• Ein Abschnitt B.8 von Dive in Python 3 über spezielle Methoden von Python-Operatoren

⁺ _{Der bitweise ODER-Operator an Ort und Stelle kann nicht auf Literale angewendet werden. Ordnen Sie Namen Objekte zu.}

⁺⁺ _{Spezielle Methoden geben dieselben Operationen wie die entsprechenden Operatoren zurück.}

In Python und vielen anderen Programmiersprachen |ist die bitweise ODER-Verknüpfung . |=ist zu |wie es +=ist +, dh eine Kombination aus Betrieb und Zuordnung.

Also var |= valueist kurz für var = var | value.

Ein häufiger Anwendungsfall ist das Zusammenführen von zwei Sätzen:

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

Bei Verwendung mit Sätzen wird eine Vereinigungsoperation ausgeführt.

Dies ist nur eine ODER-Verknüpfung zwischen der aktuellen Variablen und der anderen. Sein T=Trueund F=False, sehen Sie die Ausgabe grafisch:

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

Beispielsweise:

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

Es führt ein binäres bitweises ODER der linken und rechten Seite der Zuweisung durch und speichert dann das Ergebnis in der linken Variablen.

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

Es ist bitweise oder. Nehmen wir an 32 |= 10, Bild 32 und 10 sind binär.

32 = 10 0000
10 = 00 1010

Jetzt weil | ist oder, mach ein bisschen oder auf den beiden Zahlen

dh 1 oder 0 -> 1, 0 oder 0 -> 0. Setzen Sie dies entlang der Kette fort

10 0000 | 00 1010 = 10 1010.

Ändern Sie nun die Binärzahl in eine Dezimalzahl, 10 1010 = 42.

Denken Sie für | = an die bekannten Beispiele x +=5. Es bedeutet x = x + 5,also, wenn wir haben x |= 5, bedeutet es x = x bitwiseor with 5.

So geben Sie einen Anwendungsfall an (nachdem Sie Zeit mit den anderen Antworten verbracht haben):

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

Grundsätzlich anyohne Kurzschluss: Kann nützlich sein, wenn Sie jeden Artikel bearbeiten und mindestens einen Erfolg usw. aufzeichnen müssen.

Siehe auch die Vorbehalte in dieser Antwort

In Python funktioniert | = (ior) wie eine Union-Operation. Wenn x = 5 und x | = 5 sind, werden beide Werte zuerst in Binärwerte umgewandelt, dann wird die Vereinigungsoperation ausgeführt und wir erhalten die Antwort 5.