What does the "|=" operator in Python mean?

Just as the += operator increments the value of a variable, something like x +=y is equivalent to x = x + y , the |= operator runs the or binary between the current value and the other parameter, something like x |= y is equivalent to x = x | y .

The or binary is nothing more than the operation or executed bit by bit. For example, let's take two positive integers:

x = 5
y = 13

We can check the binary representation of each value through the native function bin .

print(bin(x), bin(y)) # 0b101 0b1101

That can be expanded to 8 bits for 00000101 and 00001101 . O or binary will do the operation or bit by bit, returning 1 when at least 1 of the operands is 1 or 0 when both are 0.

00000101 | 00001101 = 00001101

Note that the result, in this example, will be the same as the second operand, so doing 5 | 13 results in 13. Thus:

x |= y
print(x) # 13

  

See working at Ideone .

Application

One of the most common applications of this operator is to define flags used in the configurations of some system. Flags are commonly Boolean values, which can only receive values of 0 or 1. Using the boolean type, it is common for compilers and interpreters to allocate more than just 1 bit for such a type, even if it actually occupies , a single bit. To work around this, you can store all the flags into another variable type, using the | operator. Considering that the type char is represented by 8 bits, which is the default in C, it would be possible to store 8 different flags in a char . With Python, because it's dynamic typing, this ends up getting a bit abstract, but the philosophy behind it ends up being the same.

Let's look at an example with code:

Let's consider that our application has 8 different configuration options. For simplicity, I'll give generic names from A to H:

CONFIG_A = 1     # bin: 0b00000001
CONFIG_B = 2     # bin: 0b00000010
CONFIG_C = 4     # bin: 0b00000100
CONFIG_D = 8     # bin: 0b00001000
CONFIG_E = 16    # bin: 0b00010000
CONFIG_F = 32    # bin: 0b00100000
CONFIG_G = 64    # bin: 0b01000000
CONFIG_H = 128   # bin: 0b10000000

Notice that with these given integer values, each configuration will represent only one bit in the binary representation. This will allow that if our configuration has the 0b00000101 value, it means that the CONFIG_A and CONFIG_C settings have been set. This setting can be done through the | operator:

config = CONFIG_A | CONFIG_C  # bin: 0b00000101

  

See working at Ideone .

In the code, to check if a given configuration has been defined, simply use the inverse operation & (and bit by bit). For example:

def foo(config):
    if (config & CONFIG_A): print("Configuração A foi definida")
    if (config & CONFIG_B): print("Configuração B foi definida")
    if (config & CONFIG_C): print("Configuração C foi definida")
    if (config & CONFIG_D): print("Configuração D foi definida")
    if (config & CONFIG_E): print("Configuração E foi definida")
    if (config & CONFIG_F): print("Configuração F foi definida")
    if (config & CONFIG_G): print("Configuração G foi definida")
    if (config & CONFIG_H): print("Configuração H foi definida")
    print(" -- + --")

Testing the function:

foo(CONFIG_A)
foo(CONFIG_B | CONFIG_D)
foo(CONFIG_H | CONFIG_E | CONFIG_F)

The output will be:

Configuração A foi definida
 -- + --
Configuração B foi definida
Configuração D foi definida
 -- + --
Configuração E foi definida
Configuração F foi definida
Configuração H foi definida
 -- + --

  

See working at Ideone .

For integers, it is the bitwise or OR compound assignment operator. Like all composite assignment operators, a | = b is the same as a = a | b . Where | is the symbol of OR bit by bit.

  

| = Bitwise inclusive OR    link

     

| = (bitwise OR assignment) Performs bitwise OR and assigns value to   the left operand.    link

My understanding after searching ... The |= will assign the value after executing a OR between two variables, but bit by bit.

For example:

   0101 (decimal 5)
OR 0011 (decimal 3)
 = 0111 (decimal 7)

Another example:

a |= 10 //Supondo que a vale 12.

   1100 (decimal 12)
OR 1010 (decimal 10)
 = 1110 (decimal 14)

//Dessa forma a será igual a 14.

Take a look at this link I took it as a base. It's the same question as yours with plenty of examples and use case: link