Tengo el siguiente código:
url = 'abcdc.com'
print(url.strip('.com'))
Esperaba: abcdc
Tengo: abcd
Ahora lo hago
url.rsplit('.com', 1)
¿Hay una mejor manera?
Tengo el siguiente código:
url = 'abcdc.com'
print(url.strip('.com'))
Esperaba: abcdc
Tengo: abcd
Ahora lo hago
url.rsplit('.com', 1)
¿Hay una mejor manera?
Respuestas:
strip
no significa "eliminar esta subcadena". x.strip(y)
trata y
como un conjunto de caracteres y elimina todos los caracteres de ese conjunto desde los extremos de x
.
En su lugar, podría usar endswith
y cortar:
url = 'abcdc.com'
if url.endswith('.com'):
url = url[:-4]
O usando expresiones regulares :
import re
url = 'abcdc.com'
url = re.sub('\.com$', '', url)
url = url[:-4] if any(url.endswith(x) for x in ('.com','.net')) else url
EXAMLPLE.COM
nombres de dominio que no distinguen entre mayúsculas y minúsculas? (Este es un voto para la solución regex)
rsplit()
solución no tiene el mismo comportamiento que endswith()
cuando la cadena original no tiene la subcadena al final, sino en algún lugar en el medio. Por ejemplo: "www.comeandsee.com".rsplit(".com",1)[0] == "www.comeandsee"
pero"www.comeandsee.net".rsplit(".com",1)[0] == "www"
s[:-n]
tiene una advertencia: porque n = 0
no devuelve la cadena con los últimos cero caracteres cortados, sino la cadena vacía.
Si está seguro de que la cadena solo aparece al final, entonces la forma más simple sería usar 'reemplazar':
url = 'abcdc.com'
print(url.replace('.com',''))
www.computerhope.com
. hacer un chequeo con endswith()
y debería estar bien.
def strip_end(text, suffix):
if not text.endswith(suffix):
return text
return text[:len(text)-len(suffix)]
return text[:-len(suffix)]
Como parece que nadie ha señalado esto todavía:
url = "www.example.com"
new_url = url[:url.rfind(".")]
Esto debería ser más eficiente que los métodos que se utilizan, split()
ya que no se crea un nuevo objeto de lista, y esta solución funciona para cadenas con varios puntos.
Depende de lo que sepa sobre su URL y de lo que está tratando de hacer exactamente. Si sabe que siempre terminará en '.com' (o '.net' o '.org'), entonces
url=url[:-4]
Es la solución más rápida. Si se trata de una URL más general, entonces probablemente sea mejor que busques en la biblioteca urlparse que viene con python.
Si, por otro lado, simplemente desea eliminar todo después del '' final. en una cuerda entonces
url.rsplit('.',1)[0]
trabajará. O si quieres solo quieres todo hasta el primer '.' entonces intenta
url.split('.',1)[0]
En una linea:
text if not text.endswith(suffix) or len(suffix) == 0 else text[:-len(suffix)]
¿Qué tal url[:-4]
?
.ca
o .co.uk
url.
Para las URL (como parece ser parte del tema en el ejemplo dado), se puede hacer algo como esto:
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)
Ambos generarán:
('http://www.stackoverflow', '.com')
Esto también se puede combinar str.endswith(suffix)
si solo necesita dividir ".com", o algo específico.
url.rsplit ('. com', 1)
No está del todo bien.
Lo que realmente necesitarías escribir es
url.rsplit('.com', 1)[0]
, y se ve bastante sucinto en mi humilde opinión.
Sin embargo, mi preferencia personal es esta opción porque usa solo un parámetro:
url.rpartition('.com')[0]
Comenzando Python 3.9
, puede usar removesuffix
en su lugar:
'abcdc.com'.removesuffix('.com')
# 'abcdc'
Si necesita quitar algún extremo de una cadena si existe, de lo contrario no haga nada. Mis mejores soluciones Probablemente querrá usar una de las primeras 2 implementaciones, sin embargo, he incluido la tercera para completar.
Para un sufijo constante:
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'
Para una expresión regular:
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"
Para una colección de sufijos constantes, la forma asintóticamente más rápida para una gran cantidad de llamadas:
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')
el último es probablemente significativamente más rápido en pypy que en cpython. Es probable que la variante de expresiones regulares sea más rápida que esta para prácticamente todos los casos que no impliquen grandes diccionarios de posibles sufijos que no pueden representarse fácilmente como expresiones regulares, al menos en cPython.
En PyPy, la variante regex es casi con certeza más lenta para un gran número de llamadas o cadenas largas, incluso si el módulo re utiliza un motor regex de compilación DFA ya que la gran mayoría de los gastos generales de los lambda serán optimizados por el JIT.
En cPython, sin embargo, el hecho de que su código c en ejecución para la expresión regular compare casi seguramente las ventajas algorítmicas de la versión de colección de sufijos en casi todos los casos.
import re
def rm_suffix(url = 'abcdc.com', suffix='\.com'):
return(re.sub(suffix+'$', '', url))
Quiero repetir esta respuesta como la forma más expresiva de hacerlo. Por supuesto, lo siguiente tomaría menos tiempo de CPU:
def rm_dotcom(url = 'abcdc.com'):
return(url[:-4] if url.endswith('.com') else url)
Sin embargo, si la CPU es el cuello de botella, ¿por qué escribir en Python?
¿Cuándo es la CPU un cuello de botella de todos modos? En los conductores, tal vez.
Las ventajas de usar la expresión regular es la reutilización del código. ¿Qué pasa si luego quieres eliminar '.me', que solo tiene tres caracteres?
El mismo código haría el truco:
>>> rm_sub('abcdc.me','.me')
'abcdc'
En mi caso, necesitaba plantear una excepción, así que hice:
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)]
Aquí, tengo un código más simple.
url=url.split(".")[0]
Suponiendo que desea eliminar el dominio, sin importar cuál sea (.com, .net, etc.). Recomiendo encontrar .
y eliminar todo a partir de ese momento.
url = 'abcdc.com'
dot_index = url.rfind('.')
url = url[:dot_index]
Aquí estoy usando rfind
para resolver el problema de las URL como las abcdc.com.net
que deberían reducirse al nombre abcdc.com
.
Si también le preocupan los www.
s, debe verificarlos explícitamente:
if url.startswith("www."):
url = url.replace("www.","", 1)
El 1 en reemplazo es para bordes extraños como www.net.www.com
Si su URL se vuelve más salvaje que eso, mire las respuestas de expresiones regulares con las que la gente ha respondido.
Utilicé la función rstrip incorporada para hacerlo como sigue:
string = "test.com"
suffix = ".com"
newstring = string.rstrip(suffix)
print(newstring)
test
"test.ccom"
.
Este es un uso perfecto para expresiones regulares:
>>> 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')