Bitwise Operations in Python

Python integers never overflow — here is what that means for bitwise operations, and why it changes everything

Python's integer type is unlike nearly every other language's. There is no 32-bit or 64-bit ceiling — integers grow to whatever size they need, limited only by available memory. This changes how bitwise operations behave in surprising and useful ways. A ~x in Python does not wrap around at 32 bits, and a left shift never silently truncates the high bits. Use the BitwiseCalc to compare Python's arbitrary-precision results against fixed-width systems as you follow along.

Arbitrary Precision: No Overflow, No Wrapping

In C, (1 << 31) << 1 overflows and produces undefined behavior for signed ints. In Python:

>>> (1 << 31) << 1
4294967296       # 2^32 — no overflow
>>> (1 << 100)
1267650600228229401496703205376  # 2^100, just works

This means Python bitwise operations are closer to mathematical truth than hardware simulation. ~5 gives -6 because Python uses infinite two's complement — conceptually, there is an infinite string of 1s to the left of any negative number. This is elegant for abstract bit manipulation but can surprise developers coming from fixed-width languages. Use x & 0xFFFFFFFF to clamp to 32 bits when you need hardware-accurate results.

IntFlag Enum: Readable Bit Flags

Python 3.6+ supports IntFlag, which combines the readability of enums with bitwise combinability:

from enum import IntFlag

class Permission(IntFlag):
    READ    = 1   # 0b001
    WRITE   = 2   # 0b010
    EXECUTE = 4   # 0b100

perms = Permission.READ | Permission.WRITE  # Permission.READ|WRITE
has_read = bool(perms & Permission.READ)     # True
has_exec = bool(perms & Permission.EXECUTE)  # False

The output Permission.READ|WRITE is not just a string — Python automatically decomposes the combined flag back into its named components. This beats raw integer bitmasks for maintainability, especially in APIs and configuration systems. Try building flag combinations on the bit flags calculator to understand the underlying binary before wrapping it in enums.

Built-in Methods: bit_count(), bit_length(), bin(), hex(), oct()

Python 3.8 added int.bit_count() (popcount), eliminating the need for manual Kernighan loops:

>>> (0b10110011).bit_count()
5   # five 1-bits in 10110011

>>> (256).bit_length()
9   # 256 = 0b1_0000_0000 — needs 9 bits

>>> bin(42)
'0b101010'
>>> hex(255)
'0xff'
>>> oct(8)
'0o10'

bin() strips leading zeros by default. For fixed-width display, use format strings: f"{42:08b}" produces '00101010'.

When Bitwise Beats Set Operations

Storing a collection of small integers (0-63) as bits in a single Python int can be faster than using a set. Membership testing with (bits >> item) & 1 is an O(1) bit check with no hash computation:

# Instead of: numbers = {3, 7, 12, 45, 62}
bits = (1 << 3) | (1 << 7) | (1 << 12) | (1 << 45) | (1 << 62)

def contains(bits, n):
    return (bits >> n) & 1

# Union: bits_a | bits_b
# Intersection: bits_a & bits_b

For dense integer sets under 64 elements, this approach uses 8 bytes instead of hundreds for a Python set object. The performance crossover depends on sparsity — very sparse sets (storing one value in a million) waste memory with bits, but for compact ranges, bitwise representation is the clear winner.

NumPy Bitwise for Array Operations

When operating on large arrays of integers, NumPy provides vectorized bitwise functions that run in compiled C behind the scenes:

import numpy as np

arr = np.array([0b0011, 0b0110, 0b1100], dtype=np.uint8)
mask = 0b0101

result = np.bitwise_and(arr, mask)  # array([1, 4, 4])
# 0b0011 & 0b0101 = 0b0001 = 1
# 0b0110 & 0b0101 = 0b0100 = 4
# 0b1100 & 0b0101 = 0b0100 = 4

These are orders of magnitude faster than Python-level loops for arrays with thousands of elements or more.

Python's big-integer model makes it an excellent playground for learning bitwise operations. There is no overflow to worry about, no sign-extension confusion, and the REPL gives instant feedback. Once you understand the patterns here, porting them to fixed-width languages is mostly a matter of adding masks. Bookmark the BitwiseCalc for cross-checking results against 32-bit and 64-bit representations.