High order functions: filter, map y reduce

Facundo: Estoy seguro de que no caen 2 veces
yo: caigo
Facundo:

La diferencia entre filter y map:

• filter devuelve True or False según el valor esté dentro de los criterios buscados o no. En caso de que no cumpla con la condición, no será devuelto y la lista se verá reducida por este filtro.
• Map funciona muy parecido, pero su diferencia radica en que no puede eliminar valores de la lista del array entregado. Es decir, el output tiene la misma cantidad de valores que el input.

Cómo funciona reduce:

• Reduce toma 2 valores entregados como parámetros y el iterador como otro parámetro. Realiza la función con estos 2 valores, y luego con el resultado de esto y el valor que le sigue en el array. Y así hasta pasar por todos los valores de la lista.

High order funcions
O funciones de orden superior, son funciones que reciben como parámetro a otra función.
Funciones de orden superior de importancia:

• filter → recibe una función filtro (anónima) y un iterable (lista, tupla, etc) devolviendonos un iterador: objeto optimizado recorrer elemento a elemento (iterar) por lo que no lo podemos inprimir de manera directa (para ello lo convertimos a una lista), su sintaxis es: filter(<funcion filtro>, <iterable>)
• map → al igual que filter recibe una función anónima y un iterable como parámetros pero en este caso map ejecuta la función sobre cada uno de los elementos del iterable, sintaxis: map(<funcion>, <iterable>)
• reduce → tenemos que importar esta función desde functools para poder usarla, tiene los mismos argumentos que las anteriores funciones, reduce el iterable por medio de la función anonima, su sintaxis es: reduce(<funcion reduccion>, <iterable>), la función de reducción necesita de dos parámetros, uno que almacena el resultado (o el primer valor del iterable) y otro que opera con el siguiente valor del iterable: lambda a,b: <expresión>

Cuando te dicen que no caes 2 veces

Facundo: eso es todo por esta clase
Yo sin entender nada:

Acá le dejo el código de la clase para poder practicar y entender:

from functools import reduce
def main():

    #Filter
    myList = [1,4,5,7,9,13,19,21]

    odd = list(filter(lambda x: x % 2 != 0, myList))
    print(odd)

    #Map
    myList2 = [1, 2, 3, 4, 5]

    squares = list(map(lambda x: x**2, myList2))
    print(squares)

    myList3 = [2, 2, 2, 2, 2]
    
    allMultiplied = reduce(lambda a, b: a * b, myList3)
    print(allMultiplied)

if __name__ == '__main__':
    main()

Es te video puede ser de gran ayuda:
https://www.youtube.com/watch?v=hUes6y2b--0

High Order Functions

Funciones que reciben como parámetro otra función

Filter

devuelve True or False según el valor esté dentro de los criterios buscados o no. En caso de que no cumpla con la condición, no será devuelto y la lista se verá reducida por este filtro.

"""
Dada una lista de numeros filtra para quedarte solo con 
los números impares
"""

my_list = [i for i in range(10)]

# Usando def
def get_odds(arr):
    odds = []
    for n in arr:
        if n % 2 == 1:
            odds.append(n)
    return odds

# Usando List Comprehension
odds = [n for n in my_list if n % 2 == 1]

# Usando Filter
odds_filter = list(filter(lambda n: n % 2 == 1, my_list))
print(odds_filter)

Map

Funciona muy parecido, pero su diferencia radica en que no puede eliminar valores de la lista del array entregado. Es decir, el output tiene la misma cantidad de valores que el input.

"""
Obtener todos los numeros de una lista multiplicados al cuadrado
"""

# Usando Def
def get_squares(arr):
    squares = []
    for n in arr:
        squares.append(n * n)
    return squares

# Usando List Comprehension
squares = [n * n for n in my_list]

# Usando Map
squares_map = list(map(lambda x: x*x, my_list))
print(squares_map)

Reduce

Toma 2 valores entregados como parámetros y el iterador como otro parámetro. Realiza la función con estos 2 valores, y luego con el resultado de esto y el valor que le sigue en el array. Y así hasta pasar por todos los valores de la lista.

"""
Suma todos los valores de una lista
"""
from functools import reduce

# Usando def
def get_sum(arr):
    result = 0
    for n inarr:
        result += n
    return result

# Usando Reduce
sum = reduce(lambda a, b: a + b, my_list)
print(sum)

Cuando vuelves a caer por segunda vez, pero te das cuenta que fue una broma. 😅

Este curso se pone cada vez más bueno…

Apuntes clase 12

Desafío inicial,

print([i**2 for i in range(1, 6)])

Alguien más revisó la duración del video cuando dijo: Nos vemos en la siguiente clase ??? jajaj

Filter:

Map:

Reduce:

Por si nos les quedo claro las diferencias entre filter, map y reduce. Ayuda a comprender mas a fondo
https://taverasmisael.com/blog/usar-map-filter-y-reduce-para-olvidarnos-de-los-bucles-for#:~:text=A diferencia de filter%2C map,de la transformación que apliquemos.&text=A map le pasamos una,sin afectar el array original.

Ojalá también hubiera una clase sobre decorators

Cuando caes dos veces

• Usar filter en lugar de list comprehension mejora el rendimiento en memoria y computo.
• A medida que la función de filtrado se va haciendo más compleja, será necesario usar funciones regulares en lugar de lambda functions, por cuestiones de legibilidad.
• Fuente: https://www.digitalocean.com/community/tutorials/how-to-use-the-python-filter-function-es

si completaste el curso basico de python lo tienes que entender sin problema

Por lo que entiendo, reduce también sirve para sumar grandes cantidades de números que estén en una lista de forma rápida, no solo para multiplicar. Pongo ejemplo de mi código:

from functools import reduce

lista = [2,2,3,3,4,4]

resultado = reduce(lambda a, b: a+b, lista)

print(resultado)

Resultado= 18

Reduce también tiene a diferencia de otras funciones, sí devuelve un objeto primitivo y es un entero.

🔆 Las High order functions permite recibir funciones en los parámetros de las funciones.

def saludo(func):
    func()


def hola():
    print("Hola!!!")


def adios():
    print("Adios!!!")


saludo(hola)
saludo(adios)

Filter: Recorre toda la lista para devolver uno varios elementos de esta. sirve para filtrar (devolver) elementos específicos en una lista.

