The term 'string prefix' is explained here.
What if you have a string that has been assigned to a variable already, how do you add the string prefix to that (without using the same string)? This can be assigned a new variable, or reassigned to the same one.
You can't retroactively add or remove a string literal prefix. Once its been made, it's just a str (or bytes with a b prefix). If you need to convert something that was a bytes literal to str or vice-versa, you use the bytes.decode or str.encode method respectively, like you would on any bytes or str, regardless of whether it began as a literal or not, because there is no difference between literal and non-literal strings immediately after the literal is evaluated.
str literals might be interned where non-literal strs rarely are, but this is not relevant to use unless you're incorrectly using is for string comparisons.u is an optional, meaningless prefix on Python 3 for aid in porting Python 2 scripts. It just says "this string can contain Unicode", but on Python 3, that's how all str are already.str to look like bytes literals ('stng'.encode('latin-1')) but that assumes they contain only latin-1 characters; if they contain non-latin-1 characters, there is no single equivalent byte. Literals are literals; the literal itself possesses or lacks a prefix, you can't retroactively change it.r and f prefixes are literally impossible to graft on after the fact with anything but the loosest heuristics, and b is almost as bad.
In general, you can't. String prefixes are part of syntax, not data. In other words, they don't create a different type of string, but create a string in a different way.
u does nothing in Python 3. It only exists for compatibility with Python 2.
f can be emulated with str.format() for simple cases, but to fully emulate an f-string, you'd have to evaluate it, but that's a security risk since f-strings can contain arbitrary code.
r can be emulated with str.encode('unicode_escape').decode() in some cases, but not all, for example, this string literal is lossy:
>>> r'\x61'
'\\x61'
>>> s = '\x61'
>>> s
'a'
>>> s.encode('unicode_escape').decode()
'a'
b is an exception in that it actually does create a different type: a bytes object. It can be emulated with the raw_unicode_escape encoding, though I don't have any experience using it so I'm not sure if it's the same:
>>> b'a\x89\u2013'
b'a\x89\\u2013'
>>> 'a\x89\u2013'
'a\x89–'
>>> 'a\x89\u2013'.encode('raw_unicode_escape')
b'a\x89\\u2013'
>>> 'a\x89\u2013'.encode('raw_unicode_escape').decode('raw_unicode_escape')
'a\x89–'
Also just for reference, the grammar calls them stringprefix, and just "prefix" in the text.
According to Python 2 manual
Unicode Literals in Python Source Code
In Python source code, Unicode literals are written as strings prefixed with the ‘u’ or ‘U’ character: u'abcdefghijk'. Specific code points can be written using the \u escape sequence, which is followed by four hex digits giving the code point. The \U escape sequence is similar, but expects 8 hex digits, not 4.
But in Python 3
Since Python 3.0, the language’s str type contains Unicode characters, meaning any string created using "unicode rocks!", 'unicode rocks!', or the triple-quoted string syntax is stored as Unicode.
The default encoding for Python source code is UTF-8, so you can simply include a Unicode character in a string literal:
As far as it concerns the already created variables, either by user input or by reading a file or whatever, you have to read on each method how to manipulate unicodes
python "string encoding declaration"using the "term" in this way, and it's by the guy who made the edit.