J'essaie de supprimer des caractères spécifiques d'une chaîne à l'aide de Python. C'est le code que j'utilise en ce moment. Malheureusement, il semble ne rien faire à la chaîne.

for char in line:
    if char in " ?.!/;:":
        line.replace(char,'')

Comment dois-je procéder correctement?

Les chaînes en Python sont immuables (ne peuvent pas être modifiées). Pour cette raison, l'effet de line.replace(...)est simplement de créer une nouvelle chaîne, plutôt que de changer l'ancienne. Vous devez la relier (l'assigner) linepour que cette variable prenne la nouvelle valeur, avec ces caractères supprimés.

De plus, la façon dont vous le faites va être relativement lente. Cela risque également d'être un peu déroutant pour les pythonateurs expérimentés, qui verront une structure doublement imbriquée et penseront un instant que quelque chose de plus compliqué se passe.

À partir de Python 2.6 et des versions plus récentes de Python 2.x *, vous pouvez utiliser à la place str.translate, (mais lisez la suite pour les différences Python 3):

line = line.translate(None, '!@#$')

ou remplacement d'expression régulière par re.sub

import re
line = re.sub('[!@#$]', '', line)

Les caractères entre crochets constituent une classe de caractères . Tous les caractères dans linelesquels se trouvent dans cette classe sont remplacés par le deuxième paramètre pour sub: une chaîne vide.

En Python 3, les chaînes sont Unicode. Vous devrez traduire un peu différemment. kevpie le mentionne dans un commentaire sur l'une des réponses, et c'est noté dans la documentation destr.translate .

Lors de l'appel de la translateméthode d'une chaîne Unicode, vous ne pouvez pas passer le deuxième paramètre que nous avons utilisé ci-dessus. Vous ne pouvez pas non plus passer Nonecomme premier paramètre. Au lieu de cela, vous passez une table de traduction (généralement un dictionnaire) comme seul paramètre. Ce tableau mappe les valeurs ordinales des caractères (c'est-à-dire le résultat de leur appel ord) aux valeurs ordinales des caractères qui devraient les remplacer, ou - utilement pour nous - Nonepour indiquer qu'ils doivent être supprimés.

Donc, pour faire la danse ci-dessus avec une chaîne Unicode, vous appelleriez quelque chose comme

translation_table = dict.fromkeys(map(ord, '!@#$'), None)
unicode_line = unicode_line.translate(translation_table)

Ici dict.fromkeyset mapsont utilisés pour générer succinctement un dictionnaire contenant

{ord('!'): None, ord('@'): None, ...}

Encore plus simple, comme le dit une autre réponse , créez la table de traduction en place:

unicode_line = unicode_line.translate({ord(c): None for c in '!@#$'})

Ou créez la même table de traduction avec str.maketrans:

unicode_line = unicode_line.translate(str.maketrans('', '', '!@#$'))

* pour la compatibilité avec les Pythons antérieurs, vous pouvez créer une table de traduction "null" à passer à la place de None:

import string
line = line.translate(string.maketrans('', ''), '!@#$')

Ici string.maketransest utilisé pour créer une table de traduction , qui est juste une chaîne contenant les caractères avec des valeurs ordinales de 0 à 255.

Est-ce que je manque le point ici, ou est-ce juste le suivant:

string = "ab1cd1ef"
string = string.replace("1","") 

print string
# result: "abcdef"

Mettez-le en boucle:

a = "a!b@c#d$"
b = "!@#$"
for char in b:
    a = a.replace(char,"")

print a
# result: "abcd"

>>> line = "abc#@!?efg12;:?"
>>> ''.join( c for c in line if  c not in '?:!/;' )
'abc#@efg12'

Peasy facile avec re.subexpression régulière à partir de Python 3.5

re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)

Exemple

>>> import re

>>> line = 'Q: Do I write ;/.??? No!!!'

>>> re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)
'QDoIwriteNo'

Explication

Dans les expressions régulières (regex), |est un OU logique et \échappe les espaces et les caractères spéciaux qui peuvent être des commandes regex réelles. Alors que subsignifie substitution, dans ce cas avec la chaîne vide ''.

Pour l'exigence inverse d' autoriser uniquement certains caractères dans une chaîne, vous pouvez utiliser des expressions régulières avec un opérateur complément complément [^ABCabc]. Par exemple, pour supprimer tout sauf les lettres ascii, les chiffres et le tiret:

>>> import string
>>> import re
>>>
>>> phrase = '  There were "nine" (9) chick-peas in my pocket!!!      '
>>> allow = string.letters + string.digits + '-'
>>> re.sub('[^%s]' % allow, '', phrase)

'Therewerenine9chick-peasinmypocket'

