Filter

FILTER
La función filter(), devuelve un valor que esta siendo iterado de la cual su resultado será el valor que se esta buscando en el filter

SINTAXIS

_filter (function, iterable_

Valores.

filter: Una función que se ejecutara para cada elemento iterable
iterable: Lo que se va a filtrar.

Ejercicio:

Tenemos una lista de estudiantes de la cual debemos saber quienes son de Colombia y quienes son considerados mayores de edad al tener igual o mas de 18 años y cuantos son.

people = [
  {
    'name' : 'Pedro',
    'country': 'Colombia',
    'age' : 18,
    'course' : 'developer'
  },
  {
    'name' : 'Juan',
    'country': 'Perú',
    'age' : 17,
    'course' : 'UX'
  },
  {
    'name' : 'Carlos',
    'country': 'Chile',
    'age' : 31,
    'course' : 'Diseño'
  },
  {
    'name' : 'Ana Maria',
    'country': 'Colombia',
    'age' : 25,
    'course' : 'Tester'
  }
]

• Ahora planteamos el primer problema a resolver, cuales son los estudiantes de Colombia y cuantos son:

countrie = list(filter(lambda country: country['country'] == 'Colombia', people))
print(countrie)
print(len(countrie))

_Produccion:_
[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'name': 'Ana Maria', 'country': 'Colombia', 'age': 25, 'course': 'Tester'}]
2

Ya sabemos que hay 2 personas en nuestros cursos que son de Colombia quienes son: Pedro y Ana Maria.

• Ahora necesitamos saber quienes son considerados mayores de edad al tener 18 años o más.

adult = list(filter(lambda age: age['age'] >= 18, people))
print(adult)
print(len(adult))

_Producción:_
[{'name': 'Pedro', 'country': 'Colombia', 'age': 18, 'course': 'developer'}, {'name': 'Carlos', 'country': 'Chile', 'age': 31, 'course': 'Diseño'}, {'name': 'Ana Maria', 'country': 'Colombia', 'age': 25, 'course': 'Tester'}]
3

Con esto podemos saber que hay 3 estudiantes que son considerados mayores de edad al tener 18 años o más quienes serían: Pedro con 18 años, carlos, con 31 años y Ana Maria con 25 años.

Dejo el código aquí para un mejor acceso:

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print(len(matches))

new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

me parecio curioso como se veria la misma formulacion pero con la funcion map, me retorna la lista con valores boolean

numbers = [1, 2, 3, 4, 5]
new_numbers = list(map(lambda x: x %2==0, numbers))

[False, True, False, True, False]

Soy de Venezuela y me resulta insultante que Ecuador nos haya ganado 5 a 0. 😤🤣

Hay que tomar en cuenta que filter, map y reduce retornan generadores, no listas.
Por lo que a la hora de trabajar con ellas a veces conviene convertirlas, ya sea con:
list(filter(…))
o con [*filter(…)]

Algo a tener en cuenta, es que al usar usar filter, nos devolverá los mismos objetos que teniamos en nuestro iterable original, por lo tanto si se modifica un objeto filtrado afectará a ambos iterables (el filtrado y el original)

Con dos condiciones:

saber si es de Perú y si es mayor de edad.

new_people = list(filter(lambda condic1 : condic1['country'] == 'Perú' and condic1['age'] > 18, people))
print(new_people)
print(len(new_people))

Production:
[]
0

No existe persona que cumpla esos requisitos 😢.
Gracias Camilo Enrique Mejia me ayudó tu aporte.

La función filter() es una función integrada que se utiliza para filtrar una secuencia (como una lista o un diccionario) y retornar los elementos que cumplen con cierta condición. La función filter() toma dos argumentos: una función que se utilizará para evaluar cada elemento de la secuencia, y la secuencia que se va a filtrar.

• La función que se utiliza con filter() debe tomar un elemento como entrada y retornar True o False según si el elemento debe ser incluido en el resultado filtrado. Los elementos que retornan True se incluyen en el resultado, mientras que los elementos que retornan False se excluyen.

Dejo algunos programas sencillos usando lambdas y filter.

