Dizedeki karakterlerin listesini kaldırma

Python dizesindeki karakterleri kaldırmak istiyorum:

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

Ama kaldırmam gereken birçok karakter var. Bir liste düşündüm

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

Ama nasıl kullanabilir listiçinde karakterleri değiştirmek için string?

Python2 kullanıyorsanız ve girişleriniz dizelerse (unicodes değil), kesinlikle en iyi yöntem str.translate:

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

Aksi takdirde, dikkate alınması gereken aşağıdaki seçenekler vardır:

C. Konu karakterini karaktere göre yineleyin, istenmeyen karakterleri ve joinsonuç listesini atlayın :

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

(Jeneratör versiyonunun ''.join(c for c ...)daha az verimli olacağını unutmayın ).

B. Anında ve re.subboş bir dize ile düzenli bir ifade oluşturun :

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

( re.escapekarakterlerin normal ifadeyi beğenmesini ^veya kesmemesini sağlar ]).

C. Aşağıdakilerin eşleme varyantınıtranslate kullanın :

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

Tam test kodu ve zamanlamaları:

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

Sonuçlar:

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

(Bir yan not olarak, bu rakam remove_chars_translate_bytesbize endüstrinin neden bu kadar uzun bir süredir Unicode'u benimsemeye isteksiz olduğuna dair bir ipucu verebilir).

Şunları kullanabilirsiniz str.translate():

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

Misal:

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

Translate yöntemini kullanabilirsiniz .

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

''.join(c for c in myString if not c in badTokens)

Python3 kullanıyorsanız ve translateçözüm arıyorsanız - işlev değiştirildi ve şimdi 2 yerine 1 parametre alıyor.

Bu parametre, her anahtarın bulunacak karakterin Unicode ordinali (int) olduğu ve değerin değiştirildiği (bir Unicode ordinali veya anahtarı eşleştirmek için bir dize olabilir) olduğu bir tablodur (sözlük olabilir).

İşte bir kullanım örneği:

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

Normal ifade kullanan başka bir yaklaşım:

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

Neden basit bir döngü değil?

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

Ayrıca 'list' listelerini adlandırmaktan kaçının. Yerleşik işlevi geçersiz kılar list.

böyle bir şey kullanabilirsin

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

Bu kod benim değil ve buradan geliyor onun harika bir makale ve derinlemesine bunu yapıyor

Ayrıca UTF-8 aksanının kaldırılmasıyla ilgili ilginç bir konu, char'ı standart aksanlı char'a dönüştüren bir dize oluşturur:

Python unicode dizesindeki aksanları kaldırmanın en iyi yolu nedir?

konudan kod özeti:

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

Belki istediğinizi başarmanın daha modern ve işlevsel bir yolu:

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

lütfen bu özel amaç için oldukça aşırı olduğunu unutmayın, ancak daha karmaşık koşullara ihtiyacınız olduğunda, filtre kullanışlı olur

basit yol,

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('[!@#$%^&*()_+<>]', '', str)

çıktı:

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

Buna ne dersin - bir astar.

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

Bence bu yeterince basit ve yapacak!

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]

bunu yapmanın bir yolu bu. Ancak kaldırmak istediğiniz karakterlerin listesini tutmaktan yorulduysanız, bunu yinelediğiniz dizelerin sipariş numarasını kullanarak yapabilirsiniz. sipariş numarası o karakterin ascii değeridir. karakter olarak 0 için ascii numarası 48 ve küçük harf z için ascii numarası 122'dir:

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]

Bugünlerde programa daldım ve şimdi tekrarlama ve değerlendirme konusunda iyi olduğumu düşünüyorum. HAHAHA. Sadece yeni yollar paylaşın:

ilk olarak, değerlendirin

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

ikinci olarak, onu geri alın

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, küçümseme. Sadece yeni bir fikir paylaşmak istiyorum.

Bunun için bir çözüm düşünüyorum. İlk olarak dize girdisini bir liste olarak yapardım. Sonra liste öğelerini değiştirmek istiyorum. Sonra join komutunu kullanarak listeyi bir dize olarak döndürürüm. Kod şöyle olabilir:

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)

Bu, dizeden herhangi bir şeyi kaldıracaktır. Bunun hakkında ne düşünüyorsun?

İşte bir more_itertoolsyaklaşım:

import more_itertools as mit


s = "A.B!C?D_E@F#"
blacklist = ".!?_@#"

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

Burada blacklist, bulunan öğeleri bölmek , sonuçları düzleştirmek ve dizeye katılmak.

Python 3, tek satırlı liste anlama uygulaması.

from string import ascii_lowercase # 'abcdefghijklmnopqrstuvwxyz'
def remove_chars(input_string, removable):
  return ''.join([_ for _ in input_string if _ not in removable])

print(remove_chars(input_string="Stack Overflow", removable=ascii_lowercase))
>>> 'S O'

Kaldırmak *%,&@! aşağıdaki dizeden:

s = "this is my string,  and i will * remove * these ** %% "
new_string = s.translate(s.maketrans('','','*%,&@!'))
print(new_string)

# output: this is my string  and i will  remove  these