ฉันกำลังพยายามลบอักขระเฉพาะจากสตริงโดยใช้ Python นี่คือรหัสที่ฉันใช้อยู่ตอนนี้ น่าเสียดายที่มันไม่ได้ทำอะไรกับสตริง

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

ฉันจะทำสิ่งนี้อย่างถูกต้องได้อย่างไร

สตริงใน Python ไม่เปลี่ยนรูป (ไม่สามารถเปลี่ยนแปลงได้) ด้วยเหตุนี้ผลกระทบของline.replace(...)จึงเป็นเพียงการสร้างสตริงใหม่แทนที่จะเปลี่ยนสตริงเก่า คุณต้องเชื่อมโยงใหม่ (มอบหมาย) lineเพื่อให้ตัวแปรนั้นรับค่าใหม่โดยลบอักขระเหล่านั้นออก

นอกจากนี้วิธีการที่คุณกำลังทำอยู่นั้นจะค่อนข้างช้า นอกจากนี้ยังมีแนวโน้มที่จะสับสนเล็กน้อยกับผู้ที่มีประสบการณ์เรื่องงูหลามซึ่งจะเห็นโครงสร้างซ้อนซ้อนกันและคิดอยู่ครู่หนึ่งว่ามีบางอย่างที่ซับซ้อนกว่าเกิดขึ้น

การเริ่มต้นใน Python 2.6 และ Python 2.x เวอร์ชั่นใหม่กว่านั้นคุณสามารถใช้แทนstr.translate(แต่อ่านเพื่อความแตกต่างของ Python 3):

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

หรือการแทนที่นิพจน์ปกติด้วย re.sub

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

ตัวละครในวงเล็บเป็นการชั้นเรียนตัวอักษร อักขระใด ๆlineที่อยู่ในคลาสนั้นจะถูกแทนที่ด้วยพารามิเตอร์ที่สองเป็นsub: สตริงว่าง

ใน Python 3 สตริงเป็น Unicode คุณจะต้องแปลให้แตกต่างกันเล็กน้อย kevpie กล่าวนี้ในการแสดงความคิดเห็นเกี่ยวกับหนึ่งในคำตอบและก็ระบุไว้ในเอกสารstr.translate

เมื่อเรียกใช้translateเมธอดของสตริง Unicode คุณจะไม่สามารถผ่านพารามิเตอร์ที่สองที่เราใช้ด้านบน คุณไม่สามารถผ่านNoneเป็นพารามิเตอร์แรกได้ แต่คุณส่งตารางการแปล (โดยปกติคือพจนานุกรม) เป็นพารามิเตอร์เท่านั้น ตารางนี้แมปค่าลำดับของอักขระ (เช่นผลลัพธ์ของการโทรหาordพวกเขา) กับค่าลำดับของอักขระที่ควรแทนที่พวกเขาหรือ - เป็นประโยชน์กับเรา - Noneเพื่อระบุว่าพวกเขาควรถูกลบ

ดังนั้นในการเต้นด้านบนด้วยสาย Unicode คุณจะต้องเรียกมันว่า

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

ที่นี่dict.fromkeysและmapถูกใช้เพื่อสร้างพจนานุกรมที่มีอย่างกระชับ

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

ง่ายขึ้นเช่นเดียวกับที่อีกคำตอบหนึ่งไว้สร้างตารางการแปลแทน:

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

หรือสร้างตารางการแปลเดียวกันกับstr.maketrans:

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

* เพื่อความเข้ากันได้กับ Pythons รุ่นก่อนหน้าคุณสามารถสร้างตารางการแปล "null" เพื่อส่งแทนNone:

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

ที่นี่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'

peasy ง่าย ๆ ด้วยre.subการแสดงออกปกติ ณ Python 3.5

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

ตัวอย่าง

>>> import re

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

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

คำอธิบาย

ในนิพจน์ทั่วไป (regex) |เป็น OR เชิงตรรกะและ\เว้นวรรคและอักขระพิเศษที่อาจเป็นคำสั่ง regex จริง ในขณะที่subย่อมาทดแทน''ในกรณีนี้กับสตริงที่ว่างเปล่า