"""
1. Filtrar números pares de una lista de enteros.
"""

lista = [1,2,3,4,5,6,7,8,9,10]
resultado = list(filter(lambda pares:pares%2==0,lista))
print(resultado)

"""
2. Filtrar números primos de una lista de enteros.
"""

def es_primo(numero):
    if numero <= 1:
        return False
    for i in range(2, int(numero ** 0.5) + 1):
        if numero % i == 0:
            return False
    return True

lista = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultado = list(filter(es_primo, lista))
print(resultado)

"""
3. Filtrar palabras que comienzan con una letra específica de una lista de palabras.
"""

lista = ["Mercurio", "Venus", "Tierra", "Marte", "Jupiter"]
resultado = list(filter(lambda palabra:(palabra.lower().startswith("m")),lista))
print(resultado)

"""
4. Filtrar nombres de una lista de nombres que tengan más de cierta cantidad de letras.
"""

lista = ["Ana","Juan","Laura","Ramiro","Mario"]
resultado = list(filter(lambda palabra:len(palabra)>5,lista))
print(resultado)

"""
5. Filtrar elementos de una lista de strings que tienen una longitud impar.
"""

lista = ["Ana","Juan","Laura","Ramiro","Mario"]
resultado = list(filter(lambda palabra:len(palabra)%2!=0,lista))
print(resultado)

"""
6. Filtrar los elementos de una lista de diccionarios para obtener aquellos cuyo valor de la clave "edad" sea mayor que 30.
"""

lista = [ {
            'nombre' : 'Patricia',
            'edad': 28 
          },
          { 
            'nombre' : 'Marco',
            'edad': 32
          },
         { 
            'nombre' : 'Laura',
            'edad': 25
          },
         { 
            'nombre' : 'Ramiro',
            'edad': 46
          }
        ]


resultado = list(filter(lambda palabra:palabra['edad']>30,lista))
print(resultado)

"""
7. Filtrar los elementos de una lista de diccionarios para obtener aquellos que contienen una clave "categoria" con un valor específico.
"""

lista = [ {
            'pelicula' : 'saw',
            'genero': 'terror'
          },
          { 
            'pelicula' : 'one day',
            'genero': 'romance'
          },
         { 
            'pelicula' : 'hangover',
            'genero': 'comedia'
          },
         { 
            'pelicula' : 'mi vecino totoro',
            'genero': 'animada'
          }
        ]


resultado = list(filter(lambda pelicula:pelicula['genero']=="terror",lista))
print(resultado)

Mi aporte sin ver la lección…

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print("-"*10)

no_draw_results_list = list(filter(lambda item: item['home_team_result'] != "Draw" , matches))
print(no_draw_results_list)

home_team_winner_list = list(filter(lambda item: item["home_team_result"] == "Win" , no_draw_results_list))
print(home_team_winner_list)

away_team_winner_list = list(filter(lambda item: item["home_team_result"] == "Lose" , no_draw_results_list))
print(away_team_winner_list)

home_team_winner = list(map(lambda item: item["home_team"], home_team_winner_list))
print(home_team_winner)

away_team_winner = list(map(lambda item: item["away_team"], away_team_winner_list))
print(away_team_winner)

La función filter devuelve un iterador donde los elementos se filtran a través de una función para probar si el elemento se acepta o no.

numbers = [1,2,3,4,5]
new_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(new_numbers)
print(numbers)

• Python’s filter()es una función incorporada que le permite procesar un iterable y extraer aquellos elementos que satisfacen una condición dada. Este proceso se conoce comúnmente como una operación de filtrado .
• Con filter(), puede aplicar una función de filtrado a un iterable y producir un iterable nuevo con los elementos que satisfacen la condición en cuestión. En Python, filter()es una de las herramientas que puedes usar para la programación funcional .

Aca les dejo una idea muy grafica de filter

El filter() es una función incorporada en Python que permite filtrar los elementos de un objeto iterable (como una lista, tupla o diccionario) basándose en una función que devuelve True o False.

La función filter() recibe dos argumentos:

