Supprimer tous les caractères spéciaux, la ponctuation et les espaces de la chaîne

Voici une expression rationnelle pour correspondre à une chaîne de caractères qui ne sont pas des lettres ou des chiffres:

[^A-Za-z0-9]+

Voici la commande Python pour faire une substitution regex:

re.sub('[^A-Za-z0-9]+', '', mystring)

Chemin plus court:

import re
cleanString = re.sub('\W+','', string )

Si vous voulez des espaces entre les mots et les nombres, remplacez " par ''

Je pense que juste filter(str.isalnum, string) fonctionne

In [20]: filter(str.isalnum, 'string with special chars like !,#$% etcs.')
Out[20]: 'stringwithspecialcharslikeetcs'

#!/usr/bin/python
import re

strs = "how much for the maple syrup? $20.99? That's ricidulous!!!"
print strs
nstr = re.sub(r'[?|$|.|!]',r'',strs)
print nstr
nestr = re.sub(r'[^a-zA-Z0-9 ]',r'',nstr)
print nestr

Vous pouvez ajouter plus de caractère spécial et qui sera remplacé par " ne signifie rien, c'est-à-dire qu'ils seront supprimés.

Après avoir vu cela, j'étais intéressé à développer les réponses fournies en découvrant qui s'exécute le moins de temps possible, alors j'ai vérifié certaines des réponses proposées avec timeit contre deux des chaînes d'exemple:

• string1 = 'Special $#! characters spaces 888323'
• string2 = 'how much for the maple syrup? $20.99? That s ricidulous!!!'

Exemple 1

'.join(e for e in string if e.isalnum())

• string1 Résultat: 10.7061979771
• string2 Résultat: 7.78372597694

Exemple 2

import re re.sub('[^A-Za-z0-9]+', '', string)

• string1 Résultat: 7.10785102844
• string2 Résultat: 4.12814903259

Exemple 3

import re re.sub('\W+','', string)

• string1 Résultat: 3.11899876595
• string2 Résultat: 2.78014397621

Les résultats ci-dessus sont un produit du résultat le plus bas obtenu à partir d'une moyenne de: repeat(3, 2000000)

Exemple 3 peut être 3x plus rapide que Exemple 1.

En supposant que vous voulez utiliser une expression rationnelle et que vous voulez / avez besoin D'Unicode-cognisant 2.code x qui est 2to3-prêt:

>>> import re
>>> rx = re.compile(u'[\W_]+', re.UNICODE)
>>> data = u''.join(unichr(i) for i in range(256))
>>> rx.sub(u'', data)
u'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\xaa\xb2 [snip] \xfe\xff'
>>>

L'approche la plus générique utilise les "catégories" de la table unicodedata qui classe chaque caractère. Par exemple, le code suivant filtre uniquement les caractères imprimables en fonction de leur catégorie:

import unicodedata
# strip of crap characters (based on the Unicode database
# categorization:
# http://www.sql-und-xml.de/unicode-database/#kategorien

PRINTABLE = set(('Lu', 'Ll', 'Nd', 'Zs'))

def filter_non_printable(s):
    result = []
    ws_last = False
    for c in s:
        c = unicodedata.category(c) in PRINTABLE and c or u'#'
        result.append(c)
    return u''.join(result).replace(u'#', u' ')

Regardez l'URL donnée ci-dessus pour toutes les catégories connexes. Vous pouvez également bien sûr filtrer par les catégories de ponctuation.

Utiliser traduire:

import string

def clean(instr):
    return instr.translate(None, string.punctuation + ' ')

Mise en garde: ne fonctionne que sur les chaînes ascii.

s = re.sub(r"[-()\"#/@;:<>{}`+=~|.!?,]", "", s)

import re
abc = "askhnl#$%askdjalsdk"
ddd = abc.replace("#$%","")
print (ddd)

Et vous verrez votre résultat comme

' askhnlaskdjalsdk

Différemment que tout le monde a fait en utilisant regex, j'essaierais d'exclure chaque caractère qui n'est pas ce que je veux, au lieu d'énumérer explicitement ce que je ne veux pas.

Par exemple, si Je ne veux que des caractères de ' A à z '(majuscules et minuscules) et des nombres, j'exclurais tout le reste:

import re
s = re.sub(r"[^a-zA-Z0-9]","",s)

Cela signifie " remplacer chaque caractère qui n'est pas un nombre, ou un caractère dans la plage 'a à z' ou 'A à Z' par une chaîne vide".

En fait, si vous insérer le caractère spécial ^ à la première place de votre regex, vous obtiendrez la négation.

Astuce supplémentaire: si vous avez également besoin de minuscules le résultat, vous pouvez rendre l'expression rationnelle encore plus rapide et plus facile, tant que vous ne trouverez pas de majuscules maintenant.

import re
s = re.sub(r"[^a-z0-9]","",s.lower())

import re
my_string = """Strings are amongst the most popular data types in Python. We can create the strings by enclosing characters in quotes. Python treats single quotes the 

Identique aux guillemets doubles."""

# if we need to count the word python that ends with or without ',' or '.' at end

count = 0
for i in text:
    if i.endswith("."):
        text[count] = re.sub("^([a-z]+)(.)?$", r"\1", i)
    count += 1
print("The count of Python : ", text.count("python"))