पायथन में एक स्ट्रिंग के अंत से मैं एक सबस्ट्रिंग कैसे निकालूं?

Question

मेरे पास निम्नलिखित कोड हैं:

url = 'abcdc.com'
print(url.strip('.com'))

मैंने उम्मीद की: abcdc

मुझे मिला: abcd

अब मैं करता हूँ

url.rsplit('.com', 1)

क्या कोई बेहतर तरीका है?

Comments

स्ट्रिप स्ट्रिंग के दोनों सिरों से दिए गए वर्णों को स्ट्रिप करता है, आपके मामले में यह स्ट्रिप्स "", "सी", "ओ" और "एम"।

— ट्रूप्पो

यह उन पात्रों को स्ट्रिंग के सामने से भी हटा देगा। तुम सिर्फ यह अंत से निकालना चाहते हैं, तो उपयोग rstrip ()

— आंद्रे मिलर

हाँ। str.strip वह नहीं करता है जो आपको लगता है कि यह करता है। str.strip स्ट्रिंग के आरंभ और अंत से निर्दिष्ट किसी भी वर्ण को हटा देता है। तो, "acbacda" .strip ("विज्ञापन") 'cbac' देता है; शुरुआत में और अंत में दा छीन लिए गए थे। चीयर्स।

— scvalex

साथ ही, यह किसी भी क्रम में वर्णों को हटा देता है : "site.ocm"> "साइट"।

— एरिक ओ लेबिगॉट

@scvalex, वाह सिर्फ महसूस किया कि यह उम्र के लिए यह प्रयोग किया जाता रहा है कि जिस तरह से है - यह खतरनाक है क्योंकि कोड अक्सर काम के लिए होता वैसे भी

— फ्लैश

Answer 1

stripइसका मतलब यह नहीं है "इस प्रतिस्थापन को हटा दें"। पात्रों के एक सेट के रूप में x.strip(y)व्यवहार करता है yऔर उस सेट के अंत से किसी भी वर्ण को अलग करता है x।

इसके बजाय, आप उपयोग कर सकते हैं endswith और टुकड़ा :

url = 'abcdc.com'
if url.endswith('.com'):
    url = url[:-4]

या नियमित अभिव्यक्ति का उपयोग कर :

import re
url = 'abcdc.com'
url = re.sub('\.com$', '', url)

Comments

हाँ, मैं खुद सोचता हूं कि पहला उदाहरण, एंड्सविथ () परीक्षण के साथ, बेहतर होगा; रेगेक्स एक में कुछ प्रदर्शन जुर्माना शामिल होगा (रेगेक्स को पार्स करना, आदि)। मैं rsplit () एक के साथ नहीं जाऊंगा, लेकिन ऐसा इसलिए है क्योंकि मुझे नहीं पता कि आप वास्तव में क्या हासिल करने की कोशिश कर रहे हैं। मुझे लगता है कि यह .com को हटा रहा है अगर और केवल अगर यह url के अंत में दिखाई दे? Rsplit समाधान अगर आप की तरह 'www.commercialthingie.co.uk' डोमेन नाम पर इसका इस्तेमाल होता आप मुसीबत देना होगा

— steef

url = url[:-4] if any(url.endswith(x) for x in ('.com','.net')) else url

— बुरहान खालिद

क्या होगा अगर मैं EXAMLPLE.COMडोमेन नाम लिखता हूं तो मामला संवेदनशील नहीं है। (यह रेगेक्स समाधान के लिए एक वोट है)

— जैसन

यह फिर से लिखना नहीं है, rsplit()समाधान में एक ही व्यवहार नहीं है endswith()जब मूल स्ट्रिंग के अंत में सबस्ट्रिंग नहीं होता है, लेकिन कहीं बीच में। उदाहरण के लिए: "www.comeandsee.com".rsplit(".com",1)[0] == "www.comeandsee"लेकिन"www.comeandsee.net".rsplit(".com",1)[0] == "www"

— Steef

वाक्य रचना s[:-n]एक चेतावनी है: के लिए n = 0, इस काटा पिछले शून्य पात्रों के साथ स्ट्रिंग वापस नहीं करता है, लेकिन खाली स्ट्रिंग के बजाय।

— ब्लेंडरबेंडर

Answer 2

यदि आप सुनिश्चित हैं कि स्ट्रिंग केवल अंत में दिखाई देती है, तो सबसे सरल तरीका 'प्रतिस्थापित' का उपयोग करना होगा:

url = 'abcdc.com'
print(url.replace('.com',''))

Comments

वह भी url की जगह लेगा www.computerhope.com। के साथ एक जाँच करें endswith()और ठीक होना चाहिए।

— ghostdog74

"www.computerhope.com".endswith(".com")सच है, यह अभी भी टूट जाएगा!