Map: Recorre toda la lista, la modifica y devuelve la misma lista, pero modificada. Sirve parar realizar una operación a todos los elementos de la lista uno a uno y devolver la lista con sus valores modificados.

Reduce: no devuelve una lista, devuelve un valor haciendo una operación con todos los elementos. Sirve para hacer acumulaciones de los elementos de una lista.

1.Filter:
La función filter extrae elementos de un iterable (lista,tupla etc.) El cual regresa un True.

2.Filter Sintax:
filter(función, iterable)

3.Argumentos de filter:

• Función: Una función normal que contiene la lógica.
• iterable: Un iterable como listas o tuplas.

4.¿Qué regresa filter?
La función filter regresa un iterador.
Nota: Este iterador por lo general es convertido a listas o tuplas etc.

Ejemplo:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Regresa True si el número es par
def check_even(number):
    if number % 2 == 0:
          return True  

    return False

#Aquí la función filter extrae los número de la lista numbers.
#Cada elemento de la lista de números es pasado por la función check_even.
#Si even_numbers_iterator regresa True ese elemento es extraido(ejemplo: 2,4,6,8,10).
#Si el elemento regresa False , ese valor sera filtrado (ejemplo:1,3,5,7,9).
even_numbers_iterator = filter(check_even, numbers)

# convertimos a una lista.
even_numbers = list(even_numbers_iterator)

print(even_numbers)

# Output: [2, 4, 6, 8, 10

Me da la idea de que al usar filter, usaremos una condicional para solo seleccionar los elementos que nos interesan. Por el contrario, con map, usamos todos los elementos de la lista pero afectados por algo, por ejemplo, el cuadrado.
Es así ?

La razón por la qué entiendo que se usa list() para envolver a filtre() y map() es porque estas devuelven un objeto iterable, lo que hace list() es ir llamando el siguiente elemento del objeto y convertirlo en lista.

• 1er reto:

my_list = [1,4,5,6,9,13,19,21]
odd = list(filter(lambda x: x%2 != 0, my_list))
print(odd)

• 2do reto:

 squares = [i**2 for i in range(1, 6)]
 print(squares)

• 3er reto:

my_list = range(1,6)
squares = list(map(lambda x: x**2, my_list))
print(squares)

• 4to reto:

from functools import reduce

my_list = [2,2,2,2,2]

multiplied = reduce(lambda a, b: a*b, my_list)

print(multiplied)

🐍 Comparto un complemento a estas clases con la documentación de Python:

 
Python Doc - FILTER
Sintaxis de filter: filter(function, iterable)
Ejemplo:
odd = list(filter(lambda x: x%2 != 0, my_list))
 
Python Doc - MAP
Similar a filter, MAP usa la misma sintaxis con la diferencia que soporta mas de un iterable: map(function, iterable, ...)
Ejemplo:
odd = list(map(lambda x: x**2, my_list))
 
Python Doc - REDUCE
Similar a filter y map usa la misma sintaxis con la diferencia que retorna un solo valor recorriendo el iterable de izq-der y aplica la expresión de cálculo que le indiquemos a la función lambda: reduce(function, iterable, initializer-optional)
Ejemplo:

# Impor module
    from functools import reduce
    my_list = [2, 2, 2, 2, 2]

    odd = reduce(lambda a, b: a * b, my_list) 
    print(odd)

Excelente explicación!!!

Facundo: Nos vemos en la siguente clase.
Nosotros:

En esta clase no estoy de acuerdo con Facundo, “no hace falta que lo entiendas para aplicarlo”. Me parece que al menos vendría bien un enlace externo donde podamos leer y entender los iteradores.

Para elevar al cuadrado con ciclo For y con lista comprehesion

def run():
    list = []
    
    for i in range(1, 6):
        list.append(i**2)
    
    list1 = [i**2 for i in range(1, 6)]
    
    print(list)
    print(list1)

if __name__ == "__main__":
    run()

Resumen de la Clase:

# High order functions: filter, map y reduce
# 
# filter function = filter(function,parameter)
#
data_1 = [1,4,5,6,9,13,19,21]
list_filter = list(filter(lambda x:x %2 != 0, data_1))
print(list_filter)
#
# map function = map(function,parameter)
data_2 = [1,2,3,4,5]
list_map = list(map(lambda x:x**2, data_2))
print(list_map)
#
# reduce function = reduce(function,parameter)
from functools import reduce
data_3 = [2,2,2,2,2]
list_reduce = reduce(lambda a, b:a*b, data_3)
print(list_reduce)

Estuve revisando, y vi que también con la función de map, podemos pasar como lista una lista de funciones, e iterar una lista de valores sobre ellas, cómo el siguiente ejemplo:

list = [1, 2, 4, 7]
def squares(x):
    return x ** 2
def cubes(x):
    return x ** 3
functions = [cuadrado, cubo]
for i in list:
    values = list(map(lambda x : x(f), functions))
    print(values)

Como resultado, imprime el resultado de las dos funciones para cada elemento de la lista:

[1, 1]
[4, 8]
[16, 64]
[49, 343]

Las definiciones las tome de @Edkar Chachati.

from functools import reduce
# las funciones de orden superior, son funciones que reciben otra funcion como parametro
# ejemplo filter, map, reduce
my_list = [1, 4, 5, 6, 9, 13, 19, 21]
my_list_reduce = [2, 2, 2, 2, 2, 2, 2]

'''devuelve True or False según el valor esté dentro de 
los criterios buscados o no. En caso de que no cumpla con la condición,
 no será devuelto y la lista se verá reducida por este filtro'''
odd = list(filter(lambda x: x % 2 != 0, my_list))

'''Funciona muy parecido, pero su diferencia radica en que no puede eliminar valores 
de la lista del array entregado. Es decir, el output tiene la misma
 cantidad de valores que el input.'''
odd_map = list(map(lambda x: x**2, my_list))

'''Toma 2 valores entregados como parámetros y el iterador como otro parámetro. Realiza 
la función con estos 2 valores, y luego con el resultado de esto y el valor 
que le sigue en el array. Y así hasta pasar por todos los valores de la lista.'''
odd_reduce = list(map(lambda a,b: a**b, my_list_reduce))

print(odd)
print(odd_map)
print(odd_reduce)

def run():
    numbers = [1,2,3,4,5];
    print(
        list(map(lambda x: x**2, numbers))
    );

