Wie entferne ich einen Teilstring vom Ende eines Strings in Python?

Ich habe folgenden Code:

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

Ich erwartete: abcdc

Ich habe: abcd

Jetzt mache ich

url.rsplit('.com', 1)

Gibt es einen besseren Weg?

strip bedeutet nicht "diesen Teilstring entfernen". x.strip(y)behandelt yals Zeichensatz und entfernt alle Zeichen in diesem Satz von den Enden von x.

Stattdessen könnten Sie verwenden endswith und schneiden:

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

Oder mit regulären Ausdrücken :

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

Wenn Sie sicher sind, dass die Zeichenfolge nur am Ende angezeigt wird, ist es am einfachsten, 'replace' zu verwenden:

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

Da es so aussieht, als hätte noch niemand darauf hingewiesen:

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

Dies sollte effizienter sein als die verwendeten Methoden, split()da kein neues Listenobjekt erstellt wird. Diese Lösung funktioniert für Zeichenfolgen mit mehreren Punkten.

Hängt davon ab, was Sie über Ihre URL wissen und was Sie genau versuchen. Wenn Sie wissen, dass es immer mit '.com' (oder '.net' oder '.org') endet, dann

 url=url[:-4]

ist die schnellste Lösung. Wenn es sich um allgemeinere URLs handelt, ist es wahrscheinlich besser, in die mit Python gelieferte URL-Bibliothek zu schauen.

Wenn Sie andererseits einfach alles nach dem letzten '.' Entfernen möchten. in einer Zeichenfolge dann

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

wird funktionieren. Oder wenn Sie wollen, wollen Sie einfach alles bis zum ersten '.' dann versuche es

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

Wenn Sie wissen, dass es sich um eine Erweiterung handelt, dann

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

Dies funktioniert genauso gut mit abcdc.comoder www.abcdc.comoder abcdc.[anything]und ist erweiterbarer.

In einer Zeile:

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

Wie wäre es mit url[:-4]?

Für URLs (da es im angegebenen Beispiel ein Teil des Themas zu sein scheint) kann man Folgendes tun:

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)

Beide geben Folgendes aus: ('http://www.stackoverflow', '.com')

Dies kann auch kombiniert werden, str.endswith(suffix)wenn Sie nur ".com" oder etwas Bestimmtes teilen müssen.

url.rsplit ('. com', 1)

ist nicht ganz richtig.

Was Sie tatsächlich schreiben müssten, ist

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

und es sieht meiner Meinung nach ziemlich prägnant aus.

Meine persönliche Präferenz ist jedoch diese Option, da nur ein Parameter verwendet wird:

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

Ab Python 3.9können Sie removesuffixstattdessen Folgendes verwenden:

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

Wenn Sie ein Ende eines Strings entfernen müssen, falls vorhanden, tun Sie nichts. Meine besten Lösungen. Sie werden wahrscheinlich eine der ersten beiden Implementierungen verwenden wollen, der Vollständigkeit halber habe ich jedoch die dritte aufgenommen.

Für ein konstantes Suffix:

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'

Für eine Regex:

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"

Für eine Sammlung konstanter Suffixe der asymptotisch schnellste Weg für eine große Anzahl von Anrufen:

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

Der letzte ist bei Pypy wahrscheinlich deutlich schneller als bei Cpython. Die Regex-Variante ist wahrscheinlich in praktisch allen Fällen schneller, in denen keine großen Wörterbücher mit potenziellen Suffixen enthalten sind, die zumindest in cPython nicht einfach als Regex dargestellt werden können.

In PyPy ist die Regex-Variante für eine große Anzahl von Aufrufen oder langen Zeichenfolgen mit ziemlicher Sicherheit langsamer, selbst wenn das Re-Modul eine DFA-kompilierende Regex-Engine verwendet, da der überwiegende Teil des Overheads der Lambdas von der JIT optimiert wird.

In cPython jedoch vergleicht die Tatsache, dass Ihr laufender c-Code für den regulären Ausdruck mit ziemlicher Sicherheit die algorithmischen Vorteile der Suffix-Auflistungsversion in fast allen Fällen.

Wenn Sie nur die Erweiterung entfernen möchten:

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

Es funktioniert mit jeder Erweiterung, wobei potenzielle andere Punkte auch im Dateinamen vorhanden sind. Es teilt die Zeichenfolge einfach als Liste auf Punkte und verbindet sie ohne das letzte Element.

import re

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

Ich möchte diese Antwort als den ausdrucksstärksten Weg wiederholen. Folgendes würde natürlich weniger CPU-Zeit in Anspruch nehmen:

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

Wenn jedoch die CPU der Flaschenhals ist, warum in Python schreiben?

Wann ist CPU überhaupt ein Flaschenhals? Vielleicht bei Fahrern.

Die Vorteile der Verwendung von regulären Ausdrücken liegen in der Wiederverwendbarkeit von Code. Was ist, wenn Sie als nächstes '.me' entfernen möchten, das nur drei Zeichen enthält?

Der gleiche Code würde den Trick machen:

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

In meinem Fall musste ich eine Ausnahme auslösen, also tat ich Folgendes:

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

Hier habe ich einen einfachsten Code.

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

Angenommen, Sie möchten die Domain entfernen, unabhängig davon, um was es sich handelt (.com, .net usw.). Ich empfehle, das zu finden .und alles von diesem Punkt an zu entfernen.

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

Hier verwende ich rfind, um das Problem von URLs zu lösen, die abcdc.com.netauf den Namen reduziert werden sollten abcdc.com.

Wenn Sie auch über www.s besorgt sind , sollten Sie explizit nach ihnen suchen:

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

Die 1 in Ersetzen ist für seltsame Randfälle wie www.net.www.com

Wenn Ihre URL wilder wird, sehen Sie sich die Regex-Antworten an, mit denen die Leute geantwortet haben.

Ich habe die eingebaute rstrip- Funktion verwendet, um Folgendes zu tun:

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

Sie können split verwenden:

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

Dies ist eine perfekte Verwendung für reguläre Ausdrücke:

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