Proyecto: filtrando datos

Data ⬇⬇⬇

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

Luis Arturo Cruz Cruz

Hola,

Les comparto una alternativa al operador | para versiones de Python mayores a 3.5 pero menores a 3.9

old_people = list(map(lambda worker: {**worker, **{"old": worker["age"] > 70}}, DATA))

<h3>Fuente</h3>

https://stackoverflow.com/questions/38987/how-do-i-merge-two-dictionaries-in-a-single-expression-taking-union-of-dictiona

Josue Farley Lopez Carvajal

Un tip:
Pueden colocar DATA en un archivo aparte y luego importarlo en el archivo donde van a trabajar:

from data_filtering_db import DATA

David Eduardo Bueno Núñez

#Con list comprehensions
adults = [worker ['name'] for worker in DATA if worker ['age'] > 18]
old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]

#Con high order functions
all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))

all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))

Jhonfred Galarraga

Reto completado:

def main():
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))
    adults = [worker['name'] for worker in DATA if worker['age'] > 18]
    old_confirmation = lambda worker_age: worker_age > 70
    old_people = [worker | {'old': old_confirmation(worker['age'])} for worker in DATA]

    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    main()

Jesús Kaimorts Díaz Medina

Proyecto de Filtrar datos

La forma en como he entendido mejor map y filter es conociendo que a cada una se le pasa una funcion especial. En otros lenguajes, como Java, cuando se utiliza la funcion Filter() se le debe de pasar un Predicate, y cuando se utiliza un Map() otra funcion como: UnaryOperator, Function, etc.

Predicate: Es una funcion que toma un parametro y el resultado de una comparacion.

La idea queda mas clara cuando guardo ese Predicate en una variable, usando la lambda, y otra lambda para usar mi funcion de mapeo.

Version con List Comprehension:

    # Usando 'List Comprehension'
    all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    label_python = "use Python - with List Comprehension"
    show_workers(all_python_devs, label_python)

Version con High Order Function:

# Usando 'High Order Function'
Predicate = lambda worker : worker["language"] == "python"
all_python_devs = list(filter(Predicate, DATA))
MapFunc = lambda worker : worker["name"]
all_python_devs = list(map(MapFunc, all_python_devs))
label_python = "use Python - with High Order Functions"
show_workers(all_python_devs, label_python)

Ademas, he implementado una funcion show_workers(), para mostrar el contenido de dicha transformacion: Filtrado y mapeo:

def show_workers(workers, label=""):
    print("People who", label)
    for i, worker in enumerate(workers):
        print(f"\t{(i+1)}. {worker}")

A continuacion comparto las distintas tareas pedidas para el proyecto:

Trabajadores que laboran en Platzi

Version con ‘List Comprehension’

all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
label_platzi = "work at Platzi - with List Comprehension"
show_workers(all_platzi_workers, label_platzi)

Version con ‘High Order Function’

# Usando 'High Order Function'
	Predicate = lambda worker : worker["organization"] == "Platzi"
all_platzi_workers = list(filter(Predicate, DATA))
MapFunc = lambda worker : worker["name"]
all_platzi_workers = list(map(MapFunc, all_platzi_workers))
label_python = "work at Platzi - with High Order Functions"    
show_workers(all_platzi_workers, label_python)

Agregar la llave old a un nuevo diccionario

Version con ‘List Comprehension’

all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
label_platzi = "work at Platzi - with List Comprehension"
show_workers(all_platzi_workers, label_platzi)

Version con ‘High Order Function’

	#MapFunc = lambda worker : worker | {"old": worker["age"] > 70}
MapFunc = lambda worker : {**worker, **{"old": worker["age"] > 70}}
old_people = list(map(MapFunc, DATA))
label_old = "is old - with High Order Functions"
show_workers(old_people, label_old)

Explicacion de la llave `old`

Lo que en realidad hace la siguiente linea de codigo:

{**worker, **{"old": worker["age"] > 70}}

Es incrustar, pegar, agregar, la llave old en el diccionaro, pero como?:

Obtenemos el diccionario, y todos sus campos en el usando {**worker}:

{'name': 'Facundo', 'age': 72, 'organization': 'Platzi', 'position': 'Technical Coach', 'language': 'python'}

Obtenemos un diccionario con los campos old y su valor correspondiente, segun la condicion establecida: {**{"old": worker["age"] > 70}}

{'old': True}

Como podemos ver, la edad de Facundo es 72 anios, por esa razon su valor es True

Finalmente, agregamos llave old en el diccionario de worker: {**worker, **{"old": worker["age"] > 70}}

{'name': 'Facundo', 'age': 72, 'organization': 'Platzi', 'position': 'Technical Coach', 'language': 'python', 'old': True}

Eduardo Gutiérrez Contreras

Uso Ubuntu 20.04 y me daba este error:
TypeError: unsupported operand type(s) for |: ‘dict’ and 'dict’
Y pues resulta que yo empecé acá macho alfa pelo en pecho todo empoderado haciendo el curso con mi instalación por default de Python en Ubuntu 20.04 (Xubuntu, para ser más preciso). Pero ¡oh sorpresa! Ubuntu 20.04 utiliza Python 3.8 y ni se te ocurra actualizarlo a 3.9 porque podrías romper algunos programas de Ubuntu. ¿Solución? Virtual Environments.
Y pues sí que se puede instalar Python 3.9 en Ubuntu 20.04, sólo que el intérprete se llama python3.9 en lugar de python3 (esto para no romper los paquetes que ya funcionan en Ubuntu hechos para la versión 3.8). Para no tener que escribir Python3.9 cada vez que ejecutemos nuestro código vamos a crear un entorno virtual con el nuevo intérprete, una vez instalado. Para instalarlo usamos:

sudo apt install python3.9 python3.9-venv

Ya con ello nos vamos a la carpeta en la que vamos a trabajar, inicializamos git si acaso no lo hemos hecho y si no hemos iniciado antes un venv podemos iniciarlo justo como Facundo nos enseñó, pero usando el intérprete de Python 3.9:

python3.9 -m venv venv

Peeero si estás como yo, que hizo todo desde antes con la versión 3.8, seguro ya tienes un directorio venv que creaste usando Python 3.8. Yo decidí renombrarlo para no tener problemas y poder seguir usando el alias que ya hicimos clases atrás (o también puedes eliminarlo para no tener que después agregar venv3.8 lo a tu .gitignore):

mv venv venv3.8

y ahora sí, a crear tu venv pero con el intérprete python3.9

python3.9 -m venv venv

actívalo usando el alias que hicimos en clases anteriores y listo:

avenv

Ya dentro del entorno virtual dale python3 -V y te debe de dar que estás usando la versión 3.9 (ojo la V es mayúscula)

(venv) $ python3 -V
Python 3.9.5

La parte más difícil de todo esto es que, partir de ahora, cada vez que crees tu entorno virtual, no debes olvidar usar python3.9
…
Ya por último, si utilizas el botoncito de “play” de Visual Studio Code para correr tus scripts de python (yo así soy de flojo), debes de cambiar el intérprete por default. En VS Code, presiona Ctrl+Shift+P y busca Preferences: Open User Settings
Ya estando ahí ahora busca python: default interpreter. Te debe de salir la ruta que es /bin/python3, simplemente cámbiala a /bin/python3.9 y listo.

¡Felices sesiones maratónicas de programación!

Daniel Eduardo Sosa Martin

def run():
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA ))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA ))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

    oll_people = [worker | {"oll": worker["age"] > 70} for worker in DATA]

    for worker in oll_people:
        print(worker)

if __name__ == "__main__":
    run()

R0Y3R

Map es util cuando quiero filtar un dato de algo es lo mas parecido al list comprehension sin condicional
Filter es util cuando quiero usar un operador logico para filtar los datos

Cesar Elías Armendariz Ruano

Código en pares:

all_python_devs

all_python_devs = [worker["name"]
                       for worker in DATA if worker['language'] == 'python']

all_python_devs = list(
        filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))

all_platzy_workers

all_platzy_workers = [worker['name']
                          for worker in DATA if worker['organization'] == 'Platzi']

all_platzy_workers = list(
        filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzy_workers = list(
        map(lambda worker: worker['name'], all_platzy_workers))

adults

adults = list(filter(lambda worker: worker['age'] >= 18, DATA))
    adults = list(map(lambda worker: worker['name'], adults))

adults = [worker['name'] for worker in DATA if worker['age'] >= 18]

old_people

old_people = list(map(lambda worker: worker | {
                      'old': worker['age'] > 70}, DATA))

 old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]

para recorrer cualquier variable

for worker in old_people:
        print(worker)

Fabricio Escalante Pérez

def challenge():
    all_python_devs = list(map(lambda worker: worker['name'], list(filter(lambda worker: worker['language'] == 'python', DATA))))

    all_platzi_workers = list(map(lambda worker: worker['name'], list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))))

    adults = [worker['name'] for worker in DATA if worker['age'] > 18]


    old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]

Santiago Valencia Valencia

user_deleted_1572741

👾 Completando la solución del filtrado de datos, usando filter, map y list comprehensions.

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]


def run():
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))
    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))

    old_people = list(filter(lambda worker: worker["age"] > 50, DATA))
    old_people = list(map(lambda worker: worker["name"], old_people))

    adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))

    print("- Python Developers -")
    for worker in all_python_devs:
        print(worker)

    print("\n- Platzi Workers -")
    for worker in all_Platzi_workers:
        print(worker)

    print("\n- Holds -")
    for people in old_people:
        print(people)

    print("\n- Adults -")
    for adult in adults:
        print(adult)


if __name__ == '__main__':
    run()

Alfonso Neil Jimenez Casallas

Uso del operador | (pipe) para unir diccionarios en Python

Christian Alvarenga

En la parte del primer high order function, en vez de poner solo print (worker) se puede poner print (worker [‘name’]) y con eso te tira solo los nombres de los mayores de edad.

Diego Armando Henao Rodríguez

Hola compañeros una ayuda por favor, porque me sale el siguiente error:

TypeError: unsupported operand type(s) for |: ‘dict’ and ‘dict’

Mi código es el siguiente:

def run():
all_python_devs = [worker[“name”] for worker in DATA if worker[“language”] == “python”]
adults = list(filter(lambda worker: worker[“age”] > 18, DATA))
adults = list(map(lambda worker: worker[“name”], adults))

# Agregar un diccionario al diccionario exitente con pipe |
old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))

for worker in all_python_devs:
    print(worker)

for worker in adults:
    print(worker)

for worker in old_people:
    print(worker)

if name == ‘main’:
run()

Danilo Huamani Zapata

hace 4 meses

RETO HIGH ORDER FUNCTION “all_python_devs”

    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    print("Reto High Order Function all_python_devs")
    for worker in all_python_devs:
        print(worker)

