Побитовое И
&
Оператор выполнит двоичный И, где бит копируется , если она существует в обоих операндов. Это означает:
# 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