Para búsquedas fuera de línea, ¿es más rápido simplemente usar str.find/rfind que usar re.match/search?¿Qué es una operación más rápida, re.match/search o str.find?
Es decir, para una cadena dada, s, debería usar:
if s.find('lookforme') > -1:
do something
o
if re.match('lookforme',s):
do something else
?
La pregunta: cuál es más rápido se responde mejor usando timeit.
from timeit import timeit
import re
def find(string, text):
if string.find(text) > -1:
pass
def re_find(string, text):
if re.match(text, string):
pass
def best_find(string, text):
if text in string:
pass
print timeit("find(string, text)", "from __main__ import find; string='lookforme'; text='look'")
print timeit("re_find(string, text)", "from __main__ import re_find; string='lookforme'; text='look'")
print timeit("best_find(string, text)", "from __main__ import best_find; string='lookforme'; text='look'")
La salida es:
0.441393852234
2.12302494049
0.251421928406
Así que no sólo debe usted utilizar el operador in porque es más fácil de leer, pero debido a que es más rápido también.
Micro optimizaciones, en el mejor de los casos, para elegir en función del tiempo. Sin embargo, +1 desde que especificó el caso más legible ... – ircmaxell
Ciertamente respondió la pregunta correctamente, sukhbir. De acuerdo, aunque +1 para la legibilidad y que demostraste que la respuesta es la "pitonica". –
Claramente usted lideró el jurado automático al llamar a uno de los "mejores consejos" ;-) –
Utilice esta:
if 'lookforme' in s:
do something
Regex necesita ser compilado en primer lugar, que añade algo de sobrecarga. La búsqueda de cadenas normal de Python es muy eficiente de todos modos.
Si busca el mismo término mucho o cuando hace algo más complejo, entonces regex se vuelve más útil.
+1 Primero se pythonic: luego, si el rendimiento se convierte en un problema, explora diferentes implementaciones para ver si mejoran el rendimiento. –
re.compile acelera mucho las expresiones regulares si está buscando lo mismo una y otra vez. Pero acabo de obtener una gran aceleración mediante el uso de "en" para descartar casos malos antes de que coincida. Anecdótico, lo sé. ~ Ben
He tenido el mismo problema. Solía% timeit de Jupyter para comprobar:
import re
sent = "a sentence for measuring a find function"
sent_list = sent.split()
print("x in sentence")
%timeit "function" in sent
print("x in token list")
%timeit "function" in sent_list
print("regex search")
%timeit bool(re.match(".*function.*", sent))
print("compiled regex search")
regex = re.compile(".*function.*")
%timeit bool(regex.match(sent))
x en la frase 61,3 ns ± 3 ns por bucle (.. Media ± std dev de 7 carreras, 10000000 bucles cada uno)
x en la lista de contadores 93,3 ns ± 1,26 ns por lazo (media ± std. prog. de 7 carreras, 10000000 bucles cada uno)
de búsqueda de expresiones regulares 772 ns ± 8,42 ns por bucle (media ± std. prog. de 7 carreras, 1000000 bucles cada uno)
búsqueda de expresiones regulares compiladas 420 ns ± 7.68 ns por ciclo (media ± estándar de 7 ejecuciones, 1000000 bucles cada uno)
La compilación es rápida pero lo simple es mejor.
Por un momento, estoy bastante seguro de que la expresión regular sería más lenta, debido a la sobrecarga adicional. –
Debe tener cuidado al comparar los dos, ya que tienen una funcionalidad diferente. Buscar busca la cadena completa, mientras que la coincidencia solo coincide con el comienzo (es decir, puede salir temprano, según los datos). Entonces estás comparando manzanas y naranjas allí. –