पायथन में एक स्ट्रिंग से विशिष्ट वर्ण निकालें

Question

मैं पायथन का उपयोग करके एक स्ट्रिंग से विशिष्ट वर्णों को निकालने का प्रयास कर रहा हूं। यह वह कोड है जिसका मैं अभी उपयोग कर रहा हूं। दुर्भाग्य से यह स्ट्रिंग को कुछ नहीं करता है।

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

मैं इसे ठीक से कैसे करूं?

Comments

यह 5 साल से अधिक हो गया है, लेकिन filterफ़ंक्शन और एक लैम्ब्डा अभिव्यक्ति का उपयोग करने के बारे में कैसे filter(lambda ch: ch not in " ?.!/;:", line):। सुंदर संक्षिप्त और कुशल भी, मुझे लगता है। बेशक, यह एक नया स्ट्रिंग लौटाता है जिसे आपको एक नाम निर्दिष्ट करना होगा।

— जॉन रेड

@ जॉन्डर: वास्तव में यह एक पुनरावृत्ती लौटाता है जो वर्णों की सूची देता है लेकिन यदि आप इसे उत्तर में रखते हैं तो हम में से कुछ इसे वोट देकर प्रसन्न होंगे।

— बिल बेल

@BillBell: stackoverflow.com/a/46930314/1587329 और stackoverflow.com/a/41413861/1587329

— सर्व-इन-

@BillBell: PS: यह पायथन 3 में एक पुनरावृत्तिकर्ता है और पायथन 2 में एक स्ट्रिंग, ट्यूपल या सूची है

— सर्व

संबंधित: जब तक आप इसका आउटपुट असाइन नहीं करते, पायथन स्ट्रिंग पद्धति को कॉल क्यों नहीं करता?

— जॉर्जी

Answer 1

पायथन में तार अपरिवर्तनीय हैं (बदला नहीं जा सकता)। इस वजह से, इसका प्रभाव line.replace(...)केवल पुराने को बदलने के बजाय एक नई स्ट्रिंग बनाने के लिए है। आपको उन वर्णों को हटाए जाने के साथ उस चर को नया मान लेने के लिए उसे (असाइन करना ) करना होगा line।

इसके अलावा, आप जिस तरह से कर रहे हैं वह अपेक्षाकृत धीमा, अपेक्षाकृत हल्का होने वाला है। यह भी अनुभवी pythonators के लिए थोड़ा भ्रमित होने की संभावना है, जो एक दोहरी-नेस्टेड संरचना को देखेंगे और एक पल के लिए सोचेंगे कि कुछ और जटिल हो रहा है।

पायथन 2.6 और नए पायथन 2.x संस्करणों * में शुरू, आप इसके बजाय उपयोग कर सकते हैं str.translate, (लेकिन पायथन मतभेदों के लिए पढ़ें):

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

या नियमित अभिव्यक्ति के साथ प्रतिस्थापन re.sub

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

कोष्ठक में संलग्न वर्ण एक वर्ण वर्ग का गठन करते हैं । lineउस वर्ग में जो भी वर्ण हैं, उन्हें दूसरे पैरामीटर के साथ बदल दिया जाता है sub: एक खाली स्ट्रिंग।

पायथन 3 में, स्ट्रिंग्स यूनिकोड हैं। आपको थोड़ा अलग अनुवाद करना होगा। kevpie ने इसका उत्तर में से एक पर एक टिप्पणी में उल्लेख किया है, और यह प्रलेखनstr.translate में नोट किया गया है ।

translateएक यूनिकोड स्ट्रिंग की विधि को कॉल करते समय , आप दूसरे पैरामीटर को पारित नहीं कर सकते हैं जो हमने ऊपर उपयोग किया था। आप Noneपहले पैरामीटर के रूप में भी पास नहीं हो सकते । इसके बजाय, आप केवल पैरामीटर के रूप में एक अनुवाद तालिका (आमतौर पर एक शब्दकोश) पास करते हैं। यह तालिका पात्रों के क्रमिक मूल्यों (अर्थात ordउन पर कॉल करने का परिणाम ) को उन पात्रों के क्रमिक मूल्यों के लिए मैप करती है, जिन्हें उन्हें प्रतिस्थापित करना चाहिए, या उपयोगी रूप से हमारे लिए-None यह इंगित करने के लिए कि उन्हें हटा दिया जाना चाहिए।

तो एक यूनिकोड स्ट्रिंग के साथ उपरोक्त नृत्य करने के लिए आप कुछ ऐसा कहेंगे

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('', '', '!@#$'))

