it-swarm.com.de

Eine Liste von Zeichen in Zeichenfolge entfernen

Ich möchte Zeichen in einem String in Python entfernen:

string.replace(',', '').replace("!", '').replace(":", '').replace(";", '')...

Aber ich habe viele Charaktere, die ich entfernen muss. Ich dachte über eine Liste nach

list = [',', '!', '.', ';'...]

Aber wie kann ich die list verwenden, um die Zeichen in der string zu ersetzen?

206
Laura

Wenn Sie Python2 verwenden und Ihre Eingaben Strings (keine Unicodes) sind, ist die absolut beste Methode str.translate :

>>> chars_to_remove = ['.', '!', '?']
>>> subj = 'A.B!C?'
>>> subj.translate(None, ''.join(chars_to_remove))
'ABC'

Andernfalls sind folgende Optionen zu berücksichtigen:

A. Wiederholen Sie den Betreff char für char, lassen Sie unerwünschte Zeichen und join die resultierende Liste aus:

>>> sc = set(chars_to_remove)
>>> ''.join([c for c in subj if c not in sc])
'ABC'

(Beachten Sie, dass die Generatorversion ''.join(c for c ...) weniger effizient ist).

B. Erstellen Sie im Handumdrehen einen regulären Ausdruck und re.sub mit einem leeren String:

>>> import re
>>> rx = '[' + re.escape(''.join(chars_to_remove)) + ']'
>>> re.sub(rx, '', subj)
'ABC'

( re.escape stellt sicher, dass Zeichen wie ^ oder ] den regulären Ausdruck nicht beschädigen).

C. Verwenden Sie die Mapping-Variante von translate :

>>> chars_to_remove = [u'δ', u'Γ', u'ж']
>>> subj = u'AжBδCΓ'
>>> dd = {ord(c):None for c in chars_to_remove}
>>> subj.translate(dd)
u'ABC'

Vollständiger Testcode und Timings:

#coding=utf8

import re

def remove_chars_iter(subj, chars):
    sc = set(chars)
    return ''.join([c for c in subj if c not in sc])

def remove_chars_re(subj, chars):
    return re.sub('[' + re.escape(''.join(chars)) + ']', '', subj)

def remove_chars_re_unicode(subj, chars):
    return re.sub(u'(?u)[' + re.escape(''.join(chars)) + ']', '', subj)

def remove_chars_translate_bytes(subj, chars):
    return subj.translate(None, ''.join(chars))

def remove_chars_translate_unicode(subj, chars):
    d = {ord(c):None for c in chars}
    return subj.translate(d)

import timeit, sys

def profile(f):
    assert f(subj, chars_to_remove) == test
    t = timeit.timeit(lambda: f(subj, chars_to_remove), number=1000)
    print ('{0:.3f} {1}'.format(t, f.__name__))

print (sys.version)
PYTHON2 = sys.version_info[0] == 2

print ('\n"plain" string:\n')

chars_to_remove = ['.', '!', '?']
subj = 'A.B!C?' * 1000
test = 'ABC' * 1000

profile(remove_chars_iter)
profile(remove_chars_re)

if PYTHON2:
    profile(remove_chars_translate_bytes)
else:
    profile(remove_chars_translate_unicode)

print ('\nunicode string:\n')

if PYTHON2:
    chars_to_remove = [u'δ', u'Γ', u'ж']
    subj = u'AжBδCΓ'
else:
    chars_to_remove = ['δ', 'Γ', 'ж']
    subj = 'AжBδCΓ'

subj = subj * 1000
test = 'ABC' * 1000

profile(remove_chars_iter)

if PYTHON2:
    profile(remove_chars_re_unicode)
else:
    profile(remove_chars_re)

profile(remove_chars_translate_unicode)

Ergebnisse:

2.7.5 (default, Mar  9 2014, 22:15:05) 
[GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)]

"plain" string:

0.637 remove_chars_iter
0.649 remove_chars_re
0.010 remove_chars_translate_bytes

unicode string:

0.866 remove_chars_iter
0.680 remove_chars_re_unicode
1.373 remove_chars_translate_unicode

---

3.4.2 (v3.4.2:ab2c023a9432, Oct  5 2014, 20:42:22) 
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)]

"plain" string:

0.512 remove_chars_iter
0.574 remove_chars_re
0.765 remove_chars_translate_unicode

unicode string:

0.817 remove_chars_iter
0.686 remove_chars_re
0.876 remove_chars_translate_unicode

(Als Randbemerkung könnte die Zahl für remove_chars_translate_bytes uns einen Hinweis geben, warum die Industrie Unicode so lange nicht akzeptieren wollte).

254
georg

Sie können str.translate() verwenden:

s.translate(None, ",!.;")

Beispiel:

>>> s = "asjo,fdjk;djaso,oio!kod.kjods;dkps"
>>> s.translate(None, ",!.;")
'asjofdjkdjasooiokodkjodsdkps'
108
Sven Marnach

Sie können die Methode translate verwenden.

s.translate(None, '!.;,')
35
''.join(c for c in myString if not c in badTokens)
15
ninjagecko

Wenn Sie python3 verwenden und nach der Lösung translate suchen, wurde die Funktion geändert und nimmt jetzt 1 statt 2 Parameter an. 

Dieser Parameter ist eine Tabelle (kann ein Wörterbuch sein), in der jeder Schlüssel die Unicode-Ordnungszahl (int) des zu suchenden Zeichens ist und der Wert die Ersetzung ist (kann entweder eine Unicode-Ordnungszahl oder eine Zeichenfolge sein, der der Schlüssel zugeordnet wird).

