10 mejores métodos para utilizar la lista de filtros de Python

Python, un lenguaje de programación versátil, ofrece muchas herramientas para manipular estructuras de datos de manera eficiente. Una de esas herramientas poderosas es la función filter(), que le permite filtrar elementos de un iterable en función de una condición específica. Esta función es invaluable para tareas de limpieza, transformación y análisis de datos.

Aquí presentamos diez métodos para usar la lista de filtros de Python y el código Python de muestra para filtrar números pares de una lista.

• Usando filtrar() con función Lambda:

La función filter() toma una función lambda como primer argumento, que define la condición de filtrado. Itera sobre lo iterable, aplica la función lambda a cada elemento y produce solo aquellos elementos que satisfacen la condición. Este método es conciso y eficaz, lo que lo convierte en una opción popular para operaciones de filtrado sencillas.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

numbers = (1, 2, 3, 4, 5, 6)
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(even_numbers)  # Output: (2, 4, 6)

• Usando filtrar() con una función definida por el usuario:

Puede definir una función personalizada para implementar la lógica de filtrado. Este enfoque es útil cuando la condición de filtrado compleja requiere varios pasos. Luego, la función filter() aplica esta función personalizada a cada elemento del iterable, generando solo aquellos que cumplen con los criterios.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

def is_even(x):
    return x % 2 == 0


numbers = (1, 2, 3, 4, 5, 6)
even_numbers = list(filter(is_even, numbers))
print(even_numbers)  # Output: (2, 4, 6)

• Usando la comprensión de listas con un condicional:

Las listas por comprensión proporcionan una forma concisa y elegante de crear nuevas listas basadas en iterables existentes. Al incorporar una expresión condicional dentro de la comprensión, puede filtrar elementos y construir una nueva lista que contenga solo aquellos que cumplan la condición especificada.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

numbers = (1, 2, 3, 4, 5, 6)
even_numbers = (x for x in numbers if x % 2 == 0)
print(even_numbers)  # Output: (2, 4, 6)

• Usando expresiones generadoras:

Las expresiones generadoras son similares a las listas por comprensión, pero generan elementos sobre la marcha, lo que ahorra memoria. Esto es particularmente útil cuando se trata de grandes conjuntos de datos o cuando necesita procesar elementos uno a la vez. Al incluir una expresión condicional dentro de la expresión generadora, puede filtrar elementos y generar solo aquellos que cumplan con los criterios.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

numbers = (1, 2, 3, 4, 5, 6)
even_numbers = (x for x in numbers if x % 2 == 0)
print(list(even_numbers))  # Output: (2, 4, 6)

• Usando NumPy dónde() Función:

La función where() de NumPy está diseñada específicamente para filtrar e indexar matrices. Toma una condición como entrada y devuelve una matriz booleana que indica qué elementos satisfacen la condición. Al utilizar esta matriz booleana como índice, puede extraer los elementos filtrados de la matriz original.

Complejidad temporal y espacial: O (n), donde n es la longitud de la matriz.

Código Python:

import numpy as np

numbers = np.array((1, 2, 3, 4, 5, 6))
even_numbers = numbers(np.where(numbers % 2 == 0))
print(even_numbers)  # Output: (2 4 6)

• Usando pandas consulta() Método:

Pandas, una potente biblioteca de análisis de datos, proporciona el método query() para filtrar DataFrames en función de expresiones condicionales. Puede especificar la condición de filtrado como una cadena y el método query() selecciona de manera eficiente las filas que cumplen con los criterios. Este método es particularmente útil para operaciones de filtrado complejas en grandes conjuntos de datos.

Complejidad temporal y espacial: depende del tamaño del DataFrame y de la complejidad de la consulta.

Código Python:

import pandas as pd

df = pd.DataFrame({'numbers': (1, 2, 3, 4, 5, 6)})
even_numbers_df = df.query('numbers % 2 == 0')
print(even_numbers_df)

• Usando itertools.filterfalse():

La función filterfalse() del módulo itertools es lo opuesto a filter(). Filtra elementos que no satisfacer la condición dada. Esto puede resultar útil en determinados escenarios en los que desea conservar elementos que no cumplen con criterios específicos.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

from itertools import filterfalse

numbers = (1, 2, 3, 4, 5, 6)
odd_numbers = list(filterfalse(lambda x: x % 2 == 0, numbers))
print(odd_numbers)  # Output: (1, 3, 5)

• Usando functools.partial():

La función functools.partial() le permite crear funciones parcialmente aplicadas, que pueden ser útiles para filtrar. Al corregir ciertos argumentos de una función, puede crear una nueva función que requiera menos argumentos, lo que facilita su uso con filter().

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

from functools import partial

def is_divisible_by(x, divisor):
    return x % divisor == 0

is_even = partial(is_divisible_by, divisor=2)
numbers = (1, 2, 3, 4, 5, 6)
even_numbers = list(filter(is_even, numbers))
print(even_numbers)  # Output: (2, 4, 6)

• Usando un bucle y condicional:

Un enfoque sencillo para el filtrado implica iterar sobre lo iterable y comparar cada elemento con la condición. Si un elemento cumple la condición, se agrega a una nueva lista. Si bien este método es fácil de entender, puede resultar menos eficiente que otros métodos, especialmente para conjuntos de datos grandes.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

numbers = (1, 2, 3, 4, 5, 6)
even_numbers = ()
for number in numbers:
    if number % 2 == 0:
        even_numbers.append(number)
print(even_numbers)  # Output: (2, 4, 6)

• Usando una función recursiva:

Una función recursiva puede filtrar elementos aplicando repetidamente la condición de filtrado a subconjuntos cada vez más pequeños del iterable. Si bien este enfoque puede ser elegante y conciso, es importante considerar la posible sobrecarga de las llamadas a funciones, especialmente para conjuntos de datos grandes.

Complejidad temporal y espacial: O (n), donde n es la longitud del iterable.

Código Python:

def filter_recursive(iterable, condition):
    if not iterable:
        return ()
    head, *tail = iterable
    return (head) + filter_recursive(tail, condition) if condition(head) else filter_recursive(tail, condition)


numbers = (1, 2, 3, 4, 5, 6)
even_numbers = filter_recursive(numbers, lambda x: x % 2 == 0)
print(list(even_numbers))  # Output: (2, 4, 6)

ConclusiónLa función filter() de Python, combinada con varias técnicas como funciones lambda, funciones definidas por el usuario, listas por comprensión, expresiones generadoras y más, proporciona formas potentes y flexibles de filtrar datos. Además de los 10 métodos discutidos, puede usar functools.reduce, more_itertools e isin() de Pandas para filtrar listas en Python. La elección del método a menudo depende de factores como el formato de los datos, la legibilidad, el rendimiento y los requisitos específicos de su aplicación. Al comprender estos métodos, podrá manipular y analizar datos de manera efectiva en Python.