RETO HIGH ORDER FUNCTION “all_Platzi_workers”

    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))

    print("Reto High Order Function all_platzi_workers")
    for worker in all_Platzi_workers:
        print(worker)

RETO LIST COMPREHENSIONS - ADULTS

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

    print("Reto list comprehension Adults")
    for worker in adults:
        print(worker)

RETO LIST COMPREHENSIONS - OLD PEOPLE

old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]

print("Reto list comprehension Old_people")
for worker in old_people:
    print(worker)

Darwin Quiñones

Quiero compartir el reto y los ejercicios de la clase. Además hice uno de mi cuenta. Espero y sirva de ayuda.

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run(): 
    
    #list comprehension
    
    all_not_student_devs = [worker['name'] for worker in DATA if worker['position'] != 'Student']
    all_python_devs = [worker['name'] for worker in DATA if worker['language'] == 'python']
    all_platzi_workers = [worker['name'] for worker in DATA if worker['organization'] == 'Platzi']
    
    adults2 = [worker['name'] for worker in DATA if worker['age'] > 18]
    old_people2 = [worker['name'] for worker in DATA if worker['age'] > 70]
    
    #high functions
    all_python_devs2 = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs2 = list(map(lambda worker: worker['name'], all_python_devs2))
    
    all_platzi_workers2 = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers2 = list(map(lambda worker: worker['name'], all_platzi_workers2))
    
    all_old_devs2 = list(filter(lambda worker: worker['age'] >= 20, DATA))
    all_old_devs = list(map(lambda worker: worker['name'], all_old_devs2))
    
    
    adults = list(filter(lambda worker: worker['age'] > 18, DATA))
    adults = list(map(lambda worker: worker['name'], adults))
    
    # agregar una llave y un valor al dicionario 
    old_people = list(map(lambda worker: worker | {'old': worker['age'] > 70}, DATA))
    
    
    for worker in old_people2:
        print(worker)
    


if __name__ == '__main__': 
    run()

Antonio Demarco Bonino

Reto terminado. Aclaro que este símbolo “|” se hace con ALT + 124.

Código de las funciones:

def run():
    programers = list(filter(lambda worker: worker["language"] == 'python', DATA))
    prog_name = list(map(lambda worker: worker["name"], programers))
    platzi_workers = list(map(lambda worker: worker | {"tech": worker["language"] == 'python'}, DATA))

    officials = list(filter(lambda worker: worker["organization"] == 'Platzi', DATA))
    off_name = list(map(lambda worker: worker["name"], officials))
    platzi_workers_list = list(map(lambda worker: worker | {"company": worker["organization"] == 'Platzi'}, DATA))

    adults_people = [worker['name'] for worker in DATA if worker['age'] > 17]
    old_people = [worker['name'] for worker in DATA if worker['age'] > 70]


    for worker in prog_name:
        print(f'{worker} programa en Python')
    for worker in platzi_workers:
        print(worker)
    for worker in off_name:
        print(f'{worker} trabaja en Platzi')
    for worker in platzi_workers_list:
        print(worker)
    for worker in adults_people:
        print(f'{worker} es adulto mayor de 18 años')
    for worker in old_people:
        print(f'{worker} es un adulto mayor a 70')
if __name__ == '__main__':
    run()

Gabriel Missael Barco

Proyecto: filtrando datos.

Tenemos una lista con diccionarios sobre distintas personas. 👀
Cuando en Python colocamos una variable en mayúsculas, significa que no esperamos modificarla, esto es, es una constante ⛵.
El operador pipe | te permite unir un diccionario viejo con uno nuevo, y es un feature nuevo de python 3.9 🤯 (sumar diccionarios).

Solución al reto:

def main():
    all_python_devs = list(
        filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))

    all_platzi_devs = list(
        filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_devs = list(map(lambda worker: worker['name'], all_platzi_devs))

    adults = [worker['name'] for worker in DATA if worker['age'] > 18]
    old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]

    print(all_python_devs, all_platzi_devs, adults, old_people)

if __name__ == '__main__':
    main()

Julianhndz

Reto completado

def run():
    
    """all_python_devs usando High Order Functions filter y map"""
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    """all_platzi_worker usando High Order Funtions filter y map"""
    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], DATA))
    
    """adults usando list comprehensions"""
    adults =[worker["name"] for worker in DATA if worker["age"] > 18]
    
    """old people usando list comprehensions"""
    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]
    
    for worker in old_people:
        print(worker)