สำหรับความต้องการผกผันของเพียงช่วยให้ตัวอักษรบางอย่าง[^ABCabc]ในสตริงคุณสามารถใช้นิพจน์ปกติกับผู้ประกอบการชุดสมบูรณ์ ตัวอย่างเช่นหากต้องการลบทุกอย่างยกเว้นตัวอักษรตัวเลขและยัติภังค์:

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

จากเอกสารการแสดงออกปกติของงูหลาม :

ตัวละครที่ไม่อยู่ในช่วงสามารถจับคู่ได้โดยเติมเต็มชุด หากอักขระตัวแรกของชุดคือ'^'อักขระทั้งหมดที่ไม่ได้อยู่ในชุดจะถูกจับคู่ ยกตัวอย่างเช่น[^5]จะตรงกับตัวอักษรใด ๆ ยกเว้น '5' และ[^^]จะตรงกับตัวอักษรใด ๆ '^'ยกเว้น ^ไม่มีความหมายพิเศษหากไม่ใช่ตัวอักษรตัวแรกในชุด

ผู้ถามเกือบจะได้มัน เช่นเดียวกับสิ่งของส่วนใหญ่ใน Python คำตอบนั้นง่ายกว่าที่คุณคิด

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

คุณไม่ต้องทำสิ่งซ้อนกันถ้า / เพื่อวนซ้ำ แต่คุณต้องตรวจสอบอักขระแต่ละตัวแยกกัน

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

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

สตริงไม่เปลี่ยนรูปใน Python replaceวิธีการส่งกลับสตริงใหม่หลังจากที่เปลี่ยน ลอง:

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

ฉันประหลาดใจที่ยังไม่มีใครแนะนำให้ใช้ฟังก์ชั่นฟิลเตอร์ builtin

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

    s = "1212edjaq"

สมมติว่าเราต้องการกรองทุกอย่างที่ไม่ใช่ตัวเลข การใช้วิธีการกรองในตัว "... เทียบเท่ากับนิพจน์ตัวสร้าง (รายการสำหรับรายการใน iterable ถ้าฟังก์ชั่น (รายการ))" [ Python 3 Builtins: ตัวกรอง ]

    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"

ฉันไม่แน่ใจว่ากรองได้อย่างไรจัดอันดับในแง่ของประสิทธิภาพ แต่เป็นสิ่งที่ดีที่จะรู้วิธีใช้เมื่อทำรายการความเข้าใจและ

UPDATE

เหตุผลเนื่องจากตัวกรองคุณสามารถใช้รายการความเข้าใจและจากสิ่งที่ฉันได้อ่านมันควรจะมีประสิทธิภาพมากขึ้นเพราะ lambdas เป็นผู้จัดการกองทุนเฮดจ์ฟันด์วอลล์สตรีทของโลกการเขียนโปรแกรม ข้อดีอีกอย่างคือมันเป็นหนึ่งซับที่ไม่ต้องนำเข้าใด ๆ ตัวอย่างเช่นการใช้สตริงเดียวกันกับที่กำหนดไว้ข้างต้น

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

ใช้filterคุณต้องการเพียงหนึ่งบรรทัด

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

ถือว่านี้สตริงเป็น iterable และการตรวจสอบตัวละครทุกตัวถ้าlambdaผลตอบแทน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.

นี่เป็นวิธีที่เป็นไปได้ในการบรรลุภารกิจนี้:

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

ดังนั้นดูเหมือนว่า try4 นั้นเร็วที่สุดสำหรับอินพุตนี้โดยเฉพาะ

นี่คือเวอร์ชั่นที่รองรับ Python 2/3 ของฉัน ตั้งแต่แปล 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

เกี่ยวกับสิ่งนี้:

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

นอกจากนี้คุณยังสามารถใช้ฟังก์ชันเพื่อแทนที่นิพจน์ทั่วไปหรือรูปแบบอื่นที่แตกต่างด้วยการใช้รายการ ด้วยสิ่งนี้คุณสามารถผสมนิพจน์ปกติคลาสอักขระและรูปแบบข้อความพื้นฐานได้อย่างแท้จริง มันมีประโยชน์จริง ๆ เมื่อคุณต้องการแทนที่องค์ประกอบจำนวนมากเช่นองค์ประกอบ 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และลอย (aka ทศนิยม) และจำนวนเต็มสามารถใช้% d d

