Recordando generadores e iteradores

def my_gen():
    for i in range(1, 201):
        if i % 2 == 0:
            yield i

my_first_gen = my_gen()

for i in range(100):
    print(next(my_first_gen))```

Mi código:

def n_pairs():
    for i in range(1, 201):
        if i%2 == 0:
            yield i 
            print(i)
n_first_pairs = n_pairs()

for i in range(101):
    (next(n_first_pairs))

Además dejo este articulo en el que explican cuando usar yield o return. -->GeeksforGeeks

Mi versión del reto (usando expresiones generadoras)

# numero de elementos a generar
num_elements = 100

# Expreion generadora
# Es como una List Comprehension pero en vez de crear 
# una lista con todos los elementos de una vez
# los genera a medida que se le van pidiendo con next()
my_gen = (i for i in range(1, num_elements + 1) if i % 2 == 0)

#voy pidiendo cada elemento, uno a uno
print(next(my_gen))
print(next(my_gen))
print(next(my_gen))
print(next(my_gen))

Dato curioso: Aunque son muy parecidas la huella en memoria de una expresión generadora es significativamente menor que la de una una list comprehension.

from sys import getsizeof

my_list = [i**2 for i in range(100)]
my_genexp = (i**2 for i in range(100))

print("List: ", getsizeof(my_list))
print("GenExp: ", getsizeof(my_genexp))

## List:  920
## GenExp:  104

def numerosPares():
    for n in range(1,101):
        yield n*2

my_par = numerosPares()

while True:
    try:
        print(next(my_par))
    except:
        print('fin de la iteracion')
        break

Se puede usar list compehension para crear generadores:

numeros_pares = (x for x in range (0,101) if x % 2 == 0)
print(next(numeros_pares))

Creo que pago platzi solo por facundo. Es buenisimo

Usando dos for 😆

def my_gen_challenge():
    for i in range(2,201):
        if i % 2 == 0:
            yield i

my_second_gen = my_gen_challenge()

for i in range(100):
    print(next(my_second_gen))

Construyendo una lista con los primeros 100 números pares

def gen_pares(n):
  for i in range(2, 2 * n + 1, 2):
    yield i

pares_100 = list(gen_pares(100))
print(pares_100)

Tengo una duda porqué mi código compila los números del 2 al 98, pero si imprimo el primer next solito, me imprime 0

# Función para generar los números pares del 0 al 100
def my_gen():
    a = 0
    while a < 101:
        yield a
        a += 2
   
# Agignar el generador a una variable
my_generator = my_gen()

# Imprimir los resultados 
for item in my_generator:
    print(next(my_generator))

Hay mil formas de resolverlo. Esta fue la mía:

def numeros_pares(inicio, fin):
    for numero in range(inicio, fin):
        yield numero * 2


def run():
    for n in numeros_pares(1, 101):
        print(n)


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

¿Cómo funciona un for por detras?
python convierte la lista en un objeto iterable

my_list = [1, 2, 3, 4, 5]
my_iter = iter(my_list)
print(type(my_iter))

Se extraen los elementos usando la función next

print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
print(next(my_iter))
#cuando no hay más elementos devuelve un error de tipo StopIteration
print(next(my_iter))

Mientras que return detiene la ejecución de la función y destruye las variables locales yield es un return parcial que no las destruy y que cuando se llama de nuevo parte desde donde se quedó.

def my_gen():
    a = 1
    yield a

    a = 2
    yield a

    a = 3
    yield a


my_first_gen = my_gen()

print(next(my_first_gen))
print(next(my_first_gen))
print(next(my_first_gen))
#también devuelve un error de tipo StopIteration
print(next(my_first_gen))

wow viendo los aportes si que ocurren mejores ideas

   
my_gen2 =(x for x in range(0,101) if x%2==0 )



print(next(my_gen2))
print(next(my_gen2))

def my_func():
    lista = []
    for i in range(0,101):        
        if i % 2 == 0:
            lista.append(i)
            yield lista
   
   
my_gen = my_func() 

print(next(my_gen))
print(next(my_gen))
print(next(my_gen))
print(next(my_gen))

como resultado
[0]
[0, 2]
[0, 2, 4]
[0, 2, 4, 6]

Yo lo hice con List comprehension:

cien_pares = [x for x in range(0,101) if x % 2 == 0]
print(cien_pares)

Como para no olvidar, usamos un while:

my_list = []
for i in range(300):
    my_list.append(i)

my_iter = iter(my_list)


def odd(a):
    if (a % 2 == 0):
        return a
    return False


def my_func(list):
    count = 0
    while (count <= 100):
        result = odd(next(list))
        if (result):
            count += 1
            print(result)


gen = my_func(my_iter)

mi solución:

def even_number():
    for i in range(101):
        if i % 2 == 0:
            yield i

if __name__ == "__main__":
    for num in even_number():
        print(num)

Realicé el ejercicio de varias formas creando list comprehension directamente, una con condicional y otra sin condicional, luego si creé dos funciones allí les dejo el codigo si les puede ayudar perfecto y si tengo que corregir algo del codigo les agradeceria su aopyo!

#realice dos ejemplos para generar sin hacer una funcion con list comprehension

list_comprehension = [number*2 for number in range(1,51)]
#print (list_comprehension)

otra_list = [number for number in range(1,101) if number % 2 == 0]
#print (otra_list)

iterable_1 = iter(list_comprehension)
#print (iterable_1)
print ('*' * 10 + 'Primera manera sin funcion' + '*' * 10)
for i in range(len(list_comprehension)):
    print (next(iterable_1))

print ('*' * 10 + 'Segunda manera sin funcion' + '*' * 10)

iterable_2 = iter(otra_list)
for j in range(len(otra_list)):
    print (next(iterable_2))
#realice una funcion que genera inmediatamente un iterable con return
def my_gen():
    list_in_fun = [number for number in range(1,101) if number % 2 == 0]
    iterable_3 = iter(list_in_fun)
    return iterable_3
    

fun_iter = my_gen()
print ('*' * 10 + 'Tercera manera con funcion' + '*' * 10)
print (type(fun_iter))
for i in range(50):
    print (next(fun_iter))

def otra_fun():
    list_in_fun = [number for number in range(1,101) if number % 2 == 0]
    #iterable = iter(list_in_fun)
    for i in list_in_fun:
        yield i

prueba = otra_fun()
print ('*' * 10 + 'Cuarta manera con funcion' + '*' * 10)
for pares in range(50):
    print (next(prueba))

def pares():
    nmax = 0
    n = 0

    while nmax < 100:
        nmax += 1
        n += 2
        yield n

if __name__ == "__main__":
    for items in pares ():
        print( items)

 

def my_gen():
    for i in range(1, 101):
        if i % 2 == 0:
            yield i

my_first_gen = my_gen()

for i in range(100):
    print(next(my_first_gen))```