if __name__ == "__main__":
    run()```

Natalia Arteaga Corrales

hace 12 días

    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    old_people = [dict(worker, **{"old": worker["age"] > 70}) for worker in DATA ]

Augusto Huerta

hace 3 meses

También puedes usar dictinary methods para obtener los nombres de los trabajadores sin usar map .;D

adults = list(filter(lambda worker: worker['age'] <= 18,DATA))
for person in adults:
    print(person['name'], "es un adulto")

Juan Esteban Perdomo Santos

Esta es mi solucion

#!/usr/bin/env python3
from data import DATA

def main():
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['language'] == 'python', all_python_devs))

    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['organization'] == 'Platzi', all_platzi_workers))

    '''
    adults = list(filter(lambda edad: edad['age'] >= 18, DATA)) 
    adults = list(map(lambda worker: worker['name'], adults)) 

    old_people = list(map(lambda worker: worker | {'old': worker['age'] > 70}, DATA))
    '''


    adults = [worker['name'] for worker in DATA if worker['age'] >= 18]

    old_people = [worker | {'old': worker['age'] > 70} for worker in DATA]

    for i in old_people:
        print(i)


if __name__ == '__main__':
    main()

Sergio Alexander Cadena

def run():

print("All_python_devs")
all_python_devs = list(filter(lambda x: x["language"] == "python",DATA))
all_python_devs = list(map(lambda x : x["name"],all_python_devs))

for i in all_python_devs:
    print(i)

print("\nAll_Platzi_workers")
all_platzi_workers = list(filter(lambda x : x["organization"] == "Platzi",DATA))
all_platzi_workers = list(map(lambda x : x["name"],all_platzi_workers))

for i in all_platzi_workers:
    print(i)

print("\nAll_Adults")
all_adults = [i["name"] for i in DATA if i["age"] >= 18]
for i in all_adults:
    print(i)

print("\nOld_people")
# old_people = list(map(lambda x: x | {"old": x["age"] >= 70} , DATA))
old_people = [i | {"old": i["age"] >= 70} for i in DATA ]
print(old_people)

if name == “main”:
run()

Tatiana Rodriguez Cruz

hace 3 meses

Hola a todos, aquí esta mi solución:

    # Language
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = map(lambda worker: worker["name"], all_python_devs)

    # Platzi workers Op 1
    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = map(lambda worker: worker["name"], all_Platzi_workers)

    # Platzi workers Op 2
    all_Platzi_workers = list(map(lambda worker: worker | {"platzi_worker": worker["organization"] == "Platzi"}, DATA))
    all_Platzi_workers = list(filter(lambda worker: worker["platzi_worker"] == True, all_Platzi_workers))

    # old_people
    old_people = [ worker | {"old": worker["age"] > 70}  for worker in DATA ]

David Torres Guevara

My solution to the challenge:

def run():
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))
    print(all_python_devs)
    

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    print(adults)

    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]
    print(old_people)

    
if __name__=='__main__':
    run()

JCesar Mourinho

MI solución:
“all_python_devs” usando filter y map:

 all_python_devs = list(filter(lambda worker: worker["language"]  == "python", DATA)) 
    all_python_devs = list(map(lambda workers: workers["name"], all_python_devs))

“all_Platzi_workers” usando filter y map:

all_Platzi_workers = list(filter(lambda worker : worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))

“adults” usando list comprehensions:

 adults = [worker["name"] for worker in DATA if worker["age"] > 18]

“old_people” usando list comprehensions::

 old_people = [worker | {"old" :worker["age"] > 70 } for worker in DATA]

Francisco Antonio Rivera Viveros

mi resultado (🟥"TENGO EL DE OLD por si quieren saber como se hace"🟥)

List comprehensions

#Adults
adults_2 = [worker["name"] for worker in DATA if worker["age"] > 18]

#OLD 
old_people_2 = [worker | {"old": worker["age"] > 70 } for worker in DATA]

Explicare brevemente el como hice el OLD ☝️ primero tenemos un list comprehensions llevan el valor que guardaremos ciclo tras ciclo el ciclo y por último la condición en este caso no hay condición y el ciclo de nuestro caso en particular es simple solo es for worker in DATA es decir sería como un for i in range, pero en lugar del range es DATA y en lugar de i es worker pero es lo mismo luego viene lo difícil lo que casi no entendemos lo primero para poder entender esto es saber que es lo que tenemos y que es lo que queremos, en primer lugar sabemos que tenemos una lista de diccionarios es decir cada elemento de la lista en lugar de ser un número o una palabra es diccionario cada elemento y como sabemos un diccionario tiene claves y valores por ejemplo “name”: “Freddy” en este caso el name es la clave y freddy el valor nuestro diccionario puede tener mas y mas claves y valores entonces cada diccionario es apenas un elemento de la lista es como una monstruosidad ¿no?, en segundo lugar queremos que a cada diccionario se le agregue una clave y un valor mas es decir un “old” : True
la clave que queremos agregar es “old” y sus valores serán True o False será True si la persona tiene más de 70 años y false si tiene menos de eso, sabiendo que queremos y que tenemos pasemos al código ya sabemos que el for lo que hará es pasar una vez por cada uno de los diccionarios de la lista lo que le tenemos que decir o lo que nos falta decirle es que queremos que haga cuando pase por cada uno de los diccionarios y lo que queremos es agregar old y evaluar si es true o false entonces nuestra variable worker que también podría ser la letra “i” de toda la vida al momento de pasar por los diccionarios su valor va a ser un diccionario por lo tanto tenemos que encontrar la forma de agregar claves al diccionario, pero al menos yo no encontré como hacerlo de una forma sencilla así que , al menos la solución más fácil que yo encontré fue convertir la clave “old” en un diccionario así es esta clave sola sería un diccionario y esto lo hacemos poniendolo entre llaves así {“old”:True} y para saber si es False o true tenemos que utilizarla edad de la persona del diccionario que se encuentra en “age” por lo tanto usamos worker[“age”] o i[“age”] si estas utilizando i en lugar de worker y como lo que dijimos era que si es mayor de 70 el valor old sera true entonces lo podemos compara de esta manera worker[“age”] > 70 recordemos que worker[“age”] representa la edad o es la edad para convertir entonces old en un diccionario quedaria así {“old”: worker[“age”] > 70 } de esta manera nuestro diccionario dice lo siguiente para el diccionario actual si la edad es menor de 70 no es viejo u old es false y si es mayor de 70 es viejo u old es True ahora solo flata agregarlo a el diccionario actual por el que esta pasando nuestro cilo podemos sumar clos diccionarios con este simbolo “|” quedando así la sentencia work | {“old”: worker[“age”] > 17} ahora cada vez que nuestro ciclo pase por un diccionario lo que va a hacer es evaluar si old es true o false y agregarlo quedando nuestro list comprehensions asi [workwer | {“old”: workwer[“age”] > 17 for worker in DATA]

Si llegaste hasta aquí gracias por leerlo todo !

Filter Map

# Python Devs
all_python_devs_= list(filter(lambda worker : worker["language"] == 'python', DATA))
    all_python_devs = list(map(lambda worker : worker["name"], all_python_devs_2))


#Platzi Workers
all_platzi_workers = list(filter(lambda worker : worker["organization"] == 'Platzi', DATA))
all_platzi_workers = list(map(lambda worker : worker["name"], all_platzi_workers_2))

Nancho35

Codigo Organizado

#============================
    #   Python_devs and Platzi workers
    #============================
    #List Comprehension 
    all_python_devs = list([worker["name"] for worker in DATA if worker["language"] == "python"])
    all_Platzi_devs = list([worker["name"] for worker in DATA if worker["organization"] == "Platzi"])

    print ("********************** List Comprehension **********************")
    print ("* Python_devs *")
    print (all_python_devs)

    print (" * Platzi_devs *")
    print (all_Platzi_devs)

    print ("---------------------------------------------------------")
    #Filter Maps
    all_python_devs_filter = list(filter(lambda worker: worker["language"] == "python", DATA ))
    all_python_devs_map = list(map(lambda worker: worker["name"], all_python_devs_filter ))

    all_Platzi_devs_filter = list(filter(lambda worker:worker["organization"] == "Platzi",DATA))
    all_Platzi_devs_map = list(map(lambda worker: worker["name"],all_Platzi_devs_filter))

    print ("********************** Filter Maps **********************")
    print ("* Python_devs *")
    print (all_python_devs_map)

    print (" * Platzi_devs *")
    print (all_Platzi_devs_map)


    #============================
    #   Old people and adults
    #============================

    #List Comprehension 

    old_people_comprehension = list([worker["name"] for worker in DATA if worker["age"] > 70])
    all_adults_devs = list([worker["name"] for worker in DATA if worker["age"] >=  18])

    print ("********************** List Comprehension **********************")
    print ("* Old people *")
    print (old_people_comprehension)

    print ("* Adults *")
    print (all_adults_devs)

    #Filter Maps
    old_people = list(map(lambda worker: worker | {"old": worker["age"] >70},DATA))
    all_adults_devs = list(filter(lambda worker: worker["age"] >= 18,DATA))
    all_adults_devs_map = list(map(lambda worker: worker["name"] ,all_adults_devs))


    print ("********************** Filter Maps **********************")
    print ("* Old people *")
    print (old_people)

    print ("* Adults *")
    print (all_adults_devs_map)

alejandro cardenas

    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))
    adults = [worker['name'] for worker in DATA if worker['age'] > 18]
    old_people = [worker | {'old': worker['age']} for worker in DATA if worker['age'] > 70]
    old_people = [worker['name'] for worker in old_people]
    for workers in old_people:
        print(workers)

Fernutz

hace 7 meses

Así resolví el reto:

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]


def run():
    #Examples class

    #all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    #all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    #adults = list(filter(lambda worker: worker["age"] >18, DATA))
    # adults = list(map(lambda worker: worker["name"], adults))
    # old_people = list(map(lambda worker: worker | {"old":worker["age"] > 70}, DATA))

    # Reto
    all_python_devs = list(
        filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    all_platzi_workers = list(
        filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(
        map(lambda worker: worker["name"], all_platzi_workers))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]

    #Result 
    print("\n** For all python devs **")
    for worker in all_python_devs:
        print(worker)

    print("\n** For all Platzi workers **")
    for worker in all_platzi_workers:
        print(worker)

    print("\n** For old people **")
    for worker in adults:
        print(worker)

    print("\n** For adults **")
    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    run()

Para correrlo utilicé la versión 3.9 de Python

$ python3.9 filter_data.py
** For all python devs **
Facundo
Karo
Pablo
Lorena

** For all Platzi workers **
Facundo
Héctor
Gabriel
Isabella

** For old people **
Facundo
Luisana
Héctor
Gabriel
Isabella
Karo
Ariel
Pablo
Lorena

** For adults **
{'name': 'Facundo', 'age': 72, 'organization': 'Platzi', 'position': 'Technical Coach', 'language': 'python', 'old': True}
{'name': 'Luisana', 'age': 33, 'organization': 'Globant', 'position': 'UX Designer', 'language': 'javascript', 'old': False}
{'name': 'Héctor', 'age': 19, 'organization': 'Platzi', 'position': 'Associate', 'language': 'ruby', 'old': False}
{'name': 'Gabriel', 'age': 20, 'organization': 'Platzi', 'position': 'Associate', 'language': 'javascript', 'old': False}
{'name': 'Isabella', 'age': 30, 'organization': 'Platzi', 'position': 'QA Manager', 'language': 'java', 'old': False}
{'name': 'Karo', 'age': 23, 'organization': 'Everis', 'position': 'Backend Developer', 'language': 'python', 'old': False}
{'name': 'Ariel', 'age': 32, 'organization': 'Rappi', 'position': 'Support', 'language': '', 'old': False}
{'name': 'Juan', 'age': 17, 'organization': '', 'position': 'Student', 'language': 'go', 'old': False}
{'name': 'Pablo', 'age': 32, 'organization': 'Master', 'position': 'Human Resources Manager', 'language': 'python', 'old': False}
{'name': 'Lorena', 'age': 56, 'organization': 'Python Organization', 'position': 'Language Maker', 'language': 'python', 'old': False}

Diego Alejandro Estrada Navea

hace 7 meses

El símbolo “|” conocido como “pipe” es un nuevo feature de Python >3.9 en el cual puedas juntar dos diccionarios.

data = list(map(lambda elemento: elemento | {"nueva_llave": "nuevo_valor"}, iterable))

Victor Juan Jimenez Flores

Vengo de javascript y la verdad que estaba acostumbrado a combinar map y filter en una misma línea de forma fácil. Hacer esto en python lo veo más complicado, pero quedé enamorado de los list comprenhensions que me solucionan lo anterior 😁

Mi solución:

all_python_devs = list(map(lambda el1: el1["name"], filter(
        lambda el2: el2["language"] == "python", DATA)))

all_platzi_workers = list(map(lambda el1: el1["name"], filter(
        lambda el2: el2["organization"] == "Platzi", DATA)))

adults = [worker["name"] for worker in DATA if worker['age'] > 18]

old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]

Nelson Stevens Boada Muñoz

Franklin José González Viloria

Reto aceptado y realizado. Aunque no comprendo bien como funciona la list comprehensions en el caso de la lista old_people.
def run():
os.system(“cls”)
#
all_python_devs = list(filter(lambda worker: worker[“language”]==“python”,DATA))
all_python_devs = list(map(lambda worker: worker[“name”], all_python_devs))
all_platzi_workers = list(filter(lambda worker: worker[“organization”] == “Platzi”, DATA))
all_platzi_workers = list(map(lambda worker: worker[“name”], all_platzi_workers))
adults = [worker[“name”] for worker in DATA if worker[“age”] > 18]
old_people = [{**worker, **{“old”: worker[“age”] > 70}} for worker in DATA]
#
print(“Desarrolladores de Python:”)
for worker in all_python_devs:
print(worker)
print("")
print(“Trabajadores de Platzi:”)
for worker in all_platzi_workers:
print(worker)
print("")
print(“Mayores de 18 años:”)
for worker in adults:
print(worker)
print("")
print(“Añadir nueva llave (old:) al diccionario para aquellos mayores de 70 con true o false”)
for worker in old_people:
print(worker)

if name == ‘main’:
run()

DAVID EDUARDO BAEZ SANCHEZ

Reto

def run():

    # Comprehensions solutions
    #all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    all_python_devs =list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs=list(map(lambda worker: worker["name"],all_python_devs))

    #all_Platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    all_Platzi_workers = list(map(lambda worker: worker | {"work_platzi": worker["organization"] =="Platzi"}, DATA))

    #adults =  [worker["name"] for worker in DATA if worker["age"] > 18]
    #adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    #adults = list(map(lambda worker: worker["name"], adults))
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

    
    #old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))
    old_people =[worker["name"] for worker in DATA if worker["age"]> 70]


    print("Trabajadores que su lenguaje es Python")
    print("-------------------------------------")
    print("")
    for worker in all_python_devs:
        print(worker)

    print("")
    print("")
    print("Trabajadores de Platzi")
    print("-------------------------------------")
    print("")
    for worker in all_Platzi_workers:
        print(worker)

    print("")
    print("")
    print("Trabajadores Adultos")
    print("-------------------------------------")
    print("")
    for worker in adults:
        print(worker)

    print("")
    print("")
    print("Trabajadores Viejitos")
    print("-------------------------------------")
    print("")
    for worker in old_people:
        print(worker)

if __name__ == '__main__':
    run()

Emilio José Vargas Posada

Para las list y dict comprenhensions encerrarlas en los corchetes cuadrados ([list comprenhension]) es equivalente a encerrarla en la función list(list comprenhension) y de forma homóloga encerrar la dict comprenhension en ({ dict comprenhension }) es equivalente a encerararla en la función dict( dict comprenhension ), por si hay alguien al que se le dificulte entender esto, estos símbolos que las encierran son para declarar una lista o un diccionario.

Juan David Suarez

def filter_python():
    python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    for worker in python_devs:
        print(worker["name"])

def comprehension_adults():
    adults = [worker["name"] for worker in DATA if worker["age"] >= 18]
  for worker in adults:
        print(worker)

Max Alejandro Baldiviezo Morón

#all_pyhton_devs con HOF
    all_pyhton_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_pyhton_devs = list(map(lambda worker: worker["name"] , all_pyhton_devs))
#all_platzi_workers con HOF 
    all_pyhton_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_pyhton_workers = list(map(lambda worker: worker["name"], all_pyhton_workers))
#old_people list comprehemsion
    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]
#adults list comprehension
    adults = [worker["name"] for worker in DATA if worker["age"] > 18

Fernando Camacho

Este es el código que realice para resolver el reto que nos propuso el profesor

def run():
    # all_python_devs = [worker["name"] for worker in DATA if worker['language'] == 'python']
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    # all_Platzi_workers = [worker["name"] for worker in DATA if worker['organization'] == 'Platzi']
    all_Platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_Platzi_workers = list(map(lambda worker: worker['name'], all_Platzi_workers))
    # adults = list(filter(lambda worker: worker['age'] > 18, DATA))
    # adults = list(map(lambda worker: worker['name'], adults))
    adults = [worker['name'] for worker in DATA if worker['age'] > 18]
    # old_people = list(map(lambda worker: worker | {'old': worker['age'] > 70} , DATA))
    old_people = [worker['name'] for worker in DATA if worker['age'] > 70]

    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    run()

Oscar Ivan Vivas Reinoso

Hola, les comparto mi versión tratando de hacer el código mas legible:

    python_devs = lambda worker: worker["language"] == "python"
    only_name = lambda worker : worker["name"]
    all_python_devs = list(map(only_name, filter(python_devs, DATA)))

    Platzi_workers = lambda worker: worker["organization"] == "Platzi"
    all_Platzi_workers = list(map(only_name, filter(Platzi_workers, DATA)))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    old_people = [worker | { "old": worker["age"] > 70} for worker in DATA]

Juan Esteban Moreno Vergara

hace 14 horas

Les comparto la solución del reto

def run():
    
    all_python_devs = list(filter(lambda worker: worker["language"] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))
    
    all_platzi_devs = list(filter(lambda worker: worker["organization"] == 'Rappi', DATA))
    all_platzi_devs = list(map(lambda worker: worker["name"], all_platzi_devs))
    
    adults = [worker["name"] for worker in DATA if worker["age"] > 30 ]
    old_people = [worker | {"old": "TRUE"} for worker in DATA if worker["age"] > 30 ]
    
    for worker in old_people:
        print(worker)






if __name__ == '__main__':
    run()

Y les comparto las notas de la clase:

def run ():
    all_python_devs = [worker["name"] for worker in DATA if worker["language"] == 'python']  ## hacer una lista de un dictionario de trabajadores que usen python usando list comprehension.
    all_platzi_devs = [worker["name"] for worker in DATA if worker["organization"] == 'Platzi'] ## lo mismo de arriba pero con trabajadores de Platzi
    
    adults = list(filter(lambda worker: worker["age"] > 30, DATA))
    ## con esta high order function lo que estoy haciendo es hacer una lista con filter de cada worker = (es cada diccionario en DATA):
    ## si cumple la condición del iterable Data. "worker" va hacer referencia de cada diccionario de mi diccionario anidado. Filter compara la iteración true or false.
    
    adults = list(map(lambda worker:  worker["name"], adults))
    ## Aquí solo necesito traerme el nombre, entonces sobreescribo la variable con map que lo que hace en la función lambda es traerme la expressión y a comparación de filter
    ## filter que solo comopara la expressión en true or false. entonces en este caso pues me trae solo el worker["name"]
    
    old_people = list(map(lambda worker: worker | {"old": worker["age"] > 30}, DATA))
    ## Aquí lo que estamos haciendo es que con una high order function añadimos nueva información al diccionario apartir de el retorno de una función lambda (y map)
    ## por lo cual para cada worker (diccionario en DATA): a worker (cada diccionario)  |  (simbolo PIPE --> esto es adicionarle otra llave al diccionario)(para añdir listas es un +)
    ## abro llaves {"coloco el nombre de la nueva llave": y para cada llave de cada diccionario (worker) se guarde la operación realizada}, de DATA.
    ##
    
    
    for worker in old_people:
        print(worker)



if __name__ == '__main__':
    run()

Juan Pablo Cuenca Ludeña

hace un día

Comparto mis apuntes de la clase:

Jafet Pintle

Les dejo mi solución al reto!

def run():
    #Print all python devs
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs_names = map(lambda worker: worker["name"], all_python_devs)
    print("\nPYTHON DEVS")
    for employee in all_python_devs_names:
        print(employee)

    #Print all platzi workers
    all_platzi_worker = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_worker_names = list(map(lambda worker: worker["name"], all_platzi_worker))
    print("\nPLATZI WORKERS")
    for employee in all_platzi_worker_names:
        print(employee)
    
    #Print all the adults using list comprehension
    adults = [worker["name"] for worker in DATA if worker["age"]>=18]
    print("\nAdults")
    for worker in adults:
        print(worker)
    
    #Add a new value named "old" in each dictionary
    #| pipe operator used to join dictionaries (in a list we join use '+')
    old_people = [worker | {"old": worker["age"] >= 70} for worker in DATA]
    print("\nOld People confirmation")
    for worker in old_people:
        print(worker["name"], worker["age"] , worker["old"])

if __name__ == "__main__":
    run()

Luis Miguel Sierra

Mi respuesta al reto:

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]


def run():
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))
    adults = [worker['name'] for worker in DATA if worker['age'] >= 18]
    old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]
    

    for worker in old_people:
        print(worker)

if __name__ == '__main__':
    run()

Evander Nassem Ramírez Hernández

RETO COMPLETADO

def run():
    # all_devs_python = [worker["name"] for worker in DATA if worker["language"] == "python"]
    alldevs = list(filter(lambda worker: worker["language"] == "python", DATA))
    alldevs = list(map(lambda worker: worker["name"], alldevs))
    # all_Platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    allplatzi = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    allplatzi = list(map(lambda worker: worker["name"], allplatzi))
    # adults = list(filter(lambda worker: worker["age"] > 18, DATA)) 
    # adults = list(map(lambda worker: worker["name"], adults))
    all_adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    # old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))
    old_people = [worker["name"] for worker in DATA if worker["age"] > 70]

    for worker in alldevs:
        print(worker)
    for worker in allplatzi:
        print(worker)
    for worker in all_adults:
        print(worker)
    for worker in old_people: 
        print(worker)
    
if __name__ == "__main__":
    run()

Evander Nassem Ramírez Hernández

La primera vez que intenté el reto, no lo logré y me estresé. La segunda vez, repetí todas las clases y tampoco logré. Finalmente me fui a dormir y al dia siguiente lo logré sin problemas
Recomendacióm: No te presiones si en los primeros intentos no te funciona, simplemente date tú tiempo

Joan Camilo Chivata Sanchez

hace 4 días

Comprehensions solutions

#all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]

all_python_devs = list(filter(lambda worker:worker["language"] == "python",DATA))
all_python_devs = list(map(lambda worker:worker["name"],all_python_devs))

#all_Platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]

all_Platzi_workers = list(filter(lambda worker:worker["organization"] == "Platzi",DATA))
all_Platzi_workers = list(map(lambda worker:worker["name"],all_Platzi_workers))

#adults = list(filter(lambda worker:worker["age"] > 18, DATA))
#adults = list(map(lambda worker:worker["name"],adults))

adults =  [worker["name"] for worker in DATA if worker["age"] > 18]

#old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))

old_people_mayor = [worker | {"old": "true"}  for worker in DATA if worker["age"] > 70 ]
old_people_menor = [worker | {"old": "false"}  for worker in DATA if worker["age"] < 70 ]

old_people = old_people_mayor + old_people_menor

jhon freddy tavera blandon

hace 7 días

solucion al reto de la clase

from concurrent.futures.thread import _worker


DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]
def main():
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))
    adults = [worker['name'] for worker in DATA if worker['age'] > 18]
    old_confirmation = lambda worker_age: worker_age > 70
    old_people = [worker | {'old': old_confirmation(worker['age'])} for worker in DATA]

    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    main()

Byron Rosales Hernández

hace 8 días

Reto cumplido:

# Importe la lista con los datos para que estuviera más limpio el código
<from data_worker import DATA

def run():
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))
    for worker in all_python_devs:
        print(worker)
    

if __name__ == "__main__":
    run()>

Juan Carlos Villar Quintero

hace 9 días

RETO:

Sebastián Vilte

hace 9 días

#Completo
all_python_devs = list(filter(lambda worker: worker['language'] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    
    all_Platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_Platzi_workers = list(map(lambda worker: worker['name'], all_Platzi_workers))
    
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]
    
    for worker in old_people:
        print(worker)
        
<code>

Andres Gutiérrez Castillo

hace 9 días

problemas por tener un python desactualizado en tu venv ?
En mi caso tengo WSL2 con ubuntu 20.0.4 con python 3.8.1 por lo cual no podía ejecutar el comando “dict_1 | dict_2 ” que solo está disponible para python 3.9 así que para actualizar el python de mi ambiente virtual de venv tuve que actualizar el de todo mi ubuntu (SO) siguiendo el tutorial de la siguiente página y si funciono.
https://cloudbytes.dev/snippets/upgrade-python-to-latest-version-on-ubuntu-linux

Felipe Camacho Hurtado

hace 10 días

Hola, esta fue mi solución a los retos:

#RETOS FINALES

    #1. Crear la lista all_python_devs usando filter() y map()

    all_python_devs_reto = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs_reto = list(map(lambda worker: worker["name"], all_python_devs_reto))
    print(f'Los desarrolladores de python son: {all_python_devs_reto}')

    #2. Crear la lista all_Platzi_workers usando filter() y map()

    all_platzi_workers_reto = list(filter( lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers_reto = list(map(lambda worker: worker["name"], all_platzi_workers_reto))
    print(f'Los trabajadores en platzi son: {all_platzi_workers_reto}')

    #3 Crear la lista old_people con list comprehensions

    old_people_reto = list(worker | {"old": worker["age"] >=30 } for worker in DATA)
    print(f'El nuevo diccionario es {old_people_reto}')

    #4 Crear la lista adults con list comprehensions

    adults_reto = list(worker["name"] for worker in DATA if worker["age"] >= 18)
    print(f'Los miembros del equipo que ya cumplieron la mayoria de edad son: {adults_reto}')

Jose Delgado

hace 15 días

Aqui tarea aunque admito que en este caso en particular siento que el codigo es mucho menos entendible a la hora de leerlo, y al trabajar debemos realizar codigo que sean facil de leer y entener por nuestos co worker

def run():

	all_pythondevs = list(filter(lambda worker: worker["language"]== "python", DATA))

		all_pythondevs =list(map(lambda worker:worker["name"], all_pythondevs))

		all_platziworker = list(filter(lambda worker:worker["organization"]== "Platzi",DATA))

		all_platziworker =list(map(lambda worker:worker["name"],all_platziworker))

		adults = list(filter(lambda worker: worker["age"]>=18, DATA ))

		adults = list(map(lambda worker:worker["name"], ad

Ignacio Carlos Yañez Caamaño

hace 15 días

DATA = [
{
‘name’: ‘Facundo’,
‘age’: 72,
‘organization’: ‘Platzi’,
‘position’: ‘Technical Coach’,
‘language’: ‘python’,
},
{
‘name’: ‘Luisana’,
‘age’: 33,
‘organization’: ‘Globant’,
‘position’: ‘UX Designer’,
‘language’: ‘javascript’,
},
{
‘name’: ‘Héctor’,
‘age’: 19,
‘organization’: ‘Platzi’,
‘position’: ‘Associate’,
‘language’: ‘ruby’,
},
{
‘name’: ‘Gabriel’,
‘age’: 20,
‘organization’: ‘Platzi’,
‘position’: ‘Associate’,
‘language’: ‘javascript’,
},
{
‘name’: ‘Isabella’,
‘age’: 30,
‘organization’: ‘Platzi’,
‘position’: ‘QA Manager’,
‘language’: ‘java’,
},
{
‘name’: ‘Karo’,
‘age’: 23,
‘organization’: ‘Everis’,
‘position’: ‘Backend Developer’,
‘language’: ‘python’,
},
{
‘name’: ‘Ariel’,
‘age’: 32,
‘organization’: ‘Rappi’,
‘position’: ‘Support’,
‘language’: ‘’,
},
{
‘name’: ‘Juan’,
‘age’: 17,
‘organization’: ‘’,
‘position’: ‘Student’,
‘language’: ‘go’,
},
{
‘name’: ‘Pablo’,
‘age’: 32,
‘organization’: ‘Master’,
‘position’: ‘Human Resources Manager’,
‘language’: ‘python’,
},
{
‘name’: ‘Lorena’,
‘age’: 56,
‘organization’: ‘Python Organization’,
‘position’: ‘Language Maker’,
‘language’: ‘python’,
},
]

def run():
all_python_devs = [objeto[“name”] for objeto in DATA if objeto[“language”] == “python”]
all_platzi_workers = [worker[“name”] for worker in DATA if worker[“organization”] == “Platzi”]

workers = list(filter(lambda objeto: objeto[“language”] == “python”, DATA))
workers = list (map(lambda objeto: objeto[“name”], workers))

workerss = list(filter(lambda objeto: objeto [“organization”] == “Platzi”, DATA))
workerss = list(map(lambda objeto: objeto[“name”], workerss))

adults = list(filter(lambda objeto: objeto[“age”] > 18 , DATA) )
adults = list(map(lambda objeto: objeto[“name”], adults))

adultos = [objeto[“name”] for objeto in DATA if objeto[“age”] >= 18]

#for objeto in all_python_devs:

print(objeto)

#for objeto in all_platzi_workers:

print(objeto)

for objeto in adultos:
print(objeto)

if name ==‘main’:
run()

SoyCaballero

hace 18 días

Vale la pena aclarar que en el de old_people, lo que se está modificando en la comprehension list es el primer elemento, por eso el operador pipe | es utilizado en el primer elemento, antes del iterador. No hay necesidad de condicional porque no se está filtrando, solo mapeando, Hagan de cuenta que MAPEAR es modificar el elemento en la primera instrucción del comprehensive, y FILTRAR es el condicional

all_python_devs = [worker['name'] for worker in DATA if worker['language'] == 'python']
    all_python_devs_filter = list(filter(lambda worker : worker["language"] == 'python', DATA))
    all_python_devs_map = list(map(lambda worker : worker["name"] ,all_python_devs_filter))

    if all_python_devs == all_python_devs_map:
        print("DONE")

    all_platzi_workers = [worker['name'] for worker in DATA if worker['organization'] == 'Platzi']
    all_platzi_workers_filter = list(filter(lambda worker : worker['organization'] == 'Platzi' ,DATA))
    all_platzi_workers_map = list(map(lambda worker : worker["name"] ,all_platzi_workers_filter))
    
    if all_platzi_workers == all_platzi_workers_map:
        print("DONE")

    adults = list(filter(lambda worker: worker['age'] > 18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))

    adults_comprehension = [worker['name'] for worker in DATA if worker["age"] > 18]
    
    if adults == adults_comprehension:
        print("DONE")

    old_people = list(map(lambda worker: worker | {"old": worker['age'] > 70}, DATA))
    old_people_comprehension = [worker | {'old' : worker['age'] > 70} for worker in DATA]
    if old_people == old_people_comprehension:
        print("DONE")

Kevin Echenique

hace 22 días

    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers)) 

    adults =  [worker["name"] for worker in DATA if worker["age"]>18]
    old_people = [{**worker, **{'old': worker['age'] > 70}} for worker in DATA]

Sergy_EgH

hace 23 días

Aqui mi aportacion al reto en Python 3.9, convertir lo de los pips fue complejo para ello tuve que leer los comentarios, pero basicamente es usar la base de lo que nos muestran en clase y usar el ciclo for al final.

def run():
    all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    adults = list(filter(lambda age: age["age"] > 18,DATA))
    adults = list(map(lambda worker: worker["name"], adults))

    old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))
    # el pipe | aqui nos permite unir un proceso con otro, en este caso una lista con otra.
    # solo funciona en python 3.9 en adelante
    #for worker in old_people:
    #    print(worker)

    # Inversio a las funciones anteriores
    fos_python_devs = list(filter(lambda pydev: pydev["language"] == "python",DATA))
    fos_python_devs_names = list(map(lambda name: name["name"], fos_python_devs))

    fos_platzi_workers = list(filter(lambda plat_worker: plat_worker["organization"] == "Platzi", DATA))
    fos_platzi_workers_names = list(map(lambda name: name["name"], fos_platzi_workers))

    comprehension_adults = [adult["name"] for adult in DATA if adult["age"] > 18]
    comprehension_old_people = [old | {"old": old["age"] > 70 } for old in DATA]
    for age in comprehension_old_people:
        print(age)

if __name__ == '__main__':
    run()

Johan Suarez

hace 23 días

def run():
all_python_devs2 = list(map(lambda worker: worker [“name”],
all_python_devs2))
all_platzi_workers2 = list(filter(lambda worker: worker
[“organization”] == “Platzi” , DATA))
all_platzi_workers2 = list(map(lambda worker: worker[“name”],
all_platzi_workers2))

for worker in all_platzi_workers2:
print(worker)

if name == “main”:
run()

Matias Penel

hace 24 días

Reto completado 😃 🟢

		# list comprehensions
    all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    #filter y map
    all_python_devs2 = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs2 = list(map(lambda worker: worker["name"], all_python_devs2))

    # list comprehensions
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    #filter y map
    all_platzi_workers2 = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers2 = list(map(lambda worker: worker["name"], all_platzi_workers2))

    #filter y map
    adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))
    # list comprehensions
    adults2 = [worker["name"] for worker in DATA if worker["age"] > 18]

    #filter y map
    old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))
    # list comprehensions
    old_confirmation = lambda worker_age: worker_age > 70
    old_people2 = [worker | {'old': old_confirmation(worker['age'])} for worker in DATA]

    for worker in old_people:
        print(worker)```

