Python3:

>>> b'\\u201c'.decode('unicode_escape')
'“'

or

>>> '\\u201c'.encode().decode('unicode_escape')
'“'

why not use string.replace()?

>>> s = 'some \\\\ doubles'
>>> print s
some \\ doubles
>>> print s.replace('\\\\', '\\')
some \ doubles

Or with "raw" strings:

>>> s = r'some \\ doubles'
>>> print s
some \\ doubles
>>> print s.replace('\\\\', '\\')
some \ doubles

Since the escape character is complicated, you still need to escape it so it does not escape the '

Not sure if this is exactly what you want, but it might be:

import json

print(json.dumps("abc").replace(r'\"', '"').replace('"', r'\"'))

Result:

\"abc\"

Instead of focusing on the backslashes to try to "hack" a json string / dict str into a JSON, a better solution is to take it one step at a time and start by converting my dict string into a dictionary.

import ast
txt = ast.literal_eval(txt) # convert my string to a dictionary
txt = json.loads(json.dumps(txt)) # convert my dict to JSON

You could remove dublicated backslashes with:

json.dumps(es_secret_data).replace('\\\\', '\\')

you need to escape the backslash character in python with a backslash. Thats why there is a quadruple-backslash.

But keep in mind that json adds those extra-backslashes for a reason. After replacing them, you will not be able to use json.reads() to get the original password. Json uses the backslash to escape the backslash. So a double-backslash in json stands for a single json-charakter

You are seeing an escaped forward slash. The JSON standard allows any character to be escaped, and the forward slash can be escaped by preceding it with a backward slash. See the Strings section of RFC 7159.

So \/ is an just an escaped representation for the value /:

>>> import json
>>> print json.loads(r'{"date": "\/Date(1411084800000)\/"}')
{u'date': u'/Date(1411084800000)/'}

Note how the \/ is decoded to / in the output. This escaping is entirely optional.

Your browser does the same thing; when any compliant JSON value which includes strings containing \/ sequences is being parsed, the resulting string values containg just / forward slashes. When the Kendo JSONP response (which does use \/ in strings) is received, the browser produces the exact same result as a JSONP response with the forward slashes left un-escaped.

Just provide the value in Python with the forward slashes. json.dumps() will not escape the forward slash (it doesn't have to escape it), and your browser and any other JSON compliant parser will produce the exact same value:

>>> print json.dumps({'date': '/Date(1411084800000)/'})
{"date": "/Date(1411084800000)/"}

Are you sure it actually contains slashes? Or is it just an artefact of how it's being displayed? What is the result of my_json_string[1] - is it a slash, or a quote?

a = 'RXIE-SERVER\\MSSQLSERVER_NEW'

doesn't have a double backslash. It has an escaped single backslash, it's just safer (and will eventually be required) to escape it so Python doesn't think \M is an attempt at a string escape. If you do:

print(a)

you'll see it only prints one backslash (because print outputs the raw data without showing escapes).

The reason a.replace('\\', '') doesn't work is because it replaced the single backslash with nothing (and it would do so for all backslashes); a.replace('\\\\', '\\') doesn't work because '\\\\' represents the actual doubled backslash, and you don't have any of those.

If your input came from some other source (not the literal you described) and actually has a doubled-backslash, then a.replace('\\\\', '\\') actually worked, but REPL's echo the repr of the object, and for str, that means adding the backslash escape to make it a legal, equivalent str literal, so it looked like a double-backslash, but only had one. If you change >>> a.replace('\\\\', '\\') to >>> print(a.replace('\\\\', '\\')) (which prints the human-friendly form, not the repr), you'll see it display only a single backslash.

If you don't like how it looks in your code, use raw strings to remove the need for the escape:

a = r'RXIE-SERVER\MSSQLSERVER_NEW'
#   ^ note prefix that makes it raw

The problem is that in a JSON string literal, a backslash has to be escaped to produce a literal \. However, you then need to escape all of those backslashes in your Python string literal to create the correct JSON string value.

>>> json.dumps("\\")  # A string consisting of a single backslash
'"\\\\"'

In your exact case, a properly encoded version of the path would be

>>> json.dumps({'mypath': r'\\sys\tld\a\b\c'})
'{"mypath": "\\\\\\\\sys\\\\tld\\\\a\\\\b\\\\c"}'

That looks like a lot of backslashes, but most of them are added by str.__repr__ for display purposes, not part of the actual value.

>>> print(json.dumps({'mypath': r'\\sys\tld\a\b\c'}))
{"mypath": "\\\\sys\\tld\\a\\b\\c"}

Each backslash in the original path corresponds to two backslashes in the JSON-encoded string.

---

Using a raw string literal prevents you from having to escape each backslash again in the literal:

>>> '\\\\sys\\tld\\a\\b\\c'
'\\\\sys\\tld\\a\\b\\c'
>>> r'\\sys\tld\a\b\c'
'\\\\sys\\tld\\a\\b\\c'

However, a raw string literal cannot end with a backslash, meaning you'll have to at least rely on string literal concatenation to append a backslash to a raw string literal.

>>> '\\foo\\'
'\\foo\\'
>>> r'\foo''\\'
'\\foo\\'

---

In the end, though, it's simplest to avoid Windows-style file paths altogether. At the very least, Python built-in functions like open will parse POSIX-style paths correctly, even on Windows.

# Open \\sys\tld\a\b\c
with open('//sys/tld/a/b/c') as f:
    ...

\\ is not double backslash but one escaped. Look:

print b'Z\xa6\x97\x86j2\x08q\\r\xca\xe6m'
# Z���jq\r��m

And \r (from your desired output) is not 2 chars but one:

print b'Z\xa6\x97\x86j2\x08q\r\xca\xe6m'
# ��m�jq

(When printing it to terminal, carriage return \r prevents us from seen the first letter Z)

If you really want to replace '\\r' with '\r', you can do:

print repr(word.replace('\\r', '\r'))
# 'Z\xa6\x97\x86j2\x08q\r\xca\xe6m'
print word.replace('\\r', '\r')
# ��m�jq

Or, if you want to replace all the escape sequences. Python2 version:

print repr(b'1\\t2\\n3'.decode('string_escape'))
# '1\t2\n3'
print b'1\\t2\\n3'.decode('string_escape')
# 1 2
# 3

Python3 version:

print(repr(b'1\\t2\\n3'.decode('unicode_escape')))
# '1\t2\n3'
print(b'1\\t2\\n3'.decode('unicode_escape'))
# 1 2
# 3

No need to use str replace or string replace here just convert that string to a raw string gt gt gt 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 gt gt gt strs C Users Josh Desktop 20130216 gt gt gt s r f o gt gt gt s repr representation f o gt gt gt 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 gt gt gt print strs C Users Josh Desktop 20130216 If you want the string to show during print then use str replace gt gt gt new strs strs replace gt gt gt print new strs C Users Josh Desktop 20130216 repr version will now show gt gt gt new strs C Users Josh Desktop 20130216