Wat doet | = (ior) doen in Python?

Google laat me niet zoeken |=Dus ik heb problemen met het vinden van relevante documentatie. Iedereen weet het?

Antwoord 1, Autoriteit 100%

|=Voert een In-place ^{+ bediening tussen paren objecten. In het bijzonder, tussen:}

• sets : een Union bediening
• Dictten : een update bediening
• tellers : a Unie (van Multisets) Bediening
• nummers : a bitwise of , binaire bediening

In de meeste gevallen is het gerelateerd aan de |operator. Zie hieronder voorbeelden.

sets

Bijvoorbeeld, de Unie van twee toegewezen sets s1en s2Deel de volgende gelijkwaardige uitdrukkingen:

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

waar de uiteindelijke waarde van s1gelijkwaardig is door:

1. een toegewezen of bediening
2. een in-place of bewerking
3. een in-place of bewerking via speciale methode ⁺⁺

Voorbeeld

Hier passen we toe of (|) en de in-place of (|=) naar sets :

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

Woordenboeken

in python 3,9+ , nieuw Samenvoegen (|) en update (|=) Operators worden voorgesteld tussen woordenboeken. Opmerking: deze zijn niet hetzelfde als ingestelde operators die hierboven zijn genoemd.

Gegeven bewerkingen tussen twee toegewezen DICKS d1EN d2:

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

Waar d1equivalent is via:

1. een toegewezen samenvoegbare werking
2. een in-place-merge-rechts (update) bediening; gelijk aan d1.update(d2)

Voorbeeld

Hier passen we samenvoegen (|) en update (|=) naar 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}

Tellers

De collections.Counteris gerelateerd aan een wiskundige datastructuur genaamd een multiset(mset). Het is in feite een dictaat van (object, multipliciteit) sleutel-waardeparen.

Gegeven bewerkingen tussen twee toegewezen tellers c1en c2:

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

waar c1equivalent is via:

1. een toegewezen vakbondsoperatie
2. een interne vakbondsoperatie

Een vereniging van multisetsbevat de maximale veelvouden per item. Let op, dit werkt niet op dezelfde manier als tussen twee sets of tussen twee gewone dictees.

Voorbeeld

Hier passen we unie (|) en de in-place unie (|=) toe op Tellers:

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

Cijfers

Ten slotte kun je binaire wiskunde doen.

Gegeven bewerkingen tussen twee toegewezen nummers n1en n2:

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

waar n1equivalent is via:

1. een toegewezen bitsgewijze OF-bewerking
2. een interne bitsgewijze OF-bewerking

Voorbeeld

Hier passen we bitsgewijze OR (|) en de in-place bitsgewijze OR (|=) toe op getallen:

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

Recensie

In dit gedeelte wordt kort wat bitsgewijze wiskunde besproken. In het eenvoudigste geval vergelijkt de bitsgewijze OF-bewerking twee binaire bits. Het zal altijd 1retourneren, behalve wanneer beide bits 0zijn.

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

We breiden dit idee nu verder uit dan binaire getallen. Gegeven twee willekeurige gehele getallen (zonder fractionele componenten), passen we de bitsgewijze OR toe en krijgen een integraal resultaat:

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

Hoe? Over het algemeen volgen de bitsgewijze bewerkingen enkele “regels”:

1. intern binaire equivalenten vergelijken
2. pas de bewerking toe
3. retourneer het resultaat als het opgegeven type

Laten we deze regels toepassen op onze gewone gehele getallen hierboven.

(1) Vergelijk binaire equivalenten, hier gezien als strings (0bstaat voor binair):

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

(2) Pas een bitsgewijze OF-bewerking toe op elke kolom (0wanneer beide 0zijn, anders 1):

01010
10000
-----
11010

(3) Retourneert het resultaat in het opgegeven type, b.v. grondtal 10, decimaal:

>>> int(0b11010)
26

De interne binaire vergelijking betekent dat we de laatste kunnen toepassen op gehele getallen in elke basis, b.v. hex en octaal:

>>> c = 0xa                                            # 10
>>> d = 0o20                                           # 16 
>>> c | d
26

Zie ook

• Een voorbeeld van overbelasting van de __ior__()methodeom iterables te herhalen in een MutableSetabstracte basisklasse
• R. Hettinger’s OrderedSet recept (zie respectievelijk regel 3 en 10)
• Een thread over Python-ideasover waarom om |=te gebruiken om een set bij te werken
• Een sectie B.8 van Dive in Python 3over speciale methoden van Python-operators

⁺_{De in-place bitsgewijze OR-operator kan niet worden toegepast op letterlijke waarden; wijs objecten toe aan namen.}

⁺⁺_{Speciale methoden retourneren dezelfde bewerkingen als de bijbehorende operators.}

Antwoord 2, autoriteit 96%

In Python en vele andere programmeertalen is |de bitwise- OF-bewerking. |=is voor |zoals +=is voor +, dwz een combinatie van bewerking en toewijzing.

Dus var |= valueis een afkorting voor var = var | value.

Een veelvoorkomend gebruik is het samenvoegen van twee sets:

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

Antwoord 3, autoriteit 47%

In combinatie met sets voert het een samenvoegbewerking uit.

Antwoord 4, autoriteit 39%

Dit is slechts een OF-bewerking tussen de huidige variabele en de andere. Zijnd T=Trueen F=False, zie de output grafisch:

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