Python kullanarak bir dizeden belirli karakterleri kaldırmaya çalışıyorum. Bu şu anda kullandığım kod. Ne yazık ki dizeye hiçbir şey yapmıyor gibi görünüyor.

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

Bunu nasıl düzgün bir şekilde yapabilirim?

Python'daki dizeler değiştirilemez (değiştirilemez). Bu nedenle, etkisi line.replace(...)eskisini değiştirmek yerine sadece yeni bir dize oluşturmaktır. Bu değişkenin yeni değeri almasını sağlamak için bu karakterler kaldırılmış olarak yeniden bağlamanız (atamanız) gerekir line.

Ayrıca, bunu yapma şekliniz nispeten yavaş olacaktır. Ayrıca, iki kat daha fazla iç içe bir yapı görecek ve bir an için daha karmaşık bir şeyin devam ettiğini düşünecek deneyimli pitonatörler için biraz kafa karıştırıcı olması muhtemeldir.

Python 2.6 ve daha yeni Python 2.x sürümlerinden * başlayarak, str.translate (ancak Python 3 farkları için okumaya devam edin):

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

veya ile düzenli ifade değiştirme re.sub

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

Parantez içindeki karakterler bir karakter sınıfı oluşturur . lineBu sınıftaki tüm karakterler subboş bir dize için ikinci parametreyle değiştirilir .

Python 3'te, dizeler Unicode'dur. Biraz daha farklı çevirmen gerekecek. kevpie bundan bahsediyor cevaplardan birine yapılan yorumda ve bunun belgelerindestr.translate belirtiliyor .

translateUnicode dizesinin yöntemini çağırırken, yukarıda kullandığımız ikinci parametreyi geçiremezsiniz. Ayrıca Noneilk parametre olarak geçemezsiniz . Bunun yerine, tek çeviri olarak bir çeviri tablosu (genellikle sözlük) iletirsiniz. Bu tablo sıra değerlerini eşler , karakterlerin (yani, ordonları çağırmanın sonucu ), karakterlerin yerine geçmesi gereken sıralı değerlerle veya Nonesilinmeleri gerektiğini belirtmek için - bize faydalı olarak - eşleştirir .

Bu yüzden yukarıdaki dansı bir Unicode dizesiyle yapmak için

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

Burada dict.fromkeysve mapözlü bir şekilde sözlük içeren bir sözlük oluşturmak için kullanılır

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

Daha basit, başka bir cevabın ifade ettiği gibi , çeviri tablosunu yerinde oluşturun:

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

Veya ile aynı çeviri tablosunu oluşturun str.maketrans :

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

* önceki Pythons ile uyumluluk için, yerine geçmek üzere bir "null" çeviri tablosu oluşturabilirsiniz None :

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

Burada string.maketrans, yalnızca 0 ila 255 sıra değerlerine sahip karakterleri içeren bir dize olan bir çeviri tablosu oluşturmak için kullanılır .

Buradaki noktayı kaçırıyor muyum yoksa sadece şu mı?

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

print string
# result: "abcdef"

Bir döngüye koyun:

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.subPython 3.5'ten itibaren düzenli ifade ile kolay bezelye

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

Misal

>>> import re

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

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

açıklama

Gelen düzenli ifadeler (regex), |mantıksal OR ve \hangi ifadenin komutları olabilir boşluk ve özel karakterler kaçar. Oysa bu durumda boş dize ile ikamesub anlamına gelir .''

Bir dizede yalnızca belirli karakterlere izin vermenin tersi gerekliliği için, set tamamlayıcı işleciyle normal ifadeleri kullanabilirsiniz [^ABCabc]. Örneğin, ascii harfleri, rakamları ve kısa çizgileri hariç her şeyi kaldırmak için:

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

Gönderen piton düzenli ifade belgelerinde :