"यदि आप सुनिश्चित हैं कि स्ट्रिंग केवल अंत में दिखाई देती है" क्या आपका मतलब है "यदि आप सुनिश्चित हैं कि सबस्ट्रिंग केवल एक बार दिखाई देता है"? प्रतिस्थापन के बीच में होने पर भी काम करने लगता है, लेकिन जैसा कि अन्य टिप्पणी से पता चलता है कि यह प्रतिस्थापन की किसी भी घटना को बदल देगा, यह अंत में क्यों होना चाहिए मुझे समझ में नहीं आता

— idclev 463035818

Answer 3

def strip_end(text, suffix):
    if not text.endswith(suffix):
        return text
    return text[:len(text)-len(suffix)]

Comments

यदि आप जानते हैं कि प्रत्यय खाली नहीं है (जैसे कि जब वह स्थिर होता है) तो: पाठ लौटाएं:: - len (प्रत्यय)]

— MarcH

धन्यवाद। अंतिम पंक्ति को छोटा किया जा सकता है:return text[:-len(suffix)]

— Jabba

@ जब्बा: अफसोस की बात है, कि खाली प्रत्ययों के लिए काम नहीं करेगा, जैसा कि फेनफंडाचटज़िग ने उल्लेख किया है।

— yairchu

Answer 4

चूंकि ऐसा लगता है कि किसी ने अभी तक इस पर इशारा नहीं किया है:

url = "www.example.com"
new_url = url[:url.rfind(".")]

split()नई सूची ऑब्जेक्ट के रूप में उपयोग किए जाने वाले तरीकों की तुलना में यह अधिक कुशल होना चाहिए , और यह समाधान कई बिंदुओं के साथ तार के लिए काम करता है।

Comments

वाह कि एक अच्छी चाल है। मैं इसे विफल नहीं कर पाया, लेकिन मेरे पास एक कठिन समय था कि मैं यह सोचने में सक्षम हो जाऊं कि यह विफल हो सकता है। मुझे यह पसंद है लेकिन यह बहुत ही "जादुई" है, यह जानना मुश्किल है कि यह सिर्फ इसे देखकर क्या करता है। मुझे "पाने के लिए" लाइन के प्रत्येक भाग को मानसिक रूप से संसाधित करना था।

— DevPlayer

यह विफल रहता है यदि खोजा गया स्ट्रिंग मौजूद नहीं है, और यह गलत तरीके से इसके बजाय अंतिम वर्ण को निकालता है।

— रॉबट २

Answer 5

इस बात पर निर्भर करता है कि आप अपने यूआरएल के बारे में क्या जानते हैं और वास्तव में आप क्या करने की कोशिश कर रहे हैं। यदि आप जानते हैं कि यह हमेशा '.com' (या '.net' या '.org') में समाप्त होगा

 url=url[:-4]

सबसे तेज उपाय है। यदि यह एक अधिक सामान्य URL है तो आप शायद उन urlparse लाइब्रेरी में देखने से बेहतर हैं जो अजगर के साथ आती हैं।

यदि आप दूसरी ओर आप बस फाइनल के बाद सब कुछ निकालना चाहते हैं '।' एक तार में तब

url.rsplit('.',1)[0]

काम करेगा। या अगर आप चाहते हैं कि सब कुछ पहले तक हो जाए '।' फिर कोशिश करो

url.split('.',1)[0]

Answer 6

यदि आप जानते हैं कि यह एक विस्तार है, तो

url = 'abcdc.com'
...
url.rsplit('.', 1)[0]  # split at '.', starting from the right, maximum 1 split

इस के साथ समान रूप से अच्छी तरह से काम करता है abcdc.comया www.abcdc.comया abcdc.[anything]और अधिक विस्तृत है।

Answer 7

एक पंक्ति में:

text if not text.endswith(suffix) or len(suffix) == 0 else text[:-len(suffix)]

Answer 8

कैसे के बारे में url[:-4]?

Answer 9

Urls के लिए (जैसा कि दिए गए उदाहरण से विषय का एक हिस्सा लगता है), कोई इस तरह से कर सकता है:

import os
url = 'http://www.stackoverflow.com'
name,ext = os.path.splitext(url)
print (name, ext)

#Or:
ext = '.'+url.split('.')[-1]
name = url[:-len(ext)]
print (name, ext)

दोनों का उत्पादन होगा: ('http://www.stackoverflow', '.com')

यह भी साथ जोड़ा जा सकता है str.endswith(suffix)यदि आपको ".com", या कुछ विशेष को विभाजित करने की आवश्यकता है।

Answer 10

url.rsplit ('। com', 1)

यह बहुत सही नहीं है।

आपको वास्तव में जो लिखना होगा, वह है

url.rsplit('.com', 1)[0]

, और यह बहुत रसीला IMHO दिखता है।