---

* पहले के पायथन के साथ अनुकूलता के लिए, आप इसके स्थान पर पास करने के लिए एक "अशक्त" अनुवाद तालिका बना सकते हैं None:

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

यहां string.maketransएक अनुवाद तालिका बनाने के लिए उपयोग किया जाता है , जो कि एक स्ट्रिंग है जिसमें 0 से 255 तक के आर्डिनल मान वाले अक्षर हैं।

Comments

Python3 में, line.translateकेवल एक तर्क लेता है और पहला समाधान काम नहीं करेगा

— marczoid

Python3 में, str.translate () दूसरा तर्क नहीं लेता है। तो, आपका जवाब बन जाएगा line.translate({ord(i):None for i in '!@#$'})

— नवीन

किसी भी अन्य चरित्र के रूप में ही। अजगर आपको एकल या दोहरे उद्धरणों के जोड़े का उपयोग करने देता है। तो आप सिर्फ "'"कैरेक्टर सेट के लिए लिखें ।

— intuited

@ ऊपर नवीन की टिप्पणी ने मेरे लिए काम किया। पायथनी 2.7.13। मेरे मामले में मैं "और" पात्र बनाना चाहता था:notes = notes.translate({ord(i):None for i in '\"\''})

— रयान

पायथन 3 में, आप उपयोग कर सकते हैं unicode_line.translate(str.maketrans('', '', '!@#$'))। याunicode_line.translate(dict.fromkeys(map(ord, '!@#$')))

— मार्टिन पीटर्स

Answer 2

क्या मुझे यह बात याद आ रही है, या यह सिर्फ निम्नलिखित है:

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"

Comments

यह प्रत्येक लूप में स्ट्रिंग की प्रतिलिपि बना देगा, जो वांछनीय नहीं हो सकता है। इसके अलावा यह बहुत अच्छा पायथन नहीं है। अजगर में आप इस तरह से लूप करेंगे:for char in b: a=a.replace(char,"")

— elgehelge

उपयोगकर्ता परिभाषित चर का उपयोग करना जो सिस्टम कक्षाओं को ओवरलैप करता है एक अच्छा विचार नहीं है। आप CHAR के बजाय STR और C के बजाय वेरिएबल STRING का बेहतर उपयोग करेंगे।

— अय्यर

के string=string.replace("1","")बजाय की जरूरत है । आपने इसे अपने उदाहरण के पाश भाग में कहा था, लेकिन अधिकांश लोग आपके उत्तर में तब तक नहीं पढ़ेंगे जब तक कि वे इस तरह के एक साधारण प्रश्न के लिए कोड को पहले थोड़ा सा हाथ में न दे दें।

— कोडमेद

एक अच्छा समाधान लेकिन दूसरों के रूप में पायथन-एसके के रूप में नहीं।

— स्टीव

Answer 3

>>> line = "abc#@!?efg12;:?"
>>> ''.join( c for c in line if  c not in '?:!/;' )
'abc#@efg12'

Comments

— ऐलिसो

यदि आपके पास बहुत सारे वर्ण हैं जो निषिद्ध हैं, तो आप पहले सेट में बदलकर अपने कोड को गति दे सकते हैं। blacklist = set('?:!/;')और फिर''.join(c for c in line if c not in blacklist)

— बोरिस

Answer 4

re.subपायथन 3.5 के रूप में नियमित अभिव्यक्ति के साथ आसान मटर

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

उदाहरण

>>> import re

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

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

व्याख्या

में नियमित अभिव्यक्ति (regex), |एक तार्किक है या और \रिक्त स्थान और विशेष वर्ण वास्तविक regex आदेशों हो सकता है कि निकल जाता है। जबकि प्रतिस्थापनsub के लिए खड़ा है , इस मामले में खाली स्ट्रिंग के साथ ''।

Answer 5

