Bitwise Operations in Python

Python Bitwise Operators

Python supports the same six bitwise operators as most languages: & (AND), | (OR), ^ (XOR), ~ (NOT), << (left shift), and >> (right shift). They work on any int — and in Python, int has arbitrary precision, so there is no overflow or truncation to worry about.

# Basic bitwise operations in Python
a = 0b1101  # 13
b = 0b1011  # 11

print(f"{a & b:04b}")   # 1001 (9)
print(f"{a | b:04b}")   # 1111 (15)
print(f"{a ^ b:04b}")   # 0110 (6)
print(f"{~a & 0xF:04b}") # 0010 (2) — mask to 4 bits

# Left shift — no overflow
print(1 << 100)  # 1267650600228229401496703205376
# This is impossible in C or Java without BigInt!

I use Python's bitwise operators most often in data processing and network protocol work. When I am parsing a binary packet format in a data pipeline, the same AND-shift-mask patterns I would use in C work identically in Python — except I never have to worry about integer overflow when shifting large values.

Infinite-Precision Integers — Python's Superpower

Unlike C (where int is 32 bits) or Java (where int is always 32 bits), Python integers can grow arbitrarily large. This changes how you think about bitwise operations because there is no fixed bit width. A left shift never wraps around. A negative number has an infinite number of leading 1-bits in theory.

# Python integers grow as needed
x = 1
for i in range(10):
    x <<= 8
    print(f"After {i+1} shifts: bit_length={x.bit_length()}")

# Result: after 10 left-shifts by 8, x = 2^80

# You can represent numbers that would overflow in any fixed-width language
huge = 1 << 256
print(huge.bit_length())  # 257
print(huge)               # 115792089237316195423570985008687907853269984665640564039457584007913129639936

This has a practical consequence: when you use bin() to view a negative number, Python shows a sign-and-magnitude representation rather than a fixed-width two's complement pattern. The number -5 shows as -0b101, not as ...11111011. If you need to see the two's complement pattern for a specific bit width, you must mask the result:

# Viewing negative numbers in binary
x = -5
print(bin(x))                     # -0b101
print(bin(x & 0xFF))              # 0b11111011  (8-bit two's complement)
print(bin(x & 0xFFFF))            # 0b1111111111111011  (16-bit)

# Simulating a 32-bit NOT
def not32(n):
    return ~n & 0xFFFFFFFF

print(bin(not32(5)))    # 0b11111111111111111111111111111010
print(not32(5))         # 4294967290 (unsigned), -6 if reinterpreted as signed

Python's int Bit Methods

Python 3 provides several built-in methods on the int type that make bit manipulation cleaner and faster than manual string-based approaches. I rely on these daily:

# int.bit_count() — popcount (Python 3.8+)
n = 0b10110110
print(n.bit_count())          # 5  — native C implementation, very fast

# Old way (slow, don't use in hot paths):
# print(bin(n).count('1'))    # 5  — creates string, 10-50x slower

# int.bit_length() — number of bits needed to represent the value
print((0b1101).bit_length())  # 4
print((0).bit_length())       # 0
print((-5).bit_length())      # 3  (requires 3 bits for 5, sign is separate)

# Converting to binary/hex/octal
n = 255
print(bin(n))                 # 0b11111111
print(hex(n))                 # 0xff
print(oct(n))                 # 0o377

# Format strings for more control
print(format(n, 'b'))         # 11111111  (no prefix)
print(format(n, '08b'))       # 11111111  (zero-padded to 8)
print(format(n, '04x'))       # 00ff      (zero-padded hex)
print(format(n, '#010b'))     # 0b11111111 (with prefix, padded to 10 total)

For converting integers to binary strings with specific formatting, I prefer f-strings over format() because they inline naturally:

# f-string binary formatting (Python 3.6+)
value = 42
print(f"{value:08b}")   # 00101010
print(f"{value:#010b}") # 0b00101010
print(f"{value:08x}")   # 0000002a
print(f"{value:08o}")   # 00000052

Negative Numbers and the Missing >>> Operator

Python does not have an unsigned right shift (>>>) like Java. The reason is philosophical: since Python integers have infinite precision, there is no fixed number of bits to fill with zeros from the left. A negative number conceptually has an infinite string of leading 1-bits, so -1 >> 1 is still -1 (and mathematically it should be: arithmetic right shift of -1 stays -1).

To simulate Java's >>>, you mask the result to your desired bit width:

# Simulating unsigned right shift for 32-bit values
def ushr32(value, shift):
    """Unsigned right shift for 32-bit integers."""
    return (value >> shift) & 0xFFFFFFFF

# Simulating unsigned right shift for arbitrary bit width
def ushr(value, shift, bits=32):
    mask = (1 << bits) - 1
    return (value >> shift) & mask

# Examples
x = -8  # infinite-precision two's complement: ...1111111111111000
print(ushr32(x, 2))   # 1073741822  (matches Java's -8 >>> 2)
print(ushr(x, 2, 8))  # 62          (8-bit version: 0b00111110)

# Wrapping around with mask
def to_signed32(n):
    """Convert an unsigned 32-bit value to signed Python int."""
    n &= 0xFFFFFFFF
    return n if n < 0x80000000 else n - 0x100000000

print(to_signed32(0xFFFFFFFF))  # -1
print(to_signed32(0x80000000))  # -2147483648

I keep a small bitutils.py module in my projects with these helper functions. They let me work with fixed-width binary formats (like network packet headers and binary file formats) while still enjoying Python's convenience for the rest of the code.