Jak usunąć podciąg z końca łańcucha w Pythonie?

Mam następujący kod:

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

Oczekiwałem: abcdc

Mam: abcd

Teraz ja robię

url.rsplit('.com', 1)

Czy jest lepszy sposób?

stripnie znaczy „usuń ten podciąg”. x.strip(y)traktuje yjako zestaw znaków i usuwa wszystkie znaki w tym zestawie z końcówek x.

Zamiast tego możesz użyć endswithi kroić:

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

Lub używając wyrażeń regularnych :

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

Jeśli masz pewność, że ciąg pojawi się tylko na końcu, najprostszym sposobem byłoby użycie polecenia „replace”:

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

Ponieważ wydaje się, że nikt jeszcze tego nie zauważył:

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

Powinno to być bardziej wydajne niż metody wykorzystujące, split()ponieważ nie jest tworzony nowy obiekt listy, a to rozwiązanie działa dla ciągów z kilkoma kropkami.

Zależy od tego, co wiesz o swoim adresie URL i dokładnie, co próbujesz zrobić. Jeśli wiesz, że zawsze kończy się na „.com” (lub „.net” lub „.org”), to

 url=url[:-4]

jest najszybszym rozwiązaniem. Jeśli są to bardziej ogólne adresy URL, prawdopodobnie lepiej jest zajrzeć do biblioteki urlparse dostarczanej z pythonem.

Jeśli natomiast chcesz po prostu usunąć wszystko po finałowym „.” w ciągu

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

będzie działać. Lub jeśli chcesz po prostu wszystko do pierwszego ”. więc spróbuj

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

Jeśli wiesz, że to rozszerzenie

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

Działa to równie dobrze z abcdc.comlub www.abcdc.comi abcdc.[anything]i jest bardziej rozszerzalne.

W jednej linii:

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

Jak o url[:-4]?

W przypadku adresów URL (ponieważ w podanym przykładzie wydaje się to być częścią tematu) można zrobić coś takiego:

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)

Oba będą generować: ('http://www.stackoverflow', '.com')

Można to również połączyć z, str.endswith(suffix)jeśli chcesz po prostu podzielić „.com” lub cokolwiek innego.

url.rsplit ('. com', 1)

nie jest całkiem właściwe.

To, co naprawdę musisz napisać, to

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

i wygląda całkiem zwięźle IMHO.

Jednak moją osobistą preferencją jest ta opcja, ponieważ używa tylko jednego parametru:

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

Począwszy od Python 3.9, możesz removesuffixzamiast tego użyć :

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

Jeśli chcesz usunąć jakiś koniec łańcucha, jeśli istnieje, w przeciwnym razie nic nie rób. Moje najlepsze rozwiązania. Prawdopodobnie będziesz chciał skorzystać z jednej z dwóch pierwszych implementacji, jednak dla kompletności podałem trzecią.

Dla stałego przyrostka:

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'

Dla wyrażenia regularnego:

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"

W przypadku zbioru stałych sufiksów asymptotycznie najszybszy sposób dla dużej liczby połączeń:

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

ostatni jest prawdopodobnie znacznie szybszy w pypy niż cpython. Wariant wyrażenia regularnego jest prawdopodobnie szybszy od tego praktycznie we wszystkich przypadkach, w których nie występują duże słowniki potencjalnych przyrostków, których nie można łatwo przedstawić jako wyrażenia regularnego przynajmniej w cPython.

W PyPy wariant wyrażenia regularnego jest prawie na pewno wolniejszy dla dużej liczby wywołań lub długich ciągów, nawet jeśli moduł re używa silnika wyrażeń regularnych kompilujących DFA, ponieważ ogromna większość kosztów lambda zostanie zoptymalizowana przez JIT.

Jednak w cPython fakt, że działający kod c dla wyrażenia regularnego porównuje prawie na pewno możliwości algorytmiczne wersji kolekcji sufiksów w prawie wszystkich przypadkach.

Jeśli chcesz tylko usunąć rozszerzenie:

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

Działa z dowolnym rozszerzeniem, z potencjalnymi innymi kropkami również w nazwie pliku. Po prostu dzieli ciąg jako listę na kropki i łączy go bez ostatniego elementu.

import re

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

Chcę powtórzyć tę odpowiedź jako najbardziej ekspresyjny sposób na zrobienie tego. Oczywiście, następujące czynności zajmowałyby mniej czasu procesora:

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

Jeśli jednak procesor jest szyjką butelki, po co pisać w języku Python?

Kiedy w ogóle procesor jest szyjką butelki? Może w sterownikach.

Zaletą używania wyrażeń regularnych jest możliwość ponownego użycia kodu. Co jeśli chcesz następnie usunąć „.me”, który ma tylko trzy znaki?

Ten sam kod zrobiłby lewę:

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

W moim przypadku musiałem zgłosić wyjątek, więc:

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

Tutaj mam najprostszy kod.

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

Zakładając, że chcesz usunąć domenę, bez względu na to, co to jest (.com, .net itp.). Zalecam znalezienie .i usunięcie wszystkiego od tego momentu.

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

Tutaj używam rfinddo rozwiązania problemu adresów URL, abcdc.com.netktóre należy sprowadzić do nazwy abcdc.com.

Jeśli martwisz się również o www.s, powinieneś wyraźnie je sprawdzić:

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

1 w zamianie jest dla dziwnych przypadków edgecases www.net.www.com

Jeśli Twój adres URL stanie się bardziej szalony niż to, spójrz na odpowiedzi wyrażenia regularnego, na które ludzie odpowiedzieli.

Użyłem wbudowanej funkcji rstrip, aby wykonać następujące czynności:

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

Możesz użyć podziału:

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

Jest to idealne zastosowanie do wyrażeń regularnych:

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