First, let's clarify a critical point about INT(2): in most databases (like MySQL), the number in parentheses is a display width hint, not the actual storage size. A standard INT is 4 bytes, but since you're targeting 16-bit binary, I assume you're working with a 2-byte integer type (like SMALLINT, or a custom 16-bit integer storage) where the actual value fits in 16 bits.

Now, let's break down why format(value, '016b') might not match your documentation's expected output:

The Problem with format(value, '016b') #

This function converts a decimal integer to an unsigned 16-bit binary string—but it has two key limitations that often cause mismatches:

• Negative values break it: If your dataset includes negative numbers, format(-1, '016b') outputs '-0000000000000001' instead of the 2's complement representation (1111111111111111) that most systems use for signed 16-bit integers.
• No range enforcement: If your value exceeds 65535 (the max for unsigned 16-bit) or is below -32768 (the min for signed 16-bit), format() will output a longer binary string instead of truncating/wrapping to 16 bits as expected.

Correct Conversion Methods #

Choose the approach that matches your dataset's actual integer type and storage rules:

1. For Unsigned 16-bit Integers (0 to 65535) #

Your original method works if you add range validation to ensure values stay within bounds:

def unsigned_16bit_to_binary(value):
    if not (0 <= value <= 65535):
        raise ValueError("Value must be between 0 and 65535 for unsigned 16-bit integers")
    return format(value, '016b')

# Example usage
print(unsigned_16bit_to_binary(255))  # Output: 0000000011111111

2. For Signed 16-bit Integers (-32768 to 32767) #

You need to handle 2's complement, which format() doesn't do natively. Two reliable options:

Option A: Use the struct Module (Best for Byte-Order Compliance)

This converts the integer directly to bytes (respecting big-endian or little-endian order, per your docs) then to a binary string:

import struct

def signed_16bit_to_binary(value, endian='little'):
    if not (-32768 <= value <= 32767):
        raise ValueError("Value must be between -32768 and 32767 for signed 16-bit integers")
    # Pack to bytes: '<h' = little-endian, '>h' = big-endian
    byte_format = '<h' if endian == 'little' else '>h'
    byte_data = struct.pack(byte_format, value)
    # Convert each byte to 8-bit binary and concatenate
    return ''.join(f'{byte:08b}' for byte in byte_data)

# Example: -1 in little-endian becomes 1111111111111111
print(signed_16bit_to_binary(-1))

Option B: Manual 2's Complement Calculation

If you don't want to use struct, compute the complement manually:

def signed_16bit_to_binary(value):
    if not (-32768 <= value <= 32767):
        raise ValueError("Value out of signed 16-bit integer range")
    if value >= 0:
        return format(value, '016b')
    else:
        # Calculate 2's complement by adding 2^16 to the negative value
        return format((1 << 16) + value, '016b')

# Example: -1 outputs 1111111111111111
print(signed_16bit_to_binary(-1))

Key Takeaway #

Your original format(value, '016b') only works for unsigned 16-bit positive integers. To match your documentation's expected output, you first need to confirm:

• Whether your INT(2) data is signed or unsigned
• What byte order (big-endian/little-endian) the data uses

Once you have those details, pick the corresponding method above, and your binary output should align with the docs.

内容的提问来源于stack exchange，提问作者iwishiwasashark