Dans la documentation des expressions régulières python :

Les caractères qui ne se trouvent pas dans une plage peuvent être mis en correspondance en complétant l'ensemble. Si le premier caractère de l'ensemble est '^', tous les caractères qui ne sont pas dans l'ensemble seront mis en correspondance. Par exemple, [^5]correspondra à n'importe quel caractère sauf «5» et [^^]correspondra à n'importe quel caractère sauf '^'. ^n'a pas de signification particulière si ce n'est pas le premier caractère de l'ensemble.

Le demandeur l'a presque eu. Comme la plupart des choses en Python, la réponse est plus simple que vous ne le pensez.

>>> line = "H E?.LL!/;O:: "  
>>> for char in ' ?.!/;:':  
...  line = line.replace(char,'')  
...
>>> print line
HELLO

Vous n'avez pas à faire la boucle imbriquée if / for, mais vous devez vérifier chaque caractère individuellement.

line = line.translate(None, " ?.!/;:")

>>> s = 'a1b2c3'
>>> ''.join(c for c in s if c not in '123')
'abc'

Les chaînes sont immuables en Python. La replaceméthode renvoie une nouvelle chaîne après le remplacement. Essayer:

for char in line:
    if char in " ?.!/;:":
        line = line.replace(char,'')

J'ai été surpris que personne n'ait encore recommandé d'utiliser la fonction de filtre intégré .

    import operator
    import string # only for the example you could use a custom string

    s = "1212edjaq"

Disons que nous voulons filtrer tout ce qui n'est pas un nombre. L'utilisation de la méthode de filtrage intégrée "... est équivalente à l'expression du générateur (élément pour élément dans la fonction itérable si élément (élément))" [ Python 3 Builtins: Filter ]

    sList = list(s)
    intsList = list(string.digits)
    obj = filter(lambda x: operator.contains(intsList, x), sList)))

En Python 3, cela renvoie

    >>  <filter object @ hex>

Pour obtenir une chaîne imprimée,

    nums = "".join(list(obj))
    print(nums)
    >> "1212"

Je ne sais pas comment le filtre se classe en termes d'efficacité, mais c'est une bonne chose de savoir comment l'utiliser lors de la compréhension de listes et autres.

MISE À JOUR

Logiquement, puisque le filtre fonctionne, vous pouvez également utiliser la compréhension de liste et d'après ce que j'ai lu, il est censé être plus efficace car les lambdas sont les gestionnaires de fonds spéculatifs de Wall Street du monde de la fonction de programmation. Un autre avantage est qu'il s'agit d'un monoplace qui ne nécessite aucune importation. Par exemple, en utilisant la même chaîne «s» définie ci-dessus,

      num = "".join([i for i in s if i.isdigit()])

C'est ça. Le retour sera une chaîne de tous les caractères qui sont des chiffres de la chaîne d'origine.

Si vous avez une liste spécifique de caractères acceptables / inacceptables, il vous suffit d'ajuster la partie «si» de la compréhension de la liste.

      target_chars = "".join([i for i in s if i in some_list]) 

Ou bien,

      target_chars = "".join([i for i in s if i not in some_list])

À l'aide filter, vous auriez juste besoin d'une ligne

line = filter(lambda char: char not in " ?.!/;:", line)

Cela traite la chaîne comme un itérable et vérifie chaque caractère si le lambdaretourne True:

>>> help(filter)
Help on built-in function filter in module __builtin__:

filter(...)
    filter(function or None, sequence) -> list, tuple, or string

    Return those items of sequence for which function(item) is true.  If
    function is None, return the items that are true.  If sequence is a tuple
    or string, return the same type, else return a list.

Voici quelques façons possibles d'accomplir cette tâche:

def attempt1(string):
    return "".join([v for v in string if v not in ("a", "e", "i", "o", "u")])


def attempt2(string):
    for v in ("a", "e", "i", "o", "u"):
        string = string.replace(v, "")
    return string


def attempt3(string):
    import re
    for v in ("a", "e", "i", "o", "u"):
        string = re.sub(v, "", string)
    return string


def attempt4(string):
    return string.replace("a", "").replace("e", "").replace("i", "").replace("o", "").replace("u", "")


for attempt in [attempt1, attempt2, attempt3, attempt4]:
    print(attempt("murcielago"))

PS: Au lieu d'utiliser "?.! /;:" Les exemples utilisent les voyelles ... et oui, "murcielago" est le mot espagnol pour dire bat ... mot drôle car il contient toutes les voyelles :)

PS2: Si vous êtes intéressé par les performances, vous pouvez mesurer ces tentatives avec un code simple comme:

import timeit


