Python 문자열에서 특정 문자 제거

Python 문자열에서 특정 문자 제거

Python을 사용하여 문자열에서 특정 문자를 제거하려고 합니다.이게 내가 지금 쓰고 있는 코드야.안타깝게도 문자열에는 아무런 영향을 미치지 않는 것 같습니다.

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

어떻게 하면 좋을까요?

Python의 문자열은 변경할 수 없습니다.이 때문에, 의 효과는line.replace(...)오래된 스트링을 변경하는 것이 아니라 새로운 스트링을 작성하는 것입니다.재바인드(할당)해야 합니다.line해당 변수가 새 값을 가져오도록 하려면 해당 문자를 삭제합니다.

또한, 당신이 하는 방법은 비교적 느릴 것입니다.경험이 풍부한 파이토네이터에게는 조금 혼란스러울 수 있습니다.이들 파이토네이터는 이중으로 된 구조를 보고는 좀 더 복잡한 일이 일어나고 있다고 생각할 것입니다.

Python 2.6 및 새로운 Python 2.x 버전*부터는 대신 을 사용할 수 있습니다(아래 Python 3 답변 참조).

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

또는 정규 표현 치환에 의한

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

괄호로 둘러싸인 문자는 문자 클래스를 구성합니다.의 임의의 문자line됩니다.sub빈 빈 문자열.

Python 3의 답변

Python 3에서 문자열은 유니코드입니다.당신은 조금 다르게 번역해야 할 거예요.kevpie는 이에 대해 답변 중 하나에 대한 코멘트에서 언급하고 있으며,의 매뉴얼에 기재되어 있습니다.

를 할 때translate유니코드 문자열의 메서드는 위에서 사용한 두 번째 파라미터를 전달할 수 없습니다.안 요.None첫 번째 파라미터로 지정합니다.대신 변환 테이블(일반적으로 딕셔너리)을 유일한 파라미터로 전달합니다.이 표는 문자의 서수 값(즉, 문자의 호출 결과)을 가 해당 문자를 대체하는 문자의 서수 값에 매핑하거나 유용하게 사용할 수 있도록 합니다.None이치노

그래서 유니코드 스트링으로 위 춤을 추는 것을 당신은 다음과 같이 부릅니다.

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

여기서 및 는 다음을 포함하는 사전을 간결하게 생성하는 데 사용됩니다.

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

또 다른 답변으로 번역테이블을 작성하는 것도 간단합니다.

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

또는 Joseph Lee에 의해 기동된 것과 같은 변환 테이블을 다음과 같이 작성합니다.

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

---

* Python과의 * Python을 하여 "null" 변환 하여 " 변환 테이블을 할 수 None:

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

변환 테이블을 작성하기 위해 사용합니다.변환 테이블은 서수 값이 0 ~255 인 문자를 포함하는 문자열입니다.

요점을 파악하지 못한 것입니까?아니면 다음과 같습니다.

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

print(string)
# result: "abcdef"

루프에 넣습니다.

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'

★★★★★★★★★★★★★★★★ re.sub 표현

3.5 Python 3.5를 한 re.sub이치노

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

예

import re
line = 'Q: Do I write ;/.??? No!!!'
re.sub('\ |\?|\.|\!|\/|\;|\:', '', line)

'QDoIwriteNo'

설명.

정규 표현(regex)에서는| 및 "OR"입니다.\는 실제 regex 명령일 수 있는 공백 및 특수 문자를 이스케이프합니다. 반에 whereas whereas.sub이 경우 빈 문자열로 치환합니다.''.

그 질문자가 거의 잡을 뻔했다.Python의 대부분의 것과 마찬가지로 답은 생각보다 간단합니다.

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

중첩된 if/for 루프 작업을 수행할 필요는 없지만 각 문자를 개별적으로 확인해야 합니다.

문자열에서 특정 문자만 허용하는 역요건의 경우 집합 보완 연산자와 함께 정규식을 사용할 수 있습니다.[^ABCabc]예를 들어 ASCII 문자, 숫자 및 하이픈을 제외한 모든 것을 삭제하려면 다음 절차를 수행합니다.

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