Yo evite usar for y use el ciclo while para poder iterar:

n = 100
def gen_chall(n):
    i = 0
    while i <= n:
        if i%2 == 0:
            yield i
        i += 1

my_chall = gen_chall(n)

j = 0
while j <= n//2:
    print(next(my_chall))
    j += 1

Dos formas:

def pair_generator(n=100):
    for i in range(1,n+1):
        yield(i*2)

class PairClass:
    def __init__(self, n = 100):
        self.n = n
    def __iter__(self):
        self.current = 0
        return self
    def __next__(self):
        self.current += 1
        if self.current < self.n:
            return self.current*2
        else:
            raise StopIteration

Estos dos dan el mismo resultado:

pair_instance = PairClass(n = 100)
print(list(pair_instance))
##################
print(list(pair_generator()))

def gen_number():
for i in range(100):
if i%2 == 0:
yield i

first_number = gen_number()

for number in first_number:
print(next(first_number))

buenos dias, aqui va mi aporte:

def my_gen():
    for i in range(0,201):
        if i % 2 == 0:
            yield i
    
gen_par = my_gen()

for i in range(0,101):
    print(next(gen_par))

def even_numbers():
    count = 0
    while True:
        if count % 2 == 0:
            yield count
        count += 1

if __name__ == "__main__":
    my_even_numbers = even_numbers()
    for i in range(100):
        print(next(my_even_numbers))

Codigo del reto sin utilizar el for para imprimir los resultados:

"""Generator that return the first 100 even numbers"""


def even_numbers_generator(total):
    count = 0
    num = 1
    while count < total:
        if num % 2 == 0:
            count += 1
            yield num

        num += 1


def run():
    print('Los primeros 100 números pares son:')
    my_gen = even_numbers_generator(100)
    while True:
        try:
            print(next(my_gen))
        except StopIteration:
            return


if __name__ == "__main__":
    run()

