Saya mencoba untuk menghapus karakter tertentu dari string menggunakan Python. Ini adalah kode yang saya gunakan sekarang. Sayangnya tampaknya tidak melakukan apa pun pada string.

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

Bagaimana saya melakukan ini dengan benar?

String dalam Python tidak dapat diubah (tidak dapat diubah). Karena itu, efeknya line.replace(...)hanya untuk membuat string baru, daripada mengubah yang lama. Anda perlu mem - rebind (menugaskan) itu lineagar variabel itu mengambil nilai baru, dengan karakter-karakter itu dihapus.

Juga, cara Anda melakukannya akan agak lambat, relatif. Ini juga mungkin agak membingungkan bagi pythonators berpengalaman, yang akan melihat struktur bersarang ganda dan berpikir sejenak bahwa sesuatu yang lebih rumit sedang terjadi.

Dimulai dengan Python 2.6 dan versi Python 2.x yang lebih baru *, Anda dapat menggunakan str.translate, (tetapi baca terus untuk perbedaan Python 3):

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

atau penggantian ekspresi reguler dengan re.sub

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

Karakter yang dilampirkan dalam tanda kurung merupakan kelas karakter . Setiap karakter lineyang ada di kelas itu diganti dengan parameter kedua menjadi sub: string kosong.

Dalam Python 3, string adalah Unicode. Anda harus menerjemahkan sedikit berbeda. kevpie menyebutkan ini dalam komentar di salah satu jawaban, dan itu tercantum dalam dokumentasi untukstr.translate .

Saat memanggil translatemetode string Unicode, Anda tidak dapat melewatkan parameter kedua yang kami gunakan di atas. Anda juga tidak dapat lulus Nonesebagai parameter pertama. Sebagai gantinya, Anda melewati tabel terjemahan (biasanya kamus) sebagai satu-satunya parameter. Tabel ini memetakan nilai - nilai ordinal karakter (yaitu hasil memanggilnya ord) ke nilai-nilai ordinal karakter yang harus menggantikannya, atau — berguna bagi kita — Noneuntuk menunjukkan bahwa mereka harus dihapus.

Jadi untuk melakukan tarian di atas dengan string Unicode Anda akan memanggil sesuatu seperti

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

Di sini dict.fromkeysdan mapdigunakan untuk membuat kamus berisi secara ringkas

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

Lebih sederhana, seperti jawaban lain , buat tabel terjemahan di tempat:

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

Atau buat tabel terjemahan yang sama dengan str.maketrans:

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

* untuk kompatibilitas dengan Python sebelumnya, Anda dapat membuat tabel terjemahan "null" untuk menggantikan None:

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

Di sini string.maketransdigunakan untuk membuat tabel terjemahan , yang hanya berupa string yang berisi karakter dengan nilai ordinal 0 hingga 255.

Apakah saya kehilangan poin di sini, atau hanya sebagai berikut:

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

print string
# result: "abcdef"

Letakkan dalam satu lingkaran:

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 mudah dengan re.subekspresi reguler pada Python 3.5

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

Contoh

>>> import re

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

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

Penjelasan

Dalam ekspresi reguler (regex), |adalah OR logis dan \lolos dari spasi dan karakter khusus yang mungkin perintah regex aktual. Sedangkan subsingkatan dari substitusi, dalam hal ini dengan string kosong ''.

Untuk persyaratan terbalik dengan hanya mengizinkan karakter tertentu dalam string, Anda dapat menggunakan ekspresi reguler dengan operator pelengkap yang ditetapkan [^ABCabc]. Misalnya, untuk menghapus semuanya kecuali huruf ascii, digit, dan tanda hubung:

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

Dari dokumentasi ekspresi reguler python :

Karakter yang tidak dalam jangkauan dapat dicocokkan dengan melengkapi set. Jika karakter pertama dari himpunan adalah '^', semua karakter yang tidak ada dalam himpunan akan dicocokkan. Misalnya, [^5]akan cocok dengan karakter apa pun kecuali '5', dan [^^]akan cocok dengan karakter apa pun kecuali '^'. ^tidak memiliki arti khusus jika itu bukan karakter pertama di set.

Penanya hampir memilikinya. Seperti kebanyakan hal dalam Python, jawabannya lebih sederhana daripada yang Anda pikirkan.

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

Anda tidak harus melakukan hal loop bersarang jika / untuk, tetapi Anda perlu memeriksa setiap karakter secara terpisah.

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

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

String tidak berubah dalam Python. The replacemethod mengembalikan string baru setelah penggantian. Mencoba:

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

Saya terkejut bahwa belum ada yang merekomendasikan menggunakan fungsi filter builtin .

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

    s = "1212edjaq"

Katakanlah kita ingin menyaring semua yang bukan angka. Menggunakan metode filter builtin "... setara dengan ekspresi generator (item untuk item di iterable jika fungsi (item))" [ Python 3 Builtins: Filter ]

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

Dalam Python 3 ini kembali

    >>  <filter object @ hex>

Untuk mendapatkan string yang dicetak,

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

Saya tidak yakin bagaimana peringkat filter dalam hal efisiensi tetapi itu adalah hal yang baik untuk mengetahui bagaimana menggunakan ketika melakukan pemahaman daftar dan semacamnya.

MEMPERBARUI

Secara logis, karena filter berfungsi, Anda juga dapat menggunakan pemahaman daftar dan dari apa yang telah saya baca seharusnya lebih efisien karena lambda adalah pengelola dana lindung nilai dari dunia fungsi pemrograman. Kelebihan lainnya adalah bahwa itu adalah satu-liner yang tidak memerlukan impor apa pun. Misalnya, menggunakan string yang sama yang ditentukan di atas,

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

