The encoding of that string seems to be ISO-8859-1 (a.k.a. Latin-1), not UTF-8. Once you decode the string correctly, you will be able to work with it or encode it to some other encoding like UTF-8.

raw = b'US $ to UK \xa3 (TTF)'
text = raw.decode('ISO-8859-1')

There are two different concepts being confused.

A character set is an ordering of characters, numbered from 0 to ...

An encoding is a way of representing the numbers in a character set as a sequence of bytes.

For a character set with at most 256 characters, a trivial single-byte encoding is possible.

For larger character sets, multi-byte encodings are required. They can be split into two types: fixed size, where every character uses the same number of bytes, and variable size, where different numbers of bytes are used to represent different characters.

Examples of fixed-size encodings are all single-byte encodings and UTF-32.

Examples of variable-sized encodings are UTF-8 and the various UTF-16 encodings.

Latin-1 is both a character set (containing the ASCII characters and its additional characters for writing Western European languages) and (having 256 characters) its corresponding single-byte encoding

Unicode is a character set containing (or aiming to contain) all characters to write all known languages. It is, not surprisingly, much larger than 256 characters.

UTF-8 is just one multibyte encoding of Unicode, and a variable sized one. The first byte of each UTF-8 sequence tells you how may additional bytes follow it to encode a single Unicode code point.

Unicode and Latin-1 (the character set) coincide for their first 256 code points. That is, Latin-1 is a subset of Unicode.

UTF-8 and Latin-1 coincide for their first 128 sequences. After that, they diverge. In UTF-8, code points 128 through 255 require two bytes. The first byte has the form 110xxxxx, the second 10xxxxxx. The 11 x bits are free for encoding the rest of the Latin-1 subset (plus additional blocks) of Unicode.

The byte 0xa0 is not valid UTF-8, as its binary expansion is 10100000. The first byte of a multibyte UTF-8 sequence always starts with at least two 1s (intuitively, the number of 1s indicates the number of bytes in the sequence).

If you want to encode and decode text, that's what the encode and decode methods are for:

>>> a = "Gżegżółka"
>>> b = a.encode('utf-8')
>>> b
b'G\xc5\xbceg\xc5\xbc\xc3\xb3\xc5\x82ka'
>>> c = b.decode('utf-8')
>>> c
'Gżegżółka'

Also, notice that UTF-8 is already the default, so you can just do this:

>>> b = a.encode()
>>> c = b.decode()

The only reason you need to specify arguments is:

• You need to use some other encoding instead of UTF-8,
• You need to specify a specific error handler, like 'surrogatereplace' instead of 'strict', or
• Your code has to run in Python 3.0-3.1 (which almost nobody used).

However, if you really want to, you can do what you were already doing; you just need to explicitly specify the encoding in the str call, just as you did in the bytes call:

>>> a = "Gżegżółka"
>>> b = bytes(a, 'utf-8')
>>> b
b'G\xc5\xbceg\xc5\xbc\xc3\xb3\xc5\x82ka'
>>> c = str(b, 'utf-8')
>>> c

Calling str on a bytes object without an encoding, as you were doing, doesn't decode it, and doesn't raise an exception like calling bytes on a str without an encoding, because the main job of str is to give you a string representation of the object—and the best string representation of a bytes object is that b'…'.