How to convert bytes to a string in Python

1bytes.decode()Recommended

.decode() is the method built for this job. With no arguments it decodes as UTF-8 and returns a real str — one you can slice, format and compare like any other:

data = b"Hello, CompileBytes!"
text = data.decode()

print(text)
print(type(data), type(text))
print(text.upper())

The output is Hello, CompileBytes!, then <class 'bytes'> <class 'str'>, then HELLO, COMPILEBYTES!. Notice the quotes are gone from the first line: printing bytes shows b'...', printing a string shows the text. .upper() proves it's a genuine string now — bytes has its own .upper(), but it would hand back more bytes.

2str(data, "utf-8") — and the str(data) trap

The str() constructor decodes too, but only when you give it an encoding. Call it with one argument and it doesn't decode anything — it just prints the bytes object's repr, prefix and all. This is where nearly every "how do I remove the b from my string" question comes from:

data = "café".encode()

print(data)
print(str(data, "utf-8"))
print(str(data))

Line 1 and line 3 both print b'caf\xc3\xa9'; only the middle one prints café. So str(data, "utf-8") is a fine equivalent of data.decode(), while bare str(data) is the bug — and if a b'...' already ended up in your output, the fix is to decode earlier, not to strip characters off the end.

3Other encodings and broken bytes

When the bytes aren't UTF-8, decoding them as UTF-8 raises UnicodeDecodeError. You have three ways out: name the right encoding, tolerate the bad bytes with errors=, or catch the exception. Here \xe9 is "é" in latin-1, which isn't valid UTF-8 at all:

data = b"caf\xe9 latte"

print(data.decode("latin-1"))
print(data.decode("utf-8", errors="replace"))
print(data.decode("utf-8", errors="ignore"))

try:
    data.decode()
except UnicodeDecodeError as e:
    print("UnicodeDecodeError:", e.reason)

You get café latte, then caf� latte with the U+FFFD replacement character, then caf latte with the byte silently dropped, then UnicodeDecodeError: invalid continuation byte. Prefer the first route: errors= hides data loss rather than fixing it. latin-1 is the useful last resort because it decodes any byte at all, so it never raises.

4Where the bytes came from

Most bytes reach you from a file opened in "rb" mode, an HTTP response, or a subprocess. Often you don't need to decode by hand at all — json.loads() accepts bytes directly, and read_text() decodes for you:

import json
from pathlib import Path

Path("data.json").write_bytes(b'{"tool": "CompileBytes"}')

raw = Path("data.json").read_bytes()
print(raw)
print(json.loads(raw)["tool"])
print(Path("data.json").read_text())

Prints the raw b'{"tool": "CompileBytes"}', then CompileBytes, then the decoded text. Same idea elsewhere: subprocess.run(..., text=True) gives you str instead of bytes on .stdout, and response.text is the decoded version of response.content in requests.

5Which should you use?

6Going the other way: str.encode()

.encode() is the mirror image, and it's what you need before writing to a socket or a binary file. It's also the clearest way to see that characters and bytes aren't the same thing:

text = "café"
data = text.encode()

print(data, len(text), len(data))
print(bytearray(b"abc").decode())
print(bytes([72, 105]).decode())

The first line prints b'caf\xc3\xa9' 4 5 — four characters, five bytes, because "é" takes two of them in UTF-8. The rest shows the same .decode() works on a bytearray, and that raw byte values decode just as well: [72, 105] is Hi.