Bir aralıkta olmayan karakterler, kümeyi tamamlayarak eşleştirilebilir. Kümenin ilk karakteri ise, kümede olmayan '^'tüm karakterler eşleştirilir. Örneğin, [^5]'5' [^^]dışındaki herhangi bir karakterle eşleşir ve dışındaki herhangi bir karakterle eşleşir '^'. ^setteki ilk karakter değilse özel bir anlamı yoktur.

Askerde neredeyse vardı. Python'daki çoğu şey gibi, cevap düşündüğünüzden daha basittir.

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

İç içe if / for loop şeyini yapmak zorunda değilsiniz, ancak her karakteri ayrı ayrı kontrol etmeniz gerekiyor.

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

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

Dizeler Python'da değişmez. replaceYöntem değişiminden sonra yeni bir dize döndürür. Deneyin:

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

Yerleşik filtre işlevini henüz kimsenin önermediğine şaşırdım .

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

    s = "1212edjaq"

Diyelim ki sayı olmayan her şeyi filtrelemek istiyoruz. "... yerleşik filtre yöntemini kullanmak, jeneratör ifadesine eşdeğerdir (işlev (öğe) ise yinelenebilir öğedeki öğe için)" [ Python 3 Builtins: Filter ]

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

Python 3'te bu geri döner

    >>  <filter object @ hex>

Basılı bir dize almak için,

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

Nasıl filtre emin değilim verimlilik açısından sıralandığından , ancak liste kavrayışı ve benzeri işlemleri nasıl kullanacağınızı bilmek iyi bir şey.

GÜNCELLEME

Mantıken, filtre çalışmaları da liste kavrama kullanabilirsiniz ve okudum ne daha verimli olması gerekiyordu çünkü lambdalar programlama fonksiyonu dünyanın wall street çit fonu yöneticileri. Başka bir artı, herhangi bir ithalat gerektirmeyen tek astar olmasıdır. Örneğin, yukarıda tanımlanan aynı dize 'leri kullanarak,

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

Bu kadar. Dönüş, orijinal dizede rakam olan tüm karakterlerin bir dizesi olacaktır.

Kabul edilebilir / kabul edilemez karakterlerden oluşan belirli bir listeniz varsa, yalnızca liste kavrayışının 'if' kısmını ayarlamanız gerekir.

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

Veya alternatif olarak,

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

Kullanarak filter, sadece bir satıra ihtiyacınız olacak

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

Bu, dizeyi yinelenebilir olarak ele alır ve lambdadöndürürse her karakteri kontrol eder 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.

Bu görevi gerçekleştirmenin bazı olası yolları:

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: Bunun yerine "?.! / ;:" örnekleri ünlüleri kullanır ... ve evet, "murcielago" tüm sesli harfleri içerdiği için yarasa ... komik kelime demek için İspanyolca kelimedir :)

PS2: Performansla ilgileniyorsanız, bu girişimleri aşağıdaki gibi basit bir kodla ölçebilirsiniz:

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

Kutumda şunları alacaksınız:

attempt1 2.2334518376057244
attempt2 1.8806643818474513
attempt3 7.214925774955572
attempt4 1.7271184513757465

Yani teşebbüs4 bu girdi için en hızlısıdır.

İşte benim Python 2/3 uyumlu sürümüm. Çeviri api değişti yana.

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

Buna ne dersin:

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

Ayrıca, bir işlevi kullanarak farklı türdeki normal ifadeleri veya diğer kalıpları değiştirmek için bir işlev de kullanabilirsiniz. Bununla, normal ifadeyi, karakter sınıfını ve gerçekten temel metin desenini karıştırabilirsiniz. HTML öğeleri gibi birçok öğeyi değiştirmeniz gerektiğinde gerçekten yararlıdır.

* NB: Python 3.x ile çalışır

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 işlevinde, x dizenizi ve listenizi bağımsız değişken olarak almaz. Bu elemanlar veya desen listesindeki her bir öğe için, bir yedek gerekliyse yapılır.

Çıktı:

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

