Convert regular Python string to raw string

Question

I have a string s, its contents are variable. How can I make it a raw string? I'm looking for something similar to the r'' method.

Leeway

Raw strings are just a different syntax when defining a string constant. What is it in particular you want from var that makes you think of using raw strings? – Goatsucker

Are you using Python 2 or Python 3? If Python 3, are you perhaps asking about the bytes type? – Ileac

The question is not coherent. r'' is not a "method", there is not actually such a thing as a "raw string" (there are only raw string literals, which are a different way of describing a string - and such a string is a perfectly ordinary string). It's not at all clear what transformation OP had in mind, or what purpose would have been served. Voting to close, as I should have instead of answering 12 years ago. – Precatory

See also stackoverflow.com/questions/21605526 – Precatory

See also stackoverflow.com/questions/2081640 – Precatory

Answer 1

i believe what you're looking for is the str.encode("string-escape") function. For example, if you have a variable that you want to 'raw string':

a = '\x89'
a.encode('unicode_escape')
'\\x89'

Note: Use string-escape for python 2.x and older versions

I was searching for a similar solution and found the solution via: casting raw strings python

Symptomatic

this is the solution. – Pervious

On python 3.5.1: LookupError: unknown encoding: string-escape – Amateurism

This "fails" for input "an uppercase a is \x41" – Refugia

To me it seems like "the r'' operator" and .encode() are not the same. These three: '\bla\ \n' --- r'\bla\ \n' --- ('\bla\ \n').encode("unicode_escape").decode() all give different strings it seems: '\x08la\\ \n' --- '\\bla\\ \\n' --- '\\x08la\\\\ \\n' – Gaines

In case it also helps someone else, I also needed the additional .decode() at the end like at the referenced source to get something like I was getting from r"string_goes_here" solely. However, it was a rather complex case where I was replicating an issue like here and solving. – Folia

Fails for "\x22".encode('unicode_escape'), in python that returns b'"' – Stealthy

Answer 2

Raw strings are not a different kind of string. They are a different way of describing a string in your source code. Once the string is created, it is what it is.

Precatory

+1 for the rare, accurate usage of "it is what it is" – Tadpole

this is actually wrong. There's another answer here with the correct response: "raw strings do not escape anything inside of them". – Raddle

@Raddle No, you are confused. When you create a string you may need to escape something; but once the string contains what it contains, "escaping it" is not a well-defined operation (though of course you can create a string with different contents by, for example, interpreting literal backslashes as escape codes). – Eatton

Answer 3

Since strings in Python are immutable, you cannot "make it" anything different. You can however, create a new raw string from s, like this:

raw_s = r'{}'.format(s)

Direction

>>> raw_s = r'{}'.format(normal) >>> raw_s 'The\n' >>> normal 'The\n' >>> raw=r"The\n" >>> raw 'The\\n' does not provide same output as raw – Against

This does nothing. r'{}'.format('\n') == '\n'. The r prefix only applies to what's inside the string literal, i.e. the braces. – Gutsy

For Windows paths, be sure to use os.path.join if converting path strings to avoid trouble with so-called "escape characters" (a.k.a. backslashes). – Cutler

This is roughly as useful as str(str(str(str(s)))); using format to put a string inside another string is just wasteful if one of them is otherwise empty. – Eatton

Clever, thanks. That's exactly what I was looking for and I've probably even used it in that way, but when we get stuck or a brain fart, there's Google. Thanks! – Steelhead

r'{}'.format('\n') == r'\n' return False – Eurypterid

Answer 4

As of Python 3.6, you can use the following (similar to @slashCoder):

def to_raw(string):
    return fr"{string}"

my_dir ="C:\data\projects"
to_raw(my_dir)

yields 'C:\\data\\projects'. I'm using it on a Windows 10 machine to pass directories to functions.

Froth

>>> def to_raw(string): ... return fr"{string}" ... >>> normal 'The\n' >>> to_raw(normal) 'The\n' >>> raw 'The\\n' does not provide same output as raw – Against

This doesn't actually do anything. my_dir is already 'C:\\data\\projects' because \d and \p are unrecognized escape sequences, so the backslashes are preserved. Unrecognized escape sequences will raise a SyntaxError in a future version of Python. Also try my_dir = 'C:\Users', which immediately raises a SyntaxError. – Gutsy

This is spot on - I get a file path using a TkInter dialog box, sending it to a string, which I then want to convert to a raw string to re-open the file. I can't therefore just add r'string' but fr"{string}" works perfectly! – Augment

@Augment return string would have worked just as well; fr"{string}" == string in all cases where string is an actual string and not for example an int. – Landrum

Then not doing any of this is also spot on, because this doesn't actually do anything. – Eatton

What does the f stand for in fr"string"? Is it documented somewhere in Python Docs? I see the r"", but not fr"" – Tenant