if __name__ == '__main__':
    run();

Aqui esta la comparativa, por si alguien necesita de ello:

#filter<

#   withoutfilter<

my_list = [1,3,4,2,5,4,7]

odd = [i for i in my_list if i % 2 != 0]

print(odd)

#   withoutfilter>

#   withfilter<

my_list = [1,3,4,2,5,4,7]

odd = list(filter(lambda x: x % 2 != 0, my_list))

print(odd)

#   withfilter>

#filter>

#map<

#   withoutmap<

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

scuares = [i**2 for i in my_list]

print(scuares)

#   withoutmap>

#   withmap<

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

scuares = list(map(lambda x: x**2, my_list))

print(scuares)

#   withmap>

#map>

#reduce<

#   withoutreduce<

my_list = [2,2,2,2,2]

all_multiplied = 1

for i in my_list:
    all_multiplied = all_multiplied * i

print(all_multiplied)

#   withoutreduce>

#   withreduce<

from functools import reduce

my_list = [2,2,2,2,2]

all_multiplied = reduce(lambda a, b: a * b, my_list)

print(all_multiplied)

#   withreduce>

#reduce>

def runreduse():
    lista = [2, 2, 2, 2, 2]

    all_multiply = 1

    for i in lista:
        all_multiply = all_multiply * i

    print(all_multiply)


def usoreduse():
    lista = [2, 2, 2, 2, 2]

    all_multipy = reduce(lambda a, b: a * b, lista)

    print(all_multipy)

def run():
    lista = [1, 4, 5, 6, 9, 13, 19, 21]

    odd = [i for i in lista if i % 2 != 0]

    print(odd)

def usofilter():
    lista = [1, 4, 5, 6, 9, 13, 19, 21]

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

    print(odd)

<code> 
from functools import reduce

my_list = [1,4,5,6,9,13,19,21]
my_list_map = [1,2,3,4,5]
my_list_reduce = [2,2,2,2,2]
#listcomprehesion
def listcomprehension():

    add = [i for i in my_list if i % 2 != 0]
    print(add)
#high order functions filter
def filterexample():

    odd = list(filter(lambda x: x %2 !=0,my_list))   
    print(odd)
#listcomprehesion
def listcomprehension2():

    squeres = [i**2 for i in my_list_map]
    print(squeres)

#high order functions map 
def mapexample():

    mapsqueres = list(map(lambda x :x **2, my_list_map))
    print(mapsqueres)    

#listcomprehesion
def listcomprehensio3():
    all_multiplied = 1
    for i in my_list_reduce:
        all_multiplied = all_multiplied * i
    print(all_multiplied)    

#high order functions reduce
def reduceexample():
    all_multiplied = reduce(lambda a, b:a*b,my_list_reduce)
    print(all_multiplied)
     
if __name__ == '__main__':
    listcomprehension()
    filterexample()
    listcomprehension2()
    mapexample()
    listcomprehensio3()
    reduceexample()
</code>

Que es una funcion de orden superior?: Una funcion que recibe como parametro otra funcion(nos vemos en la siguiente clase), me recordo tanto a la universidad 😅

CONCLUSIÓN

• Filter → Devolverá los elementos de un iterable (enviado como parámetro) que cumplan con la condición dada en la función enviada como parámetro

• Map → Devuelve un iterable con la misma canidad de elementos del iterable enviado como parámetro, aplicando una operación a cada elemento (definida en la función parámetro)

• Reduce → Realiza una operación (definida en la función parámetro) sobre todos los elementos del iterable enviado como parámetro para obtener 1 solo resultado. Esta función se tiene que importar de functools

Notas 😄

High order functions: filter, map y reduce.

• Una función de orden superior es una función que recibe como parámetro a otra función. 😆 Ejemplo de función de orden superior.
• En este caso, saludo es de orden superior ya que recibe una función como argumento.
• Hay tres funciones de orden superior que son muy importantes: filter, map y reduce.

def saludo(func):
	func()
def hola():
	print("Holaaa!!!")
def adios():
	print("Adioooos!!")

saludo(hola)
saludo(adios)

• Filter: Recibe una función con la cual se filtran los elementos (Debe regresar True o False) de un iterable (esos son sus dos argumentos). La función filter regresa un iterator, que es un tipo especial de objeto, por lo que debemos pasarlo a tipo lista. 🔍

my_list = [1, 4, 5, 6, 9, 13, 19, 21]
odd = list(filter(lambda x: x%2 !=0, my_list))
print(odd)

• Map: Recibe una función y un iterable. Aplica la función al iterable. De nuevo, debemos pasarlo a tipo lista. 🗺️

my_list = [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, my_list))

• Reduce: Recibe también una función y un iterable. Debe importarse del módulo functools. La función debe recibir dos elementos, y la función reduce regresa un único valor resultado de aplicar a pares el último resultado con el siguiente elemento del iterable. 🧠

from functools import reduce

my_list = [2, 2, 2, 2, 2]
all_multiplied = reduce(lambda a, b: a*b, my list)

No Facu, esta vez no me engañaste XD

muy buen profesor, explica 10/10, más profesores así

Resumen:

1. Función filter(): Devuelve un iterador donde los elementos se filtran a través de una función para probar si el elemento es aceptado o no, usualmente usa la función lambda.
2. Función map(): Ejecuta una función especifica para cada uno de los elementos en un “iterable” (un iterable puede ser una lista, un diccionario, etc). Se usa principalmente para transformar un objeto en otro objeto con alguna característica adicional.
3. Función reduce(): Esta función acepta una función y una determinada secuencia y devuelve como resultado final un único valor de la siguiente manera:
   PASO 1: Inicialmente llama a los dos primeros términos de la función, realiza la operación asignada y devuelve un resultado.
   PASO 2: A continuación, se vuelve a llamar a la función con el resultado obtenido en el paso anterior y el tercer valor de la secuencia, vuelve a realizar la operación asignada, y este proceso se repite hasta el ultimo termino de la secuencia.

#       FUNCIONES DE ORDEN SUPERIOR
# Las funciones de Python pueden tomar funciones como parámetros y devolver funciones como resultado.
# Una función que hace ambas cosas o alguna de ellas se llama función de orden superior

#        FILTER
# La función filter recibe dos parámetros, en este caso:
# 1- una lambda que a su vez recibe un x devolviendo los x cuyo modulo de dos sean diferentes a 0
# 2- El segundo parámetro es el iterable my_list
# Al final todo se guarda dentro de la función list

