Regex to the rescue!

import re

s = re.sub('[^0-9a-zA-Z]+', '*', s)

Example:

>>> re.sub('[^0-9a-zA-Z]+', '*', 'h^&ell`.,|o w]{+orld')
'h*ell*o*w*orld'

You can specify everything that you need not remove in the negated character clas.

re.sub(r'[^\w'+removelist+']', '',mystring)

Test

>>> import re
>>> removelist = "=."
>>> mystring = "asdf1234=.!@#$"
>>> re.sub(r'[^\w'+removelist+']', '',mystring)
'asdf1234=.'

Here the removelist variable is a string which contains the list of all characters you need to exclude from the removal.

What does negated character class means

When the ^ is moved into the character class it does not acts as an anchor where as it negates the character class.

That is ^ in inside a character class say like [^abc] it negates the meaning of the character class.

For example [abc] will match a b or c where as [^abc] will not match a b or c. Which can also be phrased as anything other than a b or c

I just timed some functions out of curiosity. In these tests I'm removing non-alphanumeric characters from the string string.printable (part of the built-in string module). The use of compiled '[\W_]+' and pattern.sub('', str) was found to be fastest.

$ python -m timeit -s \
     "import string" \
     "''.join(ch for ch in string.printable if ch.isalnum())" 
10000 loops, best of 3: 57.6 usec per loop

$ python -m timeit -s \
    "import string" \
    "filter(str.isalnum, string.printable)"                 
10000 loops, best of 3: 37.9 usec per loop

$ python -m timeit -s \
    "import re, string" \
    "re.sub('[\W_]', '', string.printable)"
10000 loops, best of 3: 27.5 usec per loop

$ python -m timeit -s \
    "import re, string" \
    "re.sub('[\W_]+', '', string.printable)"                
100000 loops, best of 3: 15 usec per loop

$ python -m timeit -s \
    "import re, string; pattern = re.compile('[\W_]+')" \
    "pattern.sub('', string.printable)" 
100000 loops, best of 3: 11.2 usec per loop

My answer to your previous question still applies, with some minor modifications. Only the regex changes.

Since this is more complex, define a function to pass as a callback.

In [57]: def foo(m):
    ...:     return ''.join(x if re.match('[a-zA-Z]', x)\
                              else ('' if x == '\\' else 'a') for x in m.group()) 

Now, call re.sub:

In [58]: re.sub(r'\\.*?(?= |$)', foo, text)
Out[58]: 'here i$ aame text to madify'

You were very close. You just don't need the + , because then that would would replace multiple occurances with just one dash.

You need:

re.sub('[^0-9a-zA-Z]', '-', s)

Example:

import re

s = 'ABCDE : CE ; CUSTOMER : Account Number; New Sales'

print(re.sub('[^0-9a-zA-Z]', '-', s))
# ABCDE---CE---CUSTOMER---Account-Number--New-Sales

The [..] form is known as a collection (:h /[]) and can contain a sequence of characters and/or one or more ranges of characters, separated with -. It will match any single character that is contained in the sequence/range(s). You can, of course, also match the inverse with ^.

In :h white-space you'll find a collection equivalent to \w:

\w  word character:         [0-9A-Za-z_]

So one approach is to invert/negate that equivalent:

[^0-9A-Za-z_]

Alternatively, collections can also contain the "character classes" found under :h E944. These are the same character classes that have been around forever in the BRE/ERE patterns used by legacy tools and POSIX environments.

Alphanumeric chars have the following character class equivalent:

[:alnum:]   isalnum ASCII letters and digits

You can invert/negate that like so:

[^[:alnum:]]

(You could also probably use negative lookarounds with \w but that's relatively difficult compared to this straightforward analog to [^\w].)

Update: I just realized I didn't address the full pattern you posted. Just look for a character class that's equivalent to \s and you'll find [:space:]. And " is just ". So [^\w\s"] becomes:

[^[:alnum:][:space:]"]

One other thing, this is likely to be the most performant of any possible solutions since others have lookarounds or alternations (|) and those are expensive.

Something like that is perfect for regular expressions. re.sub takes as input a regular expression that defines what to match, a string (or a function) to decide what to replace what is matched with, and a string to do all this matching and replacing on. As an example:

import re
string = "lincoln's silly flat dishwatery utterances chicago times 1863"
print re.sub(r'[^a-zA-Z ]', '', string).split()

# ouputs:
# ['lincolns', 'silly', 'flat', 'dishwatery', 'utterances', 'chicago', 'times']

This will replace all characters that are not between lowercase a-z, uppercase A-Z, or a space, with nothing -- essentially removing them.