K = 1000000
for i in range(1,5):
    t = timeit.Timer(
        f"attempt{i}('murcielago')",
        setup=f"from __main__ import attempt{i}"
    ).repeat(1, K)
    print(f"attempt{i}",min(t))

Dans ma boîte, vous obtiendrez:

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

Il semble donc que try4 soit le plus rapide pour cette entrée particulière.

Voici ma version compatible Python 2/3. Depuis l'api de traduction a changé.

def remove(str_, chars):
    """Removes each char in `chars` from `str_`.

    Args:
        str_: String to remove characters from
        chars: String of to-be removed characters

    Returns:
        A copy of str_ with `chars` removed

    Example:
            remove("What?!?: darn;", " ?.!:;") => 'Whatdarn'
    """
    try:
        # Python2.x
        return str_.translate(None, chars)
    except TypeError:
        # Python 3.x
        table = {ord(char): None for char in chars}
        return str_.translate(table)

#!/usr/bin/python
import re

strs = "how^ much for{} the maple syrup? $20.99? That's[] ricidulous!!!"
print strs
nstr = re.sub(r'[?|$|.|!|a|b]',r' ',strs)#i have taken special character to remove but any #character can be added here
print nstr
nestr = re.sub(r'[^a-zA-Z0-9 ]',r'',nstr)#for removing special character
print nestr

Que dis-tu de ça:

def text_cleanup(text):
    new = ""
    for i in text:
        if i not in " ?.!/;:":
            new += i
    return new

Vous pouvez également utiliser une fonction afin de remplacer différents types d'expressions régulières ou d'autres modèles par l'utilisation d'une liste. Avec cela, vous pouvez mélanger expression régulière, classe de caractères et modèle de texte vraiment basique. C'est vraiment utile lorsque vous devez remplacer de nombreux éléments comme ceux HTML.

* NB: fonctionne avec Python 3.x

import re  # Regular expression library


def string_cleanup(x, notwanted):
    for item in notwanted:
        x = re.sub(item, '', x)
    return x

line = "<title>My example: <strong>A text %very% $clean!!</strong></title>"
print("Uncleaned: ", line)

# Get rid of html elements
html_elements = ["<title>", "</title>", "<strong>", "</strong>"]
line = string_cleanup(line, html_elements)
print("1st clean: ", line)

# Get rid of special characters
special_chars = ["[!@#$]", "%"]
line = string_cleanup(line, special_chars)
print("2nd clean: ", line)

Dans la fonction string_cleanup, il prend votre chaîne x et votre liste non souhaitées comme arguments. Pour chaque élément de cette liste d'éléments ou de motif, si un substitut est nécessaire, il sera effectué.

Le résultat:

Uncleaned:  <title>My example: <strong>A text %very% $clean!!</strong></title>
1st clean:  My example: A text %very% $clean!!
2nd clean:  My example: A text very clean

Ma méthode que j'utiliserais ne fonctionnerait probablement pas aussi efficacement, mais elle est extrêmement simple. Je peux supprimer plusieurs caractères à différentes positions à la fois, en utilisant le découpage et le formatage. Voici un exemple:

words = "things"
removed = "%s%s" % (words[:3], words[-1:])

Cela se traduira par «supprimé» contenant le mot «ceci».

Le formatage peut être très utile pour imprimer des variables au milieu d'une chaîne d'impression. Il peut insérer n'importe quel type de données en utilisant un % suivi du type de données de la variable; tous les types de données peuvent utiliser % s , et les flottants (aussi appelés décimales) et les entiers peuvent utiliser % d .

Le découpage peut être utilisé pour un contrôle complexe des chaînes. Lorsque je mets des mots [: 3] , cela me permet de sélectionner tous les caractères de la chaîne depuis le début (les deux-points sont avant le nombre, cela signifie «du début à») jusqu'au 4ème caractère (il inclut le 4ème personnage). La raison pour laquelle 3 est égal jusqu'à la 4ème position est parce que Python commence à 0. Ensuite, quand je mets le mot [-1:] , cela signifie le 2ème dernier caractère à la fin (les deux-points sont derrière le nombre). Mettre -1 fera compter Python à partir du dernier caractère, plutôt que du premier. Encore une fois, Python commencera à 0. Donc, le mot [-1:] signifie essentiellement "de l'avant-dernier caractère à la fin de la chaîne.

Donc, en coupant les caractères avant le caractère que je veux supprimer et les caractères après et en les prenant en sandwich, je peux supprimer le caractère indésirable. Pensez-y comme une saucisse.Au milieu, c'est sale, donc je veux m'en débarrasser. Je coupe simplement les deux extrémités que je veux puis les assemble sans la partie indésirable au milieu.

