Cómo utilizar la función de filtro de Python

Introducción

La función incorporada de Python filter()se puede utilizar para crear un nuevo iterador a partir de un iterable existente (como una lista o un diccionario) que filtrará de manera eficiente los elementos mediante una función que proporcionamos. Un iterable es un objeto de Python que se puede “iterar”, es decir, que devolverá elementos en una secuencia de modo que podamos usarlo en un forbucle.

La sintaxis básica de la filter()función es:

filter(function, iterable)

Esto devolverá un objeto de filtro, que es iterable. Podemos usar una función como list()para crear una lista de todos los elementos devueltos en un objeto de filtro.

La filter()función proporciona una forma de filtrar valores que a menudo puede ser más eficiente que una comprensión de lista, especialmente cuando comenzamos a trabajar con conjuntos de datos más grandes. Por ejemplo, una comprensión de lista creará una nueva lista, lo que aumentará el tiempo de ejecución para ese procesamiento. Esto significa que después de que nuestra comprensión de lista haya completado su expresión, tendremos dos listas en la memoria. Sin embargo, filter()creará un objeto simple que contiene una referencia a la lista original, la función proporcionada y un índice de dónde ir en la lista original, lo que ocupará menos memoria.

En este tutorial, revisaremos cuatro formas diferentes de usar filter(): con dos estructuras iterables diferentes, con una lambdafunción y sin ninguna función definida.

Uso filter()con una función

El primer argumento de filter()es una función, que utilizamos para decidir si incluir o filtrar cada elemento. La función se llama una vez por cada elemento del iterable que se pasa como segundo argumento y cada vez que retorna False, se descarta el valor. Como este argumento es una función, podemos pasar una función normal o podemos hacer uso de lambdafunciones, en particular cuando la expresión es menos compleja.

A continuación se muestra la sintaxis de a lambdawith filter():

filter(lambda item: item[] expression, iterable)

Con una lista como la siguiente, podemos incorporar una lambdafunción con una expresión contra la cual queremos evaluar cada elemento de la lista:

creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']

Para filtrar esta lista y encontrar los nombres de las criaturas de nuestro acuario que empiecen con vocal, podemos ejecutar la siguiente lambdafunción:

print(list(filter(lambda x: x[0].lower() in 'aeiou', creature_names)))

Aquí declaramos un elemento de nuestra lista como x. Luego, configuramos nuestra expresión para acceder al primer carácter de cada cadena (o carácter "cero"), por lo que x[0]. Al reducir el uso de mayúsculas y minúsculas en cada uno de los nombres, nos aseguramos de que las letras coincidan con la cadena en nuestra expresión, 'aeiou'.

Finalmente pasamos el iterable creature_names. Al igual que en la sección anterior, aplicamos list()al resultado para crear una lista a partir de los filter()retornos del iterador.

El resultado será el siguiente:

Output['Ashley', 'Olly']

Este mismo resultado se puede lograr utilizando una función que definimos:

creature_names = ['Sammy', 'Ashley', 'Jo', 'Olly', 'Jackie', 'Charlie']def names_vowels(x):  return x[0].lower() in 'aeiou'filtered_names = filter(names_vowels, creature_names)print(list(filtered_names))

Nuestra función names_vowelsdefine la expresión que implementaremos para filtrar creature_names.

Nuevamente el resultado sería el siguiente:

Output['Ashley', 'Olly']

En general, lambdalas funciones logran el mismo resultado que filter()cuando usamos una función regular. La necesidad de definir una función regular aumenta a medida que aumenta la complejidad de las expresiones para filtrar nuestros datos, lo que probablemente promueva una mejor legibilidad en nuestro código.

Usando Noneconfilter()

Podemos pasar Nonecomo primer argumento a filter()para que el iterador devuelto filtre cualquier valor que Python considere “falso”. Generalmente, Python considera cualquier cosa con una longitud de 0(como una lista vacía o una cadena vacía) o numéricamente equivalente a 0como falsa, de ahí el uso del término “falso”.

En el siguiente caso queremos filtrar nuestra lista para mostrar solo los números de tanque en nuestro acuario:

aquarium_tanks = [11, False, 18, 21, "", 12, 34, 0, [], {}]

En este código tenemos una lista que contiene números enteros, secuencias vacías y un valor booleano.

filtered_tanks = filter(None, aquarium_tanks)

Usamos la filter()función with Noney pasamos la aquarium_tankslista como nuestro iterable. Como la pasamos Nonecomo primer argumento, comprobaremos si los elementos de nuestra lista se consideran falsos.

print(list(filtered_tanks))

