Python bin() Function

Spread the love

Python provides a range of built-in functions designed to facilitate coding. One of these is the bin() function, which converts a number into its binary representation. In this article, we’ll delve deeply into the nuances of this function, examining its definition, use cases, and behavior across different data types.

1. Introduction to bin( )

In digital computation, binary notation plays a pivotal role. It’s the fundamental language of computers, where information is represented using two symbols: 0 and 1. The bin() function in Python simplifies the task of converting numbers into this binary format.


The syntax of the bin() function is:


Where x is the number you wish to convert to binary.

Return Value

The bin() function returns a string representation of the binary value, prefixed by “0b”. For instance, the binary representation of the integer 5 is 0b101.

2. Usage Examples

The primary purpose of the bin() function is to convert integer numbers into their binary representation. The resulting output string is prefixed with “0b” to denote that it represents a binary value.

2.1. Basic Positive Integers:

Example 1:

print(bin(3))    # Outputs: 0b11

Here’s how this conversion works:

  • The number 3 in base 10 (our regular decimal system) can be represented as (2^1 + 2^0).
  • In binary, this is equivalent to 11. The leftmost digit represents 2^1 (which is 2), and the rightmost digit represents 2^0 (which is 1). Therefore, 2 + 1 = 3.
  • The bin() function returns the value prefixed with “0b”, hence the output 0b11.

Example 2:

print(bin(16))   # Outputs: 0b10000

For the number 16:

  • The binary representation is derived from the fact that 16 is 2^4.
  • So, in binary, this becomes 10000, where the leftmost digit represents the value 2^4, and the rest of the digits (all zeros) signify that no other powers of 2 are added.
  • Thus, the output is 0b10000.

2.2. The Number Zero:

Example 3:

print(bin(0))    # Outputs: 0b0

Zero, regardless of the base (be it decimal, binary, etc.), is always represented as 0. Therefore, in binary, it’s simply 0, and with the “0b” prefix, the output becomes 0b0.

3. Behavior Across Data Types

While the primary intention behind the bin() function is to convert integers to binary, what happens when we apply it to different data types?

3.1. Floating-Point Numbers

The bin() function is not designed to directly handle float numbers. If you attempt to convert a float to binary using bin(), Python will raise a TypeError:

# TypeError: 'float' object cannot be interpreted as an integer

For converting floats to binary, you’ll need other methods or manual computations.

3.2. Complex Numbers

Similar to floats, you cannot directly convert a complex number to binary using the bin() function:

print(bin(3 + 4j))
# TypeError: 'complex' object cannot be interpreted as an integer

3.3. Strings

Strings, unless they represent a number, cannot be passed directly to the bin() function. Doing so will lead to errors:

# TypeError: 'str' object cannot be interpreted as an integer

However, if the string contains an integer value, you can convert the string to an integer first, then pass it to bin():

print(bin(int("10")))  # Outputs: 0b1010

4. Negative Numbers

The bin() function can also handle negative numbers. When converting a negative number to binary, the output string will start with ‘-0b’, indicating it’s a negative binary number:

print(bin(-5))   # Outputs: -0b101

5. bin( ) with Custom Objects

By implementing the __index__() method in custom classes, objects of these classes can be passed to the bin() function:

class CustomNumber:
    def __index__(self):
        return 5

print(bin(CustomNumber()))  # Outputs: 0b101

Here, the __index__() method returns an integer, allowing the object to be passed to the bin() function, producing the expected binary output.

6. Removing ‘0b’ Prefix

When using the bin() function, the resulting binary representation is always prefixed with “0b”. This prefix is a convention in Python (and several other programming languages) to indicate that the following sequence of numbers is in binary format. However, there might be situations where you’d prefer the pure binary representation without this prefix. Here’s how you can remove the “0b” prefix:

1. Using String Slicing:

One of the most common methods to remove the prefix is by utilizing string slicing.


number = 5
binary_representation = bin(number)
print(binary_representation)          # Outputs: 0b101

# Remove the '0b' prefix
clean_binary = binary_representation[2:]
print(clean_binary)                   # Outputs: 101

In the above code, binary_representation[2:] is slicing the string from the third character onward (0-indexed), effectively removing the first two characters “0b”.

2. Using the format( ) Function:

The built-in format() function provides an alternate way to get the binary representation without the “0b” prefix.


number = 5
clean_binary = format(number, 'b')
print(clean_binary)                   # Outputs: 101

Here, the 'b' argument to the format() function indicates that we want the binary representation of the number.

3. Handling Negative Numbers:

When dealing with negative numbers, the “0b” prefix is not the only thing you’ll see; there’s also a “-” sign indicating that the number is negative. If you want to remove the prefix but keep the sign, a little extra care is required.

Example using slicing:

number = -5
binary_representation = bin(number)
print(binary_representation)          # Outputs: -0b101

# Remove the '-0b' prefix but keep the negative sign
if number < 0:
    clean_binary = "-" + binary_representation[3:]
    clean_binary = binary_representation[2:]

print(clean_binary)                   # Outputs: -101

In this example, we checked if the number is negative. If it is, we slice from the fourth character onwards and add back the negative sign.

7. Converting Back to Integer

Converting a binary string back to its integer representation is as vital as converting an integer to binary, especially when dealing with binary data manipulation or bit-level operations.

1. Using the int( ) Function:

The built-in int() function in Python can be used to convert a string in binary format back to its integer representation. The function takes in two arguments: the string to be converted and the base of the numeral system. For binary, the base is 2.


binary_str = "101"
decimal_representation = int(binary_str, 2)
print(decimal_representation)         # Outputs: 5

In the code above, the int() function takes the binary string “101” and the base 2, and it returns the decimal (base 10) representation, which is 5.

2. Manual Conversion:

Though using the int() function is the most direct and efficient way to convert a binary string to an integer, understanding the manual method of conversion can be illuminating.


binary_str = "101"
decimal_representation = sum([int(bit) * (2**index) for index, bit in enumerate(reversed(binary_str))])
print(decimal_representation)         # Outputs: 5

Here’s a step-by-step breakdown:

  1. We reverse the binary string using reversed(binary_str). This is because the rightmost bit represents the lowest power of 2 (i.e., 2^0), and the leftmost bit represents the highest power.
  2. We use enumerate() to get both the index (which will represent the power of 2) and the bit itself.
  3. For each bit, we calculate its decimal value with int(bit) * (2**index).
  4. The sum() function aggregates these decimal values, yielding the integer representation of the binary string.

3. Handling Negative Binary Strings:

If you’ve stored negative numbers in binary format with a “-” prefix (like “-101” for -5), you’ll need to handle them slightly differently.


binary_str = "-101"

# Check for negative sign
if binary_str[0] == '-':
    is_negative = True
    binary_str = binary_str[1:]  # Remove the negative sign
    is_negative = False

decimal_representation = int(binary_str, 2)

# Convert back to negative if needed
if is_negative:
    decimal_representation = -decimal_representation

print(decimal_representation)         # Outputs: -5

In this example, we first check if the binary string starts with a negative sign. If it does, we note this with the is_negative flag and remove the “-” prefix. After converting the positive portion to an integer, we convert it back to a negative number if necessary.

8. Conclusion

The bin() function in Python offers a streamlined way to convert integers to their binary representation. While it might seem niche, having a solid grasp of this function can prove invaluable in numerous computing scenarios. Whether you’re debugging, working with low-level computations, or merely curious about the binary form of numbers, bin() is the go-to built-in function. Always keep in mind its constraints with data types to avoid pitfalls and errors.

Leave a Reply