Введение

Примеры

Побитовое И

& Оператор выполнит двоичный И, где бит копируется , если она существует в обоих операндов. Это означает:

 # 0 & 0 = 0
# 0 & 1 = 0
# 1 & 0 = 0
# 1 & 1 = 1

# 60 = 0b111100
# 30 = 0b011110
60 & 30
# Out: 28
# 28 = 0b11100

bin(60 & 30)
# Out: 0b11100 

Побитовое ИЛИ

| Оператор выполнит двоичное «или», где бит копируется, если он существует в любом из операндов. Это означает:

 # 0 | 0 = 0
# 0 | 1 = 1 
# 1 | 0 = 1
# 1 | 1 = 1

# 60 = 0b111100 
# 30 = 0b011110
60 | 30
# Out: 62
# 62 = 0b111110

bin(60 | 30)
# Out: 0b111110 

Побитовое XOR (исключающее ИЛИ)

^ Оператор будет выполнять двоичный XOR , в котором двоичный 1 копируется тогда и только тогда , когда это значение ровно один операнд. Другой способ задания этого является то , что результат 1 только если операнды разные. Примеры включают в себя:

 # 0 ^ 0 = 0
# 0 ^ 1 = 1
# 1 ^ 0 = 1
# 1 ^ 1 = 0

# 60 = 0b111100
# 30 = 0b011110
60 ^ 30
# Out: 34
# 34 = 0b100010

bin(60 ^ 30)
# Out: 0b100010 

Побитовый сдвиг влево

<< оператор выполняет побитовое «сдвиг влево» , где значение левого операнда перемещается влево на число битов данных в правом операнде.

 # 2 = 0b10
2 << 2
# Out: 8
# 8 = 0b1000

bin(2 << 2)
# Out: 0b1000

 

Выполнение левого разрядное смещение 1 эквивалентно умножению на 2 :

 7 << 1
# Out: 14

 

Выполнение левого разрядного смещения n эквивалентно умножения на 2**n :

 3 << 4
# Out: 48 

Побитовый сдвиг вправо

>> оператор выполняет побитовое «сдвиг вправо» , где значение левого операнда перемещается вправо на число битов данных в правом операнде.

 # 8 = 0b1000
8 >> 2
# Out: 2
# 2 = 0b10

bin(8 >> 2)
# Out: 0b10

 

Выполнение правильного битового смещения 1 эквивалентно целочисленного деления на 2 :

 36 >> 1
# Out: 18

15 >> 1
# Out: 7

 

Выполнение правильного битового смещения n эквивалентно целочисленное деление на 2**n :

 48 >> 4
# Out: 3

59 >> 3
# Out: 7 

Побитовое НЕ

~ Оператор переворачивает все биты числа. Поскольку компьютеры используют прямой код - прежде всего, в дополнении до двух обозначений для кодирования отрицательных двоичных чисел , где отрицательные числа записываются с ведущим один (1) вместо ведущего нуля (0).

Это означает , что если вы используете 8 бит для представления номера вашего дополнительного кода комплемента, вы бы относиться к модели от 0000 0000 до 0111 1111 для представления чисел от 0 до 127 и резервного 1xxx xxxx для представления отрицательных чисел.

Восьмиразрядные числа с двумя дополнительными числами

Биты  Значение без знака  Значение двух дополнений  0000 0000  0  0  0000 0001  1  1  0000 0010  2  2  0111 1110  126  126  0111 1111  127  127  1000 0000  128  -128  1000 0001  129  -127  1000 0010  130  -126  1111 1110  254  -2   1111 1111  255  -1

По существу, это означает , что в то время как 1010 0110 имеет беззнаковое значение 166 (прибыл в путем добавления (128 * 1) + (64 * 0) + (32 * 1) + (16 * 0) + (8 * 0) + (4 * 1) + (2 * 1) + (1 * 0) ), оно имеет значение дополнительного код дополнение -90 (прибыли в добавлении (128 * 1) - (64 * 0) - (32 * 1) - (16 * 0) - (8 * 0) - (4 * 1) - (2 * 1) - (1 * 0) , и дополняя значение).

Таким образом, отрицательные числа в диапазоне до -128 ( 1000 0000 ). Ноль (0) представляется в виде 0000 0000 , и минус один (-1) , как 1111 1111 .

В целом, однако, это означает , ~n = -n - 1 .

 # 0 = 0b0000 0000
~0
# Out: -1
# -1 = 0b1111 1111

# 1 = 0b0000 0001
~1
# Out: -2
# -2 = 1111 1110

# 2 = 0b0000 0010
~2
# Out: -3
# -3 = 0b1111 1101

# 123 = 0b0111 1011
~123
# Out: -124
# -124 = 0b1000 0100

 

Обратите внимание, что общий эффект этой операции при нанесении на положительные числа можно суммировать:

~n -> -|n+1|

И затем, применительно к отрицательным числам, соответствующий эффект:

~-n -> |n-1|

Следующие примеры иллюстрируют это последнее правило ...

 # -0 = 0b0000 0000
~-0
# Out: -1 
# -1 = 0b1111 1111
# 0 is the obvious exception to this rule, as -0 == 0 always

# -1 = 0b1000 0001
~-1
# Out: 0
# 0 = 0b0000 0000

# -2 = 0b1111 1110
~-2
# Out: 1
# 1 = 0b0000 0001

# -123 = 0b1111 1011
~-123
# Out: 122
# 122 = 0b0111 1010


 

Операции на месте

Все операторы Побитового (кроме ~ ) имеет свои собственные места версии

a = 0b001
a &= 0b010 
# a = 0b000

a = 0b001
a |= 0b010 
# a = 0b011

a = 0b001
a <<= 2 
# a = 0b100

a = 0b100
a >>= 2 
# a = 0b001

a = 0b101
a ^= 0b011 
# a = 0b110

Синтаксис

Параметры

Примечания