Mi código con el olvidado while

def my_gen(i):
    while i < 100:
        yield i
        i +=1
        
my_fake_iter = my_gen(0)

for i in my_fake_iter:
    print(next(my_fake_iter))

mi primer aporte 😃

def funpar():
    a = 2
    yield a
    
    while a <200:
        a += 2
        yield a
mypar = funpar()
b = 0
while b < 100:
    print(next(mypar))
    b += 1

num = 100

def pares(num=0):
    c = 0
    cantidad = 0
    while cantidad < num:
        if c % 2 == 0:
            cantidad += 1
            yield c
        c += 1

numero = pares(num)
while True:
    try:
        print(next(numero))
    except StopIteration:
        print("Termino")
        break

Mi aporte:

def pair_list():
    for i in range(2, 201, 2):
            yield i

gen = pair_list()

for i in range(1, 101):
    print(i, ': ', next(gen))

def my_gen():
for i in range(1,201):
if i % 2 == 0:
yield i

my_first_gen= my_gen()

for i in range (100):

print(next(my_first_gen))

reto

def even_numbers():
    a = 0
    yield a

    while a<100:
        a += 2
        yield a

my_gen = even_numbers()
for i in range(100):
    print(next(my_gen))

Comparto una posible solución usando la función range () y su parámetro de steps con algo de formato de en el print para una mejor lectura:

def first_100_even():

    for i in range(0,1000,2):
        if i == 0:
            pass
        else:
            yield i


iterator = first_100_even()

for i in range(1,101):
    print('Counter: ',i, ' - Even Number: ', next(iterator))

Aquí mi solución

def generator():

    for i in range(1, 1000):
        if i % 2 == 0:
            yield i
            
generador_2 = generator()
c = 1
for i in range(100):
    print(next(generador_2), ' : ', c)
    c += 1
    

en el tema platzi de vsc ya te dice que no retornará todo xD

def get_number_pair(max_number):
    for i in range(1, max_number):
        if i % 2 == 0:
            yield i


for number_pair in get_number_pair(200):
    print(number_pair)

def gen_first_100_odd_numbers(x):
    i = x * 2
    yield i

for i in range(1, 100):
    print(next(gen_first_100_odd_numbers(i)))

This is my solution.

def pair_numbers():
   i = 2
   while True:
      yield i
      i+=2

pair_numbers_100 = pair_numbers()

for i in range(100):
   print(next(pair_numbers_100))

# Función que genera el generador
def my_gen():
	for i in range(0, 201,2):
		yield i

# Se almacena el generador 
gen = my_gen()

# Se imprime por consola el resultado
for i in range(100):
	print(next(gen))

_challenge completed _

def my_generator_pairs():
for i in range(1,101):
if (i%2==0):
yield i

pairs=my_generator_pairs()
while True:
try:
print(next(pairs))
except StopIteration:
break

Reto:

def generador():
    x=0
    while True:
        if x%2==0 and x<=100:
            yield x
            x+=1
        elif x%2!=0 and x<=100:
            x+=1
            continue
        elif x==101:
            return False

def run():
    pares=generador()
    for element in pares:
        print(element)


if __name__=='__main__':
    run()

Según yo, la intención era no usar for loop pero bueno, creo me perdí en esa parte. Como sea, con bucle for, este es mi código:

<code> 
def pairs():
    for p in range(2, 100):
        if p % 2 == 0: 
            yield p

saved_pairs = pairs()

print(next(saved_pairs))
print(next(saved_pairs))
print(next(saved_pairs))
print(next(saved_pairs))
print(next(saved_pairs))
print(next(saved_pairs))

def my_gen():
    for i in range(101):
        if i %2 ==0:
            yield i

my_first_gen = my_gen()

for i in my_first_gen:
    print(next(my_first_gen))

lista = []
def definirNumerosPares(valorIngreso):
if valorIngreso % 2 == 0 :
yield valorIngreso
yield

x = range(1,101)

for i in x:
valor = next(definirNumerosPares(i))
if valor is not None:
lista.append(valor)

print(lista)

def gen_par():
    count = 0
    while True:
        count += 2
        yield count

my_var_gen = gen_par()
for i in range(100):
    print(next(my_var_gen))

++Reto cumplido ++

rango = range(0,101)

def functionPar():
    for elemento in rango:
        if elemento % 2 == 0:
            yield elemento

numerosPar = functionPar()

for elemento in rango:
    print(next(numerosPar))

