Tôi đang cố xóa các ký tự cụ thể khỏi chuỗi bằng Python. Đây là mã tôi đang sử dụng ngay bây giờ. Thật không may, nó dường như không làm gì với chuỗi.

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

Làm thế nào để tôi làm điều này đúng?

Chuỗi trong Python là bất biến (không thể thay đổi). Bởi vì điều này, hiệu quả của line.replace(...)chỉ là tạo ra một chuỗi mới, thay vì thay đổi chuỗi cũ. Bạn cần rebind (gán) nó để linebiến đó lấy giá trị mới, với các ký tự đó bị xóa.

Ngoài ra, cách bạn đang làm nó sẽ là loại chậm, tương đối. Nó cũng có thể hơi khó hiểu với những con trăn có kinh nghiệm, những người sẽ nhìn thấy một cấu trúc gấp đôi và nghĩ trong giây lát rằng một cái gì đó phức tạp hơn đang diễn ra.

Bắt đầu trong Python 2.6 và các phiên bản Python 2.x mới hơn *, thay vào đó, bạn có thể sử dụng str.translate(nhưng đọc về sự khác biệt của Python 3):

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

hoặc thay thế biểu thức chính quy bằng re.sub

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

Các ký tự được đặt trong ngoặc tạo thành một lớp ký tự . Bất kỳ ký tự linenào trong lớp đó được thay thế bằng tham số thứ hai thành sub: một chuỗi rỗng.

Trong Python 3, chuỗi là Unicode. Bạn sẽ phải dịch một chút khác nhau. kevpie đề cập đến điều này trong một bình luận về một trong những câu trả lời, và nó được ghi chú trong tài liệu chostr.translate .

Khi gọi translatephương thức của chuỗi Unicode, bạn không thể truyền tham số thứ hai mà chúng ta đã sử dụng ở trên. Bạn cũng không thể vượt qua Nonenhư là tham số đầu tiên. Thay vào đó, bạn chuyển một bảng dịch (thường là từ điển) làm tham số duy nhất. Bảng này ánh xạ các giá trị thứ tự của các ký tự (nghĩa là kết quả của việc gọi ordchúng) đến các giá trị thứ tự của các ký tự sẽ thay thế chúng, hoặc hữu ích cho chúng taNone để chỉ ra rằng chúng nên bị xóa.

Vì vậy, để thực hiện điệu nhảy trên với một chuỗi Unicode, bạn sẽ gọi một cái gì đó như

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

Ở đây dict.fromkeysvà mapđược sử dụng để tạo ra một từ điển ngắn gọn chứa

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

Thậm chí đơn giản hơn, như một câu trả lời khác đặt nó , tạo bảng dịch tại chỗ:

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

Hoặc tạo cùng một bảng dịch với str.maketrans:

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

* để tương thích với các Pythons trước đó, bạn có thể tạo bảng dịch "null" để thay thế None:

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

Ở đây string.maketransđược sử dụng để tạo bảng dịch , đây chỉ là một chuỗi chứa các ký tự có giá trị thứ tự từ 0 đến 255.

Tôi có thiếu điểm ở đây không, hay chỉ là như sau:

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

print string
# result: "abcdef"

Đặt nó trong một vòng lặp:

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'

Dễ dàng với re.subbiểu thức chính quy như Python 3.5

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

Thí dụ

>>> import re

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

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

Giải trình

Trong các biểu thức chính quy (regex), |là một OR logic và \thoát khỏi khoảng trắng và các ký tự đặc biệt có thể là các lệnh regex thực tế. Trong khi đó sublà viết tắt của thay thế, trong trường hợp này với chuỗi rỗng ''.

Đối với yêu cầu nghịch đảo chỉ cho phép một số ký tự nhất định trong một chuỗi, bạn có thể sử dụng các biểu thức chính quy với toán tử bổ sung đã đặt [^ABCabc]. Ví dụ: để xóa mọi thứ trừ chữ ascii, chữ số và dấu gạch nối:

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

Từ tài liệu biểu thức chính quy python :