La función: Esta es la función que testeamos en cada elemento del objeto iterable. Debe devolver True si el elemento se debe mantener, False si se debe descartar.
El iterable: El objeto iterable que queremos filtrar.
Por ejemplo:

python

Copy code

numeros = [1, 2, 3, 4, 5, 6]

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

pares = filter(es_par, numeros)

print(list(pares))
Esto filtraría la lista de números para quedarse solo con los números pares, imprimiendo [2, 4, 6].

La función filter() devuelve un objeto filter, que es un iterable. Por eso debemos pasarlo a una lista para ver el resultado.

En resumen, filter() es una función de Python muy útil para filtrar elementos de una secuencia, dejando solo los que cumplen cierta condición definida en una función

Excelente clase, todo bastante bien explicado y entendible.

numbers = [1,2,3,4,5,6,7,8,9,10]
pares = list(filter(lambda x: x % 2 ==0,numbers))
impares = list(filter(lambda x:x%2 != 0,numbers))
print(pares) 
print(impares)

Tambien podemos utilizar los marcadores y no depender del campo de result:

new_list_2 = list(filter(lambda item: item['home_team_score'] > item['away_team_score'], matches))

Algo muy interesante que se puede hacer con la función filter, es crear un algoritmo para crear una lista de números perfectos. Los números perfectos son aquellos cuyo valor es igual a la suma de sus divisores (p.e. Los divisores de 6 son 1, 2 y 3, y al sumarlos 1+2+3 = 6). Los 5 primeros números perfectos son [6, 28, 496, 8128, 550336]. Para este caso decidí configurar el algoritmo para mostrar los primeros 4 números perfectos, ya que al intentar hacer mas 550 mil iteraciones casi quemo mi CPU xD. Aqui les dejo mi aporte:

def is_perfect(n):
    divisors = list(filter(lambda i: n%i == 0, list(range(1,n))))
    sum = 0
    for i in divisors:
        sum += i
    if sum == n:
        return True
    else:
        return False

perfects = list(filter(is_perfect,list(range(1,8130))))
print(perfects)

output:
[6, 28, 496, 8128]

Filter es similar a utlizar un for para recorrer el array y un condicional para decidir cuales elementos cumplen la condicion y almacenarlos en un nuevo array. Bastante util para simplificar el codigo!

TIP: cómo saber dónde está nuestro error:
El Shell de replit indica la línea y pone una flechita en donde encontró el error, en este caso observa que la flechita apunta antes de la función list:

También te dice en qué número de línea está el error, line.
Y si vas al Editor, te subraya errores. Observa que también empieza a subrayar en rojo al inicio de la función list:

En general, para depurar errores de Python, debemos comenzar de abajo hacia arriba. Lo digo porque a veces se apilan varios errores, pero el error más cercano o directo será el de hasta abajo del Shell. En este ejemplo solo hubo un error.
Con esta info ya vamos más encaminados a encontrarlo.
Faltó el = de asignación antes del list.
Espero sea útil, saludos. 😄

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]
print(matches)
print(len(matches))

new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

# FILTER
# filter(function, iterable)
win_list = list(filter(lambda i: i['home_team_result'] == 'Win', matches))
print(win_list)
print(len(win_list)) # 2

# LIST COMPREHENSION
# [expression for item in iterable if condition]
win_list_2 = [i for i in matches if i['home_team_result'] == 'Win']
print(win_list_2)
print(len(win_list_2)) # 2

people = [
    {'name': 'Pedro'     , 'country': 'Colombia' , 'age': 18 , 'course': 'developer'},
    {'name': 'Juan'      , 'country': 'Perú'     , 'age': 17 , 'course': 'UX'},
    {'name': 'Carlos'    , 'country': 'Chile'    , 'age': 31 , 'course': 'Diseño'},
    {'name': 'Ana Maria' , 'country': 'Colombia' , 'age': 25 , 'course': 'Tester'}
]

# Utilizando comprensión de lista para filtrar estudiantes de Colombia
colombian_students = [person for person in people if person['country'] == 'Colombia']
adult_students     = [person for person in people if person['age']     >= 18]

# Imprime el resultado
print(colombian_students)
print(adult_students)