The f-string is a new string format introduced with Python 3.6 which eases putting a variable in a string representation. For instance, you have the variable name and want to put it into a print statement, you can achieve this by: print(f"My name is {name}"). In older version you could use the format statement as follows: print("my name is {}".format(name)) See realpython.com/python-f-strings for some more documentation – Froth

Answer 5

raw strings apply only to string literals. they exist so that you can more conveniently express strings that would be modified by escape sequence processing. This is most especially useful when writing out regular expressions, or other forms of code in string literals. if you want a unicode string without escape processing, just prefix it with ur, like ur'somestring'.

Cordell

I wouldn't expect the @TokenMacGuy to know this but they're also useful for defining paths on Windows which uses the backslash as a separator character in paths, such as r'C:\Python27\Tools\Scripts\2to3.py' – Bowles

Alas, TokenMacGuy is just the name. My main machine runs windows. the real reason I don't use raw strings for filepaths is because I never hardcode pathnames. – Cordell

Answer 6

For Python 3, the way to do this that doesn't add double backslashes and simply preserves \n, \t, etc. is:

a = 'hello\nbobby\nsally\n'
a.encode('unicode-escape').decode().replace('\\\\', '\\')
print(a)

Which gives a value that can be written as CSV:

hello\nbobby\nsally\n

There doesn't seem to be a solution for other special characters, however, that may get a single \ before them. It's a bummer. Solving that would be complex.

For example, to serialize a pandas.Series containing a list of strings with special characters in to a textfile in the format BERT expects with a CR between each sentence and a blank line between each document:

with open('sentences.csv', 'w') as f:

    current_idx = 0
    for idx, doc in sentences.items():
        # Insert a newline to separate documents
        if idx != current_idx:
            f.write('\n')
        # Write each sentence exactly as it appared to one line each
        for sentence in doc:
            f.write(sentence.encode('unicode-escape').decode().replace('\\\\', '\\') + '\n')

This outputs (for the Github CodeSearchNet docstrings for all languages tokenized into sentences):

Makes sure the fast-path emits in order.
@param value the value to emit or queue up\n@param delayError if true, errors are delayed until the source has terminated\n@param disposable the resource to dispose if the drain terminates

Mirrors the one ObservableSource in an Iterable of several ObservableSources that first either emits an item or sends\na termination notification.
Scheduler:\n{@code amb} does not operate by default on a particular {@link Scheduler}.
@param  the common element type\n@param sources\nan Iterable of ObservableSource sources competing to react first.
A subscription to each source will\noccur in the same order as in the Iterable.
@return an Observable that emits the same sequence as whichever of the source ObservableSources first\nemitted an item or sent a termination notification\n@see ReactiveX operators documentation: Amb


...

Imago

Those extra replaces slash are not needed after .decode() – Correa

@Correa You know, I could not get it to work without them but that may have been specific to my use case. – Imago

"\x22".encode('unicode-escape').decode().replace('\\\\', '\\'), sorry but that's still just '"' – Stealthy

Answer 7

Just format like that:

s = "your string"; raw_s = r'{0}'.format(s)

Colettecoleus

No good for my case: r'{0}'.format("\x22"), which returns '"' in python 3.9. – Stealthy

Answer 8

s = "hel\nlo"
raws = '%r'%s #coversion to raw string
#print(raws) will print 'hel\nlo' with single quotes.
print(raws[1:-1]) # will print hel\nlo without single quotes.
#raws[1:-1] string slicing is performed

Degenerate

Answer 9

I suppose repr function can help you:

s = 't\n'
repr(s)
"'t\\n'"
repr(s)[1:-1]
't\\n'

Bardwell

Answer 10

With a little bit correcting @Jolly1234's Answer: here is the code:

raw_string=path.encode('unicode_escape').decode()

Giles

doesn't work for "\\ftac\admin\rec\pir".encode('unicode_escape').decode() – Finable

does not work at all in any way imaginable, only makes it worse by adding additional backslashes, completely useless – Meatman

Answer 11

The solution, which worked for me was:

fr"{orignal_string}"

Suggested in comments by @ChemEnger

Tetany

does not work at all in any way imaginable – Meatman

Answer 12

Just simply use the encode function.

my_var = 'hello'
my_var_bytes = my_var.encode()
print(my_var_bytes)

And then to convert it back to a regular string do this

my_var_bytes = 'hello'
my_var = my_var_bytes.decode()
print(my_var)

---

--EDIT--

The following does not make the string raw but instead encodes it to bytes and decodes it.

Mcdade

str.encode encodes the string to bytes, it doesn't create a raw string, which is a string in which a backslash is treated literally, not as an escape character. – Gibbs

Sorry about that I got slightly confused between them. – Mcdade