Question: How to convert a hexadecimal string such as 02af01ff00 to a normal string using the Base64 format in Python?

Short answer: Use the following fancy one-liner expression to convert the hex string s to a Base64-encoded Python string: base64.b64encode(bytes.fromhex(s)).decode().

For the long answer, keep reading!

If you’re like me, you may need a quick refresher on how Base64 encoding works and what it is exactly. Although I studied computer science a couple of years ago, I don’t have all those super basic “bits” of knowledge at the top of my head all the time.

You may already know about Base64 — in that case, I’d recommend you skip the next section and jump ahead right away.

What Is Base64 Encoding?

Base64 is a very minimal encoding where a minimal set of characters — A-Z, a-z, and 0-9, essentially — are encoded using only six bits. Each bit position doubles the number of different encodings, so the Base64 encoding can encode 2*2*2*2*2*2 = 2^6 = 64 different characters.

Here’s the whole table — fortunately, the encoding is small and efficient enough that I can show you the whole thing!

(And, no, Emojis don’t have any place in Base64, it’s VERY old school!)

Recommended Tutorial: Python Base64 – String Encoding and Decoding [+Video]

How to Convert Base64 Encoding (Hex String) to Human-Readable String in Python?

You can convert a hex string of the format '02af01ff00' to a Base64 encoded normal Python string by using the expression:

base64.b64encode(bytes.fromhex(s)).decode()

You can convert the resulting Base64 string back to a normal string by using the one-liner expression:

base64.b64decode(b64.encode()).hex()

Here’s a code example—I’ll break it down for you right after the code:

import base64 s = '02af01ff00' # hex string -> base64 string

b64 = base64.b64encode(bytes.fromhex(s)).decode() # base64 string -> hex string

s2 = base64.b64decode(b64.encode()).hex() print(s)

print(b64)

print(s2)

The output shows that you successfully converte from the hex string to the Base64 string and back to the hex string:

02af01ff00
Aq8B/wA=
02af01ff00

You can see that the start and end values of the conversion remain the same.

Let’s break down the code step by step!

Step 1: The initial hex string is still in a non-standardized format '02af01ff00'. We require it to be a bytes object because this is the required input format of the base64 functions shown in a moment. You use the bytes.fromhex() function.

>>> s = '02af01ff00'

>>> bytes.fromhex(s)

b'\x02\xaf\x01\xff\x00'

Step 2: You use the base64.b64encode() function to take the hex string (as bytes object) and convert it to a bytes object in Base64 encoding. This is almost what you want — but it’s not yet a normal Python string!

>>> base64.b64encode(bytes.fromhex(s))

b'Aq8B/wA='

Step 3: To convert the bytes object in Base64 encoding to a normal Python string, we use the bytes.decode() method.

>>> base64.b64encode(bytes.fromhex(s)).decode() 'Aq8B/wA='

Voilà, exactly what you wanted! But how to convert it back?

Step 4 and 5: You can convert the normal Base64-encoded Python string back to the hex string from the beginning by using the string.encode() method to obtain a bytes object, passing it into the base64.b64decode() function to obtain a Base64 bytes representation, and converting it to a hexadecimal string by using the bytes.hex() method.

>>> base64.b64decode('Aq8B/wA='.encode())

b'\x02\xaf\x01\xff\x00'

>>> base64.b64decode('Aq8B/wA='.encode()).hex() '02af01ff00'

Thanks

Thanks for reading through the whole tutorial, I hope you managed to solve your issue! If not, you can check out this highly interesting SO answer.

Also, make sure to check out our free Python cheat sheets for maximal learning efficiency and fun!

Summary: You can use one of the following methods to split a string after the delimiter –

• Using split
• Using string slicing
• Using regex
• Using partition
• Using removeprefix

Minimal Example

# Given String

chat = "Python Founder: Guido van Rossum"

# Method 1

print(chat.split(':')[1])

# Method 2

print(chat[chat.index(":")+1:])

# Method 3

import re

print(re.findall(":(.*)", chat)[0])

# Method 4

print(chat.partition(':')[2])

# Method 5

print(chat.removeprefix('Python Founder:'))

Problem Formulation

 Problem: Given a string; How will you split the string after the delimiter? The output must only contain the substring after the delimiter.

Example

Let’s visualize the problem with the help of an example:

# Input

text = "Subscribe to - Finxter"

# Expected Output

Finxter

Method 1: Using split()

Approach: First, we will simply split thestring using “-” as the delimiter. Next, to extract the string before the delimiter we will use the index of the required substring. As the split() function returns a list of substrings, we can extract the last part using list indexing [1] (Indexing starts at 0).

Code:

text = "Subscribe to - Finxter"

res = text.split('-')[1]

print(res)

# Finxter

Note: The split() function splits the string at a given separator and returns a split list of substrings. It returns a list of the words in the string, using sep as the delimiter string.

Related Read: Python String split()

Method 2: Using String Slicing

Prerequisite: String slicing is a concept of carving out a substring from a given string. Use slicing notation s[start:stop:step] to access every step-th element starting from index start (included) and ending in index stop (excluded). All three arguments are optional, so you can skip them to use the default values.

Approach: First, we will use the index() method to find the occurrence of the delimiter in the text. Next, we will slice the string from the index next to the index of the delimiter until the end of the string. Note that we are starting from the index of the delimiter+1 because we don’t want to include it in the final output.

Code:

text = "Subscribe to - Finxter"

res = text[text.index("-")+1:]

print(res) # Finxter

Note:

The index()  method is used to return the index of the first occurrence of the specified substring, like find() but it raises a ValueError if the substring is not found.

Related Reads:
String Slicing in Python
Python String index()

Method 3: Using regex

The re.match(pattern, string) method returns a match object if the pattern matches at the beginning of the string. The match object contains useful information such as the matching groups and the matching positions.

Approach: Use the expression re.findall("-(.*)", given_string) to match and store all characters that come after the “-“.

Code:

import re text = "Subscribe to - Finxter"

print(re.findall("-(.*)", text)[0]) # Finxter

Related Read: Python Regex Match

Method 4: Using partition

The partition() method searches for a separator substring and returns a tuple with three strings: (1) everything before the separator, (2) the separator itself, and (3) everything after it. It then returns a tuple with the same three strings.

Approach: We have used the partition method and used “-” as a separator. As we only need the substring before the delimiter, we have used the index of the required substring on the returned tuple and just printed the third element of the tuple (everything before the separator).

Code:

text = "Subscribe to - Finxter"

res = text.partition('-')[2]

print(res) # Finxter

Related Read: Python String partition()

Method 5: Using removeprefix

If you are using Python 3.9 or above then Python facilitates you with the removeprefix method that allows you to remove the substring that comes before a specified substring. Here’s a quick look at how the removeprefix method works –

Code:

text = "Subscribe to - Finxter"

print(text.removeprefix('Subscribe to -')) # Finxter

Conclusion

Hurrah! We have successfully solved the given problem using as many as five different ways. I hope you enjoyed this article and it helps you in your Python coding journey. Please subscribe and stay tuned for more interesting articles!

Do you want to master the regex superpower? Check out my new book The Smartest Way to Learn Regular Expressions in Python with the innovative 3-step approach for active learning: (1) study a book chapter, (2) solve a code puzzle, and (3) watch an educational chapter video.