Kullanacağım yöntem muhtemelen verimli bir şekilde işe yaramaz, ancak çok basittir. Dilimleme ve biçimlendirmeyi kullanarak farklı konumlardaki birden çok karakteri aynı anda kaldırabilirim. İşte bir örnek:

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

Bu, 'bu' kelimesini tutarak 'kaldırıldı' ile sonuçlanır.

Biçimlendirme , değişkenleri bir yazdırma dizesi boyunca yazdırmak için çok yararlı olabilir. % Ve ardından değişkenin veri türünü kullanarak herhangi bir veri türünü ekleyebilir ; tüm veri türleri % s , şamandıralar (ondalık sayılar olarak da bilinir) ve tamsayılar % d kullanabilir .

Dilimleme , dizeler üzerinde karmaşık kontrol için kullanılabilir. [: 3] kelimeleri koyduğumda , dizedeki tüm karakterleri baştan seçmeme izin veriyor (iki nokta üst üste sayıdan önce geliyor, bu 'başlangıçtan' anlamına gelecektir) 4. karaktere (4. karakteri içeriyor) karakter). Sebebi 3'ün 4. pozisyona kadar olmasının sebebi, Python'un 0'da başlamasıdır. Sonra, [-1:] kelimesini koyduğumda , sondaki son 2. karakter anlamına gelir (iki nokta üst üste sayının arkasındadır). -1 koymak, Python'u ilk karakterden ziyade son karakterden sayar. Yine, Python 0'da başlayacaktır. Yani, [-1:] kelimesi temel olarak 'son ikinci karakterden dizenin sonuna kadar anlamına gelir.

Bu nedenle, kaldırmak istediğim karakterden önceki karakterleri ve sonraki karakterleri kesip bir araya getirerek, istenmeyen karakteri kaldırabilirim. Bir sosis gibi düşünün.Ortada kirli, bu yüzden ondan kurtulmak istiyorum. Sadece istediğim iki ucu kestim ve sonra ortada istenmeyen kısım olmadan bir araya getirdim.

Birbirini takip eden birden fazla karakteri kaldırmak istiyorsam, sadece [] (dilimleme kısmı) içindeki sayıları kaydırıyorum. Veya farklı konumlardan birden fazla karakteri kaldırmak istersem, aynı anda birden fazla dilimi bir araya getirebilirim.

Örnekler:

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

kaldırıldı 'serin' eşittir.

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

çıkarıldı 'mac'lere eşittir.

Bu durumda, [3: 5] de bir karakter anlamına gelir pozisyonda karakteri ile 3 pozisyonunda (nihai konumunda karakter hariç) 5.

Unutmayın, Python 0'da saymaya başlar , bu yüzden de yapmanız gerekir.

Bunu dene:

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

Bu yöntem python 3.5.2'de iyi çalışır

Re modülünün normal ifade değişimini kullanabilirsiniz. ^ İfadesini kullanmak, dizenizden tam olarak ne istediğinizi seçmenize olanak tanır.

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

Bunun çıktısı "Thisisabsurd" olacaktır. Yalnızca ^ sembolünden sonra belirtilenler görünecektir.

String yöntemi replaceorijinal dizgiyi değiştirmez. Orijinali yalnız bırakır ve değiştirilmiş bir kopyasını döndürür.

İstediğiniz gibi bir şey: line = line.replace(char,'')

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

Ancak, bir karakterin her kaldırılışında yeni bir dize oluşturmak çok verimsizdir. Bunun yerine aşağıdakileri tavsiye ederim:

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

Birinin altında .. düzenli ifade kavramını kullanarak ...

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 sürümünde

Örneğin,

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

Dizeden tüm sayıları kaldırmak için

set kullanabilirsiniz

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

Özyinelemeli bölünme: s = string; karakter = kaldırılacak karakter

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)

misal:

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

Dizindeki her dosya için #, dosya adını yeniden adlandır

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

   for file_name in file_list:

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

Aşağıdaki yaklaşım bile işe yarar

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

çıktı: abcde

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