문자열에서 문자 목록 제거

문자열에서 문자 목록 제거

python의 문자열에서 문자를 제거하려는 경우:

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

하지만 제거해야 할 캐릭터가 많다.나는 리스트에 대해 생각했다.

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

하지만 어떻게 하면 그 제품을 사용할 수 있을까?list의 문자를 바꾸다string?

python2를 사용하는 경우 입력이 유니코드가 아닌 문자열인 경우 가장 좋은 방법은:

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

그렇지 않으면 다음과 같은 옵션을 고려할 수 있다.

A. 제목 문자를 문자로 반복하고 원하지 않는 문자와 결과 목록을 생략한다.

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

(참고: 제너레이터 버전은''.join(c for c ...)효율성이 떨어질 것이다.

B. 즉석에서 빈 문자열로 정규식을 생성한다.

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

(re.escape문자가 다음과 같은 문자를 사용할 수 있도록 보장함)^또는]정규 표현을 어기지 않을 것이다.

C. 의 매핑 변형 사용:

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

전체 테스트 코드 및 시간:

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

결과:

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

(측면의 참고로서, 에 대한 그림.remove_chars_translate_bytes왜 업계가 오랫동안 유니코드를 채택하기를 꺼렸는지 우리에게 실마리를 줄지도 모른다.)

사용 가능:

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

예:

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

번역 방법을 사용하면 된다.

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

만약 당신이 python3을 사용하고 있고, 그것을 찾고 있다면translate솔루션 - 기능이 변경되어 이제 2 대신 1개의 매개 변수를 사용한다.

이 매개변수는 테이블(사전이 될 수 있음)이다. 여기서 각 키는 찾을 문자의 유니코드 순서(int)이고 값은 대체 값이다(유니코드 순서형 또는 키를 매핑하는 문자열일 수 있음).

사용 예는 다음과 같다.

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

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

왜 단순한 루프가 아닌가?

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

또한 목록 이름을 'list'로 지정하지 마십시오.기본 제공 함수를 재정의함list.

regex를 사용한 또 다른 접근 방식:

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

이런게 필요할거야

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

이 코드는 나만의 코드가 아니며, 여기서 유래된 것으로, 이것을 행하는 위대한 글과 심층적인 디커스가 있다.

간단한 방법,

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)

출력:

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

또한 제거 UTF-8 억양에 대한 흥미로운 주제는 문자를 표준 비향상 문자로 변환하는 문자열을 형성한다.

파이톤 유니코드 문자열에서 억양을 제거하는 가장 좋은 방법은 무엇인가?

항목에서 코드 추출:

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

아마도 당신이 원하는 것을 성취하기 위한 좀 더 현대적이고 기능적인 방법일 것이다.

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

이 특정한 목적을 위해, 그것은 꽤 과잉 살상이지만, 일단 더 복잡한 조건이 필요하게 되면, 필터는 유용하게 쓰일 수 있다.

아래 문자열에서 *%&@! 제거:

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  

이건 어때? 한 척의 라이너.

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

나는 이것이 충분히 간단하고 할 것이라고 생각한다!

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]

이것이 그것을 하는 한 가지 방법이다.그러나 제거하고자 하는 문자 목록을 보관하는 데 지쳤다면, 실제로 반복하는 문자열의 순서 번호를 이용하여 제거할 수 있다.순서 번호는 해당 문자의 아스키 값이다.0의 아스키 번호는 0으로 48이고 소문자 z의 아스키 번호는 122이므로:

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]

Python 3.8에서는 다음과 같은 기능이 제공된다.

s.translate(s.maketrans(dict.fromkeys(',!.;', '')))

요즘 나는 계략에 빠져들어, 지금은 재귀와 평가를 잘한다고 생각한다.하하하.몇 가지 새로운 방법을 공유하십시오.

먼저, 평가하라.

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

둘째, 재발하다.

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)

이봐, 낙선하지 마.나는 단지 새로운 아이디어를 공유하고 싶다.

나는 이것에 대한 해결책을 생각하고 있다.우선 나는 문자열 입력을 목록으로 만들 것이다.그럼 내가 리스트의 항목들을 바꾸겠다.그런 다음 join 명령을 사용하여 리스트를 문자열로 반환할 것이다.코드는 다음과 같을 수 있다.

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)

이렇게 하면 끈에 있는 모든 것이 제거될 것이다.어떻게 생각하세요?

접근방법은 다음과 같다.

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'

여기서 우리는 에서 발견된 물건들에 대해 나누었다.blacklist, 결과를 평평하게 하고 끈에 연결한다.

파이톤 3, 단일 라인 목록 이해 구현.

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'

이 간단한 기능을 사용하지 않는 이유:

def remove_characters(str, chars_list):
    for char in chars_list:
        str = str.replace(char, '')
  
    return str

기능 사용:

print(remove_characters('A.B!C?', ['.', '!', '?']))

출력:

ABC

참조URL: https://stackoverflow.com/questions/10017147/removing-a-list-of-characters-in-string