python - tutorial - para que se usa elastic search

¿Cómo filtra una cadena de modo que solo se devuelvan los caracteres de su lista?

Question

Imagine una cadena, como ''Agh # $% #% 2341- -! Zdrkfd'' y solo deseo realizar alguna operación en ella de tal manera que solo se devuelvan las letras minúsculas (como ejemplo), que en este caso traería ''ghzdrkfd ''.

¿Cómo haces esto en Python? La forma obvia sería crear una lista de caracteres, ''a'' a través de ''z'', luego iterar sobre los caracteres en mi cadena y construir una nueva cadena, carácter por carácter, de aquellos en mi lista solamente. Esto parece primitivo.

Me preguntaba si las expresiones regulares son apropiadas. Reemplazar los caracteres no deseados parece problemático y tiendo a preferir las listas blancas en lugar de las negras. La función .match no parece apropiada. He revisado la página correspondiente en el sitio de Python, pero no he encontrado un método que parezca adecuado.

Si las expresiones regulares no son apropiadas y el enfoque correcto es hacer un bucle, ¿existe una función simple que "explota" una cadena en una lista? ¿O simplemente estoy golpeando a otro bucle allí?

Answer 1

Aquí hay una solución si está específicamente interesado en trabajar en cadenas:

 s = ''Agh#$%#%2341- -!zdrkfd''
lowercase_chars = [chr(i) for i in xrange(ord(''a''), ord(''z'') + 1)]
whitelist = set(lowercase_chars)
filtered_list = [c for c in s if c in whitelist]

La lista blanca es en realidad un conjunto (no una lista) para la eficiencia.

Si necesitas una cadena, usa join ():

filtered_str = ''''.join(filtered_list)

filter () es una solución más genérica. De la documentación ( http://docs.python.org/library/functions.html ):

filtro (función, iterable)

Construya una lista a partir de aquellos elementos de iterable para los cuales la función devuelve true. iterable puede ser una secuencia, un contenedor que admite iteración o un iterador. Si iterable es una cadena o una tupla, el resultado también tiene ese tipo; De lo contrario siempre es una lista. Si la función es Ninguna, se supone que la función de identidad, es decir, se eliminan todos los elementos de iterable que son falsos.

Esta sería una forma de usar filter ():

filtered_list = filter(lambda c: c.islower(), s)

Answer 2

Si buscas eficiencia. Usar la función de translate es lo más rápido que puede obtener.

Se puede utilizar para reemplazar rápidamente los caracteres y / o eliminarlos.

import string
delete_table = string.maketrans(
string.ascii_lowercase, '' '' * len(string.ascii_lowercase)
)
table = string.maketrans('''', '''')
"Agh#$%#%2341- -!zdrkfd".translate(table, delete_table)

En Python 2.6: ya no necesitas la segunda tabla

import string
delete_table = string.maketrans(
string.ascii_lowercase, '' '' * len(string.ascii_lowercase)
)
"Agh#$%#%2341- -!zdrkfd".translate(None, delete_table)

Este método es mucho más rápido que cualquier otro. Por supuesto, necesitas almacenar el delete_table en algún lugar y usarlo. Pero incluso si no lo almacena y lo construye cada vez, seguirá siendo más rápido que otros métodos sugeridos hasta ahora.

Para confirmar mis reclamos aquí están los resultados:

for i in xrange(10000):
''''.join(c for c in s if c.islower())
real 0m0.189s
user 0m0.176s
sys 0m0.012s

Mientras se ejecuta la solución de expresión regular:

for i in xrange(10000):
re.sub(r''[^a-z]'', '''', s)
real 0m0.172s
user 0m0.164s
sys 0m0.004s

[A solicitud] Si precompila la expresión regular:

r = re.compile(r''[^a-z]'')
for i in xrange(10000):
r.sub('''', s)
real 0m0.166s
user 0m0.144s
sys 0m0.008s

Ejecutando el método de traducción el mismo número de veces tomó:

real 0m0.075s
user 0m0.064s
sys 0m0.012s

Answer 3

Una solución más genérica y comprensible para tomar una inputstring y filtrarla contra una whitelist de caracteres:

inputstring = "Agh#$%#%2341- -!zdrkfd"
whitelist = "abcdefghijklmnopqrstuvwxyz"
remove = inputstring.translate(None, whitelist)
result = inputstring.translate(None, remove)
print result

Esto imprime

ghzdrkfd

El primer string.translate elimina todos los caracteres de la lista blanca de la cadena de entrada. Esto nos da los caracteres que queremos eliminar. La segunda llamada string.translate elimina de la cadena de entrada y produce el resultado deseado.

Answer 4

Usar una expresión regular es bastante fácil, especialmente para este escenario:

>>> import re
>>> s = ''ASDjifjASFJ7364''
>>> re.sub(r''[^a-z]+'', '''', s)
''jifj''

Si planeas hacer esto muchas veces, es mejor compilar la expresión regular de antemano:

>>> import re
>>> s = ''ASDjifjASFJ7364''
>>> r = re.compile(r''[^a-z]+'')
>>> r.sub('''', s)
''jifj''

Answer 5

Yo usaría un regex. Para coincidencias en minúscula [az].

Answer 6

import string
print filter(string.lowercase.__contains__, "lowerUPPER")
print filter("123".__contains__, "a1b2c3")

Answer 7

import string
print "".join([c for c in "Agh#$%#%2341- -!zdrkfd" if c in string.lowercase])

Answer 8

s = ''ASDjifjASFJ7364''
s_lowercase = ''''.join(filter(lambda c: c.islower(), s))
print s_lowercase #print ''jifj''

Answer 9

s = ''Agh#$%#%2341- -!zdrkfd''
print ''''.join(c for c in s if c.islower())

Los objetos de cadena son iterables; no hay necesidad de "explotar" la cadena en una lista. Puede poner cualquier condición que desee en la lista de comprensión, y filtrará los caracteres en consecuencia.

También puede implementar esto utilizando una expresión regular, pero esto solo ocultará el bucle. La biblioteca de expresiones regulares todavía tendrá que recorrer los caracteres de la cadena para filtrarlos.

Answer 10

>>> s = ''Agh#$%#%2341- -!zdrkfd''
>>> ''''.join(i for i in s if i in ''qwertyuiopasdfghjklzxcvbnm'')
''ghzdrkfd''