¿Hay alguna forma más agradable de escribir sucesivas declaraciones "o" en Python?

Question

cuestión muy sencilla que no puedo encontrar ninguna "buena" respuesta por mí mismo:

Digamos que tengo la siguiente condición:

if 'foo' in mystring or 'bar' in mystring or 'hello' in mystring: 
    # Do something 
    pass 

Cuando el número de or declaración puede ser bastante más tiempo dependiendo de la situación.

¿Existe alguna manera "más agradable" (más Pythonic) de escribir esto, sin sacrificar el rendimiento?

Si se piensa en usar any() pero lleva una lista de elementos booleanos, entonces tendría que crear esa lista primero (dejando de lado la evaluación de cortocircuitos en el proceso), así que supongo que es menos eficiente.

Muchas gracias.

Answer 1

Una forma podría ser

if any(s in mystring for s in ('foo', 'bar', 'hello')): 
    pass 

Lo que es iterar sobre una tupla, que se basa en la compilación de la función, por lo que no debe ser inferior a su versión original.

Si tiene miedo de que la tupla llegará a ser demasiado larga, se puede hacer

def mystringlist(): 
    yield 'foo' 
    yield 'bar' 
    yield 'hello' 
if any(s in mystring for s in mystringlist()): 
    pass 

Answer 2

Esto suena como un trabajo para una expresión regular.

import re 

if re.search("(foo|bar|hello)", mystring): 
    # Do something 
    pass 

Debe ser más rápido, también. Especialmente si compila la expresión regular antes de tiempo.

Si está generando la expresión regular automáticamente, puede usar re.escape() para asegurarse de que ningún carácter especial rompa su expresión regular. Por ejemplo, si words es una lista de cadenas que desea buscar, puede generar su patrón de esta manera:

pattern = "(%s)" % ("|".join(re.escape(word) for word in words),) 

También debe tener en cuenta que si usted tiene m palabras y la cadena tiene n caracteres, el original el código tiene O(n*m) complejidad, mientras que la expresión regular tiene O(n) complejidad. Aunque las expresiones regulares de Python no son realmente expresiones teóricas comp-sci regulares, y no son siempreO(n) complejidad, en este caso simple sí lo son.

Answer 3

Dado que procesa palabra por palabra contra mystring, seguramente se puede usar mystring como un conjunto. Luego tomar la intersección entre el conjunto que contiene las palabras mystring y los grupos destinatarios de las palabras:

In [370]: mystring=set(['foobar','barfoo','foo']) 

In [371]: mystring.intersection(set(['foo', 'bar', 'hello'])) 
Out[371]: set(['foo']) 

Su lógica 'o' son los miembros de la intersección de los dos conjuntos.

El uso de un conjunto también es más rápido. Éstos son sincronización relativa frente a un generador y expresión regular:

f1: generator to test against large string 
f2: re to test against large string 
f3: set intersection of two sets of words 

    rate/sec  f2  f1  f3 
f2 101,333  -- -95.0% -95.5% 
f1 2,026,329 1899.7%  -- -10.1% 
f3 2,253,539 2123.9% 11.2%  -- 

lo tanto, un generador y la operación in es 19x más rápido que una expresión regular y una intersección de conjuntos es 21x más rápido que una expresión regular y un 11% más rápido que un generador.

Aquí está el código que genera el tiempo:

import re 

with open('/usr/share/dict/words','r') as fin: 
    set_words={word.strip() for word in fin} 

s_words=' '.join(set_words) 
target=set(['bar','foo','hello']) 
target_re = re.compile("(%s)" % ("|".join(re.escape(word) for word in target),)) 

gen_target=(word for word in ('bar','foo','hello')) 

def f1(): 
    """ generator to test against large string """   
    if any(s in s_words for s in gen_target): 
     return True 

def f2(): 
    """ re to test against large string """ 
    if re.search(target_re, s_words): 
     return True 

def f3(): 
    """ set intersection of two sets of words """ 
    if target.intersection(set_words): 
     return True 

funcs=[f1,f2,f3] 
legend(funcs) 
cmpthese(funcs)   

Answer 4

Si usted tiene una lista conocida de artículos para comprobar en contra, también se puede escribir como

if mystring in ['foo', 'bar', 'hello']: 

El usuario no puede obtener la beneficios de garantizar el orden de comparación (no creo que Python deba verificar los elementos de la lista de izquierda a derecha), pero eso es solo un problema si sabes que 'foo' es mucho más probable que 'bar'.