So there are following things which are wrong in your pattern, let's address them first

• A-z - It includes all the character from ascii table starting from A to z, which also has non alphabetical characters which we don't want to match, so the correct one should be [A-Z] if we want only uppercase, if we want both upper and lowercase then it should be [A-Za-z] or you can turn on i flag
• ^\s - ^ means negation only when you use it as first character inside the character class elsewhere it is treated as literal ^

So your regex should be

 [^A-Za-z\s]

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'

Use re.sub

import re

regex = re.compile('[^a-zA-Z]')
#First parameter is the replacement, second parameter is your input string
regex.sub('', 'ab3d*E')
#Out: 'abdE'

Alternatively, if you only want to remove a certain set of characters (as an apostrophe might be okay in your input...)

regex = re.compile('[,\.!?]') #etc.

Since you are using Python 2.x, your r'\P{L}' is a byte string, while the input you have is Unicode. You need to make your pattern a Unicode string. See the PyPi regex reference:

If neither the ASCII, LOCALE nor UNICODE flag is specified, it will default to UNICODE if the regex pattern is a Unicode string and ASCII if it’s a bytestring.

Thus, you need to use ur'\P{L}' and a u' ' replacement pattern.

In case you want to match 1+ chars other than letters and diacritics, you will need ur'[^\p{L}\p{M}]+' regex.

A fair bit faster and works for Unicode:

full_pattern = re.compile('[^a-zA-Z0-9\\\/]|_')

def re_replace(string):
    return re.sub(full_pattern, '', string)

If you want it really fast, this is by far the best (but slightly obscure) method:

def wanted(character):
    return character.isalnum() or character in '\\/'

ascii_characters = [chr(ordinal) for ordinal in range(128)]
ascii_code_point_filter = [c if wanted(c) else None for c in ascii_characters]

def fast_replace(string):
    # Remove all non-ASCII characters. Heavily optimised.
    string = string.encode('ascii', errors='ignore').decode('ascii')

    # Remove unwanted ASCII characters
    return string.translate(ascii_code_point_filter)

Timings:

SETUP="
busy = ''.join(chr(i) for i in range(512))

import re
full_pattern = re.compile('[^a-zA-Z0-9\\\/]|_')

def in_whitelist(character):
    return character.isalnum() or character in '\\/'

def re_replace(string):
    return re.sub(full_pattern, '', string)

def wanted(character):
    return character.isalnum() or character in '\\/'

ascii_characters = [chr(ordinal) for ordinal in range(128)]
ascii_code_point_filter = [c if wanted(c) else None for c in ascii_characters]

def fast_replace(string):
    string = string.encode('ascii', errors='ignore').decode('ascii')
    return string.translate(ascii_code_point_filter)
"

python -m timeit -s "$SETUP" "re_replace(busy)"
python -m timeit -s "$SETUP" "''.join(e for e in busy if in_whitelist(e))"
python -m timeit -s "$SETUP" "fast_replace(busy)"

Results:

10000 loops, best of 3: 63 usec per loop
10000 loops, best of 3: 135 usec per loop
100000 loops, best of 3: 4.98 usec per loop

The faster way to do it is to use str.translate() This is ~50 times faster than your way

# You only need to do this once
>>> title_trans=''.join(chr(c) if chr(c).isupper() or chr(c).islower() else '_' for c in range(256))

>>> "abcde1234!@%^".translate(title_trans)
'abcde________'

# Using map+lambda
$ python -m timeit '"".join(map(lambda x: x if (x.isupper() or x.islower()) else "_", "abcd1234!@#$".strip()))'
10000 loops, best of 3: 21.9 usec per loop

# Using str.translate
$ python -m timeit -s 'titletrans="".join(chr(c) if chr(c).isupper() or chr(c).islower() else "_" for c in range(256))' '"abcd1234!@#$".translate(titletrans)'
1000000 loops, best of 3: 0.422 usec per loop

# Here is regex for a comparison
$ python -m timeit -s 'import re;transre=re.compile("[\W\d]+")' 'transre.sub("_","abcd1234!@#$")'
100000 loops, best of 3: 3.17 usec per loop

Here is a version for unicode

# coding: UTF-8

def format_title_unicode_translate(title):
    return title.translate(title_unicode_trans)

class TitleUnicodeTranslate(dict):
    def __missing__(self,item):
        uni = unichr(item)
        res = u"_"
        if uni.isupper() or uni.islower():
            res = uni
        self[item] = res
        return res
title_unicode_trans=TitleUnicodeTranslate()

print format_title_unicode_translate(u"Metallica Μεταλλικα")

Note that the Greek letters count as upper and lower, so they are not substituted. If they are to be substituted, simply change the condition to

        if item<256 and (uni.isupper() or uni.islower()):

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.

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

Given

s = '@#24A-09=wes()&8973o**_##me'  # contains letters 'Awesome'    

You can filter out non-alpha characters with a generator expression:

result = ''.join(c for c in s if c.isalpha())

Or filter with filter:

result = ''.join(filter(str.isalpha, s))    

Or you can substitute non-alpha with blanks using re.sub:

import re
result = re.sub(r'[^A-Za-z]', '', s)