Alejandro López

hace 24 días

min 8:18
solo agrega: 'name como índice de worker y no es necesario usar la funcion de o. s. map.

for worker in adults:
print(worker[‘name’]

Está bien que el profe te haga usar map como ejercicio pero como vimos no es necesario.

Walter Marvin Rodriguez Sanchez

hace 25 días

comparto mi codigo del desafio:

    #using hight functions
    all_python_devs= [worker["name"] for worker in DATA if worker["language"] == "python"]
    #using list comprenhension
    language1= list(filter(lambda worker: worker["language"] == "python", DATA ))
    language1= list(map(lambda worker: worker["name"], language1))

    #using hight functions
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    #using list comprenhension
    organization1= list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    organization1= list(map(lambda worker: worker["name"], organization1))


    #using list comprenhension
    adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    #keep only the name with map fuction
    adults = list(map(lambda worker: worker["name"], adults))
    #using hight functions
    all_adults_workers= [worker["name"] for worker in DATA if worker["age"] > 18]



    #create new valor old_people
    old_people= list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))


    # for worker in all_python_devs:
    #     print("python: ", worker)
        
    # for worker in all_platzi_workers:
    #     print("platzi: ", worker)

    # for worker in adults:
    #     print(">18: ", worker)

    for worker in language1:
        print("python: ", worker)

    for worker in organization1:
        print("platzi: ", worker)

    for worker in all_adults_workers:
        print("adults: ", worker)

