Ich versuche, bestimmte Zeichen mit Python aus einer Zeichenfolge zu entfernen. Dies ist der Code, den ich gerade verwende. Leider scheint es nichts mit der Zeichenfolge zu tun zu haben.

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

Wie mache ich das richtig?

Zeichenfolgen in Python sind unveränderlich (können nicht geändert werden). Aus diesem Grund line.replace(...)wird nur eine neue Zeichenfolge erstellt, anstatt die alte zu ändern. Sie müssen es erneut binden (zuweisen) line, damit diese Variable den neuen Wert annimmt und diese Zeichen entfernt werden.

Außerdem wird die Art und Weise, wie Sie es tun, relativ langsam sein. Es ist wahrscheinlich auch etwas verwirrend für erfahrene Pythonatoren, die eine doppelt verschachtelte Struktur sehen und für einen Moment denken, dass etwas Komplizierteres vor sich geht.

Ab Python 2.6 und neueren Python 2.x-Versionen * können Sie stattdessen Folgendes verwenden str.translate(lesen Sie jedoch weiter für Python 3-Unterschiede):

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

oder Ersatz für reguläre Ausdrücke durch re.sub

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

Die in Klammern eingeschlossenen Zeichen bilden eine Zeichenklasse . Alle Zeichen in linedieser Klasse werden durch den zweiten Parameter ersetzt sub: eine leere Zeichenfolge.

In Python 3 sind Zeichenfolgen Unicode. Sie müssen etwas anders übersetzen. kevpie erwähnt dies in einem Kommentar zu einer der Antworten und ist in der Dokumentation fürstr.translate vermerkt .

Wenn Sie die translateMethode einer Unicode-Zeichenfolge aufrufen , können Sie den oben verwendeten zweiten Parameter nicht übergeben. Sie können auch nicht Noneals ersten Parameter übergeben. Stattdessen übergeben Sie eine Übersetzungstabelle (normalerweise ein Wörterbuch) als einzigen Parameter. Diese Tabelle bildet die Ordnungswerte von Zeichen ab (dh das Ergebnis des Aufrufsord ) den Ordnungswerten der Zeichen zu, die sie ersetzen sollen, oder - für uns nützlich - um anzuzeigen None, dass sie gelöscht werden sollen.

Um den obigen Tanz mit einer Unicode-Saite zu machen, würde man so etwas nennen

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

Hier dict.fromkeysund mapwerden verwendet, um kurz und bündig ein Wörterbuch zu generieren, das enthält

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

Noch einfacher, wie eine andere Antwort sagt , erstellen Sie die Übersetzungstabelle an Ort und Stelle:

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

Oder erstellen Sie dieselbe Übersetzungstabelle mit str.maketrans:

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

* Aus Gründen der Kompatibilität mit früheren Pythons können Sie eine "Null" -Übersetzungstabelle erstellen, die anstelle von None:

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

Hier string.maketranswird eine Übersetzungstabelle erstellt , bei der es sich lediglich um eine Zeichenfolge handelt, die Zeichen mit den Ordnungswerten 0 bis 255 enthält.

Fehlt mir hier der Punkt oder ist es nur der folgende:

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

print string
# result: "abcdef"

Setzen Sie es in eine Schleife:

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'

Einfach peasy mit re.subregulärem Ausdruck ab Python 3.5

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

Beispiel

>>> import re

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

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

Erläuterung

In regulären Ausdrücken (Regex) |ist dies ein logisches ODER und es werden \Leerzeichen und Sonderzeichen ausgeblendet, bei denen es sich möglicherweise um tatsächliche Regex-Befehle handelt. Während subfür Substitution steht , in diesem Fall mit der leeren Zeichenfolge ''.

Für die umgekehrte Anforderung, nur bestimmte Zeichen in einer Zeichenfolge zuzulassen , können Sie reguläre Ausdrücke mit einem Satzkomplementoperator verwenden [^ABCabc]. So entfernen Sie beispielsweise alles außer ASCII-Buchstaben, Ziffern und dem Bindestrich:

>>> 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'

Aus der Python-Dokumentation für reguläre Ausdrücke :

