Битовые операторы
Язык Python поддерживает работу с двоичными разрядами (битами) целочисленных величин, где каждый бит числа рассматривается в отдельности. Для обеспечения этого в Python используются так называемые битовые или поразрядные операторы, которые реализуют общеизвестные битовые операции. Поддержка битовых операторов есть также в других языках программирования.
В битовых операторах (операциях) каждый операнд рассматривается как последовательность двоичных разрядов (бит), которые принимают значение 0 или 1 (двоичная система исчисления). Над этими разрядами можно выполнять известные операции (логическое «И», логическое «ИЛИ» и т.д.)
Перечень битовых операторов языка Python в порядке убывания приоритета следующий:
- ~ – битовый оператор НЕТ (инверсия, наивысший приоритет);
- , >> – операторы сдвига влево или сдвига вправо на заданное количество бит;
- & – битовый оператор И (AND);
- ^ – битовое исключающее ИЛИ (XOR);
- | – битовый оператор ИЛИ (OR).
2. Битовый оператор ~ (инверсия). Пример
В битовом операторе (операции) ~ инверсия значение любого бита числа изменяется на противоположное. Значение бита 0 устанавливается в 1, а значение 1 устанавливается в 0. То есть, положительное число становится отрицательным со смещением -1. Также отрицательное число становится положительным со смещением на -1.
# Битовый оператор ~ НЕТ - инверсия a = 0b1001 # a = 9 в десятичной системе b = ~a # b = -10 - десятичная система c = bin(b) # c = -0b1010 - двоичная система a = -0b1001 # a = -9 в десятичной системе b = ~a # b = 8 - десятичная система c = bin(b) # c = 0b1000 - двоичная система a = 0b1111 # a = 15 b = ~a # b = -16 c = bin(b) # c = -0b10000 a = -0b1111 # a = -15 b = ~a # b = 14 c = bin(b) # c = 0b1110
3. Операторы сдвига влево > . Пример
Операторы сдвига влево и сдвига вправо >> сдвигают каждый бит на одну или несколько позиций влево или вправо. Общая форма операторов следующая
где op1 , op2 – операнды. Операндом может быть число, переменная целочисленного типа или выражение, возвращающее целочисленный результат.
На рисунке 1 продемонстрирована работа операторов сдвига влево и сдвига вправо >> . При вычислении значения y , значение x сдвигается на 1 позицию влево (случай а) или вправо (случай b). Соответственно результат y множится на 2 или разделится на 2.
Рисунок 1. Работа операций: а) сдвига влево (умножение на 2); b) сдвига вправо >> (целочисленное деление на 2)
Если нужно помножить число на 16, то нужно сдвинуть это число на 4 бита влево. Если нужно разделить число на 8, то нужно сдвинуть это число на 3 бита вправо. Скорость выполнения операций сдвига выше в сравнении с операциями умножения и деления на числа кратные 2 в степени N ( N – количество сдвинутых бит).
# Операции сдвига влево > x = 5 # сдвиг влево на 3 знака, умножение на 2**3 = 8 y = x # y = x*2**3 = 40 print('x = ', x) print('y = x, y) x = 25 y = x >> 2 # y = 6 print('x = ', x) print('y = x>>2 = ', y) # Для отрицательных чисел x = -10 y = x # y = -20 print('x = ', x) print('y = x, y) x = -100 y = x >> 3 # y = -13 print('x = ', x) print('y = x>>3 = ', y)
Результат работы программы
x = 5 y = x x = 25 y = x>>2 = 6 x = -10 y = x x = -100 y = x>>3 = -13
4. Битовый оператор & (И, AND). Пример
Битовый оператор И (AND) есть бинарным и выполняет побитовое «И» для каждой пары битов операндов, которые размещаются слева и справа от знака оператора & . Общая форма оператора следующая
где op1 , op2 – операнды. Операндами могут быть числа, переменные целочисленного типа или выражения, которые возвращают целочисленный результат.
Каждый целочисленный операнд рассматривается как набор бит, над любым из которых выполняется побитовая операция «И».
На рисунке 2 показана работа битовой операции «И».
Рисунок 2. Битовый оператор & «И»
Как видно из рисунка, бит в позиции 0 первого операнда ( x ) вычисляется с битом в позиции 0 второго операнда ( y ), соответственно бит в позиции 1 первого операнда ( x ) вычисляется с битом в позиции 1 второго операнда ( y ) и т.д. При таких вычислениях результирующее значение любого бита определяется по следующим формулам:
0 & 0 = 0 0 & 1 = 0 1 & 0 = 0 1 & 1 = 1
# Битовая операция & (И, AND) x = 37 y = 58 z = x & y # z = 32 print('x = ', x) print('y = ', y) print('z = ', z)
Результат работы программы
5. Битовый оператор ^ (исключающее ИЛИ, XOR). Пример
Битовый оператор исключительное ИЛИ обозначается символом ^ и выполняет операцию сложения по модулю 2 для любого бита операндов. Общая форма оператора следующая
где op1 , op2 – целочисленные операнды.
Оператор исключающего ИЛИ (XOR) оперирует двоичными разрядами. Каждый операнд рассматривается как последовательность бит. Результат побитового исключающего ИЛИ определяется по следующим формулам
0 ^ 0 = 0 0 ^ 1 = 1 1 ^ 0 = 1 1 ^ 1 = 0
На рисунке 3 отображен пример битового исключающего ИЛИ для двух операндов.
Рисунок 3. Битовый оператор «исключающее ИЛИ»
# Битовый оператор - исключающее ИЛИ (XOR) x = 37 y = 58 z = x ^ y # z = 31 print('x = ', x) print('y = ', y) print('z = ', z)
Результат работы программы
6. Битовый оператор | ИЛИ (OR). Пример
Битовый оператор ИЛИ (OR) есть бинарным и обозначается символом | . Оператор реализует побитовое логическое сложение по образцу операторов & и ^ (см. п.п. 4, 5).
Общая форма битового оператора | следующая
где op1 , op2 – операнды, которые могут быть переменными или числами целого типа.
Для двух операндов op1 , op2 битовое ИЛИ выполняется в соответствии со следующими правилами
0 | 0 = 0 0 | 1 = 1 1 | 0 = 1 1 | 1 = 1
На рисунке 4 продемонстрирована работа битового оператора ИЛИ на примере двух произвольных операндов
Рисунок 4. Битовый оператор ИЛИ
# Битовое ИЛИ (OR) x = 37 y = 58 z = x | y # z = 63 print('x = ', x) print('y = ', y) print('z = ', z)
Результат работы программы
7. Примеры использования битовых операторов
Пример 1. Вытянуть из числа 4,5,6 биты и определить их целочисленное значение.
# Вытянуть 4,5,6 биты целого числа # ввести целое число number = int(input('Input number: ')) # фильтр на 4,5,6 биты number &= 0b1110000 # сдвинуть на 4 разряда вправо number >>= 4 print('number = ', number)
Результат работы программы
Input number: 95 number = 5
Пример 2. Умножить значения двух чисел. В первом числе взять биты, которые размещенные в позициях 0-5. Во втором числе взять биты, которые размещены в позициях 0-7.
# Умножить 0-5 биты первого числа на 0-7 биты второго числа # ввести целые числа x = int(input('x = ')) y = int(input('y = ')) # фильтр на 0-5 биты x &= 0b11111 # фильтр на 0-7 биты y &= 0b1111111 # умножить z = x*y print('x = ', x) print('y = ', y) print('z = ', z)
Результат работы программы
x = 234234253 y = 322797987 x = 13 y = 35 z = 455
Связанные темы
Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы
Чтобы посмотреть его битовое (двоичное) представление, можно воспользоваться функцией bin():
На выходе будет строка с битами этого десятичного числа. А теперь выполним инверсию его бит. Для этого в Python используется оператор ~ (тильда), которая записывается перед числом или переменной:
В результате переменная b стала отрицательной и принимает значение -122. Почему значение стало отрицательным и уменьшилось на -1? Смотрите, любое число кодируется набором бит. В Python – это довольно длинная последовательность:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 … 0 0 0 0 0 0 0 0
Самый старший бит отвечает за знак числа: 0 – положительное; 1 – отрицательное. Так вот, если взять десятичное число 0:
и инвертировать все его биты:
то мы получим число, состоящее из всех битовых единиц, а это есть не что иное, как десятичное значение -1. Мы здесь наглядно видим, как операция отрицания превращает число 0 в отрицательное и уменьшает его на -1. Так происходит со всеми целыми положительными числами:
За счет инвертирования всех бит числа.
Битовая операция И
и реализуется через оператор & (амперсанд). Например, представим, что у нас есть два числа (две переменные):
Выполним для них битовую операцию И:
Ну хорошо, разобрались, но зачем все это надо? Смотрите, если нам нужно проверить включен ли какой-либо бит числа (то есть установлен в 1), то мы можем это сделать с помощью битовой операции И, следующим образом:
if flags & mask == mask: print("Включен 2-й бит числа") else: print("2-й бит выключен")
То есть, из-за использования операции И мы в переменной flags обнуляем все биты, кроме тех, что совпадают с включенными битами в переменной mask. Так как mask содержит только один включенный бит – второй, то именно проверку на включенность этого бита мы и делаем в данном случае.
Чтобы убедиться, что все работает, присвоим переменной flags значение 1:
и запустим программу. Теперь, видим сообщение, что 2-й бит выключен, что, в общем то, верно. Вот так, с помощью битовой операции И можно проверять включены ли определенные биты в переменных.
Также битовую операцию И используют для выключения определенных битов числа. Делается это, следующим образом:
flags = 13 mask = 5 flags = flags & ~mask
Что происходит здесь? Сначала выполняется инверсия бит маски, так как операция НЕ имеет более высокий приоритет, чем операция И. Получаем, что маска состоит из вот таких бит. Затем, идет операция поразрядное И, и там где в маске стоят 1 биты переменной flags не меняются, остаются прежними, а там где стоят в маске 0 – эти биты в переменной flags тоже становятся равными 0. За счет этого происходит выключение 2-го и 0-го битов переменной flags.
Кстати, последнюю строчку можно переписать и короче:
XOR в Python: что это и как использовать
XOR (исключающее ИЛИ) — это логическая операция, которая возвращает True , если число входных значений, равных True , нечетно, и False в противном случае. В Python XOR выполняется с помощью оператора ^ .
Булевы операции XOR
В случае булевых значений XOR работает следующим образом:
True ^ True возвращает False True ^ False возвращает True False ^ True возвращает True False ^ False возвращает False
print(True ^ True) # выведет False print(True ^ False) # выведет True print(False ^ True) # выведет True print(False ^ False) # выведет False
Бинарные операции XOR
XOR также можно использовать для выполнения бинарных операций над числами. В этом случае операция XOR применяется к каждому биту чисел.
Здесь число 10 представлено в двоичном виде как 1010, а число 4 как 0100. Результат операции XOR — это 1110, что равно 14 в десятичной системе.
Применения XOR
Оператор XOR имеет множество применений в программировании, включая:
Обмен значениями: с помощью XOR можно обменять значения двух переменных без использования дополнительной переменной.
a = 5 b = 10 a ^= b b ^= a a ^= b print("a:", a) # выведет "a: 10" print("b:", b) # выведет "b: 5" Нахождение уникального элемента: XOR можно использовать для нахождения уникального элемента в массиве, где все другие элементы встречаются дважды.
def find_unique(nums): unique = 0 for num in nums: unique ^= num return unique print(find_unique([1, 2, 3, 2, 1])) #3
Проверка четности: битовая операция XOR может использоваться для проверки, является ли число четным или нечетным.
def is_even(num): return num ^ 1 == num + 1 print(is_even(4)) # выведет True print(is_even(7)) # выведет False
Заключение
XOR — это мощный инструмент в Python, который имеет множество применений, начиная от выполнения булевых операций и заканчивая решением сложных проблем. Он предлагает эффективный и элегантный способ решения многих типов задач.
Функция abs() в Python: синтаксис и примеры использования
Введение в ООП Python: понятие, преимущества и недостатки
Использование функции id() в Python: примеры и описание
Обзор функций в Python: встроенные, пользовательские, лямбда и другие
Вложенные словари Python: примеры и методы работы
Как проверить наличие символа в строке в Python: лучшие способы