Es interesante la forma de usar nuestro codigo de python con el reduce para simplificar nuestros ejercicios. Eso nos ayuda a mejorar nuestra capacidad. Espero seguir mejorando con la parte de mas adelante.

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

winners = list(map(lambda x : x ["home_team_result"] == "Win", matches))
print(winners)

# Filter

# https://www.w3schools.com/python/ref_func_filter.asp


numbers = [1,2,3,4,5]
new_numbers = list(filter(lambda x: x % 2 == 0, numbers)) # Se escribe la condición del filter (x % 2 == 0)
print(new_numbers) # Se imprimen solo los que cumplen con la condición
print(numbers)

# Filter en un diccionario

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print(len(matches))

new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches)) # Se hace el filtro de los elementos

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

Les comparto la forma que utilicé para poder resolver el ejericio, usando dictionary comprehensions, una función normal y la función filter con condicionales!

# 1. Dict comprenhensions:
def filtro(matches):
  return [match['home_team'] for match in matches if match['home_team_result'] == 'Win']

# 2. Función de toda la vida
def filtro2(matches):
  result = []
  for x in matches:
    if x['home_team_result'] == 'Win':
      result.append(x['home_team'])
  return list(result)


# 3. Filtrando con filter y trayendo todos los datos del dict
result = list(filter(lambda x: x['home_team'] if x['home_team_result'] == 'Win' else None , matches ))

print(filtro(matches))
print(filtro2(matches))
print(result)
print(matches)

numeros = [1,2,3,4,5]
nuevos_numeros = list(filter( lambda x: x % 2 == 0 , numeros))
print (numeros)
print (nuevos_numeros)

matches = [
{
‘home_team’: ‘Bolivia’,
‘away_team’: ‘Uruguay’,
‘home_team_score’: 3,
‘away_team_score’: 1,
‘home_team_result’: ‘Win’
},
{
‘home_team’: ‘Brazil’,
‘away_team’: ‘Mexico’,
‘home_team_score’: 1,
‘away_team_score’: 1,
‘home_team_result’: ‘Draw’
},
{
‘home_team’: ‘Ecuador’,
‘away_team’: ‘Venezuela’,
‘home_team_score’: 5,
‘away_team_score’: 0,
‘home_team_result’: ‘Win’
},
]

print(matches)

cantidad de elementos

print(len(matches))