Zeichen, die nicht innerhalb eines Bereichs liegen, können durch Ergänzung des Satzes abgeglichen werden. Wenn das erste Zeichen des Satzes ist '^', werden alle Zeichen, die nicht im Satz enthalten sind, abgeglichen. Zum Beispiel [^5]stimmt mit jedem Zeichen außer '5' [^^]überein und stimmt mit jedem Zeichen außer überein '^'. ^hat keine besondere Bedeutung, wenn es nicht das erste Zeichen im Satz ist.

Der Fragesteller hatte es fast geschafft. Wie die meisten Dinge in Python ist die Antwort einfacher als Sie denken.

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

Sie müssen die verschachtelte if / for-Schleife nicht ausführen, aber Sie müssen jedes Zeichen einzeln überprüfen.

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

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

Zeichenfolgen sind in Python unveränderlich. Die replaceMethode gibt nach dem Ersetzen eine neue Zeichenfolge zurück. Versuchen:

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

Ich war überrascht, dass noch niemand empfohlen hatte, die eingebaute Filterfunktion zu verwenden.

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

    s = "1212edjaq"

Angenommen, wir möchten alles herausfiltern, was keine Zahl ist. Verwenden der integrierten Filtermethode "... entspricht dem Generatorausdruck (Element für Element in iterierbarer Funktion (Element))" [ Python 3 Builtins: Filter ]

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

In Python 3 kehrt dies zurück

    >>  <filter object @ hex>

Um eine gedruckte Zeichenfolge zu erhalten,

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

Ich bin mir nicht sicher, wie Filter in Bezug auf Effizienz eingestuft werden, aber es ist eine gute Sache zu wissen, wie man sie verwendet, wenn man Listenverständnisse und dergleichen durchführt.

AKTUALISIEREN

Da Filter funktioniert, können Sie logischerweise auch das Listenverständnis verwenden, und nach dem, was ich gelesen habe, soll es effizienter sein, da Lambdas die Wall Street Hedge Fund-Manager der Programmierfunktionswelt sind. Ein weiteres Plus ist, dass es sich um einen Einzeiler handelt, für den keine Importe erforderlich sind. Verwenden Sie beispielsweise die oben definierten Zeichenfolgen.

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

Das ist es. Die Rückgabe ist eine Zeichenfolge aller Zeichen, die Ziffern in der ursprünglichen Zeichenfolge sind.

Wenn Sie eine bestimmte Liste akzeptabler / nicht akzeptabler Zeichen haben, müssen Sie nur den 'if'-Teil des Listenverständnisses anpassen.

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

oder alternativ,

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

Mit filterbenötigen Sie nur eine Zeile

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

Dies behandelt die Zeichenfolge als iterierbar und überprüft jedes Zeichen, wenn lambdaFolgendes zurückgegeben wird 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.

Hier sind einige mögliche Wege, um diese Aufgabe zu erreichen:

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: Verwenden Sie stattdessen "?.! /;:". Die Beispiele verwenden die Vokale ... und ja, "murcielago" ist das spanische Wort für Fledermaus ... lustiges Wort, da es alle Vokale enthält :)

PS2: Wenn Sie an Leistung interessiert sind, können Sie diese Versuche mit einem einfachen Code wie dem folgenden messen:

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))

In meiner Box erhalten Sie:

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

Es scheint also, dass Versuch 4 der schnellste für diese bestimmte Eingabe ist.

Hier ist meine Python 2/3 kompatible Version. Seitdem hat sich die Übersetzungs-API geändert.

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

Wie wäre es damit:

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

Sie können auch eine Funktion verwenden, um andere reguläre Ausdrücke oder andere Muster durch die Verwendung einer Liste zu ersetzen. Damit können Sie reguläre Ausdrücke, Zeichenklassen und wirklich einfache Textmuster mischen. Dies ist sehr nützlich, wenn Sie viele Elemente wie HTML-Elemente ersetzen müssen.

* NB: funktioniert mit 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)

In der Funktion string_cleanup werden Ihre Zeichenfolge x und Ihre Liste nicht als Argumente verwendet. Wenn für jedes Element in dieser Liste von Elementen oder Mustern ein Ersatz benötigt wird, wird dies durchgeführt.

Die Ausgabe:

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