एक स्ट्रिंग में केवल कुछ वर्णों की अनुमति देने की व्युत्क्रम आवश्यकता के लिए , आप एक सेट पूरक ऑपरेटर के साथ नियमित अभिव्यक्ति का उपयोग कर सकते हैं [^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' [^^]को छोड़कर किसी भी वर्ण से मेल खाएगा , और किसी भी वर्ण को छोड़कर मेल करेगा '^'। ^इसका कोई विशेष अर्थ नहीं है यदि यह सेट का पहला चरित्र नहीं है।

Answer 6

पूछने वाले के पास लगभग था। पाइथन की अधिकांश बातों की तरह, उत्तर भी आपके हिसाब से सरल है।

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

यदि आपको लूप चीज़ के लिए / नहीं तो नेस्टेड करना है, लेकिन आपको प्रत्येक वर्ण को व्यक्तिगत रूप से जांचना होगा।

Comments

हाँ, मुझे पता है, शायद बहुत देर हो चुकी है, लेकिन अगर आप बच जाते हैं तो काम करना चाहिए। इस तरह: लाइन = line.replace ('`', '') पर पढ़ें: learnpythonthehardway.org/book/ex10.html

— Aiyion.Prime

यह संभवतः प्रदर्शनकारी नहीं है क्योंकि आप हर पात्र के लिए एक नया स्ट्रिंग आवंटित कर रहे हैं

— OneCricketeer

Answer 7

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

Comments

+1 जब यूनिकोड का उपयोग किया जाता है तो उसे डिलीट स्ट्रिंग के बजाय डिलीट करने के लिए ट्रांसलेशन की आवश्यकता होती है। docs.python.org/library/stdtypes.html#str.translate

— kevpie

यह एक बढ़िया सुझाव है (Ref: docs.python.org/2/library/string.html#string.translate ) यूनिकोड नोट भी अच्छा है।

— cgseller

Answer 8

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

Comments

मेरा जवाब मूल प्रश्न का समाधान प्रदान करता है, लेकिन मुझे भी दिलचस्पी थी (शायद ओपी के रूप में) भी प्रतिक्रिया में क्यों मेरे समाधान आदर्श नहीं हो सकता है। क्या मुझे एक नया प्रश्न बनाना चाहिए और इसे संदर्भ के लिए संदर्भित करना चाहिए?

— 21

इससे मेरा वोट जाता है। अजगर संक्षिप्त

— स्टीव

Answer 9

पायथन में तार अपरिवर्तनीय हैं। replaceविधि प्रतिस्थापन के बाद एक नया स्ट्रिंग देता है। प्रयत्न:

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

Comments

आप एक ही समय में लाइन पर कैसे पुनरावृत्त कर सकते हैं और इसे संशोधित कर सकते हैं?

— यूमिरो

@ यूमिरो: पुनरावृति मूल पर आगे बढ़ती है line।

— ग्रेग हेविगिल

जानकार अच्छा लगा! इसलिए अगर मैं एक सरणी पर पुनरावृति करता हूं, तो मैं एक मूल सरणी पर पुनरावृति करता हूं। एक इटेरेटर पर Iteration संभव नहीं होगा।

— यूमिरो

Answer 10

मुझे आश्चर्य हुआ कि किसी ने अभी तक बिलिन फिल्टर फ़ंक्शन का उपयोग करने की सिफारिश नहीं की थी ।

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

    s = "1212edjaq"

मान लें कि हम वह सब कुछ फ़िल्टर करना चाहते हैं जो एक नंबर नहीं है। फ़िल्टर बिल्ट विधि का उपयोग करना "... जनरेटर की अभिव्यक्ति के बराबर है (आइटम के लिए आइटम यदि चलने योग्य है तो फ़ंक्शन (आइटम))" [ पायथन 3 बिल्ड: फ़िल्टर ]

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

पायथन 3 में यह रिटर्न देता है

    >>  <filter object @ hex>

मुद्रित स्ट्रिंग प्राप्त करने के लिए,

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

मुझे यकीन नहीं है कि कैसे फिल्टर दक्षता के मामले में रैंक करता है, लेकिन यह जानने के लिए एक अच्छी बात है कि सूची की समझ और इस तरह का उपयोग कैसे करें।

अपडेट करें

तार्किक रूप से, चूंकि फ़िल्टर काम करता है आप सूची समझ का उपयोग कर सकते हैं और मैंने जो पढ़ा है, वह अधिक कुशल माना जाता है क्योंकि लैम्ब्डा प्रोग्रामिंग फ़ंक्शन वर्ल्ड की वॉल स्ट्रीट हेज फंड मैनेजर हैं। एक और प्लस यह है कि यह एक-लाइनर है जिसे किसी भी आयात की आवश्यकता नहीं है। उदाहरण के लिए, उपर्युक्त समान स्ट्रिंग 's' का उपयोग करते हुए,

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

बस। वापसी उन सभी वर्णों की एक स्ट्रिंग होगी जो मूल स्ट्रिंग में अंक हैं।

यदि आपके पास स्वीकार्य / अस्वीकार्य पात्रों की एक विशिष्ट सूची है, तो आपको सूची की समझ के भाग को 'यदि' ही समायोजित करना होगा।

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

Comments

operator.containsयदि आप किसी lambdaभी तरह से उपयोग कर रहे हैं तो उपयोग करने का कोई कारण नहीं है। lambda x: operator.contains(intsList, x)वर्तनी होनी चाहिए lambda x: x in intsList, या यदि आप सी-लेवल चेक प्राप्त करने की कोशिश कर रहे हैं, intsList.__contains__( lambdaबिल्कुल नहीं) चाल चलेगा।

— शैडो रेंजर

Answer 11

का उपयोग करते हुए filter, आपको बस एक पंक्ति की आवश्यकता होगी

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

यह स्ट्रिंग को एक पुनरावृत्ति के रूप में मानता है और यदि 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.

Answer 12

इस कार्य को प्राप्त करने के कुछ संभावित तरीके यहां दिए गए हैं:

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

पुनश्च: इसके बजाय "?"! / ;: "उदाहरण स्वर का उपयोग करते हैं ... और हाँ," 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

तो ऐसा लगता है कि इस विशेष इनपुट के लिए प्रयास 4 सबसे तेज़ है।

Comments

आप एक बेकार listमें निर्माण कर रहे हैं attempt1और "aeiou"सरलता के लिए टपल को फिर से लिखा जा सकता है (हटाने [और ]सूची बनाए बिना जनरेटर में बदल जाएगा)। आप में attemt2, attempt3जहां आप r'[aeiou]'एक पास में उपयोग कर सकते हैं regex के कई अनुप्रयोगों का उपयोग करते हैं, में भगोड़ा मध्यस्थ तारों के टन बनाते हैं। हर एक में खामियां हैं - चीजों को करने के विभिन्न तरीकों को देखने के लिए अच्छा है, लेकिन कृपया उन्हें अच्छी कोशिश करने के लिए ठीक करें

— पैट्रिक आर्टर

@PatrickArtner आप बिलकुल सही हैं ... इस कार्य को प्राप्त करने के लिए मेरे द्वारा प्राप्त किए गए दर्जनों तरीकों से मैंने धीमे लोगों को उठाया है (ओपी को कुछ आसान दिखाना चाहते हैं) ... यह कहा, आपके बाद लोगों ने दूसरे धागे को बंद कर दिया है जो मैंने पहले से ही उत्तर पुराने धागे पर अधिक प्रयास करने के लिए प्रेरणा खो दिया है, इसलिए ... :)। अंक के लिए धन्यवाद।

— बीपीएल

@PatrickArtner ठीक है ... सिर्फ एक खातिर एक नया जोड़ा, "प्रयास 4" ... मापा नहीं गया है, लेकिन मुझे लगता है कि एक को तेज होना चाहिए

— बीपीएल

@PatrickArtner संपादित ... प्रयास 4 छोटे प्रयासों के सेट से सबसे तेज़ था। वैसे भी, मैं इस सामान के साथ अधिक समय बर्बाद नहीं कर रहा हूं :)