mi aporte del reto del profe

def my_2gen():
    for a in range (1, 201):
        if a%2 == 0:
            yield a 
    
my_second_gen = my_2gen()

for i in range(100):
    print(next(my_second_gen))

def num_pares(num):
    numeros = [i for i in range(num)]
    for i in numeros:
        if i%2 == 0:
            yield i 


if __name__ == '__main__':
    n = 201
    n_pares = num_pares(n)

    while True:
        try:
            print(next(n_pares))
        except:
            break

def my_gen():
    for i in range (1,101):
        if i %2 == 0:
            yield i



if __name__ == '__main__':
    my_first_gen = my_gen()
    for element in my_first_gen:
        print(element)

my solución al desafio

def n_pairs():
    for i in range(2, 103, 2):
        yield i
        print(i)

n_first_pairs = n_pairs()

for i in range(51):
    (next(n_first_pairs))

Dejo mi solución
Saludos

# Cien primeros números pares con una función que hace de generador

def cien_pares():
    for i in range(1,101):
        if i%2 == 0:
            yield i

pares_gen_1 = cien_pares()

for num in pares

#Cien primeros números pares con un Generator Expresión
pares_gen_2 = (i for i in range(1,101) if i%2 == 0)
print(type(pares_gen_2))
for i in pares_gen_2:
    print(i)

Para recordar mejor que con los generadores se utiliza la built-in function next() => Generation next.
El comercial de pepsi del '97 con las spice girls

Link al video https://www.youtube.com/watch?v=Sry0XhET3oc

![](

Solución al reto:

def pair_num():
    n = 0
    while n != 100:
        n += 2
        yield n        

if __name__ == '__main__':
    pair_num_list = pair_num()
    for element in pair_num_list:
        print(element)

Un Generador puede parecer que es algo raro, pero en realidad se utiliza exactamente igual que otras estructuras de datos en Python (como list, dict o set); por lo que podremos obtener los datos de un Generador utilizando un bucle “for”

El Generador de datos permitirá un flujo de datos (o Streaming) en tiempo real y tener cada uno de los datos solo cuando necesite ser consumido (procesados o utilizados por una persona). Adicionalmente, será muy importante para garantizar un trabajo óptimo y equilibrio entre el procesado de datos (procesador) y la memoria principal (la memoria RAM) de cualquier máquina.

Algo así:

def my_gen():
    for i in range(1, 201):
        if i % 2 == 0:
            yield i

my_first_gen = my_gen()

for i in range(100):
    print(next(my_first_gen))

mi solución es esta

def my_gen():
    for i in range(100):
        yield i*2


def run():
    for e in my_gen():
        print(e)


if __name__ == '__main__':
    run()

Mi forma:

def gen_pares():
    a = 1
    for i in range(100):
        if a % 2 == 0:
            yield a
        a += 1

pares = gen_pares()

print(next(pares))
for i in range(49):
    print(next(pares))

Si como yo no tenías idea de lo que es una función Built-in, te comparto la documentación de python en español en este link.
Prácticamente una Función Built-in es una función que siempre está disponible, sin la necesidad de importar ningún modulo

Hola, comparto mi código que imprime en la terminal los primeros 100 números pares.

def my_gen():
    i = 0
    while  True:
        if(i%2 == 0): 
            yield i
        i += 1

generator = my_gen()

for i in range(100):
    print(next(generator))

Reto con función recursiva:

def my_gen2(number, counter):
    if counter < number:
        if counter % 2 == 0:
            yield counter
        yield from my_gen2(number, counter+1)


my_second_gen = my_gen2(201, 1)

for i in range(100):
    print(next(my_second_gen))

RETO

def my_gen(nums=None):
    counter = -1
    while not nums or counter < nums-1:
        counter += 1
        yield counter*2

my_first_gen = my_gen(nums=100)
for i in my_first_gen:
    print(i)

Reto

def even_numbers_gen(max=None):
    x_number = 0
    for x in range(0, int(max/2)):
        x_number = x_number + 2 
        yield x_number

max_number = 100
even_number_iter = even_numbers_gen(max_number)

for _ in range(0, max_number):
    print(next(even_number_iter))

#Iterando los 100 primeros números pares
def num_pairs():
for i in range(2, 201):
if i%2 == 0:
yield i
#print(i)
num_pairs_100 = num_pairs()
#Imprimiendo los números pares almacenados
for i in range(101):
print(next(num_pairs_100))

Este es mi código para un generador de un X número de pares dado por el usuario.

import time

def pares_gen(num_pares):
    counter = 0
    n1 = 0

    while True:
        if counter < num_pares:
            if counter == 0:
                counter += 1
                yield n1
            else:
                par = n1 + 2
                n1 = par
                counter += 1
                yield par
        else:
            raise StopIteration


if __name__ == '__main__':
    pares = pares_gen(5)
    for element in pares:
        print(element)
        time.sleep(0.5)

def even_numbers():
    n=1
    while 1:
        yield 2*n
        n+=1

iter_even_number=even_numbers()

for i in range(100):
    print(next(iter_even_number))

Resumen
■■■■■■■

Los generadores son funciones que retornan un conjunto de elementos iterables llamados así porque provienen de las estructuras iterables de python como (listas, tuplas, diccionarios) por debajo, python toma a estas estructuras de datos y las convierte en un iterador que si se puede recorrer. Se dice que hacen un proceso llamado yielding

• Mantiene estados: Los generadores son muy útiles en el momento de recorrer DataSets muy largos. Especialmente cuando la memoria y performance es importante. Las funciones generadoras no cortan la ejecución con yield así como cortan la ejecución cuando se usa return, así es que guarda los estados.

• Lazy evaluation: La eficiencia de iterar en modo lazy es mejor. Un generador es como un generador de tiquetes, este no impirme todos, solo uno a la vez. Este incrementa siempre al otro valor.

• Usa método Next(iterador): Toma un item uno a la vez.

Los generadores son eficientes en el momento de iterar porque no contempla todos los datos a la vez si no uno a uno. Es decir en teoría es posible contar hasta infinito. Los generadores permiten crear iteradores que son los objetos recorribles1

lista= [1,2,3]
my_iter = iter(lista)

print(next(my_iter)) #1
print(next(my_iter)) #2
print(next(my_iter)) #3
print(next(my_iter)) # ErrorStopIteration

Crearemos un generador que cuente los 100 primeros números.

# Retorna la lsita con todos los valores
def count_to():
    yield [n for n in range(0,101) if n%2 ==0]
   
        
if __name__ == '__main__':
    i = count_to()
    print(next(i)) # Lista
    print(next(i)) # Error StopIteration
    

Notas:

• Para construir un iterador es importante tener en cuenta los Protocolos de iteradores.

• En usos más avanzados los generadores me permitirán construir cosas como Corutinas, Pipelines e inclusive usarse como Manejadores de Contexto muy eficientes

def first_one_houndred_numbers(x):
    x+=2
    yield x

if __name__ == '__main__':
    a = 0 #pivote para ir imprimiendo los pares
    i = 0 #contador de la cantidad de impresiones
    while(i<100):
        a = next(first_one_houndred_numbers(a))
        print(a)
        i+=1

def my_gen():
    for i in range(1, 101):
        if i % 2 == 0:
            yield i


pairs_numbers = my_gen()

for i in range(50):
    print(next(pairs_numbers))

Aquí les comparto mi código:

def my_gen():
    for i in range(0,101,2):
        yield i

my_first_gen = my_gen()

for i in range(51):
    print(next(my_first_gen))

Acá les dejo mi código:

def my_gen():
    iterator = [i for i in range(1, 202) if i%2 == 0]
    for i in iterator:
        yield i


def run():
    my_first__gen = my_gen()
    list = [1, 2, 3, 4, 5]
    for i in my_first__gen:
        print(next(my_first__gen))


if __name__ == '__main__':
    run()

def my_generator():
	for i in range(1, 201):
		if i % 2 == 0:
			yield i

my_first_generator = my_generator()

for i in range(100):
	print(next(my_first_generator))

Mi respuesta al desafío

<code>
def my_gen(n):
    for i in range(2,n+2,2): #Numeros pares Naturales
        yield i


if __name__ == '__main__':
    
    even_number_quantity = int(input("Cuántos numeros pares se desea buscar? "))
    
    my_first_gen = my_gen(even_number_quantity * 2)
    list_of_even_numbers = []
    for i in range(even_number_quantity):
        list_of_even_numbers.append(next(my_first_gen))
    
    print (list_of_even_numbers) 

<def my_gen():
    for i in range(1, 201):
        if i % 2 == 0:
            yield i
            print(i)

n_first_pairs = my_gen()

for i in range(101):
    (next(n_first_pairs))>

def my_gen():
    for i in range(1,51):        
            yield (i*2)


my_first_gen = my_gen()
for i in range(50):
    print(next(my_first_gen))

Acá dejo mi código

def gen_pair():
    leng=0
    i=1
    while leng<100:
        if i%2==0:
            leng+=1
            yield i
        i+=1

gener=gen_pair()

print(next(gener))
print(next(gener))
print(next(gener))```

def my_gen():
    for e in range(201):
        if e%2 == 0:
            yield e

generador = my_gen()

for i in range(101):
    print(next(generador))```

Reto:

def gen_even():
    for a in range(2, 201, 2):
        yield a

my_second_gen = gen_even()

for i in range(100):
    print(next(my_second_gen))

¿Porque es necesario asignar a una variable la función generadora? al asignarla a la variable y “llamarla” con (), ¿no se estaría ejecutando la primera vez?

`def pair_numbers_gen():
a = 0
while a <= 200:
a += 1
if a % 2 == 0:
yield a

my_pair_numbers = pair_numbers_gen()

for pair in my_pair_numbers:
print(pair)`

def pair_numbers_gen():
    a = 0
    while a <= 200:
        a += 1
        if a % 2 == 0:
            yield a


my_pair_numbers = pair_numbers_gen()

for pair in my_pair_numbers:
    print(pair)

Lectura complementaria de generadores e iteradores del Prof. David Aroesti

Hola, lo deje bastante dinámico:

Cambiar la variable range_items por el número que deseen:

# # Generate the first 100 numbers pairs
# Pairs: [num for num in range(100) if num % 2 == 0]
def check_value(num):
    value = num if num % 2 == 0 else None
    yield value

def start(range_items):
    response = list()
    for num in range(range_items):
        value = next(check_value(num))
        if value is not None:
            response.append(value)
    print(f"The pair number of the range {range_items} is:\n{response}")

# Start Process
range_items = 100
start(range_items)

def challenge():
    for i in range(2, 99, 2):
        yield i


my_iter = challenge()

while True:
    print(next(my_iter))

Por fin veo un curso donde mencionen en mas detalle el uso de los generadores, es muy importante

def my_generator():
    n = 0

    while n <= 100:
        n += 2
        yield n


gen_func = my_generator()

while True:
    print(next(gen_func))

Un generador es una función con poderes especiales:
Guardar estados de una función para utilizarlos posteriormente

def even_n(n):
    num = 0
    while num < n:
        yield num*2
        num +=1
    
m = even_n(100)

[i for i in m]

mi solucion

def search_pares():
    i = 0
    while True: 
        i += 1
        if i % 2 == 0:
            yield i

value = search_pares()

for n in range(100):
    print( next( value ))

#!/usr/bin/env python3


def numbers():
    for i in range(1, 101):
        yield i * 2
    
for j in numbers():
    if j % 2 == 0:
        print(f'{j} is pair')

def one_hundred():
    for i in range(100):
        yield i*2

my_gen= one_hundred()

while True:
    try:
       print(next(my_gen))
    except:
        print("StopIterations, only 100 even numbers  Try again...")
        break

Reto solucionado

def my_gen():
    a = [i for i in range(1, 201)]

    for i in a:
        if i % 2 == 0:
            yield i


my_first_gen = my_gen()

[print(next(my_first_gen)) for _ in range(100)]

Hace un tiempo me mate tratando de entenderlos hasta que lo logre, aqui los ejercicios

Hola a todos, tengo una duda y agradecería si alguien la puede responder o indicarme dónde puedo encontrar información:
¿Por qué al asignar la función a una variable y hacer los next de esa variable me imprime 1 2 3, pero si hago los next directamente de la función entonces me devuelve 1 1 1?
Es decir, si ejecuto el siguiente código (haciendo los next a la variable) me da 1 2 3:

my_first_gen = my_gen() 

print(next(my_first_gen))
print(next(my_first_gen))
print(next(my_first_gen))

Pero si ejecuto el siguiente código (haciendo los next a la función) me da 1 1 1:

print(next(my_gen()))
print(next(my_gen()))
print(next(my_gen()))

def pares():
    for x in range(1,201):
        if x % 2 ==0:
            yield x


Pares = pares()

for x in range(100):
    print(next(Pares))```

def first_pairs():
    count = 1
    while(count <= 100):
        yield 2*count
        count = count+1```