Meine Methode, die ich verwenden würde, würde wahrscheinlich nicht so effizient funktionieren, aber sie ist sehr einfach. Ich kann mehrere Zeichen an verschiedenen Positionen gleichzeitig entfernen, indem ich sie schneide und formatiere. Hier ist ein Beispiel:

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

Dies führt dazu, dass 'entfernt' das Wort 'dies' enthält.

Die Formatierung kann sehr hilfreich sein, um Variablen in der Mitte einer Druckzeichenfolge zu drucken. Es kann einen beliebigen Datentyp mit einem % gefolgt vom Datentyp der Variablen einfügen . Alle Datentypen können % s verwenden , und Floats (auch als Dezimalstellen bezeichnet) und Ganzzahlen können % d verwenden .

Das Schneiden kann zur komplizierten Kontrolle über Zeichenfolgen verwendet werden. Wenn ich Wörter [: 3] eingebe , kann ich alle Zeichen in der Zeichenfolge vom Anfang (der Doppelpunkt steht vor der Zahl, dies bedeutet "von Anfang bis") bis zum 4. Zeichen (einschließlich des 4.) auswählen Charakter). Der Grund, warum 3 bis zur 4. Position gleich ist, ist, dass Python bei 0 beginnt. Wenn ich dann das Wort [-1:] setze , bedeutet dies, dass das vorletzte Zeichen am Ende steht (der Doppelpunkt steht hinter der Zahl). Wenn Sie -1 setzen, zählt Python vom letzten Zeichen und nicht vom ersten. Wieder beginnt Python bei 0. Also, Wort [-1:] bedeutet also im Grunde 'vom vorletzten Zeichen bis zum Ende der Zeichenfolge.

Indem ich also die Zeichen vor dem Zeichen, das ich entfernen möchte, und die Zeichen danach abschneide und sie zusammenschiebe, kann ich das unerwünschte Zeichen entfernen. Stellen Sie es sich wie eine Wurst vor.In der Mitte ist es schmutzig, also möchte ich es loswerden. Ich schneide einfach die beiden Enden ab, die ich möchte, und setze sie dann ohne den unerwünschten Teil in der Mitte zusammen.

Wenn ich mehrere aufeinanderfolgende Zeichen entfernen möchte, verschiebe ich einfach die Zahlen im [] (Slicing-Teil). Oder wenn ich mehrere Zeichen von verschiedenen Positionen entfernen möchte, kann ich einfach mehrere Scheiben gleichzeitig zusammenfügen.

Beispiele:

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

entfernt ist gleich "cool".

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

entfernt entspricht 'macs'.

In diesem Fall bedeutet [3: 5] Zeichen an Position 3 bis Zeichen an Position 5 (ausgenommen das Zeichen an der Endposition).

Denken Sie daran, Python beginnt bei 0 zu zählen , das müssen Sie auch.

Probier diese:

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

Diese Methode funktioniert gut in Python 3.5.2

Sie können den regulären Ausdrucksersatz des re-Moduls verwenden. Mit dem Ausdruck ^ können Sie genau das auswählen, was Sie von Ihrer Zeichenfolge erwarten.

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

Die Ausgabe hierfür wäre "Thisisabsurd". Es werden nur Dinge angezeigt, die nach dem Symbol ^ angegeben sind.

Die Zeichenfolgenmethode replaceändert die ursprüngliche Zeichenfolge nicht. Es lässt das Original in Ruhe und gibt eine geänderte Kopie zurück.

Was Sie wollen, ist so etwas wie: line = line.replace(char,'')

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

Es ist jedoch sehr ineffizient, jedes Mal, wenn ein Zeichen entfernt wird, eine neue Zeichenfolge zu erstellen. Ich empfehle stattdessen Folgendes:

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

Unter einem .. ohne Verwendung des Konzepts für reguläre Ausdrücke ..

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

In Python 3.5

z.B,

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

So entfernen Sie die gesamte Nummer aus der Zeichenfolge

Sie können set verwenden

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

Rekursive Aufteilung: s = Zeichenfolge; Zeichen = zu entfernende Zeichen

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)

Beispiel:

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

# Benennen Sie für jede Datei in einem Verzeichnis den Dateinamen um

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

   for file_name in file_list:

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

Sogar der folgende Ansatz funktioniert

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

Ausgabe: abcde

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