python 정규 표현 문서:

범위를 벗어나는 문자는 세트를 보완하여 일치시킬 수 있습니다.의 첫 가 " " " 인 '^' 않은 를 들어, 「」라고 하는 것은,[^5]'와 '5'를 제외한 합니다.[^^]는, 을 제외한 합니다.'^'^첫 번째 캐릭터가 아니면 특별한 의미가 없어요.

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

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

파이썬replacerelation.drelation name 에 새 합니다.

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

하며, 이 코드에는 되어 있습니다.line루프의 내부.

" " " 는 주의해 주세요.replace()method는 문자열 내의 모든 문자를 치환하기 때문에 를 사용하여 보다 효율적으로 수행할 수 있습니다.replace()삭제할 각 문자에 대해서, 문자열내의 각 문자에 루프 하는 것이 아니라, 삭제합니다.

아직 내장 필터 기능을 사용할 것을 추천하는 사람이 없는 것에 놀랐습니다.

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

    s = "1212edjaq"

숫자가 아닌 모든 것을 걸러내고 싶다고 합시다.필터 빌트인 메서드를 사용하는 것은 제너레이터 식(함수(항목)인 경우 반복 가능한 항목의 항목)과 동일합니다." [Python 3 빌트인: 필터]

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

Python 3에서는 이 값이 반환됩니다.

    >>  <filter object @ hex>

인쇄된 문자열을 얻으려면

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

필터가 효율성에 있어서 어떻게 순위를 매기는지는 잘 모르겠지만 리스트 컴파일 등을 할 때 사용하는 방법을 아는 것은 좋은 일입니다.

갱신하다

논리적으로 필터 작업은 목록 이해도 사용할 수 있고 제가 읽은 바에 따르면 람다는 프로그래밍 기능 세계의 월스트리트의 헤지 펀드 매니저이기 때문에 더 효율적일 것입니다.또 다른 장점은 수입이 필요 없는 원라이너라는 것이다.예를 들어 위에서 정의한 것과 같은 문자열 's'를 사용하면

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

바로 그겁니다.원래 문자열의 숫자인 모든 문자의 문자열이 반환됩니다.

허용/불합격 문자의 특정 목록이 있는 경우 목록 이해의 'if' 부분만 조정하면 됩니다.

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

또는 다른 방법으로,

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

를 사용하면, 1 행이 필요하게 됩니다.

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

은 반복 로 간주되며 됩니다.lambdaTrue:

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

이것을 사용해 보세요.

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

이 방법은 Python 3에서 잘 작동합니다.

이 작업을 수행할 수 있는 몇 가지 방법은 다음과 같습니다.

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: 예에서는 "!/"를 사용하는 대신 모음을 사용합니다.스페인어로 "murcielago"는 박쥐를 뜻하죠모든 모음이 포함되어 있기 때문에 재미있는 단어:)

PS2: 퍼포먼스에 관심이 있는 경우, 다음과 같은 간단한 코드로 이러한 시도를 측정할 수 있습니다.

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

내 상자에는 다음과 같은 것이 있습니다.

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

따라서 이 특정 입력에서는 attempt4가 가장 빠른 것 같습니다.

여기 Python 2/3 호환 버전이 있습니다.translate api가 변경되었기 때문에

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

목록을 사용하여 다른 종류의 정규 표현이나 다른 패턴을 대체하기 위해 함수를 사용할 수도 있습니다.이를 통해 정규 표현식, 문자 클래스 및 매우 기본적인 텍스트 패턴을 혼합할 수 있습니다.HTML과 같은 많은 요소를 대체해야 할 때 매우 유용합니다.

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

string_cleanup 함수에서는 스트링 x와 목록을 인수로 사용합니다.요소 또는 패턴 목록의 각 항목에 대해 대체 요소가 필요한 경우 해당 항목이 수행됩니다.

출력:

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