Các ký tự không nằm trong phạm vi có thể được khớp bằng cách bổ sung cho tập hợp. Nếu ký tự đầu tiên của tập hợp là '^', tất cả các ký tự không có trong tập hợp sẽ được khớp. Ví dụ: [^5]sẽ khớp với bất kỳ ký tự nào ngoại trừ '5' và [^^]sẽ khớp với bất kỳ ký tự nào ngoại trừ '^'. ^không có ý nghĩa đặc biệt nếu đó không phải là nhân vật đầu tiên trong bộ.

Người hỏi gần như đã có nó. Giống như hầu hết mọi thứ trong Python, câu trả lời đơn giản hơn bạn nghĩ.

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

Bạn không phải thực hiện điều lặp if / for lồng nhau, nhưng bạn cần kiểm tra từng ký tự riêng lẻ.

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

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

Chuỗi là bất biến trong Python. Các replacephương thức trả về một chuỗi mới sau khi thay thế. Thử:

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

Tôi đã rất ngạc nhiên khi chưa có ai khuyến nghị sử dụng chức năng lọc dựng sẵn .

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

    s = "1212edjaq"

Nói rằng chúng tôi muốn lọc ra tất cả mọi thứ không phải là một số. Sử dụng phương thức dựng sẵn bộ lọc "... tương đương với biểu thức trình tạo (mục cho mục trong iterable if function (item))" [ Python 3 Buildins: Filter ]

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

Trong Python 3, nó trả về

    >>  <filter object @ hex>

Để có được một chuỗi in,

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

Tôi không chắc chắn làm thế nào bộ lọc xếp hạng về hiệu quả nhưng đó là một điều tốt để biết làm thế nào để sử dụng khi làm việc hiểu danh sách và như vậy.

CẬP NHẬT

Về mặt logic, vì bộ lọc hoạt động, bạn cũng có thể sử dụng khả năng hiểu danh sách và từ những gì tôi đã đọc, nó được cho là hiệu quả hơn vì lambdas là nhà quản lý quỹ phòng hộ trên phố của thế giới chức năng lập trình. Một điểm cộng nữa là nó là một lớp lót không yêu cầu nhập khẩu. Ví dụ: sử dụng cùng một chuỗi 's' được xác định ở trên,

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

Đó là nó. Trả về sẽ là một chuỗi gồm tất cả các ký tự là các chữ số trong chuỗi gốc.

Nếu bạn có một danh sách cụ thể các ký tự được chấp nhận / không thể chấp nhận, bạn chỉ cần điều chỉnh phần 'nếu' trong phần hiểu danh sách.

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

Hay cách khác,

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

Sử dụng filter, bạn chỉ cần một dòng

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

Điều này coi chuỗi là một lần lặp và kiểm tra mọi ký tự nếu lambdatrả về 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.

Dưới đây là một số cách có thể để đạt được nhiệm vụ này:

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: Thay vì sử dụng "?! /;:" Các ví dụ sử dụng nguyên âm ... và vâng, "murcielago" là từ tiếng Tây Ban Nha để nói dơi ... từ hài hước vì nó chứa tất cả các nguyên âm :)

PS2: Nếu bạn quan tâm đến hiệu suất, bạn có thể đo những lần thử này bằng một mã đơn giản như:

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

Trong hộp của tôi, bạn sẽ nhận được:

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

Vì vậy, có vẻ như nỗ lực4 là cách nhanh nhất cho đầu vào cụ thể này.

Đây là phiên bản tương thích Python 2/3 của tôi. Kể từ khi dịch api đã thay đổi.

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

Còn cái này thì sao:

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

Bạn cũng có thể sử dụng một hàm để thay thế loại biểu thức chính quy hoặc mẫu khác bằng việc sử dụng danh sách. Cùng với đó, bạn có thể trộn biểu thức chính quy, lớp ký tự và mẫu văn bản thực sự cơ bản. Nó thực sự hữu ích khi bạn cần thay thế nhiều yếu tố như HTML.

* NB: hoạt động với 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)

Trong hàm string_cleanup, nó lấy chuỗi x của bạn và danh sách của bạn không được chú ý làm đối số. Đối với mỗi mục trong danh sách các yếu tố hoặc mẫu đó, nếu cần thay thế, nó sẽ được thực hiện.

Đầu ra:

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

Phương pháp của tôi tôi có thể sử dụng có thể sẽ không hoạt động hiệu quả, nhưng nó rất đơn giản. Tôi có thể xóa nhiều ký tự ở các vị trí khác nhau cùng một lúc, sử dụng cắt và định dạng. Đây là một ví dụ:

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

