Python'da bir dizenin sonundan bir alt dizeyi nasıl kaldırabilirim?

Takip koduna sahibim:

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

Tahmin etmiştim: abcdc

Bende var: abcd

Şimdi yapıyorum

url.rsplit('.com', 1)

Daha iyi bir yol var mı?

strip"bu alt dizeyi kaldır" anlamına gelmez. bir karakter kümesi gibi x.strip(y)davranır yve o kümedeki tüm karakterleri uçlarından ayırır x.

Bunun yerine şunları kullanabilir endswithve dilimleyebilirsiniz:

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

Veya düzenli ifadeler kullanarak :

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

Dizenin yalnızca sonunda göründüğünden eminseniz, en basit yol 'replace' kullanmaktır:

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

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

Henüz kimse bunu işaret etmediği için:

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

split()Yeni liste nesnesi oluşturulmadığından, bu yöntemlerden daha verimli olmalıdır ve bu çözüm birkaç noktalı dizelerde çalışır.

URL'niz hakkında bildiklerinize ve tam olarak ne yapmaya çalıştığınıza bağlıdır. Her zaman '.com' (veya '.net' veya '.org') ile biteceğini biliyorsanız, o zaman

 url=url[:-4]

en hızlı çözümdür. Daha genel bir URL ise, muhtemelen python ile gelen urlparse kütüphanesine bakmanız daha iyidir.

Öte yandan, finalden sonra her şeyi kaldırmak istersiniz. o zaman bir dizede

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

çalışacak. Ya da sadece her şeyi ilk '' e kadar istiyorsanız. o zaman dene

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

Bunun bir uzantı olduğunu biliyorsanız,

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

Bu ile eşit derecede iyi çalışır abcdc.comya www.abcdc.comya abcdc.[anything]ve daha genişletilebilir.

Bir satırda:

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

Nasıl url[:-4]?

Url'ler için (verilen örnekte konunun bir parçası gibi göründüğü gibi), böyle bir şey yapılabilir:

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)

Her ikisi de çıktı verecektir: ('http://www.stackoverflow', '.com')

Bu, str.endswith(suffix)yalnızca ".com" u veya belirli bir şeyi bölmeniz gerektiğinde de birleştirilebilir .

url.rsplit ('. com', 1)

tam olarak doğru değil.

Aslında yazmanız gereken şey

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

ve oldukça özlü görünüyor IMHO.

Ancak, kişisel tercihim yalnızca bir parametre kullandığı için bu seçenektir:

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

Başlamak yerine Python 3.9şunları kullanabilirsiniz removesuffix:

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

Eğer varsa bir dizenin bir ucunu soymanız gerekiyorsa, aksi takdirde hiçbir şey yapmayın. En iyi çözümlerim. Muhtemelen ilk 2 uygulamadan birini kullanmak isteyeceksiniz, ancak tamlık için 3.'ü ekledim.

Sabit bir sonek için:

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'

Normal ifade için:

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"

Sürekli soneklerin toplanması için, çok sayıda çağrı için asimptotik olarak en hızlı yol:

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

sonuncusu muhtemelen pypy'den sonra cpython'dan önemli ölçüde daha hızlıdır. Normal ifade değişkeni, en azından cPython'da kolayca normal ifade olarak gösterilemeyen potansiyel soneklerin büyük sözlüklerini içermeyen neredeyse tüm durumlarda bundan daha hızlıdır.

PyPy'de regex varyantı, çok sayıda çağrı veya uzun teller için neredeyse kesinlikle daha yavaştır, çünkü re modülü, lambda yükünün büyük çoğunluğu JIT tarafından optimize edileceği için bir DFA derleme regex motoru kullanıyor olsa bile.

Bununla birlikte, cPython'da regex için çalışan c kodunuzun neredeyse tüm durumlarda sonek toplama sürümünün algoritmik avantajlarını neredeyse kesinlikle karşılaştırması gerçeği.

Yalnızca uzantıyı kaldırmak istiyorsanız:

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

Herhangi bir uzantı ile çalışır, dosya adında da potansiyel diğer noktalar vardır. Dizeyi noktalar üzerinde bir liste olarak böler ve son öğe olmadan birleştirir.

import re

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

Bu cevabı yapmanın en etkileyici yolu olarak tekrarlamak istiyorum. Tabii ki, aşağıdakiler daha az CPU zamanı alacaktır:

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

Ancak, CPU şişe boynu ise neden Python yazmalısınız?

CPU ne zaman bir şişe boynu? Sürücülerde, belki.

Düzenli ifade kullanmanın avantajları kodun yeniden kullanılabilirliği. Daha sonra yalnızca üç karakteri olan '.me' öğesini kaldırmak isterseniz ne olur?

Aynı kod hile yapar:

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

Benim durumumda bir istisna oluşturmam gerekiyordu, bu yüzden yaptım:

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

Burada, en basit bir kod var.

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

Etki alanı ne olursa olsun (.com, .net vb.) Kaldırmak istediğinizi varsayarsak. .Bu noktadan itibaren her şeyi bulmanızı ve kaldırmanızı öneririm .

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

Burada , adının azaltılması rfindgibi URL'lerin sorununu çözmek için kullanıyorum .abcdc.com.netabcdc.com

Ayrıca www.s konusunda endişeleriniz varsa , bunları açıkça kontrol etmelisiniz:

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

Yerine gelen 1 gibi garip edgecases içindir www.net.www.com

URL'niz bundan daha vahşi olursa, insanların yanıtladığı normal yanıtlara bakın.

Takip etmek için dahili rstrip işlevini kullandım:

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

Split kullanabilirsiniz:

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

Bu düzenli ifadeler için mükemmel bir kullanımdır:

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

Python> = 3.9:

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

Python <3.9:

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

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