제가 사용하는 방법은 그다지 효율적이지는 않겠지만, 매우 간단합니다.슬라이스 및 포맷을 사용하여 다른 위치에 있는 여러 문자를 동시에 삭제할 수 있습니다.다음은 예를 제시하겠습니다.

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

이렇게 되면 '제거'가 '이것'이라는 단어를 계속 사용하게 됩니다.

포맷은 인쇄 문자열 중간에 변수를 인쇄하는 데 매우 유용합니다.모든 데이터 유형은 % 뒤에 변수의 데이터 유형을 사용하여 삽입할 수 있습니다. 모든 데이터 유형은 %s을(를) 사용할 수 있으며 부동(소수라고도 함) 및 정수는 %d를 사용할 수 있습니다.

슬라이스는 줄을 복잡하게 제어하기 위해 사용될 수 있습니다.단어 [:3]을 입력하면 문자열의 첫 번째 문자(콜론은 숫자 앞에 있음, 이것은 '처음부터'를 의미함)부터 네 번째 문자(네 번째 문자 포함)까지 모두 선택할 수 있습니다.4번째 위치까지 3이 같은 이유는 Python이 0에서 시작하기 때문입니다.그리고 단어 [-1:]를 붙이면 끝의 두 번째 마지막 글자를 의미합니다(콜론은 숫자 뒤에 있습니다).-1을 입력하면 Python은 첫 번째 문자가 아닌 마지막 문자부터 카운트됩니다.다시 Python은 0에서 시작합니다.즉, 단어 [-1:]는 기본적으로 '두 번째 마지막 글자부터 문자열 끝까지'를 의미합니다.

그래서 삭제하고 싶은 캐릭터 앞과 그 뒤의 캐릭터를 잘라내서 샌드위치를 만들면 불필요한 캐릭터를 제거할 수 있습니다.소시지처럼 생각하세요.중간에 더러워서 없애고 싶어요.원하는 양끝을 잘라내고 중간에 불필요한 부분을 빼고 조립하면 됩니다.

여러 문자를 연속해서 삭제하려면 [](슬라이싱 부분)에서 숫자를 이동하기만 하면 됩니다.또는 여러 개의 문자를 다른 위치에서 제거하려면 여러 슬라이스를 한 번에 끼워 넣기만 하면 됩니다.

예:

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

removed는 'cool'과 같습니다.

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

removed는 'macs'와 같습니다.

이 경우, [3:5]는 위치 3에서 위치 5의 문자(최종 위치 문자 제외)를 의미한다.

Python은 0부터 카운트하기 시작하므로 당신도 카운트해야 합니다.

Python 3.5에서는

예.,

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

문자열에서 모든 숫자를 제거하려면

이거 어때:

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

하나 아래...정규 표현 개념을 사용하지 않고..

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

재귀 분할: s=string; chars= 제거할 문자

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)

예:

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

re 모듈의 정규 표현 치환을 사용할 수 있습니다.^ 식을 사용하면 문자열에서 원하는 것을 정확하게 선택할 수 있습니다.

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

이것에 대한 출력은 「Thisabsurd」가 됩니다.^ 기호 뒤에 지정된 항목만 표시됩니다.

디렉토리의 각 파일에 대해 파일 이름을 변경합니다.

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

   for file_name in file_list:

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

이하의 어프로치에서도 유효

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

력::abcde

방식 " " " "replace에서는 원래 문자열은 변경되지 않습니다.원본은 그대로 두고 수정된 사본을 반환합니다.

이 원하는 것은 입니다.line = line.replace(char,'')

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

그러나 문자가 삭제될 때마다 새 문자열을 만드는 것은 매우 비효율적입니다.대신 다음 사항을 권장합니다.

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

ASCII 코드를 사용하여 문자열만 허용하는 경우 다음 코드를 사용할 수 있습니다.

for char in s:
    if ord(char) < 96 or ord(char) > 123:
        s = s.replace(char, "")

a…z 이상의 모든 문자를 삭제합니다. 대문자도 마찬가지입니다.

언급URL : https://stackoverflow.com/questions/3939361/remove-specific-characters-from-a-string-in-python