Побитовые операторы Python

Автор оригинала: Robin Andrews.

Побитовые операторы и битовая манипуляция похожи на рекурсию в том смысле, что они оба являются фундаментальными для вычислений, но объем их использования будет сильно варьироваться в зависимости от вашей области. Битовые манипуляции, безусловно, важны для собеседований при приеме на работу в таких компаниях, как “большие” (Google, FB и т. Д.) и других местах, где ожидается и требуется глубокое знание основ. Это также очень важно при работе со встроенными системами и некоторыми другими областями, как показано ниже.

Применение побитовых операторов в вычислениях

• Собеседования и постоянная работа в Big Tech
• Программирование встраиваемых систем
• Алгоритмы шифрования и сжатия
• Культурное сознание в век технологий
• Низкоуровневое программирование
• Работа с графикой
• Драйверы устройств для основных операционных систем
• Сборка пакетов протокола связи

Знание побитовых операторов также важно с точки зрения культурного образования в информационную эпоху. Технология, которая использует эти процессы, окружает нас в нашей повседневной жизни, и имеет смысл иметь некоторое представление о человеческих знаниях, которые лежат в основе их существования.

Некоторые из наиболее часто используемых побитовых операторов:

• & (побитовое И)
• | (побитовое ИЛИ)
• ~ (побитовое НЕ)
• ^ (побитовое XOR)
• << (побитовый сдвиг влево)
• >> (побитовый сдвиг вправо)

Вы можете поиграть с этими операторами в оболочке Python , что является отличным способом быстро понять, как работает какая-то часть функциональности Python, или быстро проверить, что она ведет себя так, как ожидалось.

Например:

>>> 16 >> 1  # Divide by 2
8
>>> 12 << 2  # Multiply by 4
48
>>> 11 & 1   # A trick to check for even/odd
1
>>>

Эти операторы будут иметь гораздо больше смысла, если вы посмотрите на двоичное представление операндов. Ниже я привел некоторый код, который может оказаться полезным для вашего исследования. Имейте в виду, что форматирование, которое я использовал, будет работать только для положительных значений.

# A couple of useful functions
print(int('00100001', 2))  # Convert binary number in string form to decimal int
print(bin(20))  # String representation of binary number

# Python Bitwise Operator Examples
# NB the output is designed to work for positive values only!

a = 24            
b = 9             

c = a & b  # Bitwise AND
print(f"{a} & {b} = {c}")
print()
print(f"  {bin(a)[2:].zfill(8)}")
print(f"& {bin(b)[2:].zfill(8)}")
print("----------")
print(f"= {bin(c)[2:].zfill(8)}")
print()

c = a | b  # Bitwise OR
print(f"{a} | {b} = {c}")
print()
print(f"  {bin(a)[2:].zfill(8)}")
print(f"| {bin(b)[2:].zfill(8)}")
print("----------")
print(f"= {bin(c)[2:].zfill(8)}")
print()

c = a ^ b  # Bitwise XOR
print(f"{a} ^ {b} = {c}")
print()
print(f"  {bin(a)[2:].zfill(8)}")
print(f"^ {bin(b)[2:].zfill(8)}")
print("----------")
print(f"= {bin(c)[2:].zfill(8)}")
print()

b = 2
c = a >> b  # Right-shift by 2. I.e a // 4
print(f"{a} >> {b} = {c}")
print()
print(f"      {bin(a)[2:].zfill(8)}")
print(f">> {b}  {bin(b)[2:].zfill(8)}")
print("--------------")
print(f"=     {bin(c)[2:].zfill(8)}")
print()

b = 2
c = a << b  # Left-shift by 2. I.e a * 4
print(f"{a} << {b} = {c}")
print()
print(f"      {bin(a)[2:].zfill(8)}")
print(f"<< {b}  {bin(b)[2:].zfill(8)}")
print("--------------")
print(f"=     {bin(c)[2:].zfill(8)}")
print()

Основная часть кода даст следующий вывод:

24 & 9 = 8

  00011000
& 00001001
----------
= 00001000

24 | 9 = 25

  00011000
| 00001001
----------
= 00011001

24 ^ 9 = 17

  00011000
^ 00001001
----------
= 00010001

24 >> 2 = 6

      00011000
>> 2  00000010
--------------
=     00000110

24 << 2 = 96

      00011000
<< 2  00000010
--------------
=     01100000

Конечно, вы можете изменить значения a и b для выполнения различных вычислений.

Программа Python, использующая побитовые операторы

Следующая программа использует побитовые операторы Python для сбора степеней 2 это может быть использовано для представления десятичного числа, предоставленного в качестве аргумента. Посмотрите, сможете ли вы понять, как это работает, особенно побитовые операторы & и << . Добавьте операторы печати для вывода промежуточных значений, если это поможет вам увидеть, что происходит на определенном шаге.

def binary_decomp(n):
    powers = []
    i = 1
    while i <= n:
        if i & n:
            powers.append(i)
        i <<= 1
    return powers


print(binary_decomp(10))
print(binary_decomp(32))
print(binary_decomp(127))
print(binary_decomp(-24))
print(binary_decomp(0))

Выход:

[2, 8]
[32]
[1, 2, 4, 8, 16, 32, 64]
[]
[]
>>>

Теперь вы знаете о побитовых операторах Python. Надеюсь, это знание сослужит вам хорошую службу. Счастливых вычислений!

Этот контент основан на посте на мой блог на сайте compucademy.net