— बीपीएल

Answer 13

यहाँ मेरा पायथन 2/3 संगत संस्करण है। चूंकि अनुवाद एपीआई बदल गया है।

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)

Comments

मैं dict.fromkeys(map(ord, '!@#$'))मानचित्र बनाने के लिए उपयोग करूँगा ।

— मार्टिन पीटर्स

mapआम तौर पर एक सूची / कम / सेट / जनरेटर की समझ से कम पठनीय है। इतना कि गुइडो इसे भाषा से हटाना चाहते थे । उपयोग करना fromkeysभी थोड़ा चालाक है और इसके लिए डॉक्टर जांच की आवश्यकता होती है।

— ब्राइस गुइंट

@MartijnPieters: पायथन 3 के लिए, यह सिर्फ होना चाहिए str.maketrans('', '', chars), जो ordरूपांतरण और dictनिर्माण को एक ही बार में संभालता है (इसका उल्लेख इरादे में अधिक स्पष्ट नहीं है, क्योंकि यह जोड़ी के साथ बनाया गया है str.translate)।

— शैडो रेंजर

Answer 14

#!/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

Comments

क्या आपका मतलब भाषण के निशान से है? पुनः कोड से बचने और 'एक स्ट्रिंग के रूप में विचार करने के लिए बैकस्लैश है । docs.python.org/2/library/re.html

— JasTonAChair

Answer 15

इस बारे में कैसा है:

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

Comments

क्या आप प्रदान किए गए समाधान के बारे में थोड़ा और विवरण जोड़ते हुए अपने उत्तर को अधिक विस्तृत कर सकते हैं?

— अबरीसोन