David Duque Uribe

Mis respuestas
1)

<
all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
>

<
all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers))
>

<
adults = [worker for worker in DATA if worker['age']>18]

for worker in adults:
        print(worker['name'])
>

<
old_people = [worker for worker in DATA if worker['age']>70]

for worker in old_people:
print(worker['name'])
>

José Contreras

Lo hice de esta manera 😄

def run():

    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))
    
    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))

    
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    
    old_people = [worker | {"old": True} if worker["age"] > 70 else worker | {"old": False} for worker in DATA]

    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    run()

Gabriel Alvarez

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': 'Globant',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run():
    all_python_dev = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_dev = list(map(lambda worker: worker["name"], all_python_dev))
    
    all_globant_workers = list(filter(lambda worker: worker["organization"] == "Globant", DATA))
    all_globant_workers = list(map(lambda worker: worker["name"], all_globant_workers))
    
    adults = [worker["name"] for worker in DATA if worker["age"] > 20]
    
    old_worker = [worker["name"] for worker in DATA if worker["age"] > 69]
    
    # for worker in all_python_dev:
    #         print(worker)
    
    # for worker in all_globant_workers:
    #     print(worker)
    
    # for worker in adults:
    #     print(worker)
    
    for worker in old_worker:
        print(worker)



if __name__ == '__main__':
    run()

Gabriel Páez

mi aporte

#all_python_devs
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA ))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))
#all_platzi_workers
    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))
#adults
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
#old_people
    old_people = [{**worker, **{"old": worker["age"] > 70}} for worker in DATA]

Brayan Barroso

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run():
  all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
  all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
  adults = list(filter(lambda worker: worker["age"] > 18, DATA))
  adults = list(map(lambda worker: worker["name"], adults))
  old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))
  
  all_python_devs_filter = list(filter(lambda worker : worker ["language"] == "python", DATA))
  all_python_devs_map = list(map(lambda worker : worker["name"], all_python_devs_filter))
  
  all_platzi_workers_filter = list(filter(lambda worker : worker["organization"] == "Platzi", DATA))
  all_platzi_workers_map = list(map(lambda worker : worker["name"], all_platzi_workers_filter))

  adult = [worker["name"] for worker in DATA if worker["age"] > 18]

  for worker in adult:
    print(worker)

if __name__ == '__main__':
  run()

Anthony Carrillo

Acá esta mi humilde código, la verdad no supe como implementar lo ultimo de crear un nuevo diccionario con un nuevo criterio con list comprengetion, pero acá están todos los demas diccionarios con los filters, maps y list comprengetion invertidos.

def run():
## Lista de python devps con filter y map
    all_python_deps = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_deps = list(map(lambda worker: worker["name"], DATA))
    print("Todos los Python deps son:")
    print(all_python_deps)
## Lista de Platzi workers con filter y map
    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], DATA))
    print("Todos los Platzi workers son:")
    print(all_platzi_workers)
## Todos los mayores a 18 años con list comprengetion
    all_adults = [worker["name"] for worker in DATA if worker["age"] > 17]
    print("Todos los mayores de 18 son:")
    print (all_adults)

