Generadores

Clase 14 de 21 • Curso Profesional de Python

Contenido del curso

Introducción

Static Typing

Conceptos avanzados de funciones

Estructuras de datos avanzadas

Bonus

Conclusión

21
Completaste la trilogía. ¿Cómo seguir?
01:30 min

Tomar examen

Comentarios

Andrés Gutiérrez Arcia

student•

Yo uso generadores para retornar un resultado de una consulta en BigQuery. Como son muchísimos datos, es ideal iterar sobre el resultado de manera lazy

Fredy Garcia

student•

Hola Andrés que tal?, es muy interesante, me puedes compartir un ejemplo, por favor?

Julio Gutierrez

company_admin•

Tienes algún ejemplo? Saludos.

Miguel Angel Reyes Moreno

student•

Generadores

Sugar syntax de los iteradores. Los generadores son funciones que guardan un estado. Es un iterador escrito de forma más simple.

def my_gen():

  """un ejemplo de generadores"""

  print('Hello world!')
  n = 0
  yield n # es exactamente lo mismo que return pero detiene la función, cuando se vuelva a llamar a la función, seguirá desde donde se quedó

  print('Hello heaven!')
  n = 1
  yield n

  print('Hello hell!')
  n = 2
  yield n


a = my_gen()
print(next(a)) # Hello world!
print(next(a)) # Hello heaven!
print(next(a)) # Hello hell!
print(next(a)) StopIteration

Ahora veremos un generator expression (es como list comprehension pero mucho mejor, porque podemos manejar mucha cantidad de información sin tener problemas de rendimiento):

#Generator expression

my_list = [0,1,4,7,9,10]

my_second_list = [x*2 for x in my_list] #List comprehension
my_second_gen = ()x*2 for x in my_list]) #Generator expression

Luis Alejandro Vera Hernandez

student•

Gracias por el resumen

Javier Suárez Meerhoff

student•

gracias!

Pedro Alvarado Garcia

student•

En el minuto 5:44 más bien seria el doble, no el cuadrado.

Pablo Antipan Quiñenao

student•

Tenes razon Pedro! Seguramente al profesor se le fue un '*'. Con ello son efectivamente los cuadrados!

Christian Molina Vázquez

student•

Python internamente utiliza operaciones con generadores para aumentar el rendimiento. Tal es el caso de máx , min o sum. Ejemplo:

suma = sum([i for i in range(100)]) # Crea la lista en memoria.
suma_gen = sum(i for i in range(100)) #Itera sobre los valores.

El el primer caso, creamos una lista que no nos servirá y se termina guardando el espacio en memoria, en el segundo caso se itera cada valor hasta obtener el resultado sin la necesidad de guardar en memoria cada valor.

Giovanni Osorio

student•

no funciona, desde que se utiliza la función sum() for fuera de los [] o () se anula el generador y la lista

al utilizar

print(type(suma))
print(type(suma_gen))

>>>
<class 'int'>
<class 'int'>

Juan Antonio Aramburo Pasapera

student•

No es de que suma y suma_gen sean generadores, ambos son la suma de los primeros 100 números, es decir, enteros. Lo que pasa es que en suma_gen, la suma se hace sumando lo que va devolviendo el generador entonces no tienes que almacenar la lista. Mientras que en sum, primero creas la lista con list comprenhension y luego iteras sobre ella para hacer la suma. Entonces supongo que sum_gen será más eficiente, al menos en memoria.

Carlos José Tun Pinzón

student•

Generator Expression

Es lo mismo que un iterador pero escrito de forma más elegante.

Un "list comprehension" es una manera sencilla de implementar un ciclo el cual nos permite crear una nueva lista con elementos basados en los valores de una lista existente. Dicha lista creada almacena cada uno de estos nuevos valores.

A diferencia de un List comprehension que puede ocupar mucha memoria pues cada valor es almacenado en la variable, un Generator expression solo los recorre, sin guardarlos en una lista nueva. Permite traer un elemento a la vez cuando se recorra usando un ciclo for.

# Generator expression

my_list = [0, 1, 4, 7, 9, 10]

my_second_list = [x*2 for x in my_list] # List comprehension
my_second_gen = (x*2 for x in my_list)  # Generator expression

Como se puede ver en el ejemplo, la diferencia en la sintaxis únicamente es en el uso de paréntesis en lugar del uso de corchetes.

Ventajas de los Generadores:

Es mas fácil de escribir que un iterador
Ahorra Tiempo y Memoria
Permite guardar secuencias infinitas

Luis Kennedy Saavedra Fuentes

student•

Buenos días.

Mi script para ver la diferencia del tiempo al ejecutarse una list comprehension y un iterator expression

from datetime import datetime

LIST = [1, 2, 4, 5, 20, 100, 500, 1000]

def list_comprehension():
    """Function run as start"""
    time_start = datetime.now()
    list_comprehension = [x*2 for x in LIST]
    time_final = datetime.now()
    time = time_final -time_start
    print(f'Time for create list comprehension: {time}')
    
    print(f'list_comprehension: {list_comprehension}')
    return time


def generator_expression():
    """Function run as start"""
    time_start = datetime.now()
    generator_expression = (x*2 for x in LIST)
    time_final = datetime.now()
    time = time_final -time_start
    
    for i in generator_expression:
        print(i)

    print(f'Time for create generator espression: {time}')
    return time


def run():
    """Function run as start"""
    x = list_comprehension()
    y = generator_expression()
    print(f'Difference: {x - y}')


if __name__ == '__main__':
    run()

Luis Rivero

student•

También puedes hacer uso de un decorador:

from datetime import datetime
#decorador
def execution_time(func):
  def wrapper(*args, **kwargs):
    initial_time = datetime.now()
    func(*args, **kwargs)
    final_time = datetime.now()
    time_execution = final_time - initial_time
    second_execution = str(time_execution.total_seconds())
    print(f'El tiempo de ejecución fue de: {second_execution} segundos')
  return wrapper

@execution_time
def with_list_comprehension():
  my_list = [1,4,5,10,20,22,33,55]
  my_second_list = [x**2 for x in my_list]
  print(my_second_list)

@execution_time
def with_generator():
  my_list = [1,4,5,10,20,22,33,55]
  my_second_gen = (x**2 for x in my_list)
  print(next(my_second_gen)) #solo muestra 1

if __name__ == '__main__':
  with_list_comprehension()
  with_generator()

Jesús Velázquez Jiménez

student•

Los Generadores son iteradores con Sugar Syntax.

Yield es una palabra clave que se usa para retornar de una función sin destruir los estados de las variables locales y cuando se llama a la función, la ejecución comienza desde el último yield declarado. Toda función que contenga la palabra clave yield es denominada como un generador.

María Jimena Rodríguez Contreras

student•

gracias

Pablo Aquino

student•

yield, es similar a return, con la diferencia que la próxima vez que se llame a la función, esta continuará desde el último yield.
Un generador es similar a un iterador.

oscar yesid vargas pedraza

student•

si ejecutamos el siguiente código:

if __name__ == "__main__":
    my_list = [1, 2, 3, 4]
    new_list = [x for x in my_list]
    new_gene = (x for x in my_list)

    print(next(new_gene))
    print(next(new_gene))
    print(next(new_gene))
    print(next(new_gene))

obtenemos una secuencia de números

# 1
# 2
# 3
# 4

Al ejecutarlo así me fue mas fácil comprenderlo

Sebastián Andrade

student•

El codigo del generator expression podria programarse a modo de funcion asi?

def gen(arr):
	for i in arr:
		yield i**2

Pablo Antipan Quiñenao

student•

Hola! Encontré muy interesante tu código! Ahora bien, solo a modo de opinion, el profesor indica que la idea es NO emplear un array. Empleando tu misma idea, escribiría esto:

def c_gen(max=None):
    n = 0
    while n ** 2 < max:
        yield n ** 2
        n += 1

this_gen = c_gen(10)
for item in this_gen:
    print(item)

Saludos!!

Cesar Hernández Ramírez

student•

Me encantó lo que propuso @pablo, pero sí @sebastian, así sería la manera de programarse a manera de función, especialmente cuando trabajes con un array preestablecido y finito esa sería la manera de hacerlo, o si puedes replicar los datos de ese array con alguna formula en código, es ideal usar la manera que propone @pablo

Gabriel Missael Barco

student•

Generadores

Los iteradores tienen sugar syntax 💖. Son llamados generadores, los cuales son funciones que guardan un estado 🤔.

Los generadores son funciones: 🔥

def my_gen():
	"""Un ejemplo de generadores"""
	print("Hello world!")
	n = 0
	yield n 
	
	print("Hello heaven!")
	n = 1
	yield n

	print("Hello hell!")
	n = 2
	yield n

# Lo instanciamos
a = my_gen()
print(next(a)) # Hello world!
print(next(a)) # Hello heaven!
print(next(a)) # Hello hell!
print(next(a)) # StopIteration

yield este keyword es análoga al return, pero no termina la función, le pone pausa. La siguiente ejecución, corre después de este punto 👀.

Generator expression. 🤯 Se trae un elemento a la vez, y no ocupa toda la memoria 😯.

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

my_second_list = [x*2 for x in my_list] # List comprehension
my_second_gen = (x*2 for x in my_list) # Generator expression

La ventaja de los generadores es que es más fácil de escribir que un iterador, y tiene las mismas ventajas que este último. 💕

Giovanni Osorio

student•

lista de numeros impares VS generador de numeros impares

import time

impares = [2*i+1 for i in range(100)] # Crea la lista en memoria de numeros impares
impares_gen = (2*i+1 for i in range(100)) #Itera sobre los numeros impares 


print(impares)
print(type(impares))


print(impares_gen)
print(type(impares_gen))

for i in impares_gen:
    print(i)
    time.sleep(1)

Antonio Demarco Bonino

student•

¡Qué buen tema! Claramente el saber no ocupa lugar y una vez estudiado tenemos tres obligaciones: practicar, practicar y practicar... Siempre practicar.

Luis Alejandro Vera Hernandez

student•

Que alegria poder conocer este tema, simplifica mucho la sintaxis que la de un iterador

Ventajas de los Generadores:

Es mas fácil de escribir que un iterador
Ahorra Tiempo y Memoria
Permite guardar secuencias infinitas

Yeison Pachon Muñoz

student•

Algún ejemplo real donde se utilicen los generator?

Luis Kennedy Saavedra Fuentes

student•

Buenas noches. No me quedó muy claro. Generadores almacena o no? Al final dice que un generador puede almacenar secuencias, y antes dices que a diferencia de list comprehension, no almacena. O si me pueden aclarar un pcoo mas este punto por favor. Gracias.

Nicolás Arias González

student•

El generador almacena su estado interno, mas no almacena los datos como tal.

Suponiendo que tienes un generador que te devuelve X + 1, donde X es el número de veces que has llamado al generador. Internamente él almacenará el valor de X, no tiene la necesidad de "recordar" cuales fueron los valores generados anteriormente.

Por el contrario, cuando usas un list comprehension, te da como resultado una nueva lista con todos los valores que se generaron.

El resultado de esto es que un generador requiere menos memoria para operar que un list comprehension, ya que el primero almacena mucha menos información a la vez.

Cristian Collazos

student•

Un recurso que me sirvio bastante para entender a profundidad los generadores.

Reinaldo Mendoza

student•

Que cosa tan rara, nunca había visto ese yield, no se me ocurre por lo pronto una utilidad, pero seguro la debe tener, debe ser difícil acceder a una función que no sabes que va a retornar

Mateo Echavarria

student•

La principal diferencia entre List Comprehesion y Generator Expression además de los [ ] y ( ). Es que la List Comprehesion realiza todas las operaciones y luego de terminar muestra el resultado, mientras que el Generator Expression hace la operación solo si se le pide, y va una a una. ¿Es así?

Angel Mejia

student•

Los generadores ahorran memoria y tiempo de ejecución al obtener los elementos de la estructura (iterador) solo cuando se le solicite.

Carlos Esteban Lara Gil

student•

#APUNTES DE LA CLASE :snake:

Los GENERADORES son un "Sugar syntax" de los iteradores. Los generadores son funciones que guardan un estado.

Se usa yield el cual es como un return pero pausa la función hasta donde estaba el yield. Empieza desde donde se llamó el último yield, La función guarda un estado

def my_gen():
    """ Un ejemplo de generadores"""
    print('Hello world')
    n = 0
    yield n
    
    print("hello heaven")
    n = 1
    yield n
    
    print("hello hell")
    n = 2
    yield n
    
a = my_gen()

print(next(a)) 
print(next(a))
print(next(a)) 
print(next(a)) StopIteration

Cada vez que ejecuto next(a) el código ejecuta desde el yield donde está. Cuando se acaban los yield usamos el StopIteration

Generator expression

Trae un elemento a la vez cuándo se recorre

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

my_second_list = [x*2 for x in my_list]
my_second_gen = (x*w for x in my_list)

def my_gen():

  """un ejemplo de generadores"""

  print('Hello world!')
  n = 0
  yield n # es exactamente lo mismo que return pero detiene la función, cuando se vuelva a llamar a la función, seguirá desde donde se quedó

  print('Hello heaven!')
  n = 1
  yield n

  print('Hello hell!')
  n = 2
  yield n


a = my_gen()
print(next(a)) # Hello world!
print(next(a)) # Hello heaven!
print(next(a)) # Hello hell!
print(next(a)) StopIteration

from datetime import datetime

LIST = [1, 2, 4, 5, 20, 100, 500, 1000]

def list_comprehension():
    """Function run as start"""
    time_start = datetime.now()
    list_comprehension = [x*2 for x in LIST]
    time_final = datetime.now()
    time = time_final -time_start
    print(f'Time for create list comprehension: {time}')
    
    print(f'list_comprehension: {list_comprehension}')
    return time


def generator_expression():
    """Function run as start"""
    time_start = datetime.now()
    generator_expression = (x*2 for x in LIST)
    time_final = datetime.now()
    time = time_final -time_start
    
    for i in generator_expression:
        print(i)

    print(f'Time for create generator espression: {time}')
    return time


def run():
    """Function run as start"""
    x = list_comprehension()
    y = generator_expression()
    print(f'Difference: {x - y}')


if __name__ == '__main__':
    run()

from datetime import datetime
#decorador
def execution_time(func):
  def wrapper(*args, **kwargs):
    initial_time = datetime.now()
    func(*args, **kwargs)
    final_time = datetime.now()
    time_execution = final_time - initial_time
    second_execution = str(time_execution.total_seconds())
    print(f'El tiempo de ejecución fue de: {second_execution} segundos')
  return wrapper

@execution_time
def with_list_comprehension():
  my_list = [1,4,5,10,20,22,33,55]
  my_second_list = [x**2 for x in my_list]
  print(my_second_list)

@execution_time
def with_generator():
  my_list = [1,4,5,10,20,22,33,55]
  my_second_gen = (x**2 for x in my_list)
  print(next(my_second_gen)) #solo muestra 1

if __name__ == '__main__':
  with_list_comprehension()
  with_generator()

if __name__ == "__main__":
    my_list = [1, 2, 3, 4]
    new_list = [x for x in my_list]
    new_gene = (x for x in my_list)

    print(next(new_gene))
    print(next(new_gene))
    print(next(new_gene))
    print(next(new_gene))

def my_gen():
	"""Un ejemplo de generadores"""
	print("Hello world!")
	n = 0
	yield n 
	
	print("Hello heaven!")
	n = 1
	yield n

	print("Hello hell!")
	n = 2
	yield n

# Lo instanciamos
a = my_gen()
print(next(a)) # Hello world!
print(next(a)) # Hello heaven!
print(next(a)) # Hello hell!
print(next(a)) # StopIteration

import time

impares = [2*i+1 for i in range(100)] # Crea la lista en memoria de numeros impares
impares_gen = (2*i+1 for i in range(100)) #Itera sobre los numeros impares 


print(impares)
print(type(impares))


print(impares_gen)
print(type(impares_gen))

for i in impares_gen:
    print(i)
    time.sleep(1)

def my_gen():
    """ Un ejemplo de generadores"""
    print('Hello world')
    n = 0
    yield n
    
    print("hello heaven")
    n = 1
    yield n
    
    print("hello hell")
    n = 2
    yield n
    
a = my_gen()

print(next(a)) 
print(next(a))
print(next(a)) 
print(next(a)) StopIteration

Generadores

Introducción

¿Qué necesitas saber para tomar el curso?

¿Cómo funciona Python?

Cómo organizar las carpetas de tus proyectos

Static Typing

¿Qué son los tipados?

Tipado estático en Python

Practicando el tipado estático

Conceptos avanzados de funciones

Scope: alcance de las variables

Closures

Programando closures

Decoradores

Programando decoradores

Estructuras de datos avanzadas

Iteradores

La sucesión de Fibonacci

Generadores

Mejorando nuestra sucesión de Fibonacci

Sets

Operaciones con sets

Eliminando los repetidos de una lista

Bonus

Manejo de fechas

Time zones

Conclusión

Completaste la trilogía. ¿Cómo seguir?