Điều này sẽ dẫn đến 'loại bỏ' giữ từ 'này'.

Định dạng có thể rất hữu ích để in các biến giữa chừng trong một chuỗi in. Nó có thể chèn bất kỳ loại dữ liệu nào bằng cách sử dụng % theo sau là kiểu dữ liệu của biến; tất cả các loại dữ liệu có thể sử dụng % s và float (hay còn gọi là số thập phân) và số nguyên có thể sử dụng % d .

Cắt lát có thể được sử dụng để kiểm soát phức tạp trên chuỗi. Khi tôi đặt các từ [: 3] , nó cho phép tôi chọn tất cả các ký tự trong chuỗi từ đầu (dấu hai chấm đứng trước số, điều này có nghĩa là 'từ đầu đến') đến ký tự thứ 4 (bao gồm ký tự thứ 4 tính cách). Lý do 3 bằng với vị trí thứ 4 là do Python bắt đầu từ 0. Sau đó, khi tôi đặt từ [-1:] , nó có nghĩa là ký tự cuối cùng thứ 2 ở cuối (dấu hai chấm đứng sau số). Đặt -1 sẽ làm cho Python đếm từ ký tự cuối cùng, thay vì đầu tiên. Một lần nữa, Python sẽ bắt đầu từ 0. Vì vậy, từ [-1:] về cơ bản có nghĩa là 'từ ký tự cuối cùng thứ hai đến cuối chuỗi.

Vì vậy, bằng cách cắt bỏ các ký tự trước ký tự mà tôi muốn loại bỏ và các ký tự sau và kẹp chúng lại với nhau, tôi có thể loại bỏ các ký tự không mong muốn. Hãy nghĩ về nó như một cái xúc xích. Ở giữa nó bẩn, vì vậy tôi muốn thoát khỏi nó. Tôi chỉ đơn giản là cắt bỏ hai đầu tôi muốn sau đó đặt chúng lại với nhau mà không có phần không mong muốn ở giữa.

Nếu tôi muốn xóa nhiều ký tự liên tiếp, tôi chỉ cần thay đổi các số xung quanh trong [] (phần cắt). Hoặc nếu tôi muốn xóa nhiều ký tự khỏi các vị trí khác nhau, tôi có thể chỉ cần kẹp nhiều lát cùng một lúc.

Ví dụ:

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

loại bỏ bằng 'mát mẻ'.

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

loại bỏ bằng 'mac'.

Trong trường hợp này, [3: 5] có nghĩa là nhân vật ở vị trí 3 thông qua nhân vật ở vị trí 5 (không bao gồm nhân vật ở vị trí cuối cùng).

Hãy nhớ rằng, Python bắt đầu đếm từ 0 , vì vậy bạn cũng sẽ cần.

Hãy thử cái này:

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

Phương pháp này hoạt động tốt trong python 3.5.2

Bạn có thể sử dụng thay thế biểu thức chính quy của mô-đun lại. Sử dụng biểu thức ^ cho phép bạn chọn chính xác những gì bạn muốn từ chuỗi của mình.

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

Đầu ra cho điều này sẽ là "Thisisabsurd". Chỉ những thứ được chỉ định sau biểu tượng ^ sẽ xuất hiện.

Phương thức chuỗi replacekhông sửa đổi chuỗi gốc. Nó để lại bản gốc một mình và trả về một bản sao đã sửa đổi.

Những gì bạn muốn là một cái gì đó như: line = line.replace(char,'')

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

Tuy nhiên, việc tạo một chuỗi mới mỗi lần xóa một ký tự là rất không hiệu quả. Tôi đề nghị như sau thay thế:

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

Dưới đây một .. không sử dụng khái niệm biểu thức chính quy ..

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

Trong Python 3.5

ví dụ,

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

Để xóa tất cả số khỏi chuỗi

bạn có thể sử dụng bộ

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

Chia đệ quy: s = chuỗi; ký tự = ký tự để loại bỏ

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)

thí dụ:

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

# cho mỗi tệp trên một thư mục, đổi tên tệp

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

   for file_name in file_list:

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

Ngay cả cách tiếp cận dưới đây cũng hoạt động

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

đầu ra: abcde

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