हालाँकि, मेरी व्यक्तिगत पसंद यह विकल्प है क्योंकि यह केवल एक पैरामीटर का उपयोग करता है:

url.rpartition('.com')[0]

Comments

+1 विभाजन को प्राथमिकता दी जाती है जब केवल एक विभाजन की आवश्यकता होती है क्योंकि यह हमेशा एक उत्तर देता है, एक इंडेक्सइर्र्ट नहीं होगा।

— ग्रिंगो सुवे

Answer 11

में शुरू Python 3.9, आप removesuffixइसके बजाय उपयोग कर सकते हैं :

'abcdc.com'.removesuffix('.com')
# 'abcdc'

Answer 12

यदि आपको स्ट्रिंग के कुछ छोर को स्ट्रिप करने की आवश्यकता है यदि यह मौजूद है तो अन्यथा कुछ भी नहीं करें। मेरा सबसे अच्छा समाधान। आप शायद पहले 2 कार्यान्वयन में से एक का उपयोग करना चाहेंगे, लेकिन मैंने पूर्णता के लिए 3 को शामिल किया है।

एक निरंतर प्रत्यय के लिए:

def remove_suffix(v, s):
    return v[:-len(s) if v.endswith(s) else v
remove_suffix("abc.com", ".com") == 'abc'
remove_suffix("abc", ".com") == 'abc'

एक रेगेक्स के लिए:

def remove_suffix_compile(suffix_pattern):
    r = re.compile(f"(.*?)({suffix_pattern})?$")
    return lambda v: r.match(v)[1]
remove_domain = remove_suffix_compile(r"\.[a-zA-Z0-9]{3,}")
remove_domain("abc.com") == "abc"
remove_domain("sub.abc.net") == "sub.abc"
remove_domain("abc.") == "abc."
remove_domain("abc") == "abc"

बड़ी संख्या में कॉल के लिए निरंतर प्रत्यय के संग्रह के लिए सबसे तेज़ तरीका है:

def remove_suffix_preprocess(*suffixes):
    suffixes = set(suffixes)
    try:
        suffixes.remove('')
    except KeyError:
        pass

    def helper(suffixes, pos):
        if len(suffixes) == 1:
            suf = suffixes[0]
            l = -len(suf)
            ls = slice(0, l)
            return lambda v: v[ls] if v.endswith(suf) else v
        si = iter(suffixes)
        ml = len(next(si))
        exact = False
        for suf in si:
            l = len(suf)
            if -l == pos:
                exact = True
            else:
                ml = min(len(suf), ml)
        ml = -ml
        suffix_dict = {}
        for suf in suffixes:
            sub = suf[ml:pos]
            if sub in suffix_dict:
                suffix_dict[sub].append(suf)
            else:
                suffix_dict[sub] = [suf]
        if exact:
            del suffix_dict['']
            for key in suffix_dict:
                suffix_dict[key] = helper([s[:pos] for s in suffix_dict[key]], None)
            return lambda v: suffix_dict.get(v[ml:pos], lambda v: v)(v[:pos])
        else:
            for key in suffix_dict:
                suffix_dict[key] = helper(suffix_dict[key], ml)
            return lambda v: suffix_dict.get(v[ml:pos], lambda v: v)(v)
    return helper(tuple(suffixes), None)
domain_remove = remove_suffix_preprocess(".com", ".net", ".edu", ".uk", '.tv', '.co.uk', '.org.uk')

अंतिम एक संभवतया pypy तो cpython में काफी तेज है। लगभग सभी मामलों के लिए रेगेक्स वैरिएंट की तुलना में तेजी से होने की संभावना है जो संभावित प्रत्ययों के विशाल शब्दकोशों को शामिल नहीं करने के लिए है जो आसानी से कम से कम cPython में रेगेक्स के रूप में प्रतिनिधित्व नहीं कर सकते हैं।

PyPy में रेगेक्स वैरिएंट निश्चित रूप से बड़ी संख्या में कॉल या लंबे स्ट्रिंग्स के लिए धीमा है, भले ही री मॉड्यूल एक डीएफए संकलन रेगेक्स इंजन का उपयोग करता है क्योंकि लैम्बडा के ओवरहेड के विशाल बहुमत को जेआईटी द्वारा अनुकूलित किया जाएगा।

CPython में यह तथ्य है कि regex के लिए आपका रनिंग c कोड लगभग सभी मामलों में प्रत्यय संग्रह संस्करण के एल्गोरिथम फायदे की तुलना में लगभग निश्चित रूप से तुलना करता है।

Answer 13

यदि आप केवल विस्तार पट्टी का मतलब है:

'.'.join('abcdc.com'.split('.')[:-1])
# 'abcdc'

यह किसी भी विस्तार के साथ काम करता है, साथ ही फाइलनाम में संभावित अन्य डॉट्स भी मौजूद हैं। यह बस स्ट्रिंग को डॉट्स पर एक सूची के रूप में विभाजित करता है और अंतिम तत्व के बिना इसमें शामिल होता है।

Answer 14

import re

def rm_suffix(url = 'abcdc.com', suffix='\.com'):
    return(re.sub(suffix+'$', '', url))

मैं इस जवाब को सबसे स्पष्ट तरीके से दोहराना चाहता हूं। बेशक, निम्न CPU समय कम लगेगा:

def rm_dotcom(url = 'abcdc.com'):
    return(url[:-4] if url.endswith('.com') else url)

हालाँकि, यदि CPU बोतल गर्दन है तो पायथन में क्यों लिखें?

सीपीयू वैसे भी एक बोतल गर्दन है? ड्राइवरों में, हो सकता है।

नियमित अभिव्यक्ति का उपयोग करने के फायदे कोड पुन: प्रयोज्य हैं। यदि आप अगली बार '.me' को हटाना चाहते हैं, जिसमें केवल तीन वर्ण हैं?

एक ही कोड होगा चाल:

>>> rm_sub('abcdc.me','.me')
'abcdc'

Answer 15

मेरे मामले में मुझे एक अपवाद बढ़ाने की आवश्यकता थी इसलिए मैंने किया:

class UnableToStripEnd(Exception):
    """A Exception type to indicate that the suffix cannot be removed from the text."""

    @staticmethod
    def get_exception(text, suffix):
        return UnableToStripEnd("Could not find suffix ({0}) on text: {1}."
                                .format(suffix, text))


def strip_end(text, suffix):
    """Removes the end of a string. Otherwise fails."""
    if not text.endswith(suffix):
        raise UnableToStripEnd.get_exception(text, suffix)
    return text[:len(text)-len(suffix)]

Answer 16

यहाँ, मेरे पास एक सरल कोड है।

url=url.split(".")[0]

Answer 17

मान लें कि आप डोमेन को हटाना चाहते हैं, चाहे वह (.com, .net, आदि) ही क्यों न हो। मैं .उस बिंदु से सब कुछ खोजने और निकालने की सलाह देता हूं ।

url = 'abcdc.com'
dot_index = url.rfind('.')
url = url[:dot_index]

यहाँ मैं rfindurls की समस्या को हल करने के लिए उपयोग कर रहा हूँ जैसे abcdc.com.netकि नाम को कम किया जाना चाहिए abcdc.com।

यदि आप भी www.एस के बारे में चिंतित हैं , तो आपको उनके लिए स्पष्ट रूप से जांच करनी चाहिए:

if url.startswith("www."):
   url = url.replace("www.","", 1)

1 में प्रतिस्थापित अजीब edgecases की तरह है www.net.www.com

अगर आपके url को रेगेक्स के जवाबों की तुलना में कोई भी जंगल मिलता है, तो लोगों ने इसका जवाब दिया है।

Answer 18

मैंने इसका उपयोग करने के लिए अंतर्निहित rstrip फ़ंक्शन का उपयोग किया:

string = "test.com"
suffix = ".com"
newstring = string.rstrip(suffix)
print(newstring)
test

Comments

बुरा विचार। कोशिश करो "test.ccom"।

— शीतल शाह

लेकिन यह सवाल का बिंदु नहीं है। यह सिर्फ एक ज्ञात विकल्प को दूसरे के अंत से हटाने के लिए कहा गया था। यह अपेक्षा के अनुरूप काम करता है।

— एलेक्स

Answer 19

आप विभाजन का उपयोग कर सकते हैं:

'abccomputer.com'.split('.com',1)[0]
# 'abccomputer'

Comments

जब a = 'www.computerbugs.com'साथ इस परिणाम 'www'

— yairchu

Answer 20

यह नियमित अभिव्यक्ति के लिए एक सही उपयोग है:

>>> import re
>>> re.match(r"(.*)\.com", "hello.com").group(1)
'hello'

Comments

आपको यह सुनिश्चित करने के लिए एक $ भी जोड़ना चाहिए कि आप ".com" में समाप्त होने वाले होस्टनाम से मेल खा रहे हैं ।

— क्रिस्टियन सियुपिटु

Answer 21

पायथन> = 3.9:

'abcdc.com'.removesuffix('.com')

अजगर <3.9:

def remove_suffix(text, suffix):
    if text.endswith(suffix):
        text = text[:-len(suffix)]
    return text

remove_suffix('abcdc.com', '.com')

Comments

Python 3.9 के लिए आपका उत्तर इस उत्तर का एक डुप्लिकेट है । पिछले संस्करणों के लिए आपके उत्तर को भी इस धागे में कई बार उत्तर दिया गया है और यदि स्ट्रिंग में प्रत्यय नहीं है तो कुछ भी नहीं लौटाएगा।

— ज़ेवियर गुहोट