Python Language
Побитовые операторы
Поиск…
Вступление
Побитовые операции изменяют двоичные строки на уровне бит. Эти операции невероятно просты и напрямую поддерживаются процессором. Эти несколько операций необходимы при работе с драйверами устройств, низкоуровневой графикой, криптографией и сетевыми коммуникациями. В этом разделе приведены полезные сведения и примеры побитовых операторов Python.
Синтаксис
x << y # Побитовый сдвиг влево
x >> y # Побитовый правый сдвиг
x & y # Побитовое И
x | y # Побитовое ИЛИ
~ x # Побитовое NOT
x ^ y # Побитовое XOR
Побитовое И
Оператор & будет выполнять двоичный код AND , где бит копируется, если он существует в обоих операндах. Это означает:
# 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
