r/learnpython is probably a better subreddit for these kinds of questions.

Having said that, your first example actually works, try:

print("apple".replace('l', '\\'))

See Jamie Zawinksi's famous quote about regular expressions. Try to only resort to the use of re's when absolutely necessary. In this case, it isn't.

The actual content of string str (bad name for a variable, by the way, since there's a built-in type of that name) is

"abc INC\","None", "0", "test"

Why not just

str.replace('\\"', '|"')

which will do exactly what you want.

We need to specify that we want to replace a string that contains a single backslash. We cannot write that as "\", because the backslash is escaping the intended closing double-quote. We also cannot use a raw string literal for this: r"\" does not work.

Instead, we simply escape the backslash using another backslash:

result = string.replace("\\","")

No need to use str.replace or string.replace here, just convert that string to a raw string:

>>> strs = r"C:\Users\Josh\Desktop\20130216"
           ^
           |
       notice the 'r'

Below is the repr version of the above string, that's why you're seeing \\ here. But, in fact the actual string contains just '\' not \\.

>>> strs
'C:\\Users\\Josh\\Desktop\\20130216'

>>> s = r"f\o"
>>> s            #repr representation
'f\\o'
>>> len(s)   #length is 3, as there's only one `'\'`
3

But when you're going to print this string you'll not get '\\' in the output.

>>> print strs
C:\Users\Josh\Desktop\20130216

If you want the string to show '\\' during print then use str.replace:

>>> new_strs = strs.replace('\\','\\\\')
>>> print new_strs
C:\\Users\\Josh\\Desktop\\20130216

repr version will now show \\\\:

>>> new_strs
'C:\\\\Users\\\\Josh\\\\Desktop\\\\20130216'

You can use the string .replace() method along with rawstring.

Python 2:

>>> print r'pictures\12761_1.jpg'.replace("\\", "/")
pictures/12761_1.jpg

Python 3:

>>> print(r'pictures\12761_1.jpg'.replace("\\", "/"))
pictures/12761_1.jpg

There are two things to notice here:

• Firstly to read the text as a drawstring by putting r before the string. If you don't give that, there will be a Unicode error here.
• And also that there were two backslashes given inside the replace method's first argument. The reason for that is that backslash is a literal used with other letters to work as an escape sequence. Now you might wonder what is an escape sequence. So an escape sequence is a sequence of characters that doesn't represent itself when used inside string literal or character. It is composed of two or more characters starting with a backslash. Like '\n' represents a newline and similarly there are many. So to escape backslash itself which is usually an initiation of an escape sequence, we use another backslash to escape it.

I know the second part is bit confusing but I hope it made some sense.

Take a closer look at the string, they are all single slash.

In [26]: my_str[0]
Out[26]: '\\'

In [27]: my_str[1]
Out[27]: 'x'

In [28]: len(my_str[0])
Out[28]: 1

And my_str.replace('\\','\') won't work because the token here is \', which escapes ' and waits for the another closing '.
Use my_str.replace('\\', '') instead

Update: after few more days, I realize the following discussion may also be helpful. If the intension of a string with escape ('\\x' or '\\u') are eventually hex/unicode literals, they can be decoded by escape_decode.

import codecs
print(len(b'\x32'), b'\x32')                # 1 hex literal, '\x32' == '2'
print(len(b'\\x32'), b'\\x32')              # 4 chars including escapes
print(codecs.escape_decode('\\x32', 'hex')) # chars->literal, 4->1

# 1 b'2'
# 4 b'\\x32'
# (b'2', 4)

s = '\\xa5\\xc0\\xe6aK\\xf9\\x80\\xb1\\xc8*\x01\x12$\\xfbp\x1e(4\\xd6{;Z'
ed, _ = codecs.escape_decode(s, 'hex')
print(len(s), s)
print(len(ed), ed)

# 49 \xa5\xc0\xe6aK\xf9\x80\xb1\xc8*$\xfbp(4\xd6{;Z
# 22 b'\xa5\xc0\xe6aK\xf9\x80\xb1\xc8*\x01\x12$\xfbp\x1e(4\xd6{;Z'

# This string contains no backslashes; it's a single linebreak.
mystr = "\n"
# Hence this does nothing:
mystr.replace("\\", 'x') 
# and this is False:
print(mystr.startswith('\\'))

# This is a syntax error because the \ escapes the '
print(ord('\')) #EOL Err

# This is still False because there's still no '\\` in mystr
print(ord(mystr[0]) == ord('\\')) #False

If you use the \\ escape consistently you get the results you're looking for:

# This string contains a backslash and an n.
mystr = '\\n'
# Now this prints "xn":
print(mystr.replace('\\', 'x'))
# and this is True:
print(mystr.startswith('\\'))

# This prints 92
print(ord('\\'))

# This is also True:
print(ord(mystr[0]) == ord('\\'))

You can define mystr as a raw string (making '\n' a literal \ followed by n), but this doesn't work for strings like '\' because even in a raw string, the \ escapes any quotation mark immediately following it. For a string ending in \ you still need to use a normal escape sequence.

mystr = r'\n'
print(mystr.replace('\\', 'x'))
print(mystr.startswith('\\'))

print(ord('\\'))
print(ord(mystr[0]) == ord('\\'))

The difference between a string literal and a raw string is the way they are interpreted to create a string object from your source code. The objects they create are not distinct in any way. So there is no such thing as converting a string to a raw string.

In this case, '\018' stands for '\x01', which is the Start-of-Header character, followed by the character '8'.

chr(1) + '8' == '\x018' # True

And as you can see, your string contains no '\\' character.

'\\' in 'бекслеш \018 на точку' # False

Your \ is hiding the closing " so you need to use \\ - but python shouldn't care about the slashes in the path.

By default, pandas.Series.str.replace does regex substitution, not string replacement. It delegates to re.sub, not str.replace. If you want to use non-regex mode, pass regex=False:

df[whatever].str.replace('EXAMPLE\\', '', regex=False)

Alternatively, you could use a valid regex. The regex engine does its own backslash processing, so you need to use a raw string literal to avoid Python's own backslash processing:

df[whatever].str.replace(r'EXAMPLE\\', '')

See the pandas.Series.str.replace docs for other arguments and more examples.

Not sure if this is appropriate for your situation, but you could try using unicode_escape:

>>> t
'\\u0048\\u0065\\u006c\\u006c\\u006f\\u0020\\u20ac\\u0020\\u00b0'
>>> type(t)
<class 'str'>
>>> enc_t = t.encode('utf_8')
>>> enc_t
b'\\u0048\\u0065\\u006c\\u006c\\u006f\\u0020\\u20ac\\u0020\\u00b0'
>>> type(enc_t)
<class 'bytes'>
>>> dec_t = enc_t.decode('unicode_escape')
>>> type(dec_t)
<class 'str'>
>>> dec_t
'Hello € °'

Or in abbreviated form:

>>> t.encode('utf_8').decode('unicode_escape')
'Hello € °'

You take your string and encode it using UTF-8, and then decode it using unicode_escape.