my_list = [1,4,5,6,9,13,19,21]
odd = list(filter(lambda x: x%2 != 0, my_list))
print(odd)


#       MAP
# La función map recibe dos parámetros, en este caso:
# 1- una lambda que a su vez recibe un x devolviendo los x al cuadrado
# 2- El segundo parámetro es el iterable my_list2
# Al final todo se guarda dentro de la función list
my_list2 = [1,2,3,4,5]
squares = list(map(lambda x: x**2,my_list2))
print(squares)


#       REDUCE
# La función reduce recibe dos parámetros, en este caso:
# 1- Una lambda que a su vez recibe 2 parámetros a y b donde a es el valor del primer término y b el segundo
# 2- El segundo parámetro es el iterable my_list3
# Al final todo se reduce a un termino, a diferencia de filter y map, reduce debe ser importada del modulo functools
from functools import reduce

my_list3 = [2,2,2,2,2]
all_multipled = reduce(lambda a, b: a*b,my_list3)
print(all_multipled)

Visitar esta web CLIK AQUI

from functools import reduce

def run():

	# FILTER
	# obtener una lista con los numeros impares de otra lista
	# resolverlo con list comprehensions
	my_list = [1, 4, 5, 6, 9, 13, 19, 21]
	odd = [i for i in my_list if i % 2 !=0]
	print(odd)
	print("\n")

	# filter
	# resolver el problema anterior con filter y lambda
	odd = list(filter(lambda x: x%2 != 0, my_list))
	print(odd)
	print("\n")


	# MAP
	# Convertir una lista pero con los números elevados al cuadrado
	# resolverlo con list comprehensions
	my_list = [1,2,3,4,5]
	squares = [i**2for i in my_list]
	print(squares)
	print("\n")

	# map
	# resolver el problema anterior con map y lambda
	squares = list(map(lambda x: x**2, my_list))
	print(squares)
	print("\n")

	# REDUCE
	# Tengo una lista y requiere reducirse, en este caso multiplicar los numeros de la lista

	# for
	# resolverlo de una forma tradicional
	my_list = [2, 2, 2, 2, 2]
	all_multiplied = 1

	for i in my_list:
		all_multiplied = all_multiplied * i

	print(all_multiplied)

	# reduce
	# resolverlo con reduce
	# el parametro a y b son los primeros 2 elementos de la lista en la primer iteración
	# en la siguiente iteración a es el resultado de la primer multiplicación y b el siguiente elemento
	all_multiplied = reduce(lambda a,b: a*b, my_list)

	print(all_multiplied)


if __name__ == '__main__':
	run()

Les dejo un repositorio en mi Git-hub donde se encuentra el código fuente de una calculadora que desarrollé donde aplico las funciones lambdas y funciones de orden superior:

https://github.com/Julian-Bio0404/Calculadora_cientifica

No es necesario envolver el resultado de filter en una lista, porque este ya devuelve una lista en si mismo. La documentación de Python dice que filter es el equivalente a hacer un list comprehension. Si alguien conoce de algún caso excepcional, por favor que me deje saber.

Funciones de orden superior, son funciones que reciben como parámetro a otra función.
Funciones de orden superior de importancia:
filter → recibe una función filtro (anónima) y un iterable (lista, tupla, etc) devolviendonos un iterador: objeto optimizado recorrer elemento a elemento (iterar) por lo que no lo podemos inprimir de manera directa (para ello lo convertimos a una lista), su sintaxis es: filter(<funcion filtro>, <iterable>)
map → al igual que filter recibe una función anónima y un iterable como parámetros pero en este caso map ejecuta la función sobre cada uno de los elementos del iterable, sintaxis: map(<funcion>, <iterable>)
reduce → tenemos que importar esta función desde functools para poder usarla, tiene los mismos argumentos que las anteriores funciones, reduce el iterable por medio de la función anonima, su sintaxis es: reduce(<funcion reduccion>, <iterable>), la función de reducción necesita de dos parámetros, uno que almacena el resultado (o el primer valor del iterable) y otro que opera con el siguiente valor del iterable: lambda a,b: <expresión>

filter

my_list = [1,4,5,6,9,13,19,21]
# -- modo 1
# index = 0
# for i in my_list:
#     print (i, index, my_list)
#     if(i%2 == 0):
#         list2.append(i)
#     index += 1
# -- modo 2
#list2 = [i for i in my_list if i%2 != 0]
# -- modo 3
list2 = list(filter(lambda x: x%2 != 0, my_list))
print (list2)

map

my_list = [1,4,5,6,9,13,19,21]
print(list(map(lambda x: x**2, my_list)))

reduce

from functools import reduce

my_list = [2,2,2,2,2]
print(reduce(lambda x, y: x*y, my_list))

Filter
La función filter() filtra una lista de elementos para los que una función devuelve True
Ejemplo: Devolver solo los números pares de una lista

def run():
    """
    	Challenge: Return only even numbers from a list -> [1,2,3,4,5,6,7,8,9,10]
    	"""
    # solution with list comprehension
    numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    result = [number for number in numbers if number % 2 == 0]
    print(result)

    # solution with filter
    solution = list(filter(lambda number: number % 2 == 0,numbers))
    print(solution)


if __name__ == '__main__':
    run()

Map
La función map() aplica una función a cada uno de los elementos de una lista.

def run():
    """
    Create a new list with squared number of this list [1,2,3,4,5]
    """

    # Solution with listcomprehencion
    numbers = [1, 2, 3, 4, 5]
    result = [i**2 for i in numbers]
    print(result)

    # solucion with map
    solution = list(map(lambda number: number**2, numbers))
    print(solution)


if __name__ == '__main__':
    run()

Reduce
Esta función se utiliza principalmente para llevar a cabo un cálculo acumulativo sobre una lista de valores y devolver el resultado.
Para usar reduce es necesario usar from functools import reduce

from functools import reduce


def run():
    """
    resuce this list [2,2,2,2,2] to 32
    in this case we only have to create a cumulative number
    """
    numbers = [2, 2, 2, 2, 2]
    solution = reduce(
        lambda number,
        next_number: number *
        next_number, numbers
    )
    print(solution)


if __name__ == '__main__':
    run()

Mi ejercicio:

def using_filter():

    # Get only odd numbers from a list
    print("USING FILTER")
    my_list = [1, 4, 5, 6, 9, 13, 19, 21]
    print("Get only odd numbers from list", my_list)

    # Using list_comprehensions:
    odd = [i for i in my_list if i % 2 != 0]

    # Using high order function: filter
    odd2 = list(filter(lambda x: x%2 != 0, my_list))

    # Print result: [1, 5, 9, 13, 19, 21]
    print("Using list_comprehensions:", odd)
    print("Using high order function, filter:", odd2)

def using_map():

    # Get square numbers from a list
    print("USING MAP")
    my_list = [1, 2, 3, 4, 5]
    print("Get square numbers from list", my_list)

    # Using list_comprehensions:
    odd = [i**2 for i in my_list]

    # Using high order function: map
    odd2 = list(map(lambda x: x**2, my_list))

    # Print result: [1, 4, 9, 25]
    print("Using list_comprehensions:", odd)
    print("Using high order function, map:", odd2)

def using_reduce():

    # Get all the numbers from a list multiplied
    print("USING REDUCE")
    my_list = [2, 2, 2, 2, 2]
    print("Multiplied all the numbers from a list", my_list)

    # Using for:
    all_multiplied = 1
    for i in my_list:
        all_multiplied = all_multiplied * i

    # Using high order function: map
    from functools import reduce
    all_multiplied2 = reduce(lambda a, b: a * b, my_list)

    # Print result: 36
    print("Using for:", all_multiplied)
    print("Using high order function, reduce:", all_multiplied2)


if __name__ == '__main__':
    using_filter()
    print()
    using_map()
    print()
    using_reduce()

RESULTADO:

USING FILTER
Get only odd numbers from list [1, 4, 5, 6, 9, 13, 19, 21]
Using list_comprehensions: [1, 5, 9, 13, 19, 21]
Using high order function, filter: [1, 5, 9, 13, 19, 21]

USING MAP
Get square numbers from list [1, 2, 3, 4, 5]
Using list_comprehensions: [1, 4, 9, 16, 25]
Using high order function, map: [1, 4, 9, 16, 25]

USING reduce
Multiplied all the numbers from a list [2, 2, 2, 2, 2]
Using for: 32
Using high order function, reduce: 32

función de orden superior
Es una función que recibe como parámetro a otra función:

• Filter : si de una lista se requiere que s filtre por un tipo de valor en especifico
• map : si de una lista se requiere una operación en especifico y retorna el resultado a la lista
• reduce : en el ejemplo reduce el valor de la lista de valores multiplicando el primer valor con el segundo y asi hasta acabar con los valores de la lista

Con lo que he aprendido en este curso y el curso básico de python, logre terminar un proyecto que tenia planteado hacer desde hace poco tiempo, solo que no tenia los conocimientos necesarios para hacerlo. El proyecto que realice es un conversor de numero decimal a binario.

Aquí les comparto mi código.

def run():
    numero = int(input("Escribe un numero: "))

    binario = []

    LIMITE = 0

    contador = 0

    while numero > LIMITE:
        unidad = int(numero % 2)
        numero = int(numero / 2)

        if unidad == 0:
            binario.append(0)
        else:
            binario.append(1)

        contador = contador + 1
   
    binario = binario[::-1]
    binario = str(binario)
    binario = "".join(binario)

    binario = binario.replace(',', '')
    binario = binario.replace('[', '')
    binario = binario.replace(']', '')

    print(binario)

    if __name__ == '__main__':
    run()

from functools import reduce


def run():
    my_list = [1, 2, 3, 4, 5]

    # FILTER AS COMPREHENSIONS
    comprehension_filter = [i for i in my_list if i % 2 != 0]
    print(comprehension_filter)

    # FILTER AS FOR
    for i in my_list:
        if i % 2 != 0:
            print(i)

    # FILTER AS LAMBDA
    odd = list(filter(lambda x: x % 2 != 0, my_list))
    print(odd)

    # MAP AS COMPREHENSIONS
    comprehension_map = [i**2 for i in my_list]
    print(comprehension_map)

    # MAP AS FOR
    for i in my_list:
        squares = i**2
        print(squares)

    # MAP AS LAMBDA
    squares_map = list(map(lambda x: x**2, my_list))
    print(squares_map)

    # REDUCE AS FOR
    all_multiplied = 1
    for i in my_list:
        all_multiplied = all_multiplied * i
    print(all_multiplied)

    # REDUCE AS COMPREHENSIONS
    all_multiplied_lambda = reduce(lambda a, b: a * b, my_list)
    print(all_multiplied_lambda)


if __name__ == '__main__':
    run()

High order functions: filter, map y reduce

Una función de order superior es una función que recibe como parametro a otra función.

Además tiene una serie de carácterísticas especiales.

def saludo(func):
    func()

def hola():
    print("hola!!!")

def adios():
    print("adiós")

saludo(hola)
saludo(adios)

• cuando nosotros llamamos a saludo; saludo recibe la función como paramétro y ejecuta dentro de si misma
• por lo tanto, si a saludo, le pasamos como parametro la función “hola” el resultado será hola en consola

Hay tres funciones de orden superior que son importantes en una gran cantidad de lenguajes de programación. son: filter, map y reduce

filter()

Se usa para los elementos que queremos filtrar.

Ejemplo con comprehesion:

my_list = [1,4,5,6,9,13,19,21]
odd = [i for i in my_list if i % 2 != 0]
print(odd)

#output
[1,5,9,13,19,21]

así se resuelve con filter:

my_list = [1,4,5,6,9,13,19,21]
odd = list(filter(lambda x: x%2 !=0, my_list))
print(odd)

Analicemos:

1. lambda recibe como parametro una x y retorna el resultado de la expresión x%2 !=0
2. recibe un número y retorna true o false si ese número par o impar
3. filter recibe dos parametros; una función (en este caso lambda) y un iterable

2. map()

Transforma transforma la lista en la misma pero en una modificación

este es un ejemplo con list comprehesions

my_list = [1,2,3,4,5]
squares = [i**2 for i in my_list]
print(squares)

#output
[2,4,9,16,25]

Esto hizo que la lista retornara cada numero en el cuadrado de si mismo

• por cada i en esa lista, va a retornar multiplicado al cuadrado

con map es lo mismo

