# Mastering Binary Strings: Converting Character Strings in Python

## What is a Binary String?

When we talk about digital data, it all boils down to binary strings. Computers store and process data through the use of binary strings consisting of zeros and ones.

Understanding binary strings is crucial to software professionals who deal with machine-level programming. This article will explore what binary strings are and how to create them in Python.

Additionally, we will distinguish binary strings from character strings used in high-level processing and natural language processing.

In computing, binary strings are strings of bits, which can have two values: 0 or 1. Each bit can represent either an “off” or “on” state, and a byte is a collection of eight bits used to store a single value.

Computers store and manipulate data in binary code, making binary strings an important component of data representation.

### Differences between Binary and Character Strings:

Just as the name suggests, character strings are strings of characters that represent human-readable text.

In high-level programming languages, character strings are used to store textual content and are often used in libraries for natural language processing. While binary strings are used for machine-level programming, character strings are instrumental in high-level processing, making it easy to manipulate text data.

## Creating a Binary String in Python:

Creating binary strings in Python is very simple, thanks to the built-in `bin()` function. This function returns a binary representation of a decimal number, starting with the prefix “0b.” For instance, the code `bin(6)` would return `0b110` in binary form.

### Using the `bin()` function:

The `bin()` function can take any integer value and converts it to a binary string. This is shown in the following code snippet:

``````decimal_number = 8
binary_number = bin(decimal_number)

print(binary_number)``````

When run, this code will output:

``0b1000``

Note that the prefix “0b” has been added to denote that the string is in binary format. This is important when manipulating binary strings to avoid errors.

### Removing the `0b` prefix:

The “0b” prefix may not be desirable in all cases. Fortunately, we can easily remove it using slicing operators:

``````decimal_number = 8
binary_number = bin(decimal_number)[2:]

print(binary_number)``````

When run, this code will output:

``1000``

By using the `[2:]` operator, we have removed the first two characters of the binary string, keeping only the bits we are interested in.

## Converting a Character String to a Binary String:

In programming, we often encounter situations where we need to convert a character string to a binary string.

Converting a character string to a binary string is essential as it aids in data storage, transmission, and manipulation. The conversion process involves assigning a binary code for each character or symbol in a string using the Unicode value of the character.

In this section, we will explore various ways of converting a character string to a binary string in Python.

### Using `join()` and `format()` functions:

One way to convert a character string to a binary string is by using the `join()` and `format()` functions.

The `ord()` method in Python returns the Unicode value of a character. The `(8)` in the `format()` function pads the binary representation of the Unicode value with leading zeros up to a total of 8 characters.

The following code snippet demonstrates the use of `join`, `format`, and `ord` methods in converting a string to a binary string:

``````s = "ABC"
binary_string = ''.join(format(ord(i), '08b') for i in s)

print(binary_string)``````

When the above code is run, it produces the following output:

``010000010100001001000011``

The binary string represents the bit sequence of the Unicode values of the characters A, B, and C. Note that the length of the binary string depends on the length of the input string.

### Printing binary string and its type:

To confirm that the binary string returned by the `join()` and `format()` functions is a binary string, Python provides the `type()` method. The `type()` method returns the data type of the variable passed in the method’s parentheses.

In this case, it will return `'str'`, indicating the type of the variable is a string. The following code snippet adds Python’s `type()` method to the previous example, to return the binary string and show its data type:

``````s = "ABC"
binary_string = ''.join(format(ord(i), '08b') for i in s)

print(binary_string)
print(type(binary_string))``````

When the above code is run, it produces the following output:

``````010000010100001001000011
``````

## Converting a Binary String to a Normal String:

We now turn our attention to how to convert a binary string back to a regular string in Python. In Python, there are multiple ways to decode a binary string back to its corresponding character string.

We will explore four ways of converting a binary string to a normal string: Bitarray, for loop, list comprehension, and bitwise operators.

### Using Bitarray to convert Binary String to Normal String:

Bitarray is a third-party library in Python used for efficient Boolean array manipulation.

It provides multiple methods to manipulate binary strings, including string to binary conversion and binary to string conversion. We can use Bitarray’s in-built functions, such as `decode()` and `tobytes()` functions, to convert binary strings back to a regular string.

The following code snippet demonstrates how to use Bitarray to convert a binary string to a normal string:

``````from bitarray import bitarray

binary_string = '010000010100001001000011'
ba = bitarray(binary_string)
normal_string = ba.tobytes().decode()

print(normal_string)``````

The output of the above code is the original string `'ABC'` when it was initially converted to binary string.

### Using a for loop to convert Binary String to Normal String:

Another way to convert a binary string is by using a for loop.

This is where we divide the binary string into uniform chunks of eight characters each, representing bytes, before converting them to decimal values. We then use Python’s `chr()` function to convert the decimal values to Unicode characters in a new string.

The code snippet below shows how this can be achieved:

``````binary_string = '010000010100001001000011'
normal_string = ''

for i in range(0, len(binary_string), 8):
chunk = binary_string[i:i+8]
decimal_value = int(chunk, 2)
normal_string += chr(decimal_value)

print(normal_string)``````

The output of the above code is the original string `'ABC'`.

### Using List Comprehension:

List comprehension is a more concise way of writing the for loop discussed earlier. It creates a new list of Unicode characters using the decimal values obtained from parsing the binary string.

The following code snippet shows how this can be achieved:

``````binary_string = '010000010100001001000011'
normal_string = ''.join([chr(int(binary_string[i:i + 8], 2)) for i in range(0, len(binary_string), 8)])

print(normal_string)``````

As with the previous examples, the output of the above code is the original string `'ABC'`.

### Using Bitwise Operators:

The bitwise operators in Python allow for manipulation of individual bits. In a binary string, the most significant bit (MSB) represents the sign bit and is used in operations that involve negative numbers.

Using bitwise operators to convert a binary string to a normal string involves first parsing the binary string into bytes and then using the `int.from_bytes()` method to convert the bytes into decimal values. After the decimal values have been obtained, we can use Python’s `chr()` function to convert the decimals to Unicode characters, which are then used to create the normal string.

The following code snippet demonstrates the use of bitwise operators to convert a binary string to a normal string:

``````import codecs

binary_string = '010000010100001001000011'
bytes_object = codecs.decode(binary_string, "hex")
normal_string = bytes_object.decode()

print(normal_string)``````

The output of the above code is the original string `'ABC'`.

## Conclusion:

In this article, we explored different ways of converting a character string to a binary string and back to a regular string using different methods in Python.

Converting between binary strings and normal strings is an essential technique when working with data storage, transmission, and manipulation.

Each of the methods described above has its advantages, and the appropriate method can be selected based on individual project requirements.

In this article, we have explored the concepts of binary strings and how to convert between binary strings and regular (normal) strings in Python.

We have learned that binary strings are critical components of data representation in computing, and converting between these two types of strings is essential in data storage, transmission, and manipulation.

We explored various methods for converting between binary strings and normal strings, including the Bitarray library, for loops, list comprehension, and bitwise operators. It’s important to note that the appropriate conversion method depends on project requirements, and each method has its advantages.

Understanding binary strings is crucial for software professionals working with machine-level programming, data storage, transmission, and manipulation, and this article provides a solid foundation for future work in this field. By reading this article, software engineers can confidently work with binary strings in Python and improve their programming skills in this area.