การแบ่งส่วนสามารถใช้สำหรับการควบคุมสตริงที่ซับซ้อน เมื่อฉันใส่คำ [: 3]มันช่วยให้ฉันสามารถเลือกอักขระทั้งหมดในสตริงตั้งแต่เริ่มต้น (เครื่องหมายโคลอนอยู่ข้างหน้าหมายเลขซึ่งจะหมายถึง 'ตั้งแต่ต้นจนถึง') ถึงตัวที่ 4 (รวมถึงตัวที่ 4 ตัวอักษร) เหตุผลที่ 3 เท่ากับจนถึงตำแหน่งที่ 4 เป็นเพราะ Python เริ่มต้นที่ 0 จากนั้นเมื่อฉันใส่คำ [-1:]มันหมายถึงตัวละครตัวสุดท้ายที่ 2 ถึงจุดสิ้นสุด (เครื่องหมายโคลอนอยู่หลังตัวเลข) การวาง -1 จะทำให้ Python นับจากอักขระตัวสุดท้ายแทนที่จะเป็นตัวแรก Python จะเริ่มต้นที่ 0 ดังนั้นคำ [-1:]โดยทั่วไปหมายถึง 'จากอักขระตัวสุดท้ายตัวที่สองถึงจุดสิ้นสุดของสตริง

ดังนั้นโดยการตัดตัวละครออกก่อนที่ตัวละครที่ฉันต้องการจะเอาออกและตัวละครหลังจากนั้นและประกบพวกมันเข้าด้วยกันฉันสามารถลบตัวละครที่ไม่ต้องการออกได้ คิดว่ามันเหมือนไส้กรอก ตรงกลางมันสกปรกดังนั้นฉันต้องการกำจัดมัน ฉันตัดปลายทั้งสองข้างออกจากกันแล้ววางมันเข้าด้วยกันโดยไม่มีส่วนที่ไม่ต้องการอยู่ตรงกลาง

ถ้าฉันต้องการลบตัวละครที่ต่อเนื่องกันหลายตัวฉันเพียงแค่เลื่อนตัวเลขใน [] (ส่วนที่แบ่งเป็นส่วน ๆ ) หรือถ้าฉันต้องการลบอักขระหลายตัวจากตำแหน่งที่แตกต่างกันฉันก็สามารถประกบกันหลาย ๆ ชิ้นพร้อมกันได้

ตัวอย่าง:

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

ลบเท่ากับ 'เย็น'

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

ลบแล้วเท่ากับ 'macs'

ในกรณีนี้[3: 5]หมายถึงอักขระที่ตำแหน่ง 3 ถึงอักขระที่ตำแหน่ง 5 (ไม่รวมอักขระที่ตำแหน่งสุดท้าย)

จำไว้ว่าPython เริ่มนับที่ 0ดังนั้นคุณจะต้องเช่นกัน

ลองอันนี้:

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

วิธีนี้ใช้ได้ดีกับ python 3.5.2

คุณสามารถใช้การแทนที่นิพจน์ปกติของโมดูลได้ การใช้ ^ แสดงออกช่วยให้คุณสามารถเลือกสิ่งที่คุณต้องการจากสตริงของคุณ

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

ผลลัพธ์นี้จะเป็น "Thisisabsurd" เฉพาะสิ่งที่ระบุหลังจากสัญลักษณ์ ^ เท่านั้นที่จะปรากฏขึ้น

วิธีการสตริง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

ด้านล่างหนึ่ง .. โดยไม่ใช้แนวคิดการแสดงออกปกติ ..

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

ใน Python 3.5

เช่น,

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

หากต้องการลบหมายเลขทั้งหมดออกจากสตริง

คุณสามารถใช้ชุด

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

Recursive split: s = string; chars = 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!

# สำหรับแต่ละไฟล์ในไดเรกทอรีเปลี่ยนชื่อไฟล์

   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

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