Hier ist ein Anwendungsbeispiel:

>>> list = [',', '!', '.', ';']
>>> s = "This is, my! str,ing."
>>> s.translate({ord(x): '' for x in list})
'This is my string'
9
Dekel

Ein anderer Ansatz, der Regex verwendet: 

''.join(re.split(r'[.;!?,]', s))
8
alan

sie könnten so etwas verwenden

def replace_all(text, dic):
  for i, j in dic.iteritems():
    text = text.replace(i, j)
  return text

Dieser Code ist nicht mein eigener und stammt von hier es ist ein großartiger Artikel und erörtert dies ausführlich

6
krystan honour

Warum keine einfache Schleife?

for i in replace_list:
    string = string.replace(i, '')

Vermeiden Sie auch, Listen mit Namen zu benennen. Sie überschreibt die integrierte Funktion list.

6
aIKid

Ein interessantes Thema zum Entfernen von UTF-8-Akzent ist eine Zeichenkette, die Zeichen in ihre nicht-akzentuierten Zeichen konvertiert:

Was ist der beste Weg, um Akzente in einem Python-Unicode-String zu entfernen?

code-Auszug aus dem Thema:

import unicodedata

def remove_accents(input_str):
    nkfd_form = unicodedata.normalize('NFKD', input_str)
    return u"".join([c for c in nkfd_form if not unicodedata.combining(c)])
3
Sylvain

Vielleicht ein moderner und funktionaler Weg, um das zu erreichen, was Sie wünschen:

>>> subj = 'A.B!C?'
>>> list = set([',', '!', '.', ';', '?'])
>>> filter(lambda x: x not in list, subj)
'ABC'

bitte beachten Sie, dass es für diesen speziellen Zweck ein Overkill ist. Wenn Sie jedoch komplexere Bedingungen benötigen, ist der Filter praktisch

3
rioted

einfacher Weg,

import re
str = 'this is string !    >><< (foo---> bar) @-tuna-#   sandwich-%-is-$-* good'

// condense multiple empty spaces into 1
str = ' '.join(str.split()

// replace empty space with dash
str = str.replace(" ","-")

// take out any char that matches regex
str = re.sub('[[email protected]#$%^&*()_+<>]', '', str)

ausgabe:

this-is-string--foo----bar--tuna---sandwich--is---good

2
perfecto25

Heutzutage tauche ich in das Schema ein, und jetzt denke ich, dass ich gut rekursieren und auswerten kann. HAHAHA. Teilen Sie einfach einige neue Wege:

zuerst, bewerte es

print eval('string%s' % (''.join(['.replace("%s","")'%i for i in replace_list])))

zweitens rekursieren

def repn(string,replace_list):
    if replace_list==[]:
        return string
    else:
        return repn(string.replace(replace_list.pop(),""),replace_list)

print repn(string,replace_list)

Hey, lass dich nicht abstimmen. Ich möchte nur eine neue Idee teilen.

1
tcpiper

Wie wäre es damit - ein One-Liner. 

reduce(lambda x,y : x.replace(y,"") ,[',', '!', '.', ';'],";Test , ,  !Stri!ng ..")
1
Akshay Hazari

ich denke, das ist einfach genug und wird es tun!

list = [",",",","!",";",":"] #the list goes on.....

theString = "dlkaj;lkdjf'adklfaj;lsd'fa'dfj;alkdjf" #is an example string;
newString="" #the unwanted character free string
for i in range(len(TheString)):
    if theString[i] in list:
        newString += "" #concatenate an empty string.
    else:
        newString += theString[i]

dies ist eine Möglichkeit, dies zu tun. Wenn Sie jedoch die Liste der Zeichen, die Sie entfernen möchten, müde sind, können Sie dies tatsächlich tun, indem Sie die Bestellnummer der Zeichenfolgen verwenden, die Sie durchlaufen. Die Bestellnummer ist der ASCII-Wert dieses Zeichens. Die ASCII-Nummer für 0 als Zeichen ist 48 und die ASCII-Nummer für Kleinbuchstaben z ist 122, also:

theString = "lkdsjf;alkd8a'asdjf;lkaheoialkdjf;ad"
newString = ""
for i in range(len(theString)):
     if ord(theString[i]) < 48 or ord(theString[i]) > 122: #ord() => ascii num.
         newString += ""
     else:
        newString += theString[i]
1

Ich denke darüber nach einer Lösung. Zuerst würde ich die Zeichenfolge als Liste eingeben. Dann würde ich die Elemente der Liste ersetzen. Durch den Befehl join werde ich list als String zurückgeben. Der Code kann folgendermaßen aussehen:

def the_replacer(text):
    test = []    
    for m in range(len(text)):
        test.append(text[m])
        if test[m]==','\
        or test[m]=='!'\
        or test[m]=='.'\
        or test[m]=='\''\
        or test[m]==';':
    #....
            test[n]=''
    return ''.join(test)

Dies würde alles aus dem String entfernen. Was denkst du darüber?

0

Hier ist ein more_itertools Ansatz:

import more_itertools as mit


s = "[email protected]#"
blacklist = "[email protected]#"

"".join(mit.flatten(mit.split_at(s, pred=lambda x: x in set(blacklist))))
# 'ABCDEF'

Hier teilen wir uns nach Elementen auf, die in der Variablen blacklist gefunden wurden, glätten die Ergebnisse und verbinden die Zeichenfolge.

0
pylang