Itu dia. Kembali akan menjadi string dari semua karakter yang merupakan digit dalam string asli.

Jika Anda memiliki daftar karakter khusus yang dapat diterima / tidak dapat diterima, Anda hanya perlu menyesuaikan bagian 'jika' dari pemahaman daftar.

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

atau sebagai alternatif,

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

Dengan menggunakan filter, Anda hanya perlu satu baris

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

Ini memperlakukan string sebagai iterable dan memeriksa setiap karakter jika lambdamengembalikan 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.

Berikut beberapa cara yang mungkin untuk mencapai tugas ini:

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: Alih-alih menggunakan "?.! / ;:" contoh menggunakan vokal ... dan ya, "murcielago" adalah kata Spanyol untuk mengatakan kelelawar ... kata lucu karena berisi semua vokal :)

PS2: Jika Anda tertarik pada kinerja, Anda dapat mengukur upaya ini dengan kode sederhana seperti:

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

Di kotak saya, Anda akan mendapatkan:

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

Jadi sepertinya try4 adalah yang tercepat untuk input khusus ini.

Inilah versi yang kompatibel dengan Python 2/3 saya. Karena api terjemahan telah berubah.

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

Bagaimana dengan ini:

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

Anda juga dapat menggunakan fungsi untuk mengganti berbagai jenis ekspresi reguler atau pola lain dengan penggunaan daftar. Dengan itu, Anda dapat menggabungkan ekspresi reguler, kelas karakter, dan pola teks yang sangat dasar. Ini sangat berguna ketika Anda perlu mengganti banyak elemen seperti yang HTML.

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

Dalam fungsi string_cleanup, dibutuhkan string Anda x dan daftar Anda tidak diinginkan sebagai argumen. Untuk setiap item dalam daftar elemen atau pola itu, jika diperlukan pengganti, itu akan dilakukan.

Hasil:

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

Metode saya yang saya gunakan mungkin tidak akan bekerja seefisien, tetapi ini sangat sederhana. Saya dapat menghapus banyak karakter pada posisi yang berbeda sekaligus, menggunakan pengirisan dan pemformatan. Ini sebuah contoh:

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

Ini akan menghasilkan 'dihapus' memegang kata 'ini'.

Memformat bisa sangat membantu untuk mencetak variabel di tengah-tengah string cetak. Itu bisa menyisipkan tipe data apa saja menggunakan % diikuti oleh tipe data variabel; semua tipe data dapat menggunakan % s , dan mengapung (alias desimal) dan bilangan bulat dapat menggunakan % d .

Mengiris dapat digunakan untuk kontrol rumit atas string. Ketika saya menaruh kata - kata [: 3] , itu memungkinkan saya untuk memilih semua karakter dalam string dari awal (titik dua adalah sebelum angka, ini berarti 'dari awal ke') ke karakter ke-4 (termasuk ke-4 karakter). Alasan 3 sama dengan sampai posisi ke-4 adalah karena Python dimulai dari 0. Kemudian, ketika saya meletakkan kata [-1:] , itu berarti karakter terakhir ke-2 sampai akhir (titik dua berada di belakang angka). Menempatkan -1 akan membuat Python dihitung dari karakter terakhir, bukan yang pertama. Sekali lagi, Python akan mulai dari 0. Jadi, kata [-1:] pada dasarnya berarti 'dari karakter terakhir kedua hingga akhir string.

Jadi, dengan memotong karakter sebelum karakter yang ingin saya hapus dan karakter setelah dan menempelkannya bersama-sama, saya dapat menghapus karakter yang tidak diinginkan. Anggap saja seperti sosis. Di tengahnya kotor, jadi saya ingin menyingkirkannya. Saya cukup memotong dua ujung yang saya inginkan kemudian menempatkan mereka bersama tanpa bagian yang tidak diinginkan di tengah.

Jika saya ingin menghapus beberapa karakter berturut-turut, saya cukup menggeser angka-angka di dalam [] (bagian pengirisan). Atau jika saya ingin menghapus beberapa karakter dari posisi yang berbeda, saya dapat dengan mudah menyatukan beberapa irisan sekaligus.

Contoh:

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

dihapus sama dengan 'keren'.

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

dihapus sama dengan 'mac'.

Dalam hal ini, [3: 5] berarti karakter pada posisi 3 hingga karakter pada posisi 5 (tidak termasuk karakter pada posisi akhir).

Ingat, Python mulai menghitung pada 0 , jadi Anda harus melakukannya juga.

Coba yang ini:

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

Metode ini bekerja dengan baik di python 3.5.2

Anda dapat menggunakan penggantian ekspresi reguler modul re. Menggunakan ekspresi ^ memungkinkan Anda untuk memilih apa yang Anda inginkan dari string Anda.

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

Output untuk ini adalah "Thisisabsurd". Hanya hal-hal yang ditentukan setelah simbol ^ akan muncul.

Metode string replacetidak mengubah string asli. Ini meninggalkan aslinya dan mengembalikan salinan yang dimodifikasi.

Yang Anda inginkan adalah sesuatu seperti: line = line.replace(char,'')

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

Namun, membuat string baru setiap kali karakter dihapus sangat tidak efisien. Saya merekomendasikan yang berikut ini sebagai gantinya:

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

Di bawah satu .. tanpa menggunakan konsep ekspresi reguler ..

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

Dalam Python 3.5

misalnya,

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

Untuk menghapus semua nomor dari string

Anda bisa menggunakan set

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

Split rekursif: s = string; chars = chars untuk dihapus

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)

contoh:

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

# untuk setiap file pada direktori, ganti nama file

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

   for file_name in file_list:

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

Bahkan pendekatan di bawah ini berhasil

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

keluaran: abcde

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