किसी सूची में जोड़ना, फिर जुड़ना उपयोग करने की तुलना में अधिक कुशल होगा

— OneCricketeer

Answer 16

किसी सूची के उपयोग के साथ विभिन्न प्रकार की नियमित अभिव्यक्ति या अन्य पैटर्न को बदलने के लिए आप एक फ़ंक्शन का उपयोग भी कर सकते हैं। इसके साथ, आप नियमित अभिव्यक्ति, वर्ण वर्ग और वास्तव में मूल पाठ पैटर्न मिश्रित कर सकते हैं। जब आप HTML जैसे कई तत्वों को स्थानापन्न करना चाहते हैं तो यह वास्तव में उपयोगी है।

* NB: पायथन 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

Answer 17

मेरे द्वारा उपयोग की जाने वाली मेरी विधि शायद उतनी कुशलता से काम नहीं करती, लेकिन यह बड़े पैमाने पर सरल है। मैं अलग-अलग पदों पर एक साथ कई पात्रों को हटा सकता हूं, स्लाइसिंग और फॉर्मेटिंग का उपयोग करके। यहाँ एक उदाहरण है:

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

इसके परिणामस्वरूप 'यह' शब्द 'हटा' दिया जाएगा।

स्वरूपण एक प्रिंट स्ट्रिंग के माध्यम से चर चर प्रिंट करने के लिए बहुत उपयोगी हो सकता है। यह चर के डेटा प्रकार के बाद % का उपयोग करके किसी भी डेटा प्रकार को सम्मिलित कर सकता है ; सभी डेटा प्रकार % s का उपयोग कर सकते हैं , और फ़्लोट्स (उर्फ दशमलव) और पूर्णांक % d का उपयोग कर सकते हैं ।

टुकड़ा करने की क्रिया तार से अधिक जटिल नियंत्रण के लिए इस्तेमाल किया जा सकता। जब मैं शब्द [: 3] डालता हूं , तो यह मुझे शुरुआत से स्ट्रिंग में सभी वर्णों का चयन करने की अनुमति देता है (कोलन संख्या से पहले है, इसका अर्थ 'शुरुआत से' तक) 4 वर्ण तक होगा (इसमें 4 वां शामिल है चरित्र)। 4 वें स्थान तक कारण 3 बराबर होता है क्योंकि पायथन 0. से शुरू होता है। तब, जब मैंने शब्द [-1:] रखा , तो इसका मतलब है कि अंतिम अंतिम वर्ण (अंत में संख्या पीछे है)। -1 डालने से पहले के बजाय अंतिम चरित्र से पायथन की गिनती होगी। फिर से, पायथन 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 (अंतिम स्थिति में चरित्र को छोड़कर)।

याद रखें, पायथन की गिनती 0 से शुरू होती है , इसलिए आपको भी इसकी आवश्यकता होगी।

Answer 18

इसको आजमाओ:

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

यह विधि अजगर 3.5.2 में अच्छी तरह से काम करती है

Answer 19

आप पुनः मॉड्यूल के नियमित अभिव्यक्ति प्रतिस्थापन का उपयोग कर सकते हैं। ^ अभिव्यक्ति का उपयोग करना आपको अपनी स्ट्रिंग से वास्तव में वही लेने की अनुमति देता है जो आप चाहते हैं।

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

इसका आउटपुट "थिसिसबसर्ड" होगा। ^ प्रतीक के बाद केवल निर्दिष्ट चीजें दिखाई देंगी।

Answer 20

स्ट्रिंग विधि 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

Answer 21

नीचे एक .. नियमित अभिव्यक्ति अवधारणा का उपयोग करने के साथ ..

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

Answer 22

पायथन 3.5 में

जैसे,

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

स्ट्रिंग से सभी संख्या को निकालने के लिए

Answer 23

आप सेट का उपयोग कर सकते हैं

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

Comments

जवाब देते समय कुछ स्पष्टीकरण देना बेहतर होता है क्योंकि आपका जवाब क्या है।

— स्टीफन राउच

Answer 24

पुनरावर्ती विभाजन: एस = स्ट्रिंग; 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!

Answer 25

# एक निर्देशिका पर प्रत्येक फ़ाइल के लिए, फ़ाइल नाम का नाम बदलें

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

   for file_name in file_list:

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

Answer 26

यहां तक ​​कि नीचे का दृष्टिकोण भी काम करता है

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

उत्पादन: abcde

Answer 27

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

Comments

केवल स्ट्रिंग की शुरुआत या अंत से पात्रों को हटा देता है

— 16