if __name__ == '__main__':
    run()

Roger Christian Cansaya Olazabal

Reto

    #RETO
     #ver trabajadores que usan lenguaje python usando filter y maps
    all_python_devs_r=list(map(lambda worker: worker["name"] ,filter(lambda worker: worker["language"]=="python",DATA)))   
    #ver trabajadores cuya organizacion es Platzi usando filter y maps
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    all_platzi_workers_r=list(map(lambda worker: worker["name"] ,filter(lambda worker: worker["organization"]=="Platzi",DATA)))
    #Trabajadores mayores de 18 años con list_comprehensions
    adults_r = [worker["name"] for worker in DATA if worker["age"] >= 18]
    #Trabajadors agregandole una nueva llave "old" si es mayor de 70 años
    old_people_r = [worker | {"old": worker["age"] > 70} for worker in DATA ] #solo Python 3.9
    
       
    print("-"*20+" Trabajadores que manejan Python" + "-"*20)
    for worker in all_python_devs_r:
        print(worker)    
    print("-"*20+" Ver Trabajadores de Platzi" + "-"*20)
    for worker in all_platzi_workers_r:
        print(worker)
    print("-"*20+" Ver Trabajadores mayores de 18 años" + "-"*20)
    for worker in adults_r:
        print(worker)
    print("-"*20+" Ver Trabajadores mayores de 70 años" + "-"*20)
    for worker in old_people_r:
        print(worker)

if __name__ == '__main__':
    run()

Kyle Yuzzyr Navarro

