Несмотря на то, что Python не считается подходящим языком для низкоуровневого программирования, инструменты для этого у него всё же есть. Один из таких инструментов — побитовые (или битовые) операторы.
Побитовые операторы в Python предназначены для изменения строк с двоичным кодом, что может понадобиться для работы с криптографическими алгоритмами, драйверами различных устройств или, например, с сетевой инфраструктурой. Также они могут пригодиться для изменения графики низкого уровня и для любых других задач, где требуется выполнять различные действия с двоичным кодом.
Результатом действия побитовых операторов в Python является изменение объекта на уровне битов путем нескольких типов логических операций с двоичным кодом. Эти операции мы и рассмотрим в данной статье.
Поскольку мы будем работать с двоичным кодом, причем преимущественно с целыми числами, давайте сначала научимся выводить эти числа в нужном нам виде. Это делается очень просто:
>>> bin(5)
'0b101'
Вот мы и получили бинарное представление числа 5. Впрочем, совсем ли бинарное? На самом деле 5 здесь — это последние три цифры (101), а код 0b используется в Python для вывода чисел в бинарном виде (есть и -0b для отрицательных значений). Теперь мы можем вывести любое число в двоичном коде, а вот так будет выглядеть ноль и первая десятка:
>>> bin(0)
0b0
>>> bin(1)
0b1
>>> bin(2)
0b10
>>> bin(3)
0b11
>>> bin(4)
0b100
>>> bin(5)
0b101
>>> bin(6)
0b110
>>> bin(7)
0b111
>>> bin(8)
0b1000
>>> bin(9)
0b1001
>>> bin(10)
0b1010
Из этого ряда понятен принцип битового представления чисел: единицы последовательно заменяют нули, а когда все значения достигают 1, добавляется новый разряд. Досчитаем до 15:
>>> bin(11)
0b1011
>>> bin(12)
0b1100
>>> bin(13)
0b1101
>>> bin(14)
0b1110
>>> bin(15)
0b1111
Четвертый разряд исчерпан (заполнен единицами), поэтому далее в дело вступает пятый, и числа 16 и 17 будут записаны уже так:
>>> bin(16)
0b10000
>>> bin(17)
0b10001
Таким образом, двоичный код организован строго по законам математики: три разряда битов будет у чисел от 4 до 7, четвертый добавляется для чисел от 8 до 15, пять разрядов будет у чисел с 16 до 31, шесть — с 32 до 63, семь — с 64 до 127 и т. д. То есть новый разряд добавляется при очередном умножении на два. Это полезно знать при сравнении операндов с разной разрядностью: в этом случае у операнда с меньшим числом разрядов можно добавить соответствующее число нулей сразу после 0b.
Теперь мы готовы оперировать битами, используя логику следующих инструментов:
Логика работы: при сравнении двух бит (в одном и том же разряде) &
выдает 1 (то есть бит будет скопирован), если бит есть в обоих сравниваемых операндах, и 0, если это условие не выполняется (то есть бит отсутствует хотя бы в одном из операндов). Схематически работу &
можно представить так:
1&1=1
1&0=0
0&1=0
0&0=0
Это самое жесткое условие, когда бит возвращается (выдается 1) только в случае, если он был в обоих операндах. Теперь примеры:
>>> 3 & 6
2
Потому что:
3 = 0b011
6 = 0b110
2 = 0b010
Добавляем тройке третий разряд для удобства представления и видим, что только средние биты присутствуют у обоих значений (по 1 в каждом числе), поэтому возвращается такое число: 0b010, а это 2.
>>> 24 & 62
24
Потому что:
24 = 0b011000
62 = 0b111110
24 = 0b011000
Интересный результат, который получился потому, что совпадающие биты оказались ровно на тех же позициях, что и в представлении первого числа.
>>> 555 & 878
554
555 = 0b1000101011
878 = 0b1101101110
554 = 0b1000101010
А теперь примеры посложнее, попрактикуемся с числами с разным количеством разрядов:
>>> 80 & 755
80
80 = 0b0001010000
755 = 0b1011110011
80 = 0b0001010000
>>> 446 & 19
18
446 = 0b110111110
19 = 0b000010011
18 = 0b000010010
>>> 101 & 883
97
101 = 0b0001100101
883 = 0b1101110011
97 = 0b0001100001
cloud
Логика работы: при сравнении двух бит |
выдает 1 (бит будет скопирован), если бит есть хотя бы в одном из сравниваемых операндах, и 0, если он отсутствует в обоих. Схематически работу |
можно представить так:
1|1=1
1|0=1
0|1=1
0|0=0
Таким образом, бит будет возвращен во всех случаях, кроме одного: когда в обоих сравниваемых операндах нули. Примеры:
>>> 9 | 5
13
9 = 0b1001
5 = 0b0101
13 = 0b1101
Бит не копируется только во втором разряде (справа), поскольку там нули у обоих операндов, в результате возвращается 13.
>>> 87 | 59
127
87 = 0b1010111
59 = 0b0111011
127 = 0b1111111
>>> 846 | 657
991
846 = 0b1101001110
657 = 0b1010010001
991 = 0b1111011111
И задачи посложнее, с уже знакомыми цифрами, но совершенно иными результатами:
>>> 80 | 755
755
80 = 0b0001010000
755 = 0b1011110011
755 = 0b1011110011
>>> 446 | 19
447
446 = 0b110111110
19 = 0b000010011
447 = 0b110111111
>>> 101 | 883
887
101 = 0b0001100101
883 = 0b1101110011
887 = 0b1101110111
Логика работы: при сравнении двух бит ^
выдает 1 (бит будет скопирован), если сравниваемые операнды различаются, и 0, если они одинаковы. Схематически работу ^
можно представить так:
1^1=0
1^0=1
0^1=1
0^0=0
Как видим, оператору XOR
неважно, сравниваются две единицы или два нуля: в обоих случаях бит возвращен не будет: бит возвращается только при сравнении разных значений. Примеры:
>>> 5 ^ 2
7
5 = 0b0101
2 = 0b0010
7 = 0b0111
Во всех разрядах, кроме крайнего левого, операнды не совпали, поэтому в этих случаях были возвращены биты, то есть интерпретатор выдал единицы.
>>> 90 ^ 92
6
90 = 0b1011010
92 = 0b1011100
6 = 0b0000110
>>> 352 ^ 686
974
352 = 0b0101100000
686 = 0b1010101110
974 = 0b1111001110
Несколько примеров с операндами с разным количеством разрядов:
>>> 80 | 755
675
80 = 0b0001010000
755 = 0b1011110011
675 = 0b1010100011
>>> 446 | 19
429
446 = 0b110111110
19 = 0b000010011
429 = 0b110101101
>>> 101 | 883
790
101 = 0b0001100101
883 = 0b1101110011
790 = 0b1100010110
~
не сравнивает значения, а переворачивает биты в целочисленных значениях. При этом учтите, что положительные числа будут преобразованы в отрицательные со сдвигом на единицу, и наоборот. Работает это так:
>>> ~0
-1
>>> ~30
-31
>>> ~-30
29
>>> ~80
-81
>>> ~-80
79
>>> ~255
-256
>>> ~-255
254
Левый сдвиг обозначается символами <<
, при этом слева пишется изменяемое число, а справа от оператора указывается количество бит, на которое выполняется сдвиг.
>>> 1 << 1
2
Сдвинули 1 на 1 бит и получили 2, потому что:
1 = 0b01
2 = 0b10
то есть, единица переместилась на одну позицию влево. А если переместить на две?
>>> 1 << 2
4
Да, получается 4, так как:
1 = 0b001
4 = 0b100
Нетрудно догадаться, что даст сдвиг единицы на 3 позиции:
>>> 1 << 3
8
1 = 0b0001
8 = 0b1000
Вот еще пара примеров с раскладкой по битам:
>>> 10 << 1
20
10 = 0b01010
20 = 0b10100
>>> 10 << 2
40
10 = 0b001010
40 = 0b101000
Правый сдвиг обозначается символами >>
, и точно так же слева пишется изменяемое число, а справа от оператора указывается количество бит, на которое выполняется сдвиг. Это обратная операция, поэтому:
>>> 2 >> 1
1
>>> 4 >> 2
1
>>> 8 >> 3
1
>>> 40 >> 1
20
>>> 40 >> 2
10
Подготовили для вас выгодные тарифы на облачные серверы
&
и |
поможет вам лучше понять принцип работы операторов and
и or
в Python и то, как работают любые другие программы, где используется Булева логика, основанная на значениях True (1) и False (0).