Luego lo envolvemos filtered_tanksen una list()función para que devuelva una lista para filtered_tankscuando imprimamos.

Aquí, la salida muestra solo los números enteros. Todos los elementos que se evaluaron como False, que son equivalentes a 0en longitud, fueron eliminados por filter():

Output[11, 25, 18, 21, 12, 34]

Nota : Si no usamos list()e imprimimos, filtered_tanksrecibiríamos un objeto de filtro similar a esto: filter object at 0x7fafd5903240. El objeto de filtro es un iterable, por lo que podríamos recorrerlo con foro podemos usar list()para convertirlo en una lista, lo cual estamos haciendo aquí porque es una buena forma de revisar los resultados.

Con Nonenosotros hemos podido filter()eliminar rápidamente elementos de nuestra lista que se consideraban falsos.

Uso filter()con una lista de diccionarios

Cuando tenemos una estructura de datos más compleja, aún podemos utilizar filter()para evaluar cada uno de los elementos. Por ejemplo, si tenemos una lista de diccionarios, no solo queremos iterar sobre cada elemento de la lista (uno de los diccionarios), sino que también podemos querer iterar sobre cada par clave:valor en un diccionario para evaluar todos los datos.

A modo de ejemplo, digamos que tenemos una lista de cada criatura de nuestro acuario junto con diferentes detalles sobre cada una de ellas:

aquarium_creatures = [  {"name": "sammy", "species": "shark", "tank number": "11", "type": "fish"},  {"name": "ashley", "species": "crab", "tank number": "25", "type": "shellfish"},  {"name": "jo", "species": "guppy", "tank number": "18", "type": "fish"},  {"name": "jackie", "species": "lobster", "tank number": "21", "type": "shellfish"},  {"name": "charlie", "species": "clownfish", "tank number": "12", "type": "fish"},  {"name": "olly", "species": "green turtle", "tank number": "34", "type": "turtle"}]

Queremos filtrar estos datos mediante una cadena de búsqueda que le damos a la función. Para tener filter()acceso a cada diccionario y a cada elemento de los diccionarios, construimos una función anidada, como la siguiente:

def filter_set(aquarium_creatures, search_string):def iterator_func(x):for v in x.values():if search_string in v:return Truereturn Falsereturn filter(iterator_func, aquarium_creatures)

Definimos una filter_set()función que toma aquarium_creaturesy search_stringcomo parámetros. En filter_set()pasamos our iterator_func()como función a filter(). La filter_set()función devolverá el iterador resultante de filter().

Toma como argumento, que representa un elemento de nuestra lista (es decir, un único diccionario) iterator_func().x

A continuación, el forbucle accede a los valores de cada par clave:valor en nuestros diccionarios y luego utiliza una declaración condicional para verificar si search_stringestá en v, lo que representa un valor.

Al igual que en nuestros ejemplos anteriores, si la expresión se evalúa como Truela función, se agrega el elemento al objeto de filtro. Esto regresará una vez que la filter_set()función se haya completado. Nos posicionamos return Falsefuera de nuestro bucle para que verifique cada elemento en cada diccionario, en lugar de regresar después de verificar solo el primer diccionario.

Llamamos filter_set()con nuestra lista de diccionarios y la cadena de búsqueda para la que queremos encontrar coincidencias:

filtered_records = filter_set(aquarium_creatures, "2")    

Una vez completada la función tenemos nuestro objeto de filtro almacenado en la filtered_recordsvariable, la cual convertimos en una lista e imprimimos:

print(list(filtered_records))      

Recibiremos el siguiente resultado de este programa:

Output[{'name': 'ashley', 'species': 'crab', 'tank number': '25', 'type': 'shellfish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': '21', 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': '12', 'type': 'fish'}]

Hemos filtrado la lista de diccionarios con la cadena de búsqueda 2. Podemos ver que 2se han obtenido los tres diccionarios que incluían un número de tanque con . El uso de nuestra propia función anidada nos permitió acceder a cada elemento y comparar cada uno de ellos de manera eficiente con la cadena de búsqueda.

Conclusión

En este tutorial, aprendimos las diferentes formas de usar la filter()función en Python. Ahora puedes usar filter()with con tu propia función, una lambdafunción o with Nonepara filtrar elementos en estructuras de datos de distinta complejidad.

Aunque en este tutorial imprimimos los resultados filter()inmediatamente en formato de lista, es probable que en nuestros programas usemos el filter()objeto devuelto y manipulemos aún más los datos.

Si desea aprender más sobre Python, consulte nuestra serie Cómo codificar en Python 3 y nuestra página de temas de Python.