new_list = list(filter(lambda item: item[‘home_team_result’] == ‘Win’, matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

Por si preguntaban cual sería el código para calcular una lista de solo el nombre de los ganadores

print('---winners---')
winners=[]
for i in range(0,int(len(new_list))):
  winners.append(new_list[i]['home_team'])
print(winners)

Les comparto una funcion que hice para facilitar la parte visual de los resultados en la consola

def printDic(data):
    for dic in data:
        print('{')
        for key, value in dic.items():
            print(' ', key, ":", value)
        print("}")

#print(matches)
printDic(matches)

Antes de iniciar la clase hice un código con lambda para entender fácilmente la función filter():

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numero = list(filter(lambda numero: numero % 2 == 0, numeros))
print(numero)

Dejo aqui un ejemplo con un def normal 🏃‍♀️

# Definimos una función para verificar si un número es par
def es_par(numero):
    return numero % 2 == 0

# Creamos una lista de números
numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Filtramos los números pares utilizando filter() y la función es_par
numeros_pares = list(filter(es_par, numeros))

# Imprimimos los números pares
print(numeros_pares)

Super empezamos primeros pasos de bases de datos 🐧

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print('partidos =>', len(matches))
print('''
''')
#Filtramos solo los partidos locales ganadores (FILTER)
win_matches = list(filter(lambda item: item['home_team_result'] == 'Win', matches))
#transformamos los datos de esos partidos para mostrar los paises (MAP)
win_countries = list(map(lambda item: item['home_team'], win_matches))

print('win local countries =>', win_countries)
print(win_matches) #no se modificó win_countries porque no fue una inserción, solo retorna valores y los devuelve en una nueva lista de items.

Para esta clase escribí una lista de números del -20 al 20 generados aleatoriamente y apliqué un filtro para obtener los números que fueran menores que -10 o mayores que 10.

import random

elementos = 10
nunbers = [random.randint(-20,20) for i in range(0,elementos)]
print(nunbers)
filter_numbers = list(filter(lambda i: - 10 > i or i > 10, nunbers))
print(filter_numbers)

Genial el uso del filter. Lo apliqué en los dataframe y la sintaxis del código queda mucho mejor que usar Python base para el filtrado.

Aporte de mis apuntes por si gustan:

matches = [
  {
    'home_team': 'Argentina', #equipo local
    'away_team': 'Uruguay',   #equipo visitante
    'home_team_score': 3,     #goles
    'away_team_score': 1,     #goles
    'home_team_result': 'win' #marcador 
  },
  {
    'home_team': 'Brazil',     #equipo local
    'away_team': 'Mexico',     #equipo visitante
    'home_team_score': 1,      #goles
    'away_team_score': 1,      #goles
    'home_team_result': 'Draw' #marcador 
  },
  {
    'home_team': 'Chile',     #equipo local
    'away_team': 'Colombia',  #equipo visitante
    'home_team_score': 2,     #goles
    'away_team_score': 3,     #goles
    'home_team_result': 'win' #marcador 
  },
]

print(matches) # imprimimos nuestro diccionario
print(len(matches)) # imprimimos la cantidad

# creamos una nueva lista
# preguntamos por un elemento del diccionario
# le enviamos un mensaje al diccionario lo que queremos
new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(new_list) # imprimimos la nueva lista
print(len(new_list)) # imprimimos la cantidad

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print(len(matches))

new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

Quise mirar cómo obtener una lista con los nombres de los equipos que ganaron partidos como local y se me ocurrió esto:

1. Crear un filtro que elija los partidos ganados por el equipo local.

filtro = filter(lambda item : item['home_team_result'] == 'Win', matches)

1. Usar ese filtro como iterable en un map que retorne el nombre del equipo local ganador

print(list(map(lambda team : team['home_team'], filtro)))

Este es el resultado:

['Bolivia', 'Ecuador']

De igual manera, todo se puede expresar en una sola línea así:

print(list(map(lambda team : team['home_team'], filter(lambda item : item['home_team_result'] == 'Win', matches))))

Apliqué un poco más de lo que ya hemos visto en el curso:

# Librerias
import os
import random

#Funcion para limpiar pantalla
def clean_screen():
    os.system("cls")

clean_screen()

matches = [
  {
    'home_team': 'bolivia',
    'away_team': 'uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'win'
  },
  {
    'home_team': 'brazil',
    'away_team': 'mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'draw'
  },
  {
    'home_team': 'ecuador',
    'away_team': 'venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'win'
  },
]

#print(matches)
#print(len(matches))


# Opciones de inicio
print("Opciones: \n" "\nhome_team: Bolivia, Brazil, Ecuador \n" "\naway_team: Uruguay, Mexico, Venezuela \n" "\nhome_team_result: Win, Draw \n") 

# ingresa la clave del diccionario a filtrar

while True:
    key = input("Ingrese la clave del diccionario a filtrar: ").lower()
    if any(key in item for item in matches):
        break
    else:
        print(f"Por favor ingresa una clave válida para {key}")

# ingresa el valor del diccionario a filtrar
while True:
    value = input("Ingrese el valor del diccionario a filtrar: ").lower()
    if any(value in item[key] for item in matches):
        break
    else:
        print(f"Por favor ingresa un valor válido para {key}")

new_list = list(filter(lambda item: item[key] == value, matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

Filter

# Filter
# https://www.w3schools.com/python/ref_func_filter.asp

numbers = [1, 2, 3, 4, 5]

# Solo los elementos que cumplen con la condicion del filter, van a ser parte de la nueva lista
new_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(new_numbers)

# Filter no modifica la lista original, simplemente crea una nueva lista.
print(numbers)

Filter con Diccionarios

# Filter con Diccionarios
# https://www.w3schools.com/python/ref_func_filter.asp

# Lista con diccionarios dentro
matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

print(matches)
print(len(matches))

# Genera una nueva lista de los partidos ganados
new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(new_list)
print(len(new_list))

print(matches)
print(len(matches))

for e in matches:
    if e["home_team_result"] == "Win":
        print(list(e))
    else:
        pass

En este ejemplo, ponemos una lista de productos que se compraron y vamos a saber cuales productos tienen un precio menor a 3000. El código es el siguiente:

products = [{
  "cantidad": 2,
  "precio": 1043,
  "producto": "Bolsa Blanca 55 X 55"
}, {
  "cantidad": 1,
  "precio": 2535,
  "producto": "Jabon en polvo"
}, {
  "cantidad": 2,
  "precio": 6608,
  "producto": "Papel Higiénico "
}, {
  "cantidad": 2,
  "precio": 7901,
  "producto": "Toallas de manos"
}]

economicos = list(filter(lambda x: x["precio"] <= 3000, products))
print(economicos)

se siente un poco rarito ejecutar primero el metodo y dentro de ello, la lista a recorrer, deferente a javascript por ejemplo, donde se aplica de una forma “mas directa” por decirlo sobre la lista a iterar.

Algo que me gusta mucho de las lambda, es la capacidad de guardar su lógica en una variable, y llamarla dentro del map/filter… que estemos usando

from typing import Callable

filter_even: Callable[[int], bool] = lambda x: x % 2 == 0
numbers = [1, 2, 3, 4, 5]
new_numbers = list(filter(filter_even, numbers))

Creo que mejora la legibilidad y nos da la posibilidad de reutilizar el código

conseguí el mismo resultado usando list comprehensions

lista = list(filter(lambda x: x % 2 == 0, numbers))

lista1 = [i for i in numbers if i % 2 == 0]

print(lista)
print(lista1)

lista = list(filter(lambda x: x['home_team_result'] == 'Draw', matches))

lista1 = [i for i in matches if i['home_team_result'] == 'Draw']

print(lista)
print(lista1)

Filter

Util para filtrar elementos de una lista. Filter no modifica el estado original del diccionario

Filter sobre listas

#-----------Filter--------------

# nueva lista con numeros pares
numbers = [1,2,3,4,5]
new_numbers = list(filter(lambda x: x % 2 == 0, numbers))
print(new_numbers)
--> [2, 4]

Filter sobre diccionarios

#------- Filter con diccionarios ----------

matches = [
  {
    'home_team': 'Bolivia',
    'away_team': 'Uruguay',
    'home_team_score': 3,
    'away_team_score': 1,
    'home_team_result': 'Win'
  },
  {
    'home_team': 'Brazil',
    'away_team': 'Mexico',
    'home_team_score': 1,
    'away_team_score': 1,
    'home_team_result': 'Draw'
  },
  {
    'home_team': 'Ecuador',
    'away_team': 'Venezuela',
    'home_team_score': 5,
    'away_team_score': 0,
    'home_team_result': 'Win'
  },
]

# obtener una lista con los diccionarios de los equipo locales que hayan ganado
print(matches)
print(len(matches))
--> 3
		[{'home_team': 'Bolivia', 'away_team': 'Uruguay', 'home_team_score': 3, 'away_team_score': 1, 'home_team_result': 'Win'}, 
		 {'home_team': 'Brazil', 'away_team': 'Mexico', 'home_team_score': 1, 'away_team_score': 1, 'home_team_result': 'Draw'}, 
		 {'home_team': 'Ecuador', 'away_team': 'Venezuela', 'home_team_score': 5, 'away_team_score': 0, 'home_team_result': 'Win'}]

new_list = list(filter(lambda item: item['home_team_result'] == 'Win', matches))

print(len(new_list))
print(new_list)
--> 2
		[{'home_team': 'Bolivia', 'away_team': 'Uruguay', 'home_team_score': 3, 'away_team_score': 1, 'home_team_result': 'Win'}, 
		 {'home_team': 'Ecuador', 'away_team': 'Venezuela', 'home_team_score': 5, 'away_team_score': 0, 'home_team_result': 'Win'}]

Genial forma de utilizar filter!