`    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    all_platzi_workers = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'], all_platzi_workers)) 

    adults = [worker['name'] for worker in DATA if worker['age'] > 18]

    old_people = [worker | {'old': worker['age'] > 70} for worker in DATA]

    for worker in old_people:
        print(worker)e>

Obed Pantoja Hernandez

Aquí comparto la forma en la que solucioné los retos

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run():
    #all_python_devs = [worker["name"] for worker in DATA if worker["language"]=="python"]
    all_pythoin_devs = list(filter(lambda worker: worker["language"]=="python", DATA))
    all_pythoin_devs = list(map(lambda worker: worker["name"], all_pythoin_devs))
    #all_Platzi_workers = [worker["name"] for worker in DATA if worker["organization"]=="Platzi"]
    all_Platzi_workers = list(filter(lambda worker: worker["organization"]=="Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))
    adults = list(filter(lambda worker: worker["age"]>18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))
    #old_people = list(map(lambda worker: worker | {"old": worker["age"]>70}, DATA))
    old_people = [worker | {"old": True if worker["age"]>70 else False } for worker in DATA ]
    for worker in old_people:
        print(worker)

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

Adrian Lara Gallardo

Reto Completado
Realicé en una sóla línea los comandos de map y filter, para “ahorrar” tiempo, sólo que puede llegar a revolverse un poco. Me di cuenta que la función de filter permite usar funciones condicionales, mientras que map, literalmente sólo mapea una lista y se puede realizar operaciones en sus datos.

En primer lugar hice el filter.
La lista de resultado es la que recibe map, junto a su operación de devolver los nombres
Los siguientes puntos fueron comprehensions y utilicé el pipe para crear un nuevo campo.

# Reto
def main(): 
	# Se tienen que usar dos procesos para regresar sólo los nombres que deseamos. 
	# var = list(map(lambda, list(filter(lambda,DATA))))

    all_python_devs= list(map(lambda worker: worker['name'],list(filter(lambda worker: worker['language']=='python',DATA))))
    all_platzi_workers = list(map(lambda worker: worker['name'],list(filter(lambda worker:worker['organization']=='Platzi',DATA))))
    adultos = [worker['name'] for worker in DATA if worker['age']>18]
    old = [worker | {'old': worker['age']>70} for worker in DATA]
    return all_python_devs, all_platzi_workers,adultos, old
main()

jesus piedrahita

organization_platzi = list(filter(lambda workers: workers[‘organization’] == ‘Platzi’, DATA))

organization_platzi = list(map(lambda workers: workers['name'], organization_platzi))

list_age = [worker['name'] for worker in DATA if worker['age'] > 18]

list_old = [worker | {'old': worker['age'] > 70} for worker in DATA]

Gustavo Velasco

#usando filter y map:

#all_python_devs = list(filter(lambda worker: worker["language"]=="python", DATA))
#all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

#all_platzi_worker = list(filter(lambda worker: worker["organization"]=="Platzi", DATA))
#all_platzi_worker = list(map(lambda worker: worker["name"], all_platzi_worker))

#usando list comprehensions:

adults = [worker["name"] for worker in DATA if worker["age"] > 18]
old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]
#for worker in all_python_devs:
#for worker in all_platzi_worker:
#for worker in adults:

for worker in old_people:
    print(worker)

Sebastian Marat Urdanegui Bisalaya

Reto 🤓

def run():
    #High Order Functions
    all_Python_Devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_Python_Devs = list(map(lambda worker: worker["name"], all_Python_Devs))
    for worker in all_Python_Devs:
        print(worker)

    all_Platzi_Workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_Workers = list(map(lambda worker: worker["name"], all_Platzi_Workers))
    for worker in all_Platzi_Workers:
        print(worker)
        
    #List Comprehensions
    old_People = [worker["name"] for worker in DATA if worker["age"] > 70]
    for worker in old_People:
        print(worker)
    
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    for worker in adults:
        print(adults)
    

if __name__ == '__main__':
    run()

Angel Vargas Manrique

# Comprehensions solutions
    # all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    # all_Platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    # adults =  [worker["name"] for worker in DATA if worker["age"] > 18]
    # old_people = [worker["name"] for worker in DATA if worker["age"] > 70]

# High order functions
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(filter(lambda worker: worker["name"], all_python_devs))

    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))

    adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))

    old_people = list(map(lambda worker: worker | {"old": worker["age"] > 70}, DATA))

    for worker in old_people:
        if worker["old"] == True:
            print(worker["name"])

davidtcl

#challenge

    _all_python_devs=list(filter(lambda worker: worker["language"]=="python", DATA))

    print("##### _all_python_devs #####")
    for worker in _all_python_devs:
        print(worker["name"])

    _all_platzi_workers = list(filter(lambda worker: worker["age"]>18, DATA))
    print("##### _all_platzi_workers #####")
    for worker in _all_platzi_workers:
        print(worker["name"])

    _adults = [worker["name"] for worker in DATA if worker["age"]>18]
    print("##### _adults #####")
    for worker in _adults:
        print(worker)

Oscar Piedrahita

from Data_filtrer import DATA

def run():
# all_python_devs= [ worker [‘name’] for worker in DATA if worker [‘language’] == ‘python’ ]
all_python_devs = list(filter(lambda worker: worker [‘language’] == ‘python’, DATA ))

# all_platzi_workers = [worker ['name'] for worker in DATA if worker ['organization'] == 'Platzi' ]
all_platzi_workers = list(map(lambda worker: worker ['organization'] == 'Platzi', DATA  ))

# adults = list(filter(lambda worker: worker['age'] > 18 , DATA))
adults = [worker for worker in DATA if worker['age'] > 18]

# adults=list(map(lambda worker: worker ['name'], adults))
adults = [worker['name'] for worker in adults ]

# old_people = list(map(lambda worker: worker | {'old': worker['age'] > 70}, DATA ))
old_people = [worker for worker in DATA if worker['age'] > 70 ]
# old_people = list(map(lambda worker: {**worker, **{"old": worker["age"] > 70}}, DATA))




# for worker in all_python_devs:
#     print(worker)

# for worker in all_platzi_workers:
#     print(worker)

# for worker in adults:
#     print( worker)

# for worker in old_people:
#     print(worker)

for worker in all_python_devs, all_platzi_workers, adults, old_people:
    print(worker)

if name == ‘main’:
run()

<code>

Carlos Tomás

 ## ------------------challlenge------------------------------------------------------------

    #challenge with high order functions---------------

    print()
    print("-------------CHALLENGE------------")

    all_python_devs_2 = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs_2 = list(map(lambda worker: worker["name"], all_python_devs_2))
    for worker in all_python_devs_2:
        print(worker)

    print()

    all_platzi_workers__2 = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers__2 = list(map(lambda worker: worker["name"], all_platzi_workers__2))
    for worker in all_platzi_workers__2:
        print(worker)

    #callege with list comprenhesion------------------
    adults_2 = [worker["name"] for worker in DATA  if worker["age"] > 18]
    for worker in adults_2:
        print(worker)
    
    print()

    old_people_2 = [worker | {"old": worker["age"]> 70 }for worker in DATA ]
    for worker in old_people_2:
        print(worker)

Julian David Colorado Jaramillo

Muchachos aqui comparto el codigo de como resolvi el reto

<##Reto Filtrado de trabajadores usando FILTER Y MAP

    ##                       Mapeo de los nombres            
    all_python_devs2 = list(map(lambda worker:worker["name"], 
    #                       Filtrado de los trabajadores que usan python
                            filter(lambda worker:worker["language"] == "python",DATA)))
    

    ##Reto de los trabajadores de platzi usando filter
    all_Platzi_workers2 = list(map(lambda worker:worker["name"], 
    #                          Filtrado de los trabajadores que usan python
                               filter(lambda worker:worker["organization"] == "Platzi",DATA)))
    
    ## LIST COMPREHENSION
    # Reto filtrado de los trabajadores mayores de edad 
    adults2 = [worker["name"] for worker in DATA if worker["age"] > 18]
    
    
    # Reto evaluacion si cada trabajador es mayor de 70. Si lo es agregar el tag old de tipo BOOL
    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA ]
    print(old_people)>

Marlon Adrian González Garzona

#Lista de empleados con high order functions
    all_python_devs_r =list(filter(lambda worker: worker["language"]=="python",DATA))

    all_python_devs_r =list(map(lambda worker:worker["name"],all_python_devs_r))

    all_platzi_workers_r=list(filter(lambda worker:worker["organization"]=="Platzi",DATA))

    all_platzi_workers_r=list(map(lambda worker:worker["name"],all_platzi_workers_r))

    #lista de empleados usando list comprehensions
    adults_r =[worker["name"] for worker in DATA if worker["age"]>18]

    old_people_r =[worker | {"old":worker["age"]>70} for worker in DATA ]

    old_people_r_name =[worker["name"] for worker in old_people_r if worker["old"]==True]

Martin Freire

def run():
    # filtramos el nombre de todos aquellos que dominen python. filtro con filter por lenguaje, y luego mapeo cada elemento para solamente muestre el nombre de cada trabajador
    all_python_devs = list(filter( lambda worker: worker['language'] == 'python' , DATA))
    all_python_devs = list(map(lambda worker: worker['name'] , all_python_devs))
    print(all_python_devs)

    #idem con todos los trabajadores de platiz:
    all_platzi_workers = list(filter( lambda worker: worker['organization'] == 'Platzi' , DATA))
    all_platzi_workers = list(map(lambda worker: worker['name'] , all_platzi_workers))
    print(all_platzi_workers)
    
    #idem para los trabajadores mayores de 18 años:
    adults = list( filter( lambda worker: worker['age'] >= 18 , DATA))
    adults = list( map(lambda worker: worker['name'] , adults) ) 
    print(adults)

    old_people = [worker['name'] for worker in DATA if worker['age'] > 70 ]
    print(old_people)

    adults = [worker['name'] for worker in DATA if worker['age'] >= 18 ]

Eder Raúl Abarca Raviela

Reto:

    # Obtenemos el nombre de todos los que saben python:    
    # Usando list comprehension:
    nombres =[n['name'] for n in DATA if n['language']=='python']
    # Usando filter y map:
    nombres2 = list(filter(lambda n: n['language']=='python' ,DATA)) 
    nombres2 = list(map(lambda x:x['name'], nombres2))

    # Obtenemos el nombre de todos los que trabajan en Platzi
    # Usando list comprehension
    all_platzi = [n['name'] for n in DATA if n['organization'] == 'Platzi']
    # Usando filter y map
    all_platzi2 = list(filter(lambda n: n['organization']=='Platzi' ,DATA)) 
    all_platzi2 = list(map(lambda x:x['name'], all_platzi2))
   
    # Filtramos a los trabajadores mayores de 18 años
    adults = list(filter(lambda x: x['age'] > 18, DATA))
    # Con map creamos una nueva lista que solo contiene el nombre y la edad 
    adults = list(map(lambda x: [x['name'], x['age']], adults))
    # Usando list comprehension
    adults2 = [[n['name'], n['age']] for n in DATA if n['age'] > 18]

    # Anexamos el campo old a DATA
    # Usando map
    old = list(map(lambda x:{**x,**{'old':x['age'] > 70}}, DATA))
    # Usando list comprehension
    old2 = [{**x,**{'old':x['age']>70}} for x in DATA]

Jhonatan Mackalister Duran Pinilla

Mi humilde aporte

from data_worker import DATA

def challenge():
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    all_Platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi",DATA))
    all_Platzi_workers = list(map(lambda worker: worker["name"], all_Platzi_workers))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]


    # for worker in all_python_devs:
    #     print(worker)

    # for worker in all_Platzi_workers:
    #     print(worker)

    # for worker in adults:
    #     print(worker)

    for worker in old_people:
        print(worker)


if __name__ == '__main__':
    challenge()

Oscar Andres Yusti Noriega

Mi proyecto realizado agregando algo de formato

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run():
    #*************************************************************************************************
    #Vamos a filtrar todos los trabajadores que saben de python.Lo hacemos con una list comprehension
    print("-----------------------------------------")
    print("TRABAJADORES QUE SABEN PYTHON")
    print("Utilizando List Comprehension")
    all_python_devs = [worker["name"] for worker in DATA if worker["language"] == "python"]
    print(all_python_devs)#Con este print tendremos en pantalla los resultados pero en forma de lista
    #Con este "for" veremos en pantalla los resultados sin tener forma de lista
    for worker in all_python_devs:
        print(worker)
    print("\n")

    #Ahora lo mismo pero con HOF (High Order Function)
    print("Utilizando HOF")
    all_python_devs_hof = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs_hof = list(map(lambda worker: worker["name"], all_python_devs_hof))
    for worker in all_python_devs_hof:
        print(worker)
    print("---------------------------------------\n")
    #**************************************************************************************************
    #Vamos a filtrar todos los trabajadores que trabajan en Platzi.Lo hacemos con una list comprehension
    print("TRABAJADORES QUE TRABAJAN EN PLATZI")
    print("Utilizando List Comprehension")
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"] == "Platzi"]
    print(all_platzi_workers)#Con este print tendremos en pantalla los resultados pero en forma de lista
    #Con este for veremos en pantalla los resultados sin tener forma de lista
    for worker in all_platzi_workers:
        print(worker)
    print("\n")

    #Ahora lo mismo pero con HOF (High Order Function)
    print("Utilizando HOF")
    all_platzi_workers_hof= list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers_hof = list(map(lambda worker: worker["name"], all_platzi_workers_hof))
    for worker in all_platzi_workers_hof:
        print(worker)
    print("---------------------------------------\n")
    #***************************************************************************************************
    #Ahora queremos saber cuantos devs son adultos (>18), pero lo haremos con la HOF "Filter" and "Map"
    print("TRABAJADORES ADULTOS")
    print("Utilizando HOF")
    adults = list(filter(lambda worker: worker["age"] > 18, DATA))
    adults = list(map(lambda worker: worker["name"], adults))
    
    for worker in adults:
        print(worker)
    print("\n")

    #Ahora haremos lo mismo pero con list_comprehension
    print("Utilizando List Comprehension")
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]
    print(adults)#Con este print tendremos en pantalla los resultados pero en forma de lista
    #Con este "for" veremos en pantalla los resultados sin tener forma de lista
    for worker in adults:
        print(worker)
    print("---------------------------------------\n")
    #*****************************************************************************************************
    #Ahora crearemos un item en los diccionarios donde evalue si la persona
    #tiene mas de 50 anos de edad. Esto lo haremos con la HOF "Map",pero debemos tener minimo python 3.9 para que el comando "pipe" funcione
    print("ASIGNAMOS UN NUEVO ITEM A LOS DICCIONARIOS DONDE SI TIENE MAS DE 50 ANOS NOS DICE SI ES TRUE O FALSE")
    print("Utilizando HOF")
    old_people = list(map(lambda worker: worker | {"old": worker["age"] > 50}, DATA))
    for worker in old_people:
        print(worker)
    print("\n")

if __name__== '__main__':
    run()

Fredy Alexander Rodríguez Chaparro

Profesor y compañeros buenas tardes, a continuación como son mis funciones del reto:

# reto

    name_python2 = list(filter(lambda worker: worker["language"] == "python", DATA))
    name_python2 = list(map(lambda worker : worker["name"],name_python2))

    name_platzi2 = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    name_platzi2 = list(map(lambda worker : worker["name"], name_platzi2))

    adult2 = [worker["name"] for worker in DATA if worker["age"] > 18]

    old_people2  = [worker | { "old" : worker["age"] > 70} for worker in DATA]

Noé Lozano Mendoza

Mi aporte, considero que esta bien simplificado c;

    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

    old_people = [worker | {"old" : worker["age"] > 70} for worker in DATA]

Derly Escobar

Mi Reto =)

#Reto
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker : worker["name"],all_python_devs))
    print(all_python_devs)

    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))
    print(all_platzi_workers)

    adults = [worker["name"] for worker in DATA if worker["age"] >= 18]
    print(adults)

    old_people = [worker | {"old" : worker["age"] > 70} for worker in DATA]
    for worker in old_people:
        print(worker)

Baldwin Monasterio

Filtrando Datos con listas comprimidas

DATA = [
{
‘nombre’: ‘Facundo’,
‘edad’: 72,
‘organizacion’: ‘Platzi’,
‘cargo’: ‘Technical Coach’,
‘lenguaje’: ‘python’,
},
{
‘nombre’: ‘Luisana’,
‘edad’: 33,
‘organizacion’: ‘Globant’,
‘cargo’: ‘UX Designer’,
‘lenguaje’: ‘javascript’,
},
{
‘nombre’: ‘Héctor’,
‘edad’: 19,
‘organizacion’: ‘Platzi’,
‘cargo’: ‘Associate’,
‘lenguaje’: ‘ruby’,
},
{
‘nombre’: ‘Gabriel’,
‘edad’: 20,
‘organizacion’: ‘Platzi’,
‘cargo’: ‘Associate’,
‘lenguaje’: ‘javascript’,
},
{
‘nombre’: ‘Isabella’,
‘edad’: 30,
‘organizacion’: ‘Platzi’,
‘cargo’: ‘QA Manager’,
‘lenguaje’: ‘java’,
},
{
‘nombre’: ‘Karo’,
‘edad’: 23,
‘organizacion’: ‘Everis’,
‘cargo’: ‘Backend Developer’,
‘lenguaje’: ‘python’,
},
{
‘nombre’: ‘Ariel’,
‘edad’: 32,
‘organizacion’: ‘Rappi’,
‘cargo’: ‘Support’,
‘lenguaje’: ‘’,
},
{
‘nombre’: ‘Juan’,
‘edad’: 17,
‘organizacion’: ‘’,
‘cargo’: ‘Student’,
‘lenguaje’: ‘go’,
},
{
‘nombre’: ‘Pablo’,
‘edad’: 32,
‘organizacion’: ‘Master’,
‘cargo’: ‘Human Resources Manager’,
‘lenguaje’: ‘python’,
},
{
‘nombre’: ‘Lorena’,
‘edad’: 56,
‘organizacion’: ‘Python Organization’,
‘cargo’: ‘Language Maker’,
‘lenguaje’: ‘python’,
},
{
‘nombre’: ‘Abel’,
‘edad’: 61,
‘organizacion’: ‘Casero’,
‘cargo’: ‘Aprendiz de Python’,
‘lenguaje’: ‘python’,
},
] # ;-D

def run():

# Lista de nombres de quienes trabajan con Python, usando primero el método
# 'list comprehesions' y luego los métodos 'filter' y 'map'
print("Lista de nombres relacionados con lenguaje Python usando 'list comprehesions':")
desarrolladores_python = [trabajador['nombre'] for trabajador in DATA if trabajador['lenguaje'] == 'python']
for personal in desarrolladores_python:
    print(personal)

print("\nCon 'filter' y 'map':")
desarrolla_python = list(filter(lambda trabajador: trabajador['lenguaje'] == 'python', DATA))
desarrolla_python = list(map(lambda trabajador: trabajador['nombre'], desarrolla_python))
for personal in desarrolla_python:
    print(personal)

# Lista de nombres de quienes trabajan en Platzi, usando primero el método
# 'list comprehesions' y luego los métodos 'filter' y 'map'
print("\nLista de nombres relacionados con organización usando 'list comprehesions':")
trabajadores_platzi =  [trabajador['nombre'] for trabajador in DATA if trabajador['organizacion'] == 'Platzi']
for personal in trabajadores_platzi:
    print(personal)

print("\nCon 'filter' y 'map':")
trabaja_platzi = list(filter(lambda trabajador: trabajador['organizacion'] == 'Platzi', DATA))
trabaja_platzi = list(map(lambda trabajador: trabajador['nombre'], trabaja_platzi))
for personal in trabaja_platzi:
    print(personal)

# Lista de nombres de quienes son adultos, usando primero el método
#  los métodos 'filter' y 'map' y luego 'list comprehesions'
print("\nLista de nombres de adultos usando 'filter' y 'map':")
adultos = list(filter(lambda trabajador: trabajador["edad"] > 18, DATA))
adultos = list(map(lambda trabajador: trabajador['nombre'], adultos))
for personal in adultos:
    print(personal)

print("\nCon 'list comprehesions':")
adultos =  [trabajador['nombre'] for trabajador in DATA if trabajador['edad'] > 18]
for personal in adultos:
    print(personal)

# Lista de nombres de quienes son mayores de edad, usando el método
# de 'list comprehesions'
print("\nLista de dccionarios con clave añadida de mayores de edad usando el 'list comprehesions':")
gente_mayor =  [trabajador['nombre'] for trabajador in DATA if trabajador['edad'] > 60]
for personal in gente_mayor:
    print(personal)

if name == ‘main’:
run()

Rodrigo Ivan Ullauri Guaranga

#Solucion al Reto.

<code> 
def run():
    i = 0

    print("""Colaboradores que dominan Python: 
    """)
    all_python_devs = list(filter(lambda worker: worker['language'] == 'python', DATA))
    all_python_devs = list(map(lambda worker: worker['name'], all_python_devs))
    for worker in all_python_devs:
        i = i+1
        print(i, '-', worker)
    i = 0

    print("""Colaboradores que trabajan en Platzi: 
    """)
    all_Platzi_workes = list(filter(lambda worker: worker['organization'] == 'Platzi', DATA))
    all_Platzi_workes = list(map(lambda worker: worker['name'], all_Platzi_workes))
    for worker in all_Platzi_workes:
        i = i+1
        print(i, '-', worker)
    i = 0

    print("""Colaboradores que mayores de edad: 
    """)
    old_people = [x['name'] for x in DATA if x['age'] > 18]
    for worker in old_people:
        i = i+1
        print(i, '-', worker)
    i = 0

    print("""Colaboradores que mayores de 70 anios: 
    """)
    adults_people = [x['name'] for x in DATA if x['age'] > 70]
    for worker in adults_people:
        i = i+1
        print(i, '-', worker)
    i = 0


if __name__ == "__main__":
    run()

Daniel Santos Quispe Condori

Como no se como actualizarme a python 3.9, y solo usando python 3.8 lo resolvi asi 😕

#El ejemplo del profee
adults = list(filter(lambda worker: worker["age"] > 18, DATA))
adults = list(map(lambda worker: worker["name"], adults))

Lo resumi asi, pero creo que es menos entendible, o talvez no…

all_python_devs = list(map(lambda worker: worker["name"], list(
		filter(lambda worker: worker["language"] == "python", DATA))))

all_Platzi_workers = list(map(lambda worker: worker["name"], list(
		filter(lambda worker: worker["organization"] == "Platzi", DATA))))

Brayan Andres Prado Casiano

Mi solución al reto:


    #GET All python devs - high functions
    all_python_devs_func = list(filter(lambda worker: worker["language"] == "python",DATA))
    all_python_devs_func = list(map(lambda worker: worker["name"],all_python_devs_func))
    #GET All workers from platzi  - high functions
    all_platzi_workers_func = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers_func = list(map(lambda worker: worker["name"], all_platzi_workers_func))
    #GET old_people - list comprehensions
    old_people_comp = [worker | {"old": True} for worker in DATA if worker["age"] > 70]
    #GET adults - list comprenhension
    adults = [worker["name"] for worker in DATA if worker["age"] > 18]

Javier Sanchez A

Mi codigo

marvinbatz

RETO:

   #obteniendo desarrolladores de python de Platzi con Hugh order functions
    all_python_devs = list(filter(lambda worker: worker["language"] == "python", DATA))
    all_python_devs = list(map(lambda worker: worker["name"], all_python_devs))

   #obteniendo trabajadores de Platzi con Hugh Order Functions
    all_platzi_workers = list(filter(lambda worker: worker["organization"] == "Platzi", DATA))
    all_platzi_workers = list(map(lambda worker: worker["name"], all_platzi_workers))


    #obteniendo adultos con List Comprehensions
    adults = [worker["name"] for worker in DATA if worker["age"] >= 18]

    #agregando nuevo valor "old" para cada uno de los datos con list comprehensions
    old_people = [worker | {"old": worker["age"] > 70} for worker in DATA]

Carlos Rivas

Listo 😄

José Orlando Llontop Arévalo

Reto cumplido, aquí el código:

DATA = [
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'Héctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]

def run():
    print("-----------------------------------------------------------------------------------")
    # Usando comprehensions:
    all_workers_py = [worker['name'] for worker in DATA if worker['language']=='python']
    print(all_workers_py)
    #Usando Funciones anónimas(lambda) y funciones de order superior(filter y map):
    all_workers_py_02 = list(filter(lambda worker: worker['language']=='python', DATA))
    all_workers_py_02 = list(map(lambda worker: worker['name'], all_workers_py_02))
    print(all_workers_py_02)
    
    print("-----------------------------------------------------------------------------------")

    # Usando comprehensions:
    all_workers_platzi = [worker['name'] for worker in DATA if worker['organization']=='Platzi']
    print(all_workers_platzi)
    #Usando Funciones anónimas(lambda) y funciones de order superior(filter y map):
    all_workers_platzi_02 = list(filter(lambda worker: worker['organization']=='Platzi', DATA))
    all_workers_platzi_02 = list(map(lambda worker: worker['name'], all_workers_platzi_02))
    print(all_workers_platzi_02)
    
    print("-----------------------------------------------------------------------------------")
    
    # Usando comprehensions:
    all_age_18 = [worker['name'] for worker in DATA if worker['age']>=18]
    print(all_age_18)
    #Usando Funciones anónimas(lambda) y funciones de order superior(filter y map):
    adults = list(filter(lambda worker: worker['age']>=18, DATA))
    adults = list(map(lambda worker: worker['name'], adults))
    print(adults)

    print("-----------------------------------------------------------------------------------")
    # Usando comprehensions:
    old_people = [worker | {'old': worker['age']>70} for worker in DATA]
    print(old_people)
    #Usando Funciones anónimas(lambda) y funciones de order superior(filter y map):
    old_people_02 = list(map(lambda worker: worker | {'old': worker['age']>70}, DATA))
    print(old_people_02)

if __name__ == '__main__':
    run()

Juan Carlos Tufino Bernuy

DATA = [ # que en el futuro de debe modificarse por lo que se deberia llamar constante mas no variable y todo por estar en mayuscula
    {
        'name': 'Facundo',
        'age': 72,
        'organization': 'Platzi',
        'position': 'Technical Coach',
        'language': 'python',
    },
    {
        'name': 'Luisana',
        'age': 33,
        'organization': 'Globant',
        'position': 'UX Designer',
        'language': 'javascript',
    },
    {
        'name': 'HÃ©ctor',
        'age': 19,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'ruby',
    },
    {
        'name': 'Gabriel',
        'age': 20,
        'organization': 'Platzi',
        'position': 'Associate',
        'language': 'javascript',
    },
    {
        'name': 'Isabella',
        'age': 30,
        'organization': 'Platzi',
        'position': 'QA Manager',
        'language': 'java',
    },
    {
        'name': 'Karo',
        'age': 23,
        'organization': 'Everis',
        'position': 'Backend Developer',
        'language': 'python',
    },
    {
        'name': 'Ariel',
        'age': 32,
        'organization': 'Rappi',
        'position': 'Support',
        'language': '',
    },
    {
        'name': 'Juan',
        'age': 17,
        'organization': '',
        'position': 'Student',
        'language': 'go',
    },
    {
        'name': 'Pablo',
        'age': 32,
        'organization': 'Master',
        'position': 'Human Resources Manager',
        'language': 'python',
    },
    {
        'name': 'Lorena',
        'age': 56,
        'organization': 'Python Organization',
        'position': 'Language Maker',
        'language': 'python',
    },
]



#Osea de cada conjunto(dediccionario) que va estar representado por x .
#Entendimiento; para poder iterar con un bucle mi diccionario serÃ¡ necesario colocarla dentro de una lista.
def run():
    
# =============================================================================
# Primer método(List-comprehension-Higher order functions)   
# =============================================================================
    all_python_devs = [worker["name"] for worker in DATA if worker["language"]=="python"]
    print("Desarrolladores de platzi:")
    print(all_python_devs)
    all_platzi_workers = [worker["name"] for worker in DATA if worker["organization"]=="Platzi"]
    print("Desarrolladores de platzi:")
    print(all_platzi_workers)
    print("\n"*2)
    #Usamos las funciones de orden superio con filter y map:
    adults = list(filter(lambda worker: worker["age"]>18 , DATA))#Supuestamente donde se va a iterar en DATA y quien va a ser cada unos de los valores worker(parámetro de la funcion anónima labmda) y lo que va a ser almacenados será justamanete mi worker la cual esta representando a cada unos de mis diccionarios 
    adults = list(map(lambda worker: worker["name"], adults))# Para map el la seccion de condicion significa que justo en esa parte que solo se almancenará.
    # !!! Para el caso de map lo que va a almacenar sencillamente es lo que va en la seccion de condicion.
    print("Trabajadores mayores de edad:")
    print(adults)
    print("\n")
    old_people = list(map(lambda worker : worker | {"old": worker["age"]>70}, DATA))
    print(old_people)# Para esta interesante funcion lo que va a suceder es que primero se va a almacenar cada uno de los diccionarios y ademas que se añadirá una nueva clave a cada uno de los diccionarios y teninedo como valor  True or False si se cumple tal condicion
    
    for new in old_people:
        print(new)
        
# =============================================================================
# Segundo método(Higher order functions- list-comprehension)   
# =============================================================================
    print("\n"*2, "---------------------------------------------------------")    
    alpydevs = list(filter(lambda worker: worker["language"]=="python", DATA)) #Con filter filtro en conjunto
    alpydevs = list(map(lambda worker : worker["name"], alpydevs))      #   y con map almaceno datos en especifico ya no con conjuntos
    print("Desarrolladores en python:")#Una vez que eh filtrado tengo que extraer los nombres
    print(alpydevs)
    
    alplatworkers = list(filter(lambda worker : worker["organization"]=="Platzi", DATA))
    alplatworkers = list(map(lambda worker : worker["name"], alplatworkers))
    print("Desarrolladores de platzi:")
    print(alplatworkers)
    
    print("\n")
    adults = [worker["name"] for worker in DATA if worker["age"]>18]
    print("Trabajadores mayores de edad:")
    print(adults)
    print("\n")
    old_people = [worker | {"old": worker["age"] > 70 } for worker in DATA]
    #Esta es la forma de como quiero guardarlos cada uno 
    for ol in old_people:
        print(ol)
        
    
        

if __name__=="__main__":
    run()

Daniel Carmona