Si je veux supprimer plusieurs caractères consécutifs, je déplace simplement les nombres dans [] (partie de découpage). Ou si je veux supprimer plusieurs caractères de différentes positions, je peux simplement prendre en sandwich plusieurs tranches à la fois.

Exemples:

 words = "control"
 removed = "%s%s" % (words[:2], words[-2:])

supprimé est égal à «cool».

words = "impacts"
removed = "%s%s%s" % (words[1], words[3:5], words[-1])

supprimé est égal à «macs».

Dans ce cas, [3: 5] signifie caractère en position 3 à caractère en position 5 (à l'exclusion du caractère en position finale).

N'oubliez pas que Python commence à compter à 0 , vous devrez donc également le faire.

Essaye celui-là:

def rm_char(original_str, need2rm):
    ''' Remove charecters in "need2rm" from "original_str" '''
    return original_str.translate(str.maketrans('','',need2rm))

Cette méthode fonctionne bien en python 3.5.2

Vous pouvez utiliser le remplacement d'expression régulière du module re. L'utilisation de l'expression ^ vous permet de choisir exactement ce que vous voulez dans votre chaîne.

    import re
    text = "This is absurd!"
    text = re.sub("[^a-zA-Z]","",text) # Keeps only Alphabets
    print(text)

La sortie de ceci serait "Thisisabsurd". Seules les choses spécifiées après le symbole ^ apparaîtront.

La méthode chaîne replacene modifie pas la chaîne d'origine. Il laisse l'original seul et renvoie une copie modifiée.

Ce que vous voulez, c'est quelque chose comme: line = line.replace(char,'')

def replace_all(line, )for char in line:
    if char in " ?.!/;:":
        line = line.replace(char,'')
    return line

Cependant, créer une nouvelle chaîne à chaque fois qu'un caractère est supprimé est très inefficace. Je recommande plutôt ce qui suit:

def replace_all(line, baddies, *):
    """
    The following is documentation on how to use the class,
    without reference to the implementation details:

    For implementation notes, please see comments begining with `#`
    in the source file.

    [*crickets chirp*]

    """

    is_bad = lambda ch, baddies=baddies: return ch in baddies
    filter_baddies = lambda ch, *, is_bad=is_bad: "" if is_bad(ch) else ch
    mahp = replace_all.map(filter_baddies, line)
    return replace_all.join('', join(mahp))

    # -------------------------------------------------
    # WHY `baddies=baddies`?!?
    #     `is_bad=is_bad`
    # -------------------------------------------------
    # Default arguments to a lambda function are evaluated
    # at the same time as when a lambda function is
    # **defined**.
    #
    # global variables of a lambda function
    # are evaluated when the lambda function is
    # **called**
    #
    # The following prints "as yellow as snow"
    #
    #     fleece_color = "white"
    #     little_lamb = lambda end: return "as " + fleece_color + end
    #
    #     # sometime later...
    #
    #     fleece_color = "yellow"
    #     print(little_lamb(" as snow"))
    # --------------------------------------------------
replace_all.map = map
replace_all.join = str.join

Ci-dessous un .. sans utiliser le concept d'expression régulière ..

ipstring ="text with symbols!@#$^&*( ends here"
opstring=''
for i in ipstring:
    if i.isalnum()==1 or i==' ':
        opstring+=i
    pass
print opstring

En Python 3.5

par exemple,

os.rename(file_name, file_name.translate({ord(c): None for c in '0123456789'}))

Pour supprimer tout le nombre de la chaîne

vous pouvez utiliser set

    charlist = list(set(string.digits+string.ascii_uppercase) - set('10IO'))
    return ''.join([random.SystemRandom().choice(charlist) for _ in range(passlen)])

Fractionnement récursif: s = chaîne; chars = caractères à supprimer

def strip(s,chars):
if len(s)==1:
    return "" if s in chars else s
return strip(s[0:int(len(s)/2)],chars) +  strip(s[int(len(s)/2):len(s)],chars)

exemple:

print(strip("Hello!","lo"))    #He!

# pour chaque fichier d'un répertoire, renommez le nom de fichier

   file_list = os.listdir (r"D:\Dev\Python")

   for file_name in file_list:

       os.rename(file_name, re.sub(r'\d+','',file_name))

Même l'approche ci-dessous fonctionne

line = "a,b,c,d,e"
alpha = list(line)
        while ',' in alpha:
            alpha.remove(',')
finalString = ''.join(alpha)
print(finalString)

production: abcde

>>> # Character stripping
>>> a = '?abcd1234!!'
>>> t.lstrip('?')
'abcd1234!!'
>>> t.strip('?!')
'abcd1234'