my_list = [1,2,3,4,5]
squares = list(map(lambda x: x**2, my_list))
#output
[2,4,9,16,25]

• list envolviendo todo,
• map envolviendo nuestra función como primer parametro y a nuestra lista como segundo parametro
• Lambda recibe x y retorna el resultado de x**2
• Esta línea de código recorre cada uno de los elementos de esta lista, los eleva al cuadrado y los va a guardar en una nueva lista llamada square.

3. reduce()

Reduce todos los valores de la lista a un único valor.

Así se haría de la forma tradicional con for

my_list = [2,2,2,2,2]
all_multiplied = 1 
for i in my_list:
    all_multiplied *=i
    print(all_multiplied)

así se hace con reduce:

from functools import reduce
my_list = [2,2,2,2,2]
all_multiplied = reduce(lambda a,b: a*b, mylist)
print(all_multiplied)
#output
32

• En lugar de tener el código de manera directa, se importa la función reduce del "functools
• acá lambda lleva dos parametros: a,b y multiplica a*b como resultado.
• a y b, representa el primer y segundo elemento de la lista

Me dio curiosidad de ver que retorna sin la función list() 😂

aquí el resultado:

my_list = [1,4,5,6,9,13,19,21]
odd = filter(lambda x: x%2 !=0, my_list)
print(odd)


(venv) /curso_python> $ py prueba_sin_filter.py
<filter object at 0x0000029C8486DD90>

Funciones de orden superior:

Una función de orden superior es una función que recibe como parámetro a otra función.

• filter, map, reduce

from functools import reduce

# metode filter
def metode_filter():
    my_list = [1, 4, 56, 9, 19, 214]
    odd = [i for i in my_list if i % 2 != 0]
    print(odd)

    odd = list(filter(lambda x: x % 2 != 0, my_list))
    print(odd)

#metode map
def metode_map():
    my_list_2 = [1, 2, 3, 4, 5]
    squares = [i**2 for i in my_list_2]
    print(squares)

    squares = list(map(lambda x: x**2, my_list_2))
    print(squares)

#metode reduce
def metode_reduce():
    my_list_3 = [2, 2, 2, 2]
    all_multiplied = 1
    for i in my_list_3:
        all_multiplied = all_multiplied * i
    print(all_multiplied)

    all_multiplied = reduce(lambda a, b: a*b, my_list_3)
    print(all_multiplied)

def run():
    metode_filter()
    metode_map()
    metode_reduce()

if __name__ == '__main__':
    run()

Diferencias entre map() y filter()

La función map(function(), itterable)manipula iterables a través de la función que le pases para transformar datos.
map ejecuta todas las condiciones de una función en el objeto iterable.

La función filter(function(), itterable) filtra de la lista del objeto iterable solo aquellos elementos que cumplen con la condición dada en la función

Si aplicamos la misma acción utilizando map y luego filter veremos la diferencia:

Generar una lista de todos los objetos multiplicados por 2 dentro del rango del 0 al 10

• USANDO MAP

list(map(lambda var: var*2, range(0,10)))
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

• USANDO FILTER

list(map(lambda var: var*2, range(0,10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Como se observa la función map hace uso de la manipulación de datos descrita en la función en lambda, mientras que filter espera que en la función lambda se evalúe una condición para filtrar el valor en la posición de la lista que cumpla con esta condición es por eso que al no haber condiciones retorna el valor de la lista sin manipulación de datos alguna.

pd. “Come frutas y verduras”

• Función de orden superior, es una función que recibe como parámetro otra función.

#filter list(filter(myfunc,my_list))
new_list=list(filter(lambda args: condition,my_list))

#map list(map(myfunc,my_list))
new_list=list(map(lambda args: process,my_list))

#reduce reduce(lambda myfunc,my_list)
from functools import reduce
new_list=reduce(lambda arg1,arg2: arg1*arg2,my_list)

def run():
    Menu = """
    Esta es una funcion llamada "reduce"
    que multiplica todos los elementos de
    una lista
    """
    print(Menu)
    from functools import reduce
    my_list = [2,2,2,2,2]
    al_multiplied = reduce(lambda a, b: a*b, my_list)
    print(al_multiplied)

if __name__ =='__main__':
    run()

Un iterable es cualquier objeto de python que puede recorrerse. En el ejemplo de la clase se usa una lista

Filter: Se utiliza para filtrar los datos que no queremos obtener y estos mismos datos están dentro de un iterable.

Map: Se utiliza para poder modificar los valores que se encuentran dentro de un iterable.

Reduce: Se utiliza para obtener la recopilación de todos los valores que están dentro del iterable de forma reducida

def runmap():
    lista = [1, 2, 3, 4, 5]

    odd = [i**2 for i in lista]
    print(lista)
    print(odd)

def usomap():
    lista = [1, 2, 3, 4, 5]

    odd = list(map(lambda x: x**2, lista))

    print(lista)
    print(odd)

from functools import reduce

my_list = [1, 2, 3, 4, 5]
my_list2 = [2, 2, 2, 2, 2]

# Map
squares = list(map(lambda x: x**2, my_list))

print(squares)

# Filter 
odd = list(filter(lambda x: x % 2 != 0, my_list))
print(odd)

# Reduce
all_multiplied  = reduce(lambda a, b: a * b, my_list2)
print(all_multiplied)


#if __name__ == '__main__':

Me agrada saber qué “entendí esa referencia” 😸

Lo aprendi gracias a la evaluacion anterior, listComprehension para tener las raices cuadradas de la lista

powerSqr = [i ** 2 for i in myList]
    print(powerSqr)

High order functions: filter, map y reduce

Caí dos veces 😦 jajaja

Volví a caer JAJAJAJAJAJ

Aquí la clase en la que habla de iteradores:

https://platzi.com/clases/1909-scrapy/29441-recordando-generadores-e-iteradores/

Yo el primer reto lo resolví así:

my_list = [i**2 for i in range(1, 6)]

Reduce: toma una lista y la reduce a un valor. para aplicarla se debe importar de functools
Filter: realiza un filtro de una lista generando una nueva con el filtro aplicado
Map: toma una lista, se ve afectada por una operacion generando una nueva lista

Reto Map

def main():
    list = [i**2 for i in range(1, 6)]
    print(list)


if __name__ == "__main__":
    main()

def expo():
    nums_expo=[pow(i,2) for i in range(1,6,1)]
    print(nums_expo)

el reto de Map xd

def run():
My_list= [i**2 for i in range(1, 6)]
print(My_list)

if name ==‘main’:
run()

no me gusto el ejemplo usado para filter, hace dificil de entender por las sigueintes razones:

1. el ejemplo es igual o mas complejo que usando list comprehensions.
2. el forma en que usa la lambda es diferente a la forma en que la presento en la clase de funciones anonimas

Acabo de notar por acciente (escrib’i [ ]), que si dejo el c’odigo de reduce encerrado entre corchetes [ ], el resultado me lo entrega en una lsita (ver c’odigo). Pero que pasa si tuviera una lsita de odds and even (1,2,3,4,5,6,7,8,9, y quisiera el reduced de pares en una lista y el de impares en otra, ?deber’ia escribir dos l’ineas de c’odico o podr’ia en una?)

#Let's do it with REDUCE! I need to import if from functtool
from functools import reduce
reduced_all_multiplied =  [reduce(lambda a, b: a *b, list if a % 2 == 0)]
print("Here si the result with reduce Funct: ",reduced_all_multiplied)
print(type(reduced_all_multiplied))

Hoy aprendi, map, filter y reduce! excelente

Hola 😄 los primeros 3 ejercicios de esta página ocupas las tres funciones vistas en clase.
https://pythondiario.com/2018/07/ejercicios-en-python-con-funciones.html

#Reto
def run():
    lista = [1,2,3,4,5]
    lista_comp = [i**2 for i in lista]
    print(lista_comp)

if __name__ == "__main__":
    run()

High order function is a function that takes another function as an argument:

# Filter function
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
odd = list(filter(lambda x: x % 2 != 0, my_list))
print("La lista 1 es "+ str(odd))

# Map function
my_list2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
square = list(map(lambda x: x**2, my_list2))
print("La lista 2 es "+ str(square))

# Reduce function
from functools import reduce

my_list3 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
sum = reduce(lambda x, y: x + y, my_list3)
print("La suma es "+ str(sum))```

Mi aporte para el primer reto del video:

def run():
    list = [1,2,3,4,5]
    list = [i**2 for i in list]
    print(list)
if __name__ == '__main__':
    run()

Para obtener:

[1, 4, 9, 16, 25] 

Estaba escribiendo en mi cuaderno y quedé 😮

"""
This program allows you to obtain a new list with the
squares of an original list
"""


def run():
    list1 = [1,2,3,4,5]
    list2 = [i**2 for i in list1]
    print(list2)


if __name__ == "__main__":
    run()

En JavaScript se usan los mismo metodos, si la solucion es corta, se usan inline, de lo contrario se crea una arrow function aparte y se pasa por parametro, en Python seria algo asi.

jajajaja no caes dos veces (nos vemos en la siguiente clase…)

O sea el reduce hace:
[2, 2, 2, 2, 2]
a = primer 2
b = segundo 2
2x2 = 4
[4, 2, 2, 2]
a = ahora el 4
b = primer 2
4x2 = 8
[8, 2, 2]
Y así…

Este es mi código del ejercicio de sacar el cuadrado de los números, lo decidí hacer con diccionarios porque me pareció más sencillo y te da el número antes y después de exponenciarlo.

my_list = [1,2,3,4,5]
dict = {i: i**2 for i in my_list}
print(dict)

Funciones de orden superior:
Las funciones de orden superior son aquellas funciones que reciben como parámetros a otras funciones y hacen algo con ellas.
Existen 3 funciones de orden superior que son muy importantes en python:
• Filter: La función filter tiene la siguiente sintaxis filter(function, iterable), lo que hace esta función es que recibe como primer parámetro una función la cual va a ser el filtro y como segundo parámetro recibe cualquier iterable (una lista, un diccionario, un string, etc.), esta función nos devuelve un objeto iterador el cual podemos recorrer con un ciclo for o simplemente podemos usar la función list para convertirlo a una lista y mostrarlo en pantalla. La función que recibe como parámetro la función filter también puede ser una función lambda.

• Map: La función filter es muy parecida a la función filter, pero la diferencia es que mientras que filter filtra los elementos de un iterable, map hace algo a cada uno de ellos de modo que devuelve un nuevo iterable de la misma longitud que el iterable que recibe como segundo parámetro, la sintaxis es la siguiente: map(function, iterable). Al igual que filter esta función devuelve un objeto iterador y podemos recorrerlo con un ciclo for o podemos convertirlo a una lista para mostrarlo en pantalla, también se suelen utilizar funciones lambda con map. También es posible pasar mas de dos iterables en map

a = [1, 2, 3, 4, 5]
b = [6, 7, 8, 9, 10]

print(list( map(lambda x,y : x*y, a,b) ))

•Reduce: Lo que hace reduce es que toma todos los valores de un iterable y nos devuelve un único valor, en la primera iteración de reduce toma los dos primeros valores del iterable (índice 0 e índice 1) y partir de la segunda iteración tomará el resultado de reducir los dos primeros valores y tomará el siguiente valor en el iterable y así seguirá hasta recorrer por completo el iterable. Para utilizar reduce debemos de importar esta función de la librería functools.

Hermoso este lenguaje.

Otro par de ejemplos de reduce.

https://www.youtube.com/watch?v=--fGJCN_NE4

los map(), filter() y reduce() Las funciones aportan un poco de programación funcional a Python. Las tres son funciones de conveniencia que se pueden reemplazar con listas comprensivas o bucles, pero brindan un enfoque más elegante y abreviado para algunos problemas.

Antes de continuar, repasaremos algunas cosas con las que debería estar familiarizado antes de leer sobre los métodos mencionados anteriormente:

¿Qué es una función / método anónimo o lambda?

Un método anónimo es un método sin nombre, es decir, no vinculado a un identificador como cuando definimos un método usando def method:.

Nota: Aunque la mayoría de la gente usa los términos «función anónima» y «función lambda» indistintamente, no son lo mismo. Este error ocurre porque en la mayoría de los lenguajes de programación las lambdas son anónimas y todas las funciones anónimas son lambdas. Este también es el caso de Python. Por lo tanto, no profundizaremos en esta distinción en este artículo.

¿Cuál es la sintaxis de una función lambda (u operador lambda)?

lambda arguments: expression

Piense en lambdas como métodos de una línea sin nombre. Funcionan prácticamente igual que cualquier otro método en Python, por ejemplo:

def add(x,y):
return x + y

Puede traducirse a:

lambda x, y: x + y

Las lambdas difieren de los métodos normales de Python porque solo pueden tener una expresión, no pueden contener declaraciones y su tipo de retorno es un function objeto. Entonces, la línea de código anterior no devuelve exactamente el valor x + y pero la función que calcula x + y.

¿Por qué las lambdas son relevantes para map(), filter() y reduce()?

Los tres de estos métodos esperan una function objeto como primer argumento. Esta function El objeto puede ser un método predefinido con un nombre (como def add(x,y)).

Aunque, la mayoría de las veces, las funciones pasan a map(), filter()y reduce() son los que usaría solo una vez, por lo que a menudo no tiene sentido definir una función referenciable.

Para evitar definir una nueva función para sus diferentes map()/filter()/reduce() necesidades: una solución más elegante sería utilizar una función breve, desechable y anónima que solo usará una vez y nunca más: una lambda.
La función map ()

los map() La función itera a través de todos los elementos en el iterable dado y ejecuta el function pasamos como argumento en cada uno de ellos.

La sintaxis es:

map(function, iterable(s))

Podemos pasar tantos objetos iterables como queramos después de pasar el function queremos usar:

Without using lambdas

def starts_with_A(s):
return s[0] == “A”

fruit = [“Apple”, “Banana”, “Pear”, “Apricot”, “Orange”]
map_object = map(starts_with_A, fruit)

print(list(map_object))

Este código resultará en:

[True, False, False, True, False]

Como podemos ver, terminamos con una nueva lista donde la función starts_with_A() fue evaluado para cada uno de los elementos de la lista fruit. Los resultados de esta función se agregaron a la lista de forma secuencial.

Una forma más bonita de hacer exactamente lo mismo es usando lambdas:

fruit = [“Apple”, “Banana”, “Pear”, “Apricot”, “Orange”]
map_object = map(lambda s: s[0] == “A”, fruit)

print(list(map_object))

Obtenemos el mismo resultado:

[True, False, False, True, False]

Nota: Puede que hayas notado que hemos emitido map_object a una lista para imprimir el valor de cada elemento. Hicimos esto porque llamamos print() en una lista imprimirá los valores reales de los elementos. Vocación print() en map_object imprimiría las direcciones de memoria de los valores en su lugar.

los map() función devuelve el map_object type, que es iterable y podríamos haber impreso los resultados de esta manera también:

for value in map_object:
print(value)

Si quieres el map() función para devolver una lista en su lugar, puede simplemente convertirla al llamar a la función:

result_list = list(map(lambda s: s[0] == “A”, fruit))

La función filter ()

Similar a map(), filter() toma una function objeto y un iterable y crea una nueva lista.

Como el nombre sugiere, filter() forma una nueva lista que contiene solo elementos que satisfacen una determinada condición, es decir, la function pasamos devoluciones True.

La sintaxis es:

filter(function, iterable(s))

Usando el ejemplo anterior, podemos ver que la nueva lista solo contendrá elementos para los cuales el starts_with_A() devuelve la función True:

Without using lambdas

def starts_with_A(s):
return s[0] == “A”

fruit = [“Apple”, “Banana”, “Pear”, “Apricot”, “Orange”]
filter_object = filter(starts_with_A, fruit)

print(list(filter_object))

Ejecutar este código resultará en una lista más corta:

[‘Apple’, ‘Apricot’]

O reescrito usando una lambda:

fruit = [“Apple”, “Banana”, “Pear”, “Apricot”, “Orange”]
filter_object = filter(lambda s: s[0] == “A”, fruit)

print(list(filter_object))

La impresión nos da el mismo resultado:

[‘Apple’, ‘Apricot’]

La función reduce ()

reduce() funciona de manera diferente a map() y filter(). No devuelve una nueva lista basada en el function e iterable hemos pasado. En cambio, devuelve un solo valor.

Además, en Python 3 reduce() ya no es una función incorporada, y se puede encontrar en el functools módulo.

La sintaxis es:

reduce(function, sequence[, initial])

reduce() funciona llamando al function pasamos por los dos primeros elementos de la secuencia. El resultado devuelto por el function se usa en otra llamada a function junto con el siguiente (tercero en este caso), elemento.

Este proceso se repite hasta que hayamos pasado por todos los elementos de la secuencia.

El argumento opcional initial se utiliza, cuando está presente, al comienzo de este «bucle» con el primer elemento en la primera llamada a function. En cierto modo, el initial elemento es el elemento 0, antes del primero, cuando se proporciona.

reduce() es un poco más difícil de entender que map() y filter(), así que veamos un ejemplo paso a paso:

Empezamos con una lista [2, 4, 7, 3] y pasar el add(x, y) función para reduce() junto a esta lista, sin un initial valor
reduce() llamadas add(2, 4)y add() devoluciones 6
reduce() llamadas add(6, 7) (resultado de la llamada anterior a add() y el siguiente elemento de la lista como parámetros), y add() devoluciones 13
reduce() llamadas add(13, 3)y add() devoluciones 16
Como no quedan más elementos en la secuencia, reduce() devoluciones 16

La única diferencia, si hubiéramos dado un initial valor hubiera sido un paso adicional – 1.5. dónde reduce() Llamaría add(initial, 2) y usa ese valor de retorno en el paso 2.

Sigamos adelante y usemos el reduce() función:

from functools import reduce

def add(x, y):
return x + y

list = [2, 4, 7, 3]
print(reduce(add, list))

Ejecutar este código produciría:

16

Nuevamente, esto podría escribirse usando lambdas:

from functools import reduce

list = [2, 4, 7, 3]
print(reduce(lambda x, y: x + y, list))
print("With an initial value: " + str(reduce(lambda x, y: x + y, list, 10)))

Y el código resultaría en:

16
With an initial value: 26

Una aproximación de cómo podría funcionar por dentro la función filter()

def run():
    my_list = [1, 2, 45, 6, 7, 75, 4,5, 7,34 ,67, 33,45,65, 676, 6, 78, 90, 32, 21, 45]
    new_list = own_filter(lambda x: x%2 != 0, my_list)
    print(new_list)

def own_filter(funct_as_param, iter):
    return [i for i in iter if funct_as_param(i)]

if __name__ == '__main__':
    run()