How to Convert Signed to Unsigned Integer in Python?

In Python, signed integers can represent both positive and negative numbers using Two's Complement representation, where the most significant bit acts as a sign bit. Unsigned integers use all bits for magnitude, representing only non-negative values with a larger positive range.

While Python natively handles arbitrary-precision integers, you may need to simulate unsigned integer behavior when interfacing with systems that expect specific bit widths or when performing low-level operations.

Understanding Signed vs Unsigned Integers

A signed 32-bit integer ranges from -2,147,483,648 to 2,147,483,647, while an unsigned 32-bit integer ranges from 0 to 4,294,967,295. The conversion essentially maps negative values to their positive counterparts in the upper half of the unsigned range.

Method 1: Using 2**32 Addition

For 32-bit integers, add 2**32 to negative values to shift them into the unsigned range ?

signed_int = -42
unsigned_int = signed_int + 2**32

print("Signed Integer:", signed_int)
print("Unsigned Integer:", unsigned_int)
print("Binary representation:", bin(unsigned_int))

Signed Integer: -42
Unsigned Integer: 4294967254
Binary representation: 0b11111111111111111111111111010110

Method 2: Using Bitwise Left Shift (1 << 32)

The expression (1 << 32) is equivalent to 2**32 but uses bitwise operations ?

signed_int = -42
unsigned_int = signed_int + (1 << 32)

print("Signed Integer:", signed_int)
print("Unsigned Integer:", unsigned_int)
print("Verification: 1 << 32 =", 1 << 32)

Signed Integer: -42
Unsigned Integer: 4294967254
Verification: 1 << 32 = 4294967296

Method 3: Using Bitwise AND with Mask

Apply a bit mask to keep only the desired number of bits ?

def to_unsigned_32bit(signed_int):
    return signed_int & 0xFFFFFFFF

# Test with various values
test_values = [-42, -1, 0, 42, -2147483648]

for value in test_values:
    unsigned = to_unsigned_32bit(value)
    print(f"Signed: {value:11} ? Unsigned: {unsigned}")

Signed:         -42 ? Unsigned: 4294967254
Signed:          -1 ? Unsigned: 4294967295
Signed:           0 ? Unsigned: 0
Signed:          42 ? Unsigned: 42
Signed: -2147483648 ? Unsigned: 2147483648

Comparison of Methods

Practical Example

Here's a function that handles different bit widths ?

def signed_to_unsigned(value, bits=32):
    """Convert signed integer to unsigned for specified bit width."""
    if value < 0:
        return value + (1 << bits)
    return value

# Test with different bit widths
print("8-bit conversion:")
print(f"  -1 ? {signed_to_unsigned(-1, 8)}")
print(f"  -128 ? {signed_to_unsigned(-128, 8)}")

print("\n16-bit conversion:")
print(f"  -1 ? {signed_to_unsigned(-1, 16)}")
print(f"  -32768 ? {signed_to_unsigned(-32768, 16)}")

8-bit conversion:
  -1 ? 255
  -128 ? 128

16-bit conversion:
  -1 ? 65535
  -32768 ? 32768

Conclusion

Converting signed to unsigned integers in Python involves shifting negative values into the positive range using addition or bitwise operations. The bitwise AND method with masks is most efficient, while addition methods are more readable for beginners.