Comment supprimer une sous-chaîne à la fin d'une chaîne en Python?

J'ai le code suivant:

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

J'esperais: abcdc

J'ai eu: abcd

Maintenant oui

url.rsplit('.com', 1)

Y a-t-il une meilleure façon?

stripne signifie pas "supprimer cette sous-chaîne". x.strip(y)traite ycomme un ensemble de caractères et supprime tous les caractères de cet ensemble depuis la fin de x.

Au lieu de cela, vous pouvez utiliser endswithet découper:

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

Ou en utilisant des expressions régulières :

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

Si vous êtes sûr que la chaîne n'apparaît qu'à la fin, alors le moyen le plus simple serait d'utiliser '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)]

Puisqu'il semble que personne ne l'a encore souligné:

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

Cela devrait être plus efficace que les méthodes utilisant split()car aucun nouvel objet de liste n'est créé, et cette solution fonctionne pour les chaînes avec plusieurs points.

Cela dépend de ce que vous savez sur votre URL et de ce que vous essayez de faire. Si vous savez qu'il se terminera toujours par «.com» (ou «.net» ou «.org»), alors

 url=url[:-4]

est la solution la plus rapide. S'il s'agit d'URL plus générales, vous feriez probablement mieux de consulter la bibliothèque urlparse fournie avec python.

Si vous, par contre, vous voulez simplement tout supprimer après la finale "." dans une chaîne puis

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

marchera. Ou si vous voulez juste tout vouloir jusqu'au premier '.' Alors essaye

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

Si vous savez que c'est une extension, alors

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

Cela fonctionne aussi bien avec abcdc.comou www.abcdc.comou abcdc.[anything]et est plus extensible.

En une seule ligne:

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

Et alors url[:-4]?

Pour les URL (comme cela semble faire partie du sujet par l'exemple donné), on peut faire quelque chose comme ceci:

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)

Les deux produiront: ('http://www.stackoverflow', '.com')

Cela peut également être combiné avec str.endswith(suffix)si vous avez juste besoin de diviser ".com", ou quelque chose de spécifique.

url.rsplit ('. com', 1)

n'est pas tout à fait raison.

Ce que vous auriez réellement besoin d'écrire est

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

, et il semble IMHO assez succinct.

Cependant, ma préférence personnelle est cette option car elle n'utilise qu'un seul paramètre:

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

À partir de Python 3.9, vous pouvez utiliser à la removesuffixplace:

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

Si vous devez supprimer une fin de chaîne si elle existe, ne faites rien. Mes meilleures solutions. Vous voudrez probablement utiliser l'une des 2 premières implémentations, mais j'ai inclus la 3e pour être complet.

Pour un suffixe constant:

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'

Pour une expression régulière:

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"

Pour une collection de suffixes constants, le moyen asymptotiquement le plus rapide pour un grand nombre d'appels:

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

le dernier est probablement beaucoup plus rapide en pypy qu'en cpython. La variante regex est probablement plus rapide que cela pour pratiquement tous les cas qui n'impliquent pas d'énormes dictionnaires de suffixes potentiels qui ne peuvent pas être facilement représentés comme une expression régulière au moins dans cPython.

Dans PyPy, la variante d'expression régulière est presque certainement plus lente pour un grand nombre d'appels ou de longues chaînes même si le module re utilise un moteur d'expression régulière de compilation DFA car la grande majorité des frais généraux des lambda sera optimisée par le JIT.

En cPython cependant, le fait que votre code c en cours d'exécution pour l'expression régulière compare presque certainement les avantages algorithmiques de la version de la collection de suffixes dans presque tous les cas.

Vous pouvez utiliser split:

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

Si vous souhaitez supprimer uniquement l'extension:

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

Il fonctionne avec n'importe quelle extension, avec d'autres points potentiels existant également dans le nom de fichier. Il fractionne simplement la chaîne sous forme de liste sur des points et la joint sans le dernier élément.

import re

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

Je veux répéter cette réponse comme la manière la plus expressive de le faire. Bien sûr, ce qui suit prendrait moins de temps CPU:

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

Cependant, si le CPU est le goulot d'étranglement, pourquoi écrire en Python?

Quand est-ce que le CPU est un goulot d'étranglement? Dans les pilotes, peut-être.

Les avantages de l'utilisation d'une expression régulière sont la réutilisation du code. Que faire si vous souhaitez ensuite supprimer «.me», qui ne comporte que trois caractères?

Le même code ferait l'affaire:

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

Dans mon cas, je devais lever une exception, alors j'ai fait:

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

Ici, j'ai un code le plus simple.

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

En supposant que vous souhaitiez supprimer le domaine, quel qu'il soit (.com, .net, etc.). Je recommande de trouver .et de supprimer tout à partir de ce moment.

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

Ici, j'utilise rfindpour résoudre le problème des URL comme celles abcdc.com.netqui devraient être réduites au nom abcdc.com.

Si vous êtes également préoccupé par les www.s, vous devez les vérifier explicitement:

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

Le 1 en remplacement est pour les cas étranges comme www.net.www.com

Si votre URL devient plus sauvage que cela, regardez les réponses regex avec lesquelles les gens ont répondu.

J'ai utilisé la fonction rstrip intégrée pour le faire comme suit:

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